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 connais import mathet utilise sqrt. Mais je cherche une réponse à ce qui précède.

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

Vous calculez donc x ^(1/2) dans la première instance, x ⁽⁰⁾ dans la seconde.

Ce n'est donc pas faux, c'est la bonne réponse à une question différente.

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

Ce comportement est "normal" en Python 2.x, alors qu'en Python 3.x 1/2vaut 0.5. Si vous voulez que votre code Python 2.x se comporte comme l'écriture de division 3.x wrt from __future__ import division- alors 1/2évaluera 0.5et pour la compatibilité descendante, 1//2évaluera à 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)

import math
math.sqrt( x )

C'est un ajout trivial à la chaîne de réponses. Cependant, comme le sujet est un hit google très courant, cela mérite d'être ajouté, je crois.

/ effectue une division entière dans 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 une division entière. Pour obtenir la 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)

La réponse est peut-être un peu tardive, mais le moyen le plus simple et le plus précis de calculer la racine carrée est la méthode de Newton.

Vous avez un nombre dont 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 qui a du sens raccourcit considérablement la profondeur d'appel récursif.

new_estimate = (estimate + num / estimate) / 2

Cette ligne calcule une estimation plus précise avec ces 2 paramètres. Vous pouvez passer la valeur new_estimate à la fonction et calculer une autre new_estimate qui est plus précise que la précédente 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. On sait 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 souvenir: ajoutez un point après le numérateur (ou dénominateur)

16 ** (1. / 2)   # 4
289 ** (1. / 2)  # 17
27 ** (1. / 3)   # 3

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

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

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

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)