Python Language
घातांक

वाक्य - विन्यास

• मान 1 ** मान 2
• पाउ (मान 1, मान 2 [, मान 3])
• value1 .__ pow __ (value2 [, value3])
• मान 2 .__ rpow __ (मान 1)
• संचालक। pow (मान 1, मान 2)
• ऑपरेटर .__ pow __ (मान 1, मान 2)
• math.pow (मान 1, मान 2)
• math.sqrt (मान 1)
• math.exp (मान 1)
• cmath.exp (मान 1)
• math.expm1 (मान 1)

वर्गमूल: math.sqrt () और cmath.sqrt

math मॉड्यूल में math.sqrt() -फंक्शन होता है जो किसी भी संख्या के वर्गमूल की गणना कर सकता है (जिसे float बदला जा सकता है) और परिणाम हमेशा एक float :

import math

math.sqrt(9)                # 3.0
math.sqrt(11.11)            # 3.3331666624997918
math.sqrt(Decimal('6.25'))  # 2.5

यदि परिणाम complex होगा, तो math.sqrt() फ़ंक्शन एक ValueError बढ़ाता है:

math.sqrt(-10)              

ValueError: गणित डोमेन त्रुटि

math.sqrt(x) math.pow(x, 0.5) या x ** 0.5 तुलना में तेज़ है लेकिन परिणामों की सटीकता समान है। cmath मॉड्यूल math मॉड्यूल के समान है, इस तथ्य को छोड़कर यह जटिल संख्याओं की गणना कर सकता है और इसके सभी परिणाम एक + द्वि के रूप में होते हैं। यह भी उपयोग कर सकते हैं .sqrt() :

import cmath

cmath.sqrt(4)  # 2+0j
cmath.sqrt(-4) # 2j

क्या है j के साथ? j , -1 के वर्गमूल के समतुल्य है। सभी संख्याओं को एक + द्वि, या इस मामले में, एक + बीजे के रूप में डाला जा सकता है। a का वास्तविक भाग है जैसे 2 में 2+0j । चूँकि इसका कोई काल्पनिक भाग नहीं है, b 0. b जो 2j में 2 की तरह संख्या के काल्पनिक भाग का प्रतिनिधित्व करता है। चूंकि इसमें कोई वास्तविक हिस्सा नहीं है, 2j को 0 + 2j रूप में भी लिखा जा सकता है।

बिलिंस का उपयोग करते हुए घातांक: ** और पॉव ()

बेसिन pow फंक्शन या ** ऑपरेटर का उपयोग करके घातांक का उपयोग किया जा सकता है:

2 ** 3    # 8
pow(2, 3) # 8

अधिकांश (पायथन 2.x में) अंकगणितीय संचालन के लिए परिणाम का प्रकार व्यापक ऑपरेंड का होगा। यह ** लिए सच नहीं है; इस नियम से निम्नलिखित मामले अपवाद हैं:

• आधार: int , प्रतिपादक: int < 0 :

  2 ** -3
  # Out: 0.125 (result is a float)
  

• यह पायथन 3.x के लिए भी मान्य है।

• पाइथन 2.2.0 से पहले, इसने एक ValueError उभारा।

• आधार: int < 0 या float < 0 , घातांक: float != int

  (-2) ** (0.5)  # also (-2.) ** (0.5)    
  # Out: (8.659560562354934e-17+1.4142135623730951j) (result is complex)
  

• अजगर 3.0.0 से पहले, इसने एक ValueError बढ़ाया।

operator मॉड्यूल में दो कार्य शामिल हैं जो ** -ऑपरेटर के बराबर हैं:

import operator
operator.pow(4, 2)      # 16
operator.__pow__(4, 3)  # 64

या कोई सीधे __pow__ विधि को कॉल कर सकता है:

val1, val2 = 4, 2
val1.__pow__(val2)      # 16
val2.__rpow__(val1)     # 16
# in-place power operation isn't supported by immutable classes like int, float, complex:
# val1.__ipow__(val2)   

गणित मॉड्यूल का उपयोग कर घातांक: math.pow ()

math -मॉडल में एक और math.pow() फ़ंक्शन होता है। बिलिन pow() -फंक्शन या ** ऑपरेटर का अंतर यह है कि परिणाम हमेशा एक float :

import math
math.pow(2, 2)    # 4.0
math.pow(-2., 2)  # 4.0

जो जटिल इनपुट के साथ संगणना को बाहर करता है:

math.pow(2, 2+0j) 

TypeError: कॉम्प्लेक्स को फ्लोट में नहीं बदल सकते

और संगणनाएँ जो जटिल परिणामों को जन्म देंगी:

math.pow(-2, 0.5)

ValueError: गणित डोमेन त्रुटि

घातीय कार्य: math.exp () और cmath.exp ()

math और cmath -module दोनों में Euler नंबर होता है: e और इसका उपयोग बिलिन pow() -फंक्शन या ** -ओपरेटर के साथ करता है जो ज्यादातर math.exp() तरह काम करता है:

import math

math.e ** 2  # 7.3890560989306495
math.exp(2)  # 7.38905609893065

import cmath
cmath.e ** 2 # 7.3890560989306495
cmath.exp(2) # (7.38905609893065+0j)

हालांकि परिणाम अलग है और घातीय फ़ंक्शन का उपयोग करना बेस math.e साथ math.e तुलना में अधिक विश्वसनीय है।

print(math.e ** 10)       # 22026.465794806703
print(math.exp(10))       # 22026.465794806718
print(cmath.exp(10).real) # 22026.465794806718
#     difference starts here ---------------^

घातीय फ़ंक्शन माइनस 1: math.expm1 ()

math मॉड्यूल में expm1() शामिल है जो अभिव्यक्ति math.e ** x - 1 गणना कर सकता है। math.exp(x) या cmath.exp(x) तुलना में उच्च परिशुद्धता वाले बहुत छोटे x के लिए अनुमति देगा:

import math

print(math.e ** 1e-3 - 1)  # 0.0010005001667083846
print(math.exp(1e-3) - 1)  # 0.0010005001667083846
print(math.expm1(1e-3))    # 0.0010005001667083417
#                            ------------------^

बहुत छोटे x के लिए अंतर बड़ा हो जाता है:

print(math.e ** 1e-15 - 1) # 1.1102230246251565e-15
print(math.exp(1e-15) - 1) # 1.1102230246251565e-15
print(math.expm1(1e-15))   # 1.0000000000000007e-15
#                              ^-------------------

वैज्ञानिक कंप्यूटिंग में सुधार महत्वपूर्ण है। उदाहरण के लिए प्लैंक के नियम में एक घातीय फ़ंक्शन माइनस 1 है:

def planks_law(lambda_, T):
    from scipy.constants import h, k, c  # If no scipy installed hardcode these!
    return 2 * h * c ** 2 / (lambda_ ** 5 * math.expm1(h * c / (lambda_ * k * T)))

def planks_law_naive(lambda_, T):
    from scipy.constants import h, k, c  # If no scipy installed hardcode these!
    return 2 * h * c ** 2 / (lambda_ ** 5 * (math.e ** (h * c / (lambda_ * k * T)) - 1))

planks_law(100, 5000)        # 4.139080074896474e-19
planks_law_naive(100, 5000)  # 4.139080073488451e-19
#                                        ^---------- 

planks_law(1000, 5000)       # 4.139080128493406e-23
planks_law_naive(1000, 5000) # 4.139080233183142e-23
#                                      ^------------

जादू के तरीके और घातांक: बिलिन, गणित और सेमीथ

मान लें कि आपके पास एक वर्ग है जो विशुद्ध रूप से पूर्णांक मूल्यों को संग्रहीत करता है:

class Integer(object):
    def __init__(self, value):
        self.value = int(value) # Cast to an integer
        
    def __repr__(self):
        return '{cls}({val})'.format(cls=self.__class__.__name__,
                                     val=self.value)
    
    def __pow__(self, other, modulo=None):
        if modulo is None:
            print('Using __pow__')
            return self.__class__(self.value ** other)
        else:
            print('Using __pow__ with modulo')
            return self.__class__(pow(self.value, other, modulo))
    
    def __float__(self):
        print('Using __float__')
        return float(self.value)
    
    def __complex__(self):
        print('Using __complex__')
        return complex(self.value, 0)

__pow__ pow फ़ंक्शन या ** ऑपरेटर का उपयोग करना हमेशा __pow__ कॉल __pow__ :

Integer(2) ** 2                 # Integer(4)
# Prints: Using __pow__
Integer(2) ** 2.5               # Integer(5)
# Prints: Using __pow__
pow(Integer(2), 0.5)            # Integer(1)
# Prints: Using __pow__  
operator.pow(Integer(2), 3)     # Integer(8)
# Prints: Using __pow__
operator.__pow__(Integer(3), 3) # Integer(27)
# Prints: Using __pow__

__pow__() विधि का दूसरा तर्क केवल बिलिन- pow() का उपयोग करके या सीधे विधि को कॉल करके दिया जा सकता है:

pow(Integer(2), 3, 4)           # Integer(0)
# Prints: Using __pow__ with modulo
Integer(2).__pow__(3, 4)        # Integer(0) 
# Prints: Using __pow__ with modulo  

जबकि math रूपांतरण हमेशा इसे एक float परिवर्तित करते हैं और फ्लोट-संगणना का उपयोग करते हैं:

import math

math.pow(Integer(2), 0.5) # 1.4142135623730951
# Prints: Using __float__

cmath इसे complex बदलने की कोशिश करते हैं, लेकिन अगर complex कोई स्पष्ट रूपांतरण नहीं है, तो इसे float करने के लिए भी वापस आ सकते हैं:

import cmath

cmath.exp(Integer(2))     # (7.38905609893065+0j)
# Prints: Using __complex__

del Integer.__complex__   # Deleting __complex__ method - instances cannot be cast to complex

cmath.exp(Integer(2))     # (7.38905609893065+0j)
# Prints: Using __float__

न तो math और न ही cmath काम करेगा अगर __float__() -method गायब है:

del Integer.__float__  # Deleting __complex__ method

math.sqrt(Integer(2))  # also cmath.exp(Integer(2))

TypeError: एक फ्लोट की आवश्यकता है

मॉड्यूलर घातांक: 3 तर्कों के साथ पाउ ()

3 तर्कों के साथ pow() आपूर्ति करना pow() pow(a, b, c) मॉड्यूलर घातांक का मूल्यांकन करता है a ^b mod :

pow(3, 4, 17)   # 13

# equivalent unoptimized expression:
3 ** 4 % 17     # 13

# steps:
3 ** 4          # 81
81 % 17         # 13

मॉड्यूलर घातांक का उपयोग कर अंतर्निहित प्रकार के लिए केवल तभी संभव है जब:

• पहला तर्क एक int
• दूसरा तर्क एक int >= 0
• तीसरा तर्क एक int != 0

ये प्रतिबंध अजगर 3.x में भी मौजूद हैं

उदाहरण के लिए एक मॉड्यूलर उलटा फ़ंक्शन को परिभाषित करने के लिए pow के 3-तर्क रूप का उपयोग कर सकते हैं:

def modular_inverse(x, p):
    """Find a such as  a·x ≡ 1 (mod p), assuming p is prime."""
    return pow(x, p-2, p)

[modular_inverse(x, 13) for x in range(1,13)]
# Out: [1, 7, 9, 10, 8, 11, 2, 5, 3, 4, 6, 12]

जड़ें: nth- रूट के साथ भिन्नात्मक घातांक

जबकि math.sqrt फ़ंक्शन वर्गमूल के विशिष्ट मामले के लिए प्रदान किया गया है, यह अक्सर क्यूब जड़ों की तरह, nth- रूट संचालन करने के लिए भिन्नात्मक घातांक के साथ घातांक ऑपरेटर ( ** ) का उपयोग करने के लिए सुविधाजनक है।

प्रतिपादक का व्युत्क्रम घातांक के प्रतिपादक द्वारा प्रतिरूपण है। इसलिए, यदि आप किसी संख्या को 3 के घातांक में डालकर घन कर सकते हैं, तो आप किसी संख्या की घनमूल को 1/3 के घातांक में डाल सकते हैं।

>>> x = 3
>>> y = x ** 3
>>> y
27
>>> z = y ** (1.0 / 3)
>>> z
3.0
>>> z == x
True

बड़े पूर्णांक जड़ों की गणना करना

हालांकि पायथन मूल रूप से बड़े पूर्णांकों का समर्थन करता है, लेकिन बहुत बड़ी संख्याओं की मूल जड़ लेना पायथन में विफल हो सकता है।

x = 2 ** 100
cube = x ** 3
root = cube ** (1.0 / 3)

OverflowError: फ्लोट में बदलने के लिए बहुत लंबा int

ऐसे बड़े पूर्णांकों के साथ काम करते समय, आपको किसी संख्या के nth रूट की गणना करने के लिए एक कस्टम फ़ंक्शन का उपयोग करना होगा।

def nth_root(x, n):
    # Start with some reasonable bounds around the nth root.
    upper_bound = 1
    while upper_bound ** n <= x:
        upper_bound *= 2
    lower_bound = upper_bound // 2
    # Keep searching for a better result as long as the bounds make sense.
    while lower_bound < upper_bound:
        mid = (lower_bound + upper_bound) // 2
        mid_nth = mid ** n
        if lower_bound < mid and mid_nth < x:
            lower_bound = mid
        elif upper_bound > mid and mid_nth > x:
            upper_bound = mid
        else:
            # Found perfect nth root.
            return mid
    return mid + 1

x = 2 ** 100
cube = x ** 3
root = nth_root(cube, 3)
x == root
# True