ਗਣਿਤ, ਗਣਿਤਕ ਫੰਕਸ਼ਨਾਂ ਲਈ ਪਾਈਥਨ ਦੇ ਮਿਆਰੀ ਮੋਡੀਊਲ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਤੁਸੀਂ ਘਾਤ ਅੰਕੀ ਅਤੇ ਲਘੂਗਣਕ ਫੰਕਸ਼ਨਾਂ (ਕੁਦਰਤੀ ਲਘੂਗਣਕ, ਆਮ ਲਘੂਗਣਕ, ਅਤੇ ਬਾਈਨਰੀ ਲਘੂਗਣਕ) ਦੀ ਗਣਨਾ ਕਰ ਸਕਦੇ ਹੋ।
ਇੱਥੇ ਨਮੂਨਾ ਕੋਡ ਦੇ ਨਾਲ ਹੇਠਾਂ ਵਿਆਖਿਆ ਕੀਤੀ ਗਈ ਹੈ।
- ਕੁਦਰਤੀ ਲਘੂਗਣਕ ਦਾ ਆਧਾਰ (ਨੇਪੀਅਰ ਨੰਬਰ):
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**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()
ਵਰਗ ਮੂਲ (ਰੂਟ) ਨੂੰ ** ਜਾਂ 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()
ਕੁਦਰਤੀ ਲਘੂਗਣਕ (ਨੈਪੀਅਰ ਨੰਬਰ) e ਦੇ ਅਧਾਰ ਦੀ ਸ਼ਕਤੀ ਦੀ ਗਣਨਾ ਕਰਨ ਲਈ, 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 ਦੁਆਰਾ ਦਰਸਾਏ ਗਏ ਕੁਦਰਤੀ ਲਘੂਗਣਕ (ਨੇਪੀਅਰ ਨੰਬਰ e ਦੇ ਨਾਲ ਅਧਾਰ ਦੇ ਰੂਪ ਵਿੱਚ ਲੋਗਰਾਰਿਥਮ) ਦੀ ਗਣਨਾ 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
