पाइथन में वर्ग रूट को कैल्क कैसे करें?

Question

पायथन "गलत" जवाब क्यों देता है?

x= 16 

sqrt= x**(.5) 
returns 4 

sqrt= x**(1/2) 
returns 1 

हाँ, मैं import math जानते हैं और sqrt का उपयोग करें। लेकिन मैं उपरोक्त के लिए एक जवाब की तलाश में हूँ।

Answer 1

sqrt=x**(1/2) पूर्णांक विभाजन कर रहा है। 1/2 == 0।

तो तुम कंप्यूटिंग रहे हैं एक्स ^(1/2) पहले उदाहरण में, x ^{(0) दूसरे में}।

_{तो यह गलत नहीं है, यह एक अलग प्रश्न का सही उत्तर है।}

Answer 2

/ अजगर 2 में एक पूर्णांक विभाजन करता है:

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

Answer 3

आप लिखने के लिए है: sqrt = x**(1/2.0), अन्यथा

>>> 1/2 
0 

तो किसी एक नंबर एक नाव है, यह उम्मीद के रूप में काम करता है एक पूर्णांक विभाजन किया जाता है और अभिव्यक्ति 1/20 देता है।

यह व्यवहार पायथन 2.x में "सामान्य" है, जबकि पायथन 3.x 1/2 में 0.5 का मूल्यांकन करता है। यदि आप अपने पायथन 2.x कोड को 3.x w.r.t. जैसा व्यवहार करना चाहते हैं। विभाजन from __future__ import division लिखें - फिर 1/20.5 का मूल्यांकन करेगा और पीछे की संगतता के लिए, 1//2 का मूल्यांकन 0 पर होगा।

import math 
math.sqrt(x) 

Answer 4

आप जो देख रहे पूर्णांक विभाजन है:

और रिकार्ड के लिए, एक वर्गमूल गणना करने के लिए पसंदीदा तरीका यह है। डिफ़ॉल्ट रूप से चल बिन्दु विभाजन प्राप्त करने के लिए

from __future__ import division 

या, आप एक चल बिन्दु मूल्य में 1 या 1/2 के 2 परिवर्तित कर सकते हैं।

sqrt = x**(1.0/2) 

Answer 5

आप सरणियों

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

Answer 6

के वर्ग जड़ों की गणना करने के numpy उपयोग कर सकते हैं मुझे आशा है कि नीचे दिये गये कोड आपके प्रश्न का उत्तर होगा।

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) 

सादर, अली

Answer 7

यह जवाब देने के लिए एक छोटी सी देर लेकिन सबसे सरल और सटीक गणना करने के लिए वर्गमूल न्यूटन की विधि है जिस तरह से हो सकता है।

आपके पास एक संख्या है जिसे आप अपने वर्ग रूट (num) की गणना करना चाहते हैं और आपके पास इसके वर्ग रूट (estimate) का अनुमान है। अनुमान 0 से बड़ा कोई भी हो सकता है, लेकिन एक संख्या जो समझ में आता है रिकर्सिव कॉल गहराई को काफी कम करता है।

new_estimate = (estimate + num/estimate)/2 

यह पंक्ति उन 2 पैरामीटर के साथ एक अधिक सटीक अनुमान की गणना करती है। आप फ़ंक्शन में new_estimate मान पास कर सकते हैं और एक और new_estimate की गणना कर सकते हैं जो पिछले एक से अधिक सटीक है या आप इस तरह की रिकर्सिव फ़ंक्शन परिभाषा बना सकते हैं।

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) 

उदाहरण के लिए हमें 30 वर्ग वर्ग रूट खोजने की आवश्यकता है। हम जानते हैं कि 5 और 6.

newtons_method(30,5) 

के बीच 30 वें नंबर है और अनुमान 5. है प्रत्येक पुनरावर्ती कॉल से परिणाम परिणाम है कर रहे हैं:

5.5 
5.477272727272727 
5.4772255752546215 
5.477225575051661 

अंतिम परिणाम का सबसे सटीक गणना है संख्या की वर्ग जड़। यह अंतर्निहित फ़ंक्शन math.sqrt() के समान मूल्य है।