गणित का उपयोग करते हुए, गणितीय कार्यों के लिए पायथन के मानक मॉड्यूल, आप घातीय और लघुगणक कार्यों (प्राकृतिक लघुगणक, साधारण लघुगणक और द्विआधारी लघुगणक) की गणना कर सकते हैं।
नमूना कोड के साथ निम्नलिखित को यहां समझाया गया है।
- प्राकृतिक लघुगणक का आधार (नेपियर संख्या):
math.e - शक्ति::
**ऑपरेटर,pow(),math.pow() - वर्गमूल (रूट):
math.sqrt() - घातीय कार्य (प्राकृतिक घातीय कार्य):
math.exp() - एक लघुगणकीय कार्य:
math.log(),math.log10(),math.log2()
प्राकृतिक लघुगणक का आधार (नेपियर संख्या):math.e
प्राकृतिक लघुगणक (नेपियर संख्या) का आधार गणित मॉड्यूल में एक स्थिरांक के रूप में प्रदान किया जाता है, जिसे गणित द्वारा दर्शाया जाता है।
import math
print(math.e)
# 2.718281828459045
पावर: ** ऑपरेटर, पाउ (), गणित। पाउ ():**ऑपरेटर,pow(),math.pow()
शक्तियों की गणना करने के लिए, ** ऑपरेटर, अंतर्निहित फ़ंक्शन पाउ (), या गणित.पाउ () का उपयोग करें।
x का y-वर्ग निम्नानुसार प्राप्त होता है
x**ypow(x, y)math.pow(x, y)
print(2**4)
# 16
print(pow(2, 4))
# 16
print(math.pow(2, 4))
# 16.0
math.pow() तर्क को फ़्लोटिंग-पॉइंट प्रकार में परिवर्तित करता है। दूसरी ओर, पायथन का अंतर्निहित फ़ंक्शन pow() प्रत्येक प्रकार के लिए परिभाषित __pow()__ का उपयोग करता है।
उदाहरण के लिए, pow() जटिल प्रकारों को तर्क के रूप में निर्दिष्ट करने की अनुमति देता है, लेकिन math.pow() जटिल प्रकारों को फ़्लोट प्रकारों में परिवर्तित नहीं कर सकता है, जिसके परिणामस्वरूप त्रुटि होती है।
print(pow(1 + 1j, 2))
# 2j
# print(math.pow(1 + 1j, 2))
# TypeError: can't convert complex to float
पायथन बिल्ट-इन फ़ंक्शन pow() एक तीसरे तर्क, pow(x, y, z) की भी अनुमति देता है, जो z के शेष (शेष) को x की y-शक्ति में लौटाता है। यह pow(x, y) % z के समान गणना है, लेकिन pow(x, y, z) अधिक कुशल है।
print(pow(2, 4, 5))
# 1
वर्गमूल (रूट):math.sqrt()
वर्गमूल (रूट) को **0.5 का उपयोग करके ** या math.sqrt() पर सेट किया जा सकता है।
print(2**0.5)
# 1.4142135623730951
print(math.sqrt(2))
# 1.4142135623730951
print(2**0.5 == math.sqrt(2))
# True
जैसे math.pow(), math.sqrt() तर्कों को प्रोसेसिंग के लिए फ्लोटिंग-पॉइंट प्रकारों में कनवर्ट करता है, इसलिए एक प्रकार निर्दिष्ट करना जिसे फ़्लोट प्रकार में परिवर्तित नहीं किया जा सकता है, जिसके परिणामस्वरूप TypeError होगा।
print((-3 + 4j)**0.5)
# (1.0000000000000002+2j)
# print(math.sqrt(-3 + 4j))
# TypeError: can't convert complex to float
साथ ही, math.sqrt() ऋणात्मक मानों को संसाधित नहीं कर सकता, जिसके परिणामस्वरूप ValueError होता है।
print((-1)**0.5)
# (6.123233995736766e-17+1j)
# print(math.sqrt(-1))
# ValueError: math domain error
ध्यान दें कि जटिल संख्याओं के साथ व्यवहार करते समय, ** ऑपरेटर का उपयोग करने वाला उदाहरण एक त्रुटि दिखाता है, लेकिन cmath मॉड्यूल अधिक सटीक मान प्रदान करता है। नकारात्मक मूल्यों को भी संभाला जा सकता है।
- संबंधित:पायथन, जटिल संख्याओं के साथ काम करने के लिए जटिल प्रकार (पूर्ण मान, गिरावट, ध्रुवीय परिवर्तन, आदि)
import cmath
print(cmath.sqrt(-3 + 4j))
# (1+2j)
print(cmath.sqrt(-1))
# 1j
घातीय कार्य (प्राकृतिक घातीय कार्य):math.exp()
प्राकृतिक लघुगणक (नेपियर संख्या) ई के आधार की शक्ति की गणना करने के लिए, math.exp() का उपयोग करें।
math.exp(x) e का x वर्ग लौटाता है।
math.exp(x) “math.e ** x” के बराबर नहीं है और math.exp(x) अधिक सटीक है।
print(math.exp(2))
# 7.38905609893065
print(math.exp(2) == math.e**2)
# False
एक लघुगणकीय कार्य:math.log(),math.log10(),math.log2()
लॉगरिदमिक फ़ंक्शन की गणना करने के लिए, math.log(),math.log10(),math.log2() का उपयोग करें।
math.log(x, y) आधार के रूप में y के साथ x का लघुगणक देता है।
print(math.log(25, 5))
# 2.0
यदि दूसरा तर्क छोड़ दिया जाता है, तो प्राकृतिक लघुगणक नीचे दिखाया गया है।
लोगारित्म
गणित में, प्राकृतिक लघुगणक (नेपियर संख्या ई के साथ लघुगणक), जिसे लॉग या ln द्वारा दर्शाया जाता है, की गणना math.log(x) द्वारा की जा सकती है।
print(math.log(math.e))
# 1.0
लघुगणक (आधार 10)
साधारण लघुगणक (आधार 10 के साथ लघुगणक) की गणना math.log10(x) से की जा सकती है, जो कि math.log(x, 10) से अधिक सटीक है।
print(math.log10(100000))
# 5.0
द्विआधारी लघुगणक
द्विआधारी लघुगणक (आधार 2 के साथ लघुगणक) की गणना math.log2(x) से की जा सकती है, जो कि math.log(x, 2) से अधिक सटीक है।
print(math.log2(1024))
# 10.0
