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
floor
, ceil
, trunc
, और round
हमेशा एक वापसी float
।
round(1.3) # 1.0
round
हमेशा शून्य से नाता तोड़ता है।
round(0.5) # 1.0
round(1.5) # 2.0
floor
, ceil
, और trunc
हमेशा एक वापसी Integral
, मूल्य, जबकि round
रिटर्न एक Integral
मूल्य एक तर्क के साथ कॉल करता है, तो।
round(1.3) # 1
round(1.33, 1) # 1.3
round
टूट जाता है निकटतम सम संख्या की ओर। बड़ी संख्या में गणना करते समय यह पूर्वाग्रह को बड़ी संख्या में सुधारता है।
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(x, base)
दिए गए base
में x
का लघुगणक देता है (यानी log(x) / log(base)
।
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