Comment calculer la racine carrée en Python?

Pourquoi Python donne-t-il la “mauvaise” réponse?

x = 16 sqrt = x**(.5) returns 4 sqrt = x**(1/2) returns 1 

Oui, je sais import math et utiliser sqrt . Mais je cherche une réponse à ce qui précède.

sqrt=x**(1/2) effectue une division entière. 1/2 == 0 .

Donc, vous calculez x (1/2) dans le premier cas, x (0) dans le second.

Donc, ce n’est pas faux, c’est la bonne réponse à une autre question.

Vous devez écrire: sqrt = x**(1/2.0) , sinon une division entière est effectuée et l’expression 1/2 renvoie 0 .

Ce comportement est “normal” dans Python 2.x, alors que dans Python 3.x 1/2 évalué à 0.5 . Si vous voulez que votre code Python 2.x se comporte comme l’écriture 3.x wrt division à from __future__ import division – alors 1/2 sera évalué à 0.5 et pour une compatibilité ascendante, 1/2 sera évalué à 0 .

Et pour mémoire, la méthode préférée pour calculer une racine carrée est la suivante:

 import math math.sqrt(x) 

/ effectue une division entière en Python 2:

 >>> 1/2 0 

Si l’un des nombres est un flottant, cela fonctionne comme prévu:

 >>> 1.0/2 0.5 >>> 16**(1.0/2) 4.0 

Ce que vous voyez est la division entière. Pour obtenir une division en virgule flottante par défaut,

 from __future__ import division 

Ou, vous pouvez convertir 1 ou 2 de 1/2 en une valeur à virgule flottante.

 sqrt = x**(1.0/2) 
 import math math.sqrt( x ) 

C’est un ajout sortingvial à la chaîne de réponses. Cependant, puisque le sujet est très fréquenté par Google, cela mérite d’être ajouté, je crois.

Cela peut être un peu tard pour répondre, mais la méthode la plus simple et la plus précise pour calculer la racine carrée est la méthode de newton.

Vous avez un nombre que vous voulez calculer sa racine carrée (num) et vous avez une estimation de sa racine carrée (estimate) . L’estimation peut être n’importe quel nombre supérieur à 0, mais un nombre logique réduit considérablement la profondeur d’appel récursive.

 new_estimate = (estimate + num / estimate) / 2 

Cette ligne calcule une estimation plus précise avec ces 2 parameters. Vous pouvez transmettre la valeur new_estimate à la fonction et calculer un autre new_estimate qui est plus précis que le précédent ou vous pouvez créer une définition de fonction récursive comme celle-ci.

 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) 

Par exemple, nous devons trouver la racine carrée de 30. Nous soaps que le résultat est compris entre 5 et 6.

 newtons_method(30,5) 

le nombre est 30 et l’estimation est 5. Le résultat de chaque appel récursif est:

 5.5 5.477272727272727 5.4772255752546215 5.477225575051661 

Le dernier résultat est le calcul le plus précis de la racine carrée du nombre. C’est la même valeur que la fonction intégrée math.sqrt ().

Peut-être un moyen simple de se rappeler: ajoutez un point après le numérateur (ou dénominateur) 16 ** (1./2) # 4 289 ** (1./2) # 17 27 ** (1./3) # 3

J’espère que le code mentionné ci-dessous répondra à votre question.

 from __future__ import print_function 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) 

Vous pouvez utiliser NumPy pour calculer les racines carrées des tableaux:

  import numpy as np np.sqrt([1, 4, 9])