Python Language
मठ का मॉड्यूल

गोलाई: गोल, फर्श, छत, फंदा

के अलावा निर्मित round समारोह, math मॉड्यूल प्रदान करता है floor , ceil , और trunc कार्य करता है।

x = 1.55
y = -1.55

# round to the nearest integer
round(x)       #  2
round(y)       # -2

# the second argument gives how many decimal places to round to (defaults to 0)
round(x, 1)    #  1.6
round(y, 1)    # -1.6

# math is a module so import it first, then use it.
import math

# get the largest integer less than x
math.floor(x)  #  1
math.floor(y)  # -2

# get the smallest integer greater than x
math.ceil(x)   #  2
math.ceil(y)   # -1

# drop fractional part of x
math.trunc(x)  #  1, equivalent to math.floor for positive numbers
math.trunc(y)  # -1, equivalent to math.ceil for negative numbers

round(1.3)  # 1.0

round(0.5)  # 1.0
round(1.5)  # 2.0

round(1.3)      # 1
round(1.33, 1)  # 1.3

round(0.5)  # 0
round(1.5)  # 2

चेतावनी!

किसी भी फ्लोटिंग-पॉइंट प्रतिनिधित्व के साथ, कुछ अंशों का बिल्कुल प्रतिनिधित्व नहीं किया जा सकता है । इससे कुछ अप्रत्याशित गोल व्यवहार हो सकता है।

round(2.675, 2)  # 2.67, not 2.68!

नकारात्मक संख्याओं के फर्श, ट्रंक और पूर्णांक विभाजन के बारे में चेतावनी

पायथन (और C ++ और जावा) ऋणात्मक संख्याओं के लिए शून्य से गोल है। विचार करें:

>>> math.floor(-1.7)
-2.0
>>> -5 // 2
-3

लघुगणक

math.log(x) प्राकृतिक (आधार देता है e ) के लघुगणक x ।

math.log(math.e)  # 1.0
math.log(1)       # 0.0
math.log(100)     # 4.605170185988092

फ्लोटिंग-पॉइंट नंबरों की सीमाओं के कारण math.log 1 के करीब संख्या के साथ सटीक खो सकता है। 1 के करीब लॉग की सही गणना करने के लिए, math.log1p उपयोग math.log1p , जो तर्क के 1 प्लस के प्राकृतिक लघुगणक का मूल्यांकन करता है:

math.log(1 + 1e-20)  # 0.0
math.log1p(1e-20)    # 1e-20

math.log10 का उपयोग लॉग बेस 10 के लिए किया जा सकता है:

math.log10(10)  # 1.0

math.log(100, 10) # 2.0
math.log(27, 3)   # 3.0
math.log(1, 10)   # 0.0

नकल के संकेत

अजगर 2.6 और उच्चतर, में math.copysign(x, y) रिटर्न x के चिन्ह के साथ y । लौटाया गया मान हमेशा एक float ।

math.copysign(-2, 3)    # 2.0
math.copysign(3, -3)    # -3.0
math.copysign(4, 14.2)  # 4.0
math.copysign(1, -0.0)  # -1.0, on a platform which supports signed zero

त्रिकोणमिति

कर्ण की लंबाई की गणना

math.hypot(2, 4) # Just a shorthand for SquareRoot(2**2 + 4**2)
# Out: 4.47213595499958

रेडियन को / से डिग्री परिवर्तित करना

सभी math कार्य रेडियन की अपेक्षा करते हैं, इसलिए आपको डिग्री को रेडियन में बदलने की आवश्यकता है:

math.radians(45)              # Convert 45 degrees to radians
# Out: 0.7853981633974483

व्युत्क्रम त्रिकोणमितीय कार्यों के सभी परिणाम रेडियन में परिणाम लौटाते हैं, इसलिए आपको इसे वापस डिग्री में बदलने की आवश्यकता हो सकती है:

math.degrees(math.asin(1))    # Convert the result of asin to degrees
# Out: 90.0

साइन, कोसाइन, स्पर्शरेखा और व्युत्क्रम फ़ंक्शन

# Sine and arc sine
math.sin(math.pi / 2)
# Out: 1.0
math.sin(math.radians(90))   # Sine of 90 degrees
# Out: 1.0

math.asin(1)
# Out: 1.5707963267948966    # "= pi / 2"
math.asin(1) / math.pi
# Out: 0.5

# Cosine and arc cosine:
math.cos(math.pi / 2)
# Out: 6.123233995736766e-17 
# Almost zero but not exactly because "pi" is a float with limited precision!

math.acos(1)
# Out: 0.0

# Tangent and arc tangent:
math.tan(math.pi/2)
# Out: 1.633123935319537e+16 
# Very large but not exactly "Inf" because "pi" is a float with limited precision

math.atan(math.inf)
# Out: 1.5707963267948966 # This is just "pi / 2"

math.atan(float('inf'))
# Out: 1.5707963267948966 # This is just "pi / 2"

math.atan अलावा एक दो-तर्क math.atan2 फ़ंक्शन भी है, जो सही चतुर्थांश की गणना करता है और विभाजन के नुकसान को शून्य से बचाता है:

math.atan2(1, 2)   # Equivalent to "math.atan(1/2)"
# Out: 0.4636476090008061 # ≈ 26.57 degrees, 1st quadrant

math.atan2(-1, -2) # Not equal to "math.atan(-1/-2)" == "math.atan(1/2)"
# Out: -2.677945044588987 # ≈ -153.43 degrees (or 206.57 degrees), 3rd quadrant

math.atan2(1, 0)   # math.atan(1/0) would raise ZeroDivisionError
# Out: 1.5707963267948966 # This is just "pi / 2"

अतिशयोक्तिपूर्ण साइन, कोसाइन और स्पर्शरेखा

# Hyperbolic sine function
math.sinh(math.pi) # = 11.548739357257746
math.asinh(1)      # = 0.8813735870195429

# Hyperbolic cosine function
math.cosh(math.pi) # = 11.591953275521519
math.acosh(1)      # = 0.0

# Hyperbolic tangent function
math.tanh(math.pi) # = 0.99627207622075
math.atanh(0.5)    # = 0.5493061443340549

स्थिरांक

math मॉड्यूल में दो आमतौर पर उपयोग किए जाने वाले गणितीय स्थिरांक शामिल हैं।

• math.pi - गणितीय निरंतर पी
• math.e - गणितीय स्थिर ई (प्राकृतिक लघुगणक का आधार)

>>> from math import pi, e
>>> pi
3.141592653589793
>>> e
2.718281828459045
>>>

पायथन 3.5 और उच्चतर में अनंत और NaN ("संख्या नहीं") के लिए स्थिरांक हैं। एक स्ट्रिंग को float() में पास करने का पुराना सिंटैक्स अभी भी काम करता है।

math.inf == float('inf')
# Out: True

-math.inf == float('-inf')
# Out: True

# NaN never compares equal to anything, even itself
math.nan == float('nan')
# Out: False

काल्पनिक संख्या

पायथन में काल्पनिक संख्या एक "जे" या "जे" द्वारा लक्षित संख्या को दर्शाती है।

1j         # Equivalent to the square root of -1.
1j * 1j    # = (-1+0j)

अनंत और NaN ("संख्या नहीं")

पायथन के सभी संस्करणों में, हम अनंत और NaN ("संख्या नहीं") का प्रतिनिधित्व कर सकते हैं:

pos_inf = float('inf')     # positive infinity
neg_inf = float('-inf')    # negative infinity
not_a_num = float('nan')   # NaN ("not a number")

पायथन 3.5 और उच्चतर में, हम भी परिभाषित स्थिरांक math.inf और math.nan उपयोग कर सकते हैं:

pos_inf = math.inf
neg_inf = -math.inf
not_a_num = math.nan

स्ट्रिंग अभ्यावेदन inf और -inf और nan रूप में प्रदर्शित होते हैं:

pos_inf, neg_inf, not_a_num
# Out: (inf, -inf, nan)

हम isinf विधि के साथ सकारात्मक या नकारात्मक अनंत के लिए परीक्षण कर सकते हैं:

math.isinf(pos_inf)
# Out: True

math.isinf(neg_inf)
# Out: True

हम विशेष रूप से सकारात्मक अनंत के लिए या प्रत्यक्ष तुलना द्वारा नकारात्मक अनंत के लिए परीक्षण कर सकते हैं:

pos_inf == float('inf')    # or  == math.inf in Python 3.5+
# Out: True

neg_inf == float('-inf')   # or  == -math.inf in Python 3.5+
# Out: True

neg_inf == pos_inf
# Out: False

पायथन 3.2 और उच्चतर भी परिमितता के लिए जाँच की अनुमति देता है:

math.isfinite(pos_inf)
# Out: False

math.isfinite(0.0)
# Out: True

तुलनात्मक संचालक सकारात्मक और नकारात्मक अनंत के लिए अपेक्षित रूप से काम करते हैं:

import sys

sys.float_info.max
# Out: 1.7976931348623157e+308  (this is system-dependent)

pos_inf > sys.float_info.max
# Out: True

neg_inf < -sys.float_info.max
# Out: True

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

pos_inf == sys.float_info.max * 1.0000001
# Out: True

neg_inf == -sys.float_info.max * 1.0000001
# Out: True

हालाँकि शून्य द्वारा विभाजन अनंत (या नकारात्मक अनंत जहाँ उपयुक्त हो) का परिणाम नहीं देता है, बल्कि यह एक ZeroDivisionError अपवाद को जन्म ZeroDivisionError है।

try:
    x = 1.0 / 0.0
    print(x)
except ZeroDivisionError:
    print("Division by zero")

# Out: Division by zero

अनंत पर अंकगणित संचालन बस अनंत परिणाम देते हैं, या कभी-कभी NaN:

-5.0 * pos_inf == neg_inf
# Out: True

-5.0 * neg_inf == pos_inf
# Out: True

pos_inf * neg_inf == neg_inf
# Out: True

0.0 * pos_inf
# Out: nan

0.0 * neg_inf
# Out: nan

pos_inf / pos_inf
# Out: nan

NaN कभी भी किसी चीज के बराबर नहीं होता, खुद भी नहीं। हम इसके लिए isnan विधि से परीक्षण कर सकते हैं:

not_a_num == not_a_num
# Out: False

math.isnan(not_a_num)
Out: True

NaN हमेशा "बराबर नहीं" के रूप में तुलना करता है, लेकिन कभी भी इससे कम या अधिक नहीं होता है:

not_a_num != 5.0   # or any random value
# Out: True

not_a_num > 5.0   or   not_a_num < 5.0   or   not_a_num == 5.0
# Out: False

NaN पर अंकगणितीय ऑपरेशन हमेशा NaN देते हैं। इसमें -1 से गुणा शामिल है: कोई "नकारात्मक NaN" नहीं है।

5.0 * not_a_num
# Out: nan

float('-nan')
# Out: nan

-math.nan
# Out: nan

NaN और अनंत के पुराने float संस्करणों और पायथन 3.5+ math पुस्तकालय स्थिरांक के बीच एक सूक्ष्म अंतर है:

math.inf is math.inf, math.nan is math.nan
# Out: (True, True)

float('inf') is float('inf'), float('nan') is float('nan')
# Out: (False, False)

तेजी से घातांक के लिए पाउडर

कमांड लाइन से टाइमिट मॉड्यूल का उपयोग करना:

> python -m timeit 'for x in xrange(50000): b = x**3'
10 loops, best of 3: 51.2 msec per loop
> python -m timeit 'from math import pow' 'for x in xrange(50000): b = pow(x,3)' 
100 loops, best of 3: 9.15 msec per loop

अंतर्निहित ** ऑपरेटर अक्सर काम में आता है, लेकिन यदि प्रदर्शन सार का है, तो math.pow का उपयोग करें। हालाँकि, ध्यान रखें कि पाव रिटर्न तैरता है, भले ही तर्क पूर्णांक हो:

> from math import pow
> pow(5,5)
3125.0

जटिल संख्या और सेमीथ मॉड्यूल

cmath मॉड्यूल math मॉड्यूल के समान है, लेकिन जटिल विमान के लिए उपयुक्त कार्यों को परिभाषित करता है।

सबसे पहले, जटिल संख्या एक संख्यात्मक प्रकार है जो एक पुस्तकालय वर्ग द्वारा प्रदान किए जाने के बजाय खुद पायथन भाषा का हिस्सा है। इस प्रकार हमें साधारण अंकगणितीय अभिव्यक्तियों के लिए import cmath करने की आवश्यकता नहीं है।

ध्यान दें कि हम j (या J ) का उपयोग करते हैं और i नहीं।

z = 1 + 3j

हमें 1j उपयोग करना चाहिए क्योंकि j एक संख्यात्मक शाब्दिक के बजाय एक चर का नाम होगा।

1j * 1j
Out: (-1+0j)

1j ** 1j
# Out: (0.20787957635076193+0j)     # "i to the i"  ==  math.e ** -(math.pi/2)

हम real हिस्सा है और imag (काल्पनिक) हिस्सा है, साथ ही जटिल conjugate :

# real part and imaginary part are both float type
z.real, z.imag
# Out: (1.0, 3.0)

z.conjugate()
# Out: (1-3j)    # z.conjugate() == z.real - z.imag * 1j

abs और complex में निर्मित कार्य भी भाषा का हिस्सा हैं और किसी भी आयात की आवश्यकता नहीं है:

abs(1 + 1j)
# Out: 1.4142135623730951     # square root of 2

complex(1)
# Out: (1+0j)

complex(imag=1)
# Out: (1j)

complex(1, 1)
# Out: (1+1j)

complex फ़ंक्शन एक स्ट्रिंग ले सकता है, लेकिन इसमें स्थान नहीं हो सकते:

complex('1+1j')
# Out: (1+1j)

complex('1 + 1j')
# Exception: ValueError: complex() arg is a malformed string

लेकिन अधिकांश कार्यों के लिए हमें मॉड्यूल की आवश्यकता होती है, उदाहरण के लिए sqrt :

import cmath

cmath.sqrt(-1)
# Out: 1j

स्वाभाविक रूप से sqrt का व्यवहार जटिल संख्याओं और वास्तविक संख्याओं के लिए भिन्न होता है। गैर-जटिल math में एक ऋणात्मक संख्या का वर्गमूल एक अपवाद उठाता है:

import math

math.sqrt(-1)
# Exception: ValueError: math domain error

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

cmath.polar(1 + 1j)
# Out: (1.4142135623730951, 0.7853981633974483)    # == (sqrt(1 + 1), atan2(1, 1))

abs(1 + 1j), cmath.phase(1 + 1j)
# Out: (1.4142135623730951, 0.7853981633974483)    # same as previous calculation

cmath.rect(math.sqrt(2), math.atan(1))
# Out: (1.0000000000000002+1.0000000000000002j)

जटिल विश्लेषण का गणितीय क्षेत्र इस उदाहरण के दायरे से परे है, लेकिन जटिल विमान में कई कार्यों में "शाखा कट" होता है, आमतौर पर वास्तविक अक्ष या काल्पनिक अक्ष के साथ। अधिकांश आधुनिक प्लेटफ़ॉर्म IEEE 754 में निर्दिष्ट "हस्ताक्षरित शून्य" का समर्थन करते हैं, जो शाखा कटौती के दोनों किनारों पर उन कार्यों की निरंतरता प्रदान करता है। निम्नलिखित उदाहरण पायथन प्रलेखन से है:

cmath.phase(complex(-1.0, 0.0))
# Out: 3.141592653589793

cmath.phase(complex(-1.0, -0.0))
# Out: -3.141592653589793

cmath मॉड्यूल math मॉड्यूल से सीधे समकक्षों के साथ कई कार्य भी प्रदान करता है।

sqrt अलावा, exp , log , log10 , त्रिकोणमितीय फ़ंक्शंस और उनके व्युत्क्रम ( sin , cos , tan , asin , acos , atan ) के जटिल संस्करण हैं, और हाइपरबोलिक फ़ंक्शंस और उनके व्युत्क्रम ( sinh , cosh , tanh ) asinh , acosh , atanh )। ध्यान दें कि math.atan2 का कोई जटिल प्रतिरूप नहीं है। math.atan2 के दो-तर्क रूप।

cmath.log(1+1j)
# Out: (0.34657359027997264+0.7853981633974483j)

cmath.exp(1j * cmath.pi)
# Out: (-1+1.2246467991473532e-16j)   # e to the i pi == -1, within rounding error

स्थिरांक pi और e प्रदान किए जाते हैं। ध्यान दें कि ये float और complex नहीं complex ।

type(cmath.pi)
# Out: <class 'float'>

cmath मॉड्यूल भी की जटिल संस्करण प्रदान करता है isinf , और (अजगर 3.2+ के लिए) isfinite । " इन्फिनिटी और NaN " देखें। एक जटिल संख्या को अनंत माना जाता है यदि उसका वास्तविक भाग या उसका काल्पनिक भाग अनंत है।

cmath.isinf(complex(float('inf'), 0.0))
# Out: True

इसी तरह, cmath मॉड्यूल की एक जटिल संस्करण प्रदान करता है isnan । " इन्फिनिटी और NaN " देखें। एक जटिल संख्या को "एक संख्या नहीं" माना जाता है, यदि इसका वास्तविक भाग या इसका काल्पनिक भाग "संख्या नहीं" है।

cmath.isnan(0.0, float('nan'))
# Out: True 

ध्यान दें कि math.inf और math.nan स्थिरांक (पायथन 3.5 और उससे अधिक) का कोई cmath समकक्ष नहीं है

cmath.isinf(complex(0.0, math.inf))
# Out: True

cmath.isnan(complex(math.nan, 0.0))
# Out: True

cmath.inf
# Exception: AttributeError: module 'cmath' has no attribute 'inf'

पायथन 3.5 और उच्चतर में, cmath और math मॉड्यूल दोनों में एक isclose विधि है।

z = cmath.rect(*cmath.polar(1+1j))

z
# Out: (1.0000000000000002+1.0000000000000002j)

cmath.isclose(z, 1+1j)
# True