Waarom geeft Python het “verkeerde” antwoord?
x = 16
sqrt = x**(.5) #returns 4
sqrt = x**(1/2) #returns 1
Ja, ik ken import mathen gebruik sqrt. Maar ik ben op zoek naar een antwoord op het bovenstaande.
Antwoord 1, autoriteit 100%
sqrt=x**(1/2)is bezig met deling van gehele getallen. 1/2 == 0.
Je berekent dus x(1/2)in het eerste geval, x(0)in het tweede.
Dus het is niet verkeerd, het is het juiste antwoord op een andere vraag.
Antwoord 2, autoriteit 48%
Je moet schrijven: sqrt = x**(1/2.0), anders wordt een gehele deling uitgevoerd en de uitdrukking 1/2retourneert 0.
Dit gedrag is “normaal” in Python 2.x, terwijl in Python 3.x 1/2resulteert in 0.5. Als u wilt dat uw Python 2.x-code zich gedraagt als 3.x w.r.t. divisie schrijft from __future__ import division– dan wordt 1/2geëvalueerd tot 0.5en voor achterwaartse compatibiliteit, 1//2wordt geëvalueerd tot 0.
En voor de goede orde, de beste manier om een vierkantswortel te berekenen is deze:
import math
math.sqrt(x)
Antwoord 3, autoriteit 11%
import math
math.sqrt( x )
Het is een triviale toevoeging aan de antwoordketen. Aangezien het onderwerp echter een veel voorkomende Google-hit is, verdient dit het om te worden toegevoegd, denk ik.
Antwoord 4, autoriteit 5%
/voert een gehele deling uit in Python 2:
>>> 1/2
0
Als een van de getallen een float is, werkt het zoals verwacht:
>>> 1.0/2
0.5
>>> 16**(1.0/2)
4.0
Antwoord 5, autoriteit 3%
Wat je ziet is deling van gehele getallen. Om standaard drijvende-komma-deling te krijgen,
from __future__ import division
Of u kunt 1 of 2 van 1/2 omzetten in een drijvende-kommawaarde.
sqrt = x**(1.0/2)
Antwoord 6, autoriteit 2%
Dit is misschien een beetje laat om te antwoorden, maar de meest eenvoudige en nauwkeurige manier om de vierkantswortel te berekenen is de methode van Newton.
Je hebt een getal waarvan je de vierkantswortel (num)wilt berekenen en je hebt een schatting van de vierkantswortel (estimate). Schatting kan elk getal groter dan 0 zijn, maar een logisch getal verkort de recursieve oproepdiepte aanzienlijk.
new_estimate = (estimate + num / estimate) / 2
Deze regel berekent een nauwkeurigere schatting met die twee parameters. U kunt de waarde new_estimate doorgeven aan de functie en een andere new_estimate berekenen die nauwkeuriger is dan de vorige, of u kunt een recursieve functiedefinitie zoals deze maken.
def newtons_method(num, estimate):
# Computing a new_estimate
new_estimate = (estimate + num / estimate) / 2
print(new_estimate)
# Base Case: Comparing our estimate with built-in functions value
if new_estimate == math.sqrt(num):
return True
else:
return newtons_method(num, new_estimate)
We moeten bijvoorbeeld de vierkantswortel uit de jaren 30 vinden. We weten dat het resultaat tussen 5 en 6 ligt.
newtons_method(30,5)
getal is 30 en schatting is 5. Het resultaat van elke recursieve aanroep is:
5.5
5.477272727272727
5.4772255752546215
5.477225575051661
Het laatste resultaat is de meest nauwkeurige berekening van de vierkantswortel van het getal. Het is dezelfde waarde als de ingebouwde functie math.sqrt().
Antwoord 7
Misschien een eenvoudige manier om te onthouden: voeg een punt toe na de teller (of noemer)
16 ** (1. / 2) # 4
289 ** (1. / 2) # 17
27 ** (1. / 3) # 3
Antwoord 8
Als je het wilt doen zoals de rekenmachine het doet, gebruik dan de Babylonische techniek. Het wordt hieren hier.
Stel dat u de vierkantswortel van 2 wilt berekenen:
a=2
a1 = (a/2)+1
b1 = a/a1
aminus1 = a1
bminus1 = b1
while (aminus1-bminus1 > 0):
an = 0.5 * (aminus1 + bminus1)
bn = a / an
aminus1 = an
bminus1 = bn
print(an,bn,an-bn)
Antwoord 9
U kunt NumPy gebruiken om vierkantswortels van arrays te berekenen:
import numpy as np
np.sqrt([1, 4, 9])
Antwoord 10
Ik hoop dat de onderstaande code uw vraag zal beantwoorden.
def root(x,a):
y = 1 / a
y = float(y)
print y
z = x ** y
print z
base = input("Please input the base value:")
power = float(input("Please input the root value:"))
root(base,power)