पाइथन (exp, log, log10, log2) मा घातीय र logarithmic प्रकार्यहरू गणना गर्नुहोस्

व्यापार

गणितीय कार्यहरूको लागि गणित, पाइथनको मानक मोड्युल प्रयोग गरेर, तपाईंले घातांक र लोगारिदमिक प्रकार्यहरू (प्राकृतिक लोगारिदम, साधारण लोगारिदम, र बाइनरी लोगारिदम) गणना गर्न सक्नुहुन्छ।

यहाँ नमूना कोड सहितको व्याख्या गरिएको छ।

  • प्राकृतिक लघुगणकको आधार (नेपियर नम्बर):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():**अपरेटर,pow(),math.pow()

शक्तिहरू गणना गर्न, ** अपरेटर, निर्मित प्रकार्य pow(), वा math.pow() प्रयोग गर्नुहोस्।

x को y-वर्ग निम्नानुसार प्राप्त हुन्छ

  • x**y
  • pow(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

Python बिल्ट-इन प्रकार्य pow() ले तेस्रो तर्क, pow(x, y, z) लाई पनि अनुमति दिन्छ, जसले x को y-शक्तिमा z को बाँकी (बाँकी) फर्काउँछ। यो pow(x, y) % z को समान गणना हो, तर pow(x, y, z) बढी प्रभावकारी छ।

print(pow(2, 4, 5))
# 1

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

वर्गमूल (मूल) लाई ** वा math.sqrt() प्रयोग गरेर **0.5 मा सेट गर्न सकिन्छ।

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) ले x को लोगारिदम y लाई आधारको रूपमा फर्काउँछ।

print(math.log(25, 5))
# 2.0

यदि दोस्रो तर्क मेटाइयो भने, प्राकृतिक लोगारिदम तल देखाइएको छ।

लोगारिदम

गणितमा, प्राकृतिक लोगारिदम (नेपियर नम्बर e को आधारको रूपमा लगरिदम), लग वा ln द्वारा प्रतिनिधित्व गरिएको, math.log(x) द्वारा गणना गर्न सकिन्छ।

print(math.log(math.e))
# 1.0

लघुगणक (आधार १०)

साधारण लोगारिदम (आधार 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