पायथन में वर्गमूल कैसे ज्ञात करें

प्रोग्रामिंग में, किसी संख्या को घात में बढ़ाना सबसे सामान्य कार्यों में से एक है। पायथन में, ऐसा करने के कई तरीके हैं, जिनमें से प्रत्येक में अपनी विशिष्ट विशेषताएं हैं। इस लेख में, हम पायथन में किसी संख्या को घात में बढ़ाने के तरीकों के बारे में जानेंगे।

घात क्या है?

घात यह दर्शाता है कि कोई संख्या स्वयं से कितनी बार गुणा की जाती है।

उदाहरण:

2³ = 2 * 2 * 2 = 8 — दो घन में।

किसी संख्या को घात में बढ़ाने के तीन तरीके हैं:

• आसान
• मध्यम
• कठिन

आइए प्रत्येक पर करीब से नज़र डालें:

आसान स्तर

किसी संख्या को घात में बढ़ाने के लिए आप ** ऑपरेटर का उपयोग कर सकते हैं।

um = 3 ** 4  # Same as 3 * 3 * 3 * 3
print(um)  # 81

** ऑपरेटर एक सरल और बहुमुखी तरीका है जो घातांक का पता लगाने के लिए कई प्रोग्रामर की पसंद है। 

मध्यम स्तर

? pow (संक्षिप्त रूप से शक्ति) – घातांक करने के लिए कार्य

pow()

pow() फ़ंक्शन का उपयोग किसी संख्या को घातांकित करने के लिए किया जाता है। यह ** घातांक ऑपरेटर के समकक्ष है

number, exponent = 10, 3
print(pow(number, exponent))  # 1000

math.pow()

math.pow() मॉड्यूल का एक फंक्शन है जो किसी संख्या को घातांकित करने के लिए भी उपयोग किया जाता है, लेकिन यह फ़्लोट प्रकार के तर्क लेता है और फ़्लोट प्रकार का परिणाम देता है। फ़ंक्शन pow() के विपरीत, यह मापांक भागफल का समर्थन नहीं करता है।

import math
number, exponent = 10, 3
print(math.pow(number, exponent))  # 1000.0

pow() और math.pow() के बीच अंतर

वे समान कार्य करने लगते हैं, लेकिन एक सूक्ष्म अंतर है:

pow() तीन तर्क ले सकता है: संख्या, घातांक, शेषफल

r1 = pow(5, 3)  # 5*5*5 = 125
r2 = pow(5, 3, 2)  # Equivalent to (5*5*5) % 2
# Meaning the remainder when 125 is divided by 2 -> is 1
print(r1, r2)  # 125 1

math.pow() सीमित परिशुद्धता का उपयोग करता है

import math
number, exponent, remainder = 13, 100, 2
# (13 raised to the power of 100) modulo 2
print(math.pow(number, exponent) % remainder)  # 0.0
print(pow(number, exponent, remainder))  # 1

क्रियाएँ समान हैं, लेकिन परिणाम भिन्न हैं। और यह महत्वपूर्ण हो सकता है।

math.pow() हमेशा float लौटाता है

import math
LF
print(math.pow(2, 6)) # 64.0
print(pow(2, 6))  # 64

हालाँकि, यदि परिणाम एक भिन्न है, तो दोनों विधियाँ एक फ्लोट लौटाएँगी।

import math
print(math.pow(2.1, 6.2))  # 99.48546343115241
print(pow(2.1, 6.2))  # 99.48546343115241

math.pow() बड़ी संख्याओं पर क्रैश हो जाता है

import math
print(pow(2, 9999))  # Will compute without errors
print(math.pow(2, 9999))  # [Power Error] OverflowError: math range error

गति में संभावित अंतर

आइए कोड लिखें जो निष्पादन गति को मापेगा।

pow():

import timeit

pow1 = """
pow(2, 100)
"""
elapsed_time1 = timeit.timeit(pow1, number=100_000)
# Running pow1 code 100k times to reduce errors
print(elapsed_time1)

math.pow():

from timeit import timeit

pow2 = """
import math
math.pow(2, 100)
"""
elapsed_time2 = timeit(pow2, number=100_000)  # Running pow2 code 100k times
print(elapsed_time2)

परिणाम:

print("pow():", elapsed_time1)
print("math.pow():", elapsed_time2)

इससे पता चलता है कि pow() तेज है। हालाँकि, याद रखें कि बहुत कुछ डिवाइस और प्लेटफ़ॉर्म पर निर्भर करता है जहाँ परीक्षण किया जा रहा है। कुछ रिपोर्ट करते हैं कि उनके लिए math.pow() çok daha hızlı है, भले ही setup=”import math” निर्दिष्ट किया गया हो।

एक अलग कंप्यूटर और प्लेटफ़ॉर्म पर, परिणाम भिन्न होते हैं:

pow(): 0.013429596998321358
math.pow(): 0.008748997999646235

यहाँ math.pow() इसके विपरीत डेढ़ गुना तेज़ निकला।

उन्नत स्तर

Numpy एक मॉड्यूल है जो सामान्य गणितीय और संख्यात्मक संचालन प्रदान करता है।

घातांक में वृद्धि भी एक गणितीय संचालन है और इस मॉड्यूल द्वारा समर्थित है।

import numpy
print(numpy.power(2, 30))  # 1073741824

आमतौर पर “import numpy as np” लिखने की प्रथा है, जिससे np.power(2, 30)

लिखना आसान हो जाता है। यदि हम numpy.arrange() के साथ मानों का एक अनुक्रम बनाते हैं, उदाहरण के लिए, तो हमारे लिए कुछ तरकीबें खुलती हैं। उदाहरण के लिए निम्नलिखित:

import numpy as np
# input_array
arr1 = np.arange(8)
exponent = 2
print(arr1)  # [0 1 2 3 4 5 6 7]
# output_array
out = np.power(arr1, exponent)
print(out)  # [ 0  1  4  9 16 25 36 49]

arr1 = [0, 1, 2, 3, 4, 5, 6, 7]
output_array = [0, 1, 4, 9, 16, 25, 36, 49]

इस arr1 = np.arange(8) के साथ अब भी pow() में काम करना संभव है:

print(pow(arr1, 2))  # [ 0  1  4  9 16 25 36 49]

महत्वपूर्ण! विंडोज ओएस के साथ काम करते समय, त्रुटि संभव है।

जैसा कि हम जानते हैं, 2³¹ = 2147483648, लेकिन numpy.power(2, 31) -2147483648 दे सकता है। जो पहले से ही अजीब है, लेकिन numpy.power(2, 32) 0 बिल्कुल वापस कर देगा।

इसका कारण सरल है, हालाँकि अप्रत्याशित है और वास्तव में आवाज़ नहीं की जाती है: प्राप्त संख्या को आंतरिक रूप से लोंगइंट (एक पूर्णांक जो 2³¹ से बड़ा है) में परिवर्तित करने के लिए आपको जबरदस्ती निर्दिष्ट करने की आवश्यकता है।

इसलिए, हम इसे इस प्रकार ठीक करते हैं:

numpy.power(2, 31, dtype=numpy.longlong)  # We will get 2147483648, not -2147483648
numpy.power(2, 32, dtype=numpy.longlong)  # We will get 4294967296, not 0

घातांकन विधियों की गति की तुलना

आइए विभिन्न घातांकन विधियों की गति की तुलना करें और हमारे कार्यों के लिए इष्टतम चुनें।

from timeit import timeit

# ========== ** ==========
pow1 = """
2**30
"""
elapsed_time1 = timeit(pow1, number=100_000)
# Run code pow1 100,000 times for reducing tolerance
print(elapsed_time1)

# ========== pow() ==========
pow2 = """
pow(2, 30)
"""
elapsed_time2 = timeit(pow2, number=100_000)
print(elapsed_time2)

# ========== math.pow() ==========
pow3 = """
math.pow(2, 30)
"""
elapsed_time3 = timeit(pow3, number=100_000, setup="import math")  # Run code pow2 100,000 times
print(elapsed_time3)


# ========== numpy.power() ==========
pow4 = """
numpy.power(2, 30)
"""
elapsed_time4 = timeit(pow4, number=100_000, setup="import numpy")  # Run code pow2 100,000 times
print(elapsed_time4)

100000 लॉन्च (संख्या =100_000) के आधार पर, हमें निम्नलिखित परिणाम प्राप्त होते हैं:

थोड़ा सा गणित जादू

पाइथन का उपयोग करके गणितीय गणनाएँ की जा सकती हैं। कुछ गणितीय तरकीबें देखें

वर्गमूल (√)

वर्गमूल एक जानी-मानी क्रिया है:

√9 = 3
√81 = 9

लेकिन एक गणितीय तरकीब है जिसकी मदद से जड़ की गणना आप बिना याद किये और sqr/sqrt को उलझाये कर सकते हैं:

print(9 ** 0.5)  # 3.0
print(81 ** 0.5)  # 9.0

यानी 1/2 की घात वर्गमूल है:

√64 = 64 ** (1/2) = 8.0

ऋणात्मक घात

आइए ऋणात्मक घात को हल करने का प्रयास करते हैं:

print(7 ** -3)  # 0.0029154518950437317

डरावना लग रहा है। वास्तव में सब कुछ काफी तार्किक है, यदि आप इसे भिन्न के रूप में कल्पना करते हैं:

ऋणात्मक घात का उदाहरण

इसलिए 10^-1=0.1

शून्य घात

गणितीय आधार: कोई भी संख्या 0 की घात पर 1 होती है

कोड में शून्य घात का उदाहरण:

print(54532 ** 0)  # 1
print(0 ** 0)  # 1

निष्कर्ष

पावर किसी भी प्रोग्रामिंग में सबसे अधिक उपयोग किए जाने वाले ऑपरेशनों में से एक है। इस लेख में, हमने पायथन में पावर की गणना करने के तीन तरीकों का अध्ययन किया है: ऑपरेटर **, फ़ंक्शन pow(), math.pow() और numpy.power()

सबसे तेज़ और सबसे बहुमुखी तरीका ऑपरेटर ** है। यह याद रखना महत्वपूर्ण है कि बहुत कुछ आपके द्वारा उपयोग किए जा रहे डिवाइस और प्लेटफ़ॉर्म पर निर्भर करता है। आपको विधि की दक्षता, पठनीयता और भविष्य के रखरखाव पर भी विचार करना चाहिए।