ਗਣਿਤ ਦੇ ਫੰਕਸ਼ਨਾਂ ਲਈ ਗਣਿਤ, ਪਾਈਥਨ ਦੇ ਸਟੈਂਡਰਡ ਮੋਡੀਊਲ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਤੁਸੀਂ ਤਿਕੋਣਮਿਤੀ ਫੰਕਸ਼ਨਾਂ (ਪਾਪ, ਕੋਸ, ਟੈਨ) ਅਤੇ ਉਲਟ ਤਿਕੋਣਮਿਤੀ ਫੰਕਸ਼ਨਾਂ (ਆਰਕਸੀਨ, ਆਰਕੋਸ, ਆਰਕਟਾਨ) ਦੀ ਗਣਨਾ ਕਰ ਸਕਦੇ ਹੋ।
ਹੇਠ ਲਿਖੀਆਂ ਸਮੱਗਰੀਆਂ ਨੂੰ ਇੱਥੇ ਨਮੂਨਾ ਕੋਡਾਂ ਨਾਲ ਸਮਝਾਇਆ ਗਿਆ ਹੈ।
- Pi (3.1415926..):
math.pi - ਕੋਣ ਰੂਪਾਂਤਰ (ਰੇਡੀਅਨ, ਡਿਗਰੀ):
math.degrees(),math.radians() - ਸਾਈਨ, ਉਲਟ ਸਾਈਨ:
math.sin(),math.asin() - ਕੋਸਾਈਨ, ਉਲਟ ਕੋਸਾਈਨ:
math.cos(),math.acos() - ਸਪਰਸ਼, ਉਲਟ ਸਪਰਸ਼:
math.tan(),math.atan(),math.atan2() - ਹੇਠਾਂ ਅੰਤਰ:
math.atan(),math.atan2()
Pi (3.1415926..):math.pi
Pi ਗਣਿਤ ਮੋਡੀਊਲ ਵਿੱਚ ਇੱਕ ਸਥਿਰ ਵਜੋਂ ਪ੍ਰਦਾਨ ਕੀਤਾ ਗਿਆ ਹੈ। ਇਹ ਹੇਠ ਲਿਖੇ ਅਨੁਸਾਰ ਪ੍ਰਗਟ ਕੀਤਾ ਗਿਆ ਹੈ.math.pi
import math
print(math.pi)
# 3.141592653589793
ਕੋਣ ਰੂਪਾਂਤਰ (ਰੇਡੀਅਨ, ਡਿਗਰੀ):math.degrees(),math.radians()
ਗਣਿਤ ਮੋਡੀਊਲ ਵਿੱਚ ਤਿਕੋਣਮਿਤੀ ਅਤੇ ਉਲਟ ਤਿਕੋਣਮਿਤੀ ਫੰਕਸ਼ਨ ਰੇਡੀਅਨ ਨੂੰ ਕੋਣ ਦੀ ਇਕਾਈ ਵਜੋਂ ਵਰਤਦੇ ਹਨ।
ਰੇਡੀਅਨਾਂ (ਆਰਕ ਡਿਗਰੀ ਵਿਧੀ) ਅਤੇ ਡਿਗਰੀ (ਡਿਗਰੀ ਵਿਧੀ) ਵਿਚਕਾਰ ਬਦਲਣ ਲਈ math.degrees() ਅਤੇ math.radians() ਦੀ ਵਰਤੋਂ ਕਰੋ।
Math.degrees() ਰੇਡੀਅਨ ਤੋਂ ਡਿਗਰੀ ਵਿੱਚ ਬਦਲਦਾ ਹੈ, ਅਤੇ math.radians() ਡਿਗਰੀ ਤੋਂ ਰੇਡੀਅਨ ਵਿੱਚ ਬਦਲਦਾ ਹੈ।
print(math.degrees(math.pi))
# 180.0
print(math.radians(180))
# 3.141592653589793
ਸਾਈਨ, ਉਲਟ ਸਾਈਨ:math.sin(),math.asin()
ਸਾਈਨ (ਪਾਪ) ਨੂੰ ਲੱਭਣ ਲਈ ਫੰਕਸ਼ਨ math.sin() ਹੈ ਅਤੇ ਉਲਟ ਸਾਈਨ (arcsin) ਨੂੰ ਲੱਭਣ ਲਈ ਫੰਕਸ਼ਨ math.asin() ਹੈ।
ਇੱਥੇ ਡਿਗਰੀ ਨੂੰ ਰੇਡੀਅਨ ਵਿੱਚ ਬਦਲਣ ਲਈ math.radians() ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, 30 ਡਿਗਰੀ ਦੀ ਸਾਈਨ ਲੱਭਣ ਦੀ ਇੱਕ ਉਦਾਹਰਨ ਹੈ।
sin30 = math.sin(math.radians(30))
print(sin30)
# 0.49999999999999994
30 ਡਿਗਰੀ ਦਾ ਸਾਈਨ 0.5 ਹੈ, ਪਰ ਇੱਕ ਤਰੁੱਟੀ ਹੈ ਕਿਉਂਕਿ ਪਾਈ, ਇੱਕ ਅਸਪਸ਼ਟ ਸੰਖਿਆ, ਦੀ ਸਹੀ ਗਣਨਾ ਨਹੀਂ ਕੀਤੀ ਜਾ ਸਕਦੀ।
ਜੇਕਰ ਤੁਸੀਂ ਅੰਕਾਂ ਦੀ ਉਚਿਤ ਸੰਖਿਆ ਤੱਕ ਗੋਲ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ round() ਫੰਕਸ਼ਨ ਜਾਂ ਫਾਰਮੈਟ() ਵਿਧੀ ਜਾਂ ਫਾਰਮੈਟ() ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
ਨੋਟ ਕਰੋ ਕਿ round() ਦਾ ਵਾਪਸੀ ਮੁੱਲ ਇੱਕ ਨੰਬਰ (ਇੰਟ ਜਾਂ ਫਲੋਟ) ਹੈ, ਪਰ ਫਾਰਮੈਟ() ਦਾ ਵਾਪਸੀ ਮੁੱਲ ਇੱਕ ਸਤਰ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਇਸ ਨੂੰ ਅਗਲੀਆਂ ਗਣਨਾਵਾਂ ਲਈ ਵਰਤਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ round() ਦੀ ਵਰਤੋਂ ਕਰੋ।
print(round(sin30, 3))
print(type(round(sin30, 3)))
# 0.5
# <class 'float'>
print('{:.3}'.format(sin30))
print(type('{:.3}'.format(sin30)))
# 0.5
# <class 'str'>
print(format(sin30, '.3'))
print(type(format(sin30, '.3')))
# 0.5
# <class 'str'>
round() ਫੰਕਸ਼ਨ ਦਸ਼ਮਲਵ ਸਥਾਨਾਂ ਦੀ ਸੰਖਿਆ ਨੂੰ ਇਸਦੇ ਦੂਜੇ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਦਰਸਾਉਂਦਾ ਹੈ। ਨੋਟ ਕਰੋ ਕਿ ਇਹ ਸਖਤੀ ਨਾਲ ਗੋਲ ਨਹੀਂ ਹੈ। ਵੇਰਵਿਆਂ ਲਈ ਅਗਲਾ ਲੇਖ ਦੇਖੋ।
ਫਾਰਮੈਟ() ਵਿਧੀ ਅਤੇ ਫਾਰਮੈਟ() ਫੰਕਸ਼ਨ ਫਾਰਮੈਟਿੰਗ ਨਿਰਧਾਰਨ ਸਤਰ ਵਿੱਚ ਦਸ਼ਮਲਵ ਸਥਾਨਾਂ ਦੀ ਸੰਖਿਆ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ। ਵੇਰਵਿਆਂ ਲਈ ਅਗਲਾ ਲੇਖ ਦੇਖੋ।
ਜੇਕਰ ਤੁਸੀਂ ਤੁਲਨਾ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ math.isclose() ਦੀ ਵਰਤੋਂ ਵੀ ਕਰ ਸਕਦੇ ਹੋ।
print(math.isclose(sin30, 0.5))
# True
ਇਸੇ ਤਰ੍ਹਾਂ, ਇੱਥੇ 0.5 ਦੇ ਉਲਟ ਸਾਈਨ ਨੂੰ ਲੱਭਣ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈ। math.asin() ਰੇਡੀਅਨ ਵਾਪਸ ਕਰਦਾ ਹੈ, ਜੋ math.degrees() ਨਾਲ ਡਿਗਰੀਆਂ ਵਿੱਚ ਬਦਲਿਆ ਜਾਂਦਾ ਹੈ।
asin05 = math.degrees(math.asin(0.5))
print(asin05)
# 29.999999999999996
print(round(asin05, 3))
# 30.0
ਕੋਸਾਈਨ, ਉਲਟ ਕੋਸਾਈਨ:math.cos(),math.acos()
ਕੋਸਾਈਨ (cos) ਨੂੰ ਲੱਭਣ ਲਈ ਫੰਕਸ਼ਨ ਹੈ math.cos(), ਅਤੇ ਉਲਟ ਕੋਸਾਈਨ (arc cosine, arccos) ਨੂੰ ਲੱਭਣ ਲਈ ਫੰਕਸ਼ਨ math.acos() ਹੈ।
ਇੱਥੇ 60 ਡਿਗਰੀ ਦੇ ਕੋਸਾਈਨ ਅਤੇ 0.5 ਦੇ ਉਲਟ ਕੋਸਾਈਨ ਨੂੰ ਲੱਭਣ ਦਾ ਇੱਕ ਉਦਾਹਰਨ ਹੈ।
print(math.cos(math.radians(60)))
# 0.5000000000000001
print(math.degrees(math.acos(0.5)))
# 59.99999999999999
ਜੇਕਰ ਤੁਸੀਂ ਢੁਕਵੇਂ ਅੰਕ ਨੂੰ ਗੋਲ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ round() ਜਾਂ ਫਾਰਮੈਟ() ਨੂੰ ਸਾਈਨ ਦੇ ਨਾਲ ਵਰਤ ਸਕਦੇ ਹੋ।
ਸਪਰਸ਼, ਉਲਟ ਸਪਰਸ਼:math.tan(),math.atan(),math.atan2()
ਟੈਂਜੈਂਟ (tan) ਨੂੰ ਲੱਭਣ ਲਈ ਫੰਕਸ਼ਨ math.tan(), ਅਤੇ ਉਲਟ ਟੈਂਜੈਂਟ (ਆਰਕਟਾਨ) ਨੂੰ ਲੱਭਣ ਲਈ ਫੰਕਸ਼ਨ math.atan() ਜਾਂ math.atan2() ਹੈ।
Math.atan2() ਦਾ ਵਰਣਨ ਬਾਅਦ ਵਿੱਚ ਕੀਤਾ ਗਿਆ ਹੈ।
45 ਡਿਗਰੀ ਦੀ ਟੈਂਜੈਂਟ ਅਤੇ 1 ਡਿਗਰੀ ਦੇ ਉਲਟ ਸਪਰਸ਼ ਨੂੰ ਲੱਭਣ ਦੀ ਇੱਕ ਉਦਾਹਰਨ ਹੇਠਾਂ ਦਿਖਾਈ ਗਈ ਹੈ।
print(math.tan(math.radians(45)))
# 0.9999999999999999
print(math.degrees(math.atan(1)))
# 45.0
math.atan() ਅਤੇ math.atan2() ਵਿਚਕਾਰ ਅੰਤਰ
math.atan() ਅਤੇ math.atan2() ਦੋਵੇਂ ਅਜਿਹੇ ਫੰਕਸ਼ਨ ਹਨ ਜੋ ਉਲਟ ਟੈਂਜੈਂਟ ਵਾਪਸ ਕਰਦੇ ਹਨ, ਪਰ ਉਹ ਆਰਗੂਮੈਂਟਾਂ ਦੀ ਸੰਖਿਆ ਅਤੇ ਵਾਪਸੀ ਮੁੱਲਾਂ ਦੀ ਰੇਂਜ ਵਿੱਚ ਵੱਖਰੇ ਹੁੰਦੇ ਹਨ।
math.atan(x) ਕੋਲ ਇੱਕ ਆਰਗੂਮੈਂਟ ਹੈ ਅਤੇ ਰੇਡੀਅਨ ਵਿੱਚ ਆਰਕਟਾਨ(x) ਵਾਪਸ ਕਰਦਾ ਹੈ। ਵਾਪਸੀ ਦਾ ਮੁੱਲ -pi \ 2 ਅਤੇ pi \ 2 (-90 ਤੋਂ 90 ਡਿਗਰੀ) ਦੇ ਵਿਚਕਾਰ ਹੋਵੇਗਾ।
print(math.degrees(math.atan(0)))
# 0.0
print(math.degrees(math.atan(1)))
# 45.0
print(math.degrees(math.atan(-1)))
# -45.0
print(math.degrees(math.atan(math.inf)))
# 90.0
print(math.degrees(math.atan(-math.inf)))
# -90.0
ਉਪਰੋਕਤ ਉਦਾਹਰਨ ਵਿੱਚ, math.inf ਅਨੰਤਤਾ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ।
math.atan2(y, x) ਦੇ ਦੋ ਆਰਗੂਮੈਂਟ ਹਨ ਅਤੇ ਰੇਡੀਅਨ ਵਿੱਚ ਆਰਕਟਾਨ(y \ x) ਵਾਪਸ ਕਰਦਾ ਹੈ। ਇਹ ਕੋਣ ਉਹ ਕੋਣ (ਡਿਕਲੀਨੇਸ਼ਨ) ਹੈ ਜੋ ਵੈਕਟਰ ਮੂਲ ਤੋਂ ਕੋਆਰਡੀਨੇਟਸ (x, y) ਤੱਕ ਧਰੁਵੀ ਕੋਆਰਡੀਨੇਟ ਸਮਤਲ ਵਿੱਚ x ਧੁਰੀ ਦੀ ਸਕਾਰਾਤਮਕ ਦਿਸ਼ਾ ਨਾਲ ਬਣਾਉਂਦਾ ਹੈ, ਅਤੇ ਵਾਪਸ ਕੀਤਾ ਮੁੱਲ -pi ਅਤੇ pi (-180) ਵਿਚਕਾਰ ਹੁੰਦਾ ਹੈ। 180 ਡਿਗਰੀ ਤੱਕ)
ਕਿਉਂਕਿ ਦੂਜੇ ਅਤੇ ਤੀਜੇ ਚਤੁਰਭੁਜ ਵਿੱਚ ਕੋਣ ਵੀ ਸਹੀ ਢੰਗ ਨਾਲ ਪ੍ਰਾਪਤ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ, ਧਰੁਵੀ ਕੋਆਰਡੀਨੇਟ ਸਮਤਲ ‘ਤੇ ਵਿਚਾਰ ਕਰਦੇ ਸਮੇਂ math.atan2() math.atan() ਨਾਲੋਂ ਵਧੇਰੇ ਉਚਿਤ ਹੈ।
ਧਿਆਨ ਦਿਓ ਕਿ ਆਰਗੂਮੈਂਟਾਂ ਦਾ ਕ੍ਰਮ y, x, x, y ਨਹੀਂ ਹੈ।
print(math.degrees(math.atan2(0, 1)))
# 0.0
print(math.degrees(math.atan2(1, 1)))
# 45.0
print(math.degrees(math.atan2(1, 0)))
# 90.0
print(math.degrees(math.atan2(1, -1)))
# 135.0
print(math.degrees(math.atan2(0, -1)))
# 180.0
print(math.degrees(math.atan2(-1, -1)))
# -135.0
print(math.degrees(math.atan2(-1, 0)))
# -90.0
print(math.degrees(math.atan2(-1, 1)))
# -45.0
ਜਿਵੇਂ ਕਿ ਉੱਪਰ ਦਿੱਤੀ ਉਦਾਹਰਨ ਵਿੱਚ, x-ਧੁਰੇ ਦੀ ਨਕਾਰਾਤਮਕ ਦਿਸ਼ਾ (y ਜ਼ੀਰੋ ਹੈ ਅਤੇ x ਨੈਗੇਟਿਵ ਹੈ) pi (180 ਡਿਗਰੀ) ਹੈ, ਪਰ ਜਦੋਂ y ਨੈਗੇਟਿਵ ਜ਼ੀਰੋ ਹੈ, ਤਾਂ ਇਹ -pi (-180 ਡਿਗਰੀ) ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਨਿਸ਼ਾਨ ਨੂੰ ਸਖਤੀ ਨਾਲ ਸੰਭਾਲਣਾ ਚਾਹੁੰਦੇ ਹੋ ਤਾਂ ਸਾਵਧਾਨ ਰਹੋ।
print(math.degrees(math.atan2(-0.0, -1)))
# -180.0
ਨੈਗੇਟਿਵ ਜ਼ੀਰੋ ਹੇਠਾਂ ਦਿੱਤੇ ਓਪਰੇਸ਼ਨਾਂ ਦਾ ਨਤੀਜਾ ਹਨ
print(-1 / math.inf)
# -0.0
print(-1.0 * 0.0)
# -0.0
ਪੂਰਨ ਅੰਕਾਂ ਨੂੰ ਨੈਗੇਟਿਵ ਜ਼ੀਰੋ ਨਹੀਂ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ।
print(-0.0)
# -0.0
print(-0)
# 0
ਭਾਵੇਂ x ਅਤੇ y ਦੋਵੇਂ ਜ਼ੀਰੋ ਹੋਣ, ਨਤੀਜਾ ਨਿਸ਼ਾਨ ‘ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ।
print(math.degrees(math.atan2(0.0, 0.0)))
# 0.0
print(math.degrees(math.atan2(-0.0, 0.0)))
# -0.0
print(math.degrees(math.atan2(-0.0, -0.0)))
# -180.0
print(math.degrees(math.atan2(0.0, -0.0)))
# 180.0
ਅਜਿਹੀਆਂ ਹੋਰ ਉਦਾਹਰਣਾਂ ਹਨ ਜਿੱਥੇ ਨਤੀਜੇ ਦਾ ਚਿੰਨ੍ਹ ਨਕਾਰਾਤਮਕ ਜ਼ੀਰੋ ‘ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ math.atan2() ਦੇ ਨਾਲ ਨਾਲ math.sin(), math.asin(), math.tan(), ਅਤੇ math.atan() .
print(math.sin(0.0))
# 0.0
print(math.sin(-0.0))
# -0.0
print(math.asin(0.0))
# 0.0
print(math.asin(-0.0))
# -0.0
print(math.tan(0.0))
# 0.0
print(math.tan(-0.0))
# -0.0
print(math.atan(0.0))
# 0.0
print(math.atan(-0.0))
# -0.0
print(math.atan2(0.0, 1.0))
# 0.0
print(math.atan2(-0.0, 1.0))
# -0.0
ਨੋਟ ਕਰੋ ਕਿ ਹੁਣ ਤੱਕ ਦੀਆਂ ਉਦਾਹਰਣਾਂ CPython ਵਿੱਚ ਪ੍ਰੋਗਰਾਮ ਚਲਾਉਣ ਦੇ ਨਤੀਜੇ ਹਨ। ਨੋਟ ਕਰੋ ਕਿ ਹੋਰ ਲਾਗੂਕਰਨ ਜਾਂ ਵਾਤਾਵਰਣ ਨਕਾਰਾਤਮਕ ਜ਼ੀਰੋ ਨੂੰ ਵੱਖਰੇ ਢੰਗ ਨਾਲ ਸੰਭਾਲ ਸਕਦੇ ਹਨ।
