ਪਾਈਥਨ, ਗੁੰਝਲਦਾਰ ਸੰਖਿਆਵਾਂ (ਪੂਰਨ ਮੁੱਲ, ਗਿਰਾਵਟ, ਧਰੁਵੀ ਪਰਿਵਰਤਨ, ਆਦਿ) ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਗੁੰਝਲਦਾਰ ਕਿਸਮਾਂ।

ਪਾਈਥਨ ਕੋਲ ਗੁੰਝਲਦਾਰ ਸੰਖਿਆਵਾਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਇੱਕ ਮਿਆਰੀ ਕਿਸਮ ਹੈ, COMPLEX ਕਿਸਮ। ਜੇਕਰ ਤੁਸੀਂ ਸਿਰਫ਼ ਸਧਾਰਨ ਗਣਨਾ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਕੋਈ ਵੀ ਮਾਡਿਊਲ ਆਯਾਤ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ, ਪਰ ਜੇਕਰ ਤੁਸੀਂ ਮਿਆਰੀ ਲਾਇਬ੍ਰੇਰੀ cmath ਨੂੰ ਆਯਾਤ ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਗੁੰਝਲਦਾਰ ਸੰਖਿਆਵਾਂ ਦੇ ਅਨੁਸਾਰੀ ਗਣਿਤਿਕ ਫੰਕਸ਼ਨਾਂ (ਘਾਤ-ਅੰਕ, ਲਘੂਗਣਕ, ਤਿਕੋਣਮਿਤੀ, ਆਦਿ) ਦੀ ਵਰਤੋਂ ਵੀ ਕਰ ਸਕਦੇ ਹੋ।

• cmath — Mathematical functions for complex numbers — Python 3.10.4 Documentation

ਹੇਠ ਲਿਖੀਆਂ ਸਮੱਗਰੀਆਂ ਨੂੰ ਇੱਥੇ ਨਮੂਨਾ ਕੋਡ ਨਾਲ ਸਮਝਾਇਆ ਗਿਆ ਹੈ।

• ਗੁੰਝਲਦਾਰ ਵੇਰੀਏਬਲ ਤਿਆਰ ਕਰੋ
• ਅਸਲੀ ਅਤੇ ਕਾਲਪਨਿਕ ਹਿੱਸੇ ਪ੍ਰਾਪਤ ਕਰੋ:real,imagਵਿਸ਼ੇਸ਼ਤਾ
• ਸੰਯੁਕਤ ਮਿਸ਼ਰਿਤ ਸੰਖਿਆਵਾਂ ਪ੍ਰਾਪਤ ਕਰੋ:conjugate()ਢੰਗ
• ਪੂਰਨ ਮੁੱਲ (ਮਾਪ) ਪ੍ਰਾਪਤ ਕਰੋ:abs()ਫੰਕਸ਼ਨ (ਉਦਾਹਰਨ ਲਈ ਗਣਿਤ, ਪ੍ਰੋਗਰਾਮਿੰਗ, ਪ੍ਰੋਗਰਾਮਿੰਗ)
• ਗਿਰਾਵਟ ਪ੍ਰਾਪਤ ਕਰੋ (ਪੜਾਅ):math,cmathਮੋਡੀਊਲ
• ਪੋਲਰ ਕੋਆਰਡੀਨੇਟ ਪਰਿਵਰਤਨ (ਧਰੁਵੀ ਰੂਪ ਦੀ ਨੁਮਾਇੰਦਗੀ):math,cmathਮੋਡੀਊਲ
• ਕੰਪਲੈਕਸ ਨੰਬਰਾਂ ਦੀ ਗਣਨਾ (ਚਤੁਰਭੁਜ, ਸ਼ਕਤੀਆਂ, ਵਰਗ ਜੜ੍ਹ)

ਗੁੰਝਲਦਾਰ ਵੇਰੀਏਬਲ ਤਿਆਰ ਕਰੋ

ਕਾਲਪਨਿਕ ਇਕਾਈ ਨੂੰ j ਦੁਆਰਾ ਦਰਸਾਓ ਅਤੇ ਹੇਠਾਂ ਲਿਖੋ, ਨੋਟ ਕਰੋ ਕਿ ਇਹ i ਨਹੀਂ ਹੈ।

c = 3 + 4j

print(c)
print(type(c))
# (3+4j)
# <class 'complex'>

ਜੇਕਰ ਕਾਲਪਨਿਕ ਭਾਗ 1 ਹੈ, ਤਾਂ ਇਸਨੂੰ ਛੱਡਣ ਨਾਲ NameError ਹੋ ਜਾਂਦੀ ਹੈ। ਜੇ j ਨਾਮਕ ਵੇਰੀਏਬਲ ਨੂੰ ਪਹਿਲਾਂ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਹ ਉਹ ਵੇਰੀਏਬਲ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ।

1j
ਇਸ ਨੂੰ ਇਸ ਤਰੀਕੇ ਨਾਲ ਸਪੱਸ਼ਟ ਤੌਰ ‘ਤੇ ਕਿਹਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ.

# c = 3 + j
# NameError: name 'j' is not defined

c = 3 + 1j

print(c)
# (3+1j)

ਜੇਕਰ ਅਸਲੀ ਹਿੱਸਾ 0 ਹੈ, ਤਾਂ ਇਸਨੂੰ ਛੱਡਿਆ ਜਾ ਸਕਦਾ ਹੈ।

c = 3j

print(c)
# 3j

ਜੇਕਰ ਤੁਸੀਂ 0 ਦੇ ਇੱਕ ਕਾਲਪਨਿਕ ਹਿੱਸੇ ਵਾਲੇ ਮੁੱਲ ਨੂੰ ਇੱਕ ਗੁੰਝਲਦਾਰ ਗੁੰਝਲਦਾਰ ਕਿਸਮ ਦੇ ਰੂਪ ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ 0 ਨੂੰ ਸਪਸ਼ਟ ਰੂਪ ਵਿੱਚ ਲਿਖੋ। ਜਿਵੇਂ ਕਿ ਹੇਠਾਂ ਦੱਸਿਆ ਗਿਆ ਹੈ, ਓਪਰੇਸ਼ਨ ਗੁੰਝਲਦਾਰ ਕਿਸਮ ਅਤੇ ਪੂਰਨ ਅੰਕ ਕਿਸਮ ਜਾਂ ਫਲੋਟਿੰਗ-ਪੁਆਇੰਟ ਕਿਸਮ ਦੇ ਵਿਚਕਾਰ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ।

c = 3 + 0j

print(c)
# (3+0j)

ਅਸਲ ਅਤੇ ਕਾਲਪਨਿਕ ਭਾਗਾਂ ਨੂੰ ਫਲੋਟਿੰਗ-ਪੁਆਇੰਟ ਫਲੋਟ ਕਿਸਮ ਦੇ ਤੌਰ ਤੇ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਘਾਤਕ ਸੰਕੇਤ ਵੀ ਸਵੀਕਾਰਯੋਗ ਹੈ।

c = 1.2e3 + 3j

print(c)
# (1200+3j)

ਇਹ “ਕੰਪਲੈਕਸ” ਕਿਸਮ ਦੇ ਕੰਸਟਰਕਟਰ ਦੁਆਰਾ ਵੀ ਤਿਆਰ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ “ਕੰਪਲੈਕਸ(ਅਸਲ ਭਾਗ, ਕਾਲਪਨਿਕ ਭਾਗ)” ਵਿੱਚ।

c = complex(3, 4)

print(c)
print(type(c))
# (3+4j)
# <class 'complex'>

ਗੁੰਝਲਦਾਰ ਸੰਖਿਆਵਾਂ ਦੇ ਅਸਲੀ ਅਤੇ ਕਾਲਪਨਿਕ ਹਿੱਸੇ ਪ੍ਰਾਪਤ ਕਰੋ:real,imagਵਿਸ਼ੇਸ਼ਤਾ

ਇੱਕ ਗੁੰਝਲਦਾਰ ਗੁੰਝਲਦਾਰ ਕਿਸਮ ਦੇ ਅਸਲ ਅਤੇ ਕਾਲਪਨਿਕ ਭਾਗਾਂ ਨੂੰ ਕ੍ਰਮਵਾਰ ਅਸਲ ਅਤੇ ਚਿੱਤਰ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨਾਲ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਦੋਵੇਂ ਫਲੋਟਿੰਗ-ਪੁਆਇੰਟ ਫਲੋਟ ਕਿਸਮਾਂ ਹਨ।

c = 3 + 4j

print(c.real)
print(type(c.real))
# 3.0
# <class 'float'>

print(c.imag)
print(type(c.imag))
# 4.0
# <class 'float'>

ਇਹ ਸਿਰਫ਼ ਪੜ੍ਹਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਬਦਲਿਆ ਨਹੀਂ ਜਾ ਸਕਦਾ।

# c.real = 5.5
# AttributeError: readonly attribute

ਸੰਯੁਕਤ ਮਿਸ਼ਰਿਤ ਸੰਖਿਆਵਾਂ ਪ੍ਰਾਪਤ ਕਰੋ:conjugate()

ਸੰਯੁਕਤ ਮਿਸ਼ਰਿਤ ਸੰਖਿਆਵਾਂ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ, ਸੰਯੁਕਤ() ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰੋ।

c = 3 + 4j

print(c.conjugate())
# (3-4j)

ਇੱਕ ਮਿਸ਼ਰਿਤ ਸੰਖਿਆ ਦਾ ਪੂਰਨ ਮੁੱਲ (ਮਾਪ) ਪ੍ਰਾਪਤ ਕਰੋ:abs()

ਇੱਕ ਮਿਸ਼ਰਿਤ ਸੰਖਿਆ ਦਾ ਸੰਪੂਰਨ ਮੁੱਲ (ਮਾਪ) ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ, ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ abs() ਦੀ ਵਰਤੋਂ ਕਰੋ।

c = 3 + 4j

print(abs(c))
# 5.0

c = 1 + 1j

print(abs(c))
# 1.4142135623730951

ਇੱਕ ਮਿਸ਼ਰਿਤ ਸੰਖਿਆ ਦਾ ਗਿਰਾਵਟ (ਪੜਾਅ) ਪ੍ਰਾਪਤ ਕਰੋ:math,cmathਮੋਡੀਊਲ

ਇੱਕ ਮਿਸ਼ਰਿਤ ਸੰਖਿਆ ਦੇ ਗਿਰਾਵਟ (ਪੜਾਅ) ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ, ਗਣਿਤ ਜਾਂ cmath ਮੋਡੀਊਲ ਦੀ ਵਰਤੋਂ ਕਰੋ।

cmath ਮੋਡੀਊਲ ਕੰਪਲੈਕਸ ਨੰਬਰਾਂ ਲਈ ਇੱਕ ਗਣਿਤਿਕ ਫੰਕਸ਼ਨ ਮੋਡੀਊਲ ਹੈ।

• cmath — Mathematical functions for complex numbers — Python 3.10.4 Documentation

ਇਸਨੂੰ ਉਲਟ ਟੈਂਜੈਂਟ ਫੰਕਸ਼ਨ math.atan2() ਨਾਲ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤੇ ਅਨੁਸਾਰ ਗਿਣਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਜਾਂ cmath.phase() ਦੀ ਵਰਤੋਂ ਕਰੋ, ਜੋ ਕਿ ਗਿਰਾਵਟ (ਪੜਾਅ) ਵਾਪਸ ਕਰਦਾ ਹੈ।

import cmath
import math

c = 1 + 1j

print(math.atan2(c.imag, c.real))
# 0.7853981633974483

print(cmath.phase(c))
# 0.7853981633974483

print(cmath.phase(c) == math.atan2(c.imag, c.real))
# True

ਦੋਵਾਂ ਮਾਮਲਿਆਂ ਵਿੱਚ, ਕੋਣ ਦੀ ਇਕਾਈ ਜੋ ਪ੍ਰਾਪਤ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ ਰੇਡੀਅਨ ਹੈ। ਡਿਗਰੀਆਂ ਵਿੱਚ ਬਦਲਣ ਲਈ, math.degrees() ਦੀ ਵਰਤੋਂ ਕਰੋ।

print(math.degrees(cmath.phase(c)))
# 45.0

ਗੁੰਝਲਦਾਰ ਸੰਖਿਆਵਾਂ ਦਾ ਪੋਲਰ ਕੋਆਰਡੀਨੇਟ ਪਰਿਵਰਤਨ (ਧਰੁਵੀ ਰਸਮੀ ਪ੍ਰਤੀਨਿਧਤਾ):math,cmathਮੋਡੀਊਲ

ਜਿਵੇਂ ਕਿ ਉੱਪਰ ਦੱਸਿਆ ਗਿਆ ਹੈ, ਇੱਕ ਮਿਸ਼ਰਿਤ ਸੰਖਿਆ ਦਾ ਸੰਪੂਰਨ ਮੁੱਲ (ਮਾਪ) ਅਤੇ ਗਿਰਾਵਟ (ਪੜਾਅ) ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਪਰ cmath.polar() ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਉਹਨਾਂ ਨੂੰ ਇੱਕ (ਪੂਰਨ ਮੁੱਲ, ਗਿਰਾਵਟ) ਟੂਪਲ ਦੇ ਰੂਪ ਵਿੱਚ ਇਕੱਠੇ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

c = 1 + 1j

print(cmath.polar(c))
print(type(cmath.polar(c)))
# (1.4142135623730951, 0.7853981633974483)
# <class 'tuple'>

print(cmath.polar(c)[0] == abs(c))
# True

print(cmath.polar(c)[1] == cmath.phase(c))
# True

cmath.rect() ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪੋਲਰ ਕੋਆਰਡੀਨੇਟਸ ਤੋਂ ਕਾਰਟੇਸੀਅਨ ਕੋਆਰਡੀਨੇਟਸ ਵਿੱਚ ਪਰਿਵਰਤਨ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। cmath.rect(ਸੰਪੂਰਨ ਮੁੱਲ, ਵਿਵਹਾਰ) ਅਤੇ ਸਮਾਨ ਆਰਗੂਮੈਂਟਾਂ ਦੀ ਵਰਤੋਂ ਬਰਾਬਰ ਕੰਪਲੈਕਸ ਕੰਪਲੈਕਸ ਕੰਪਲੈਕਸ ਕਿਸਮ ਦੇ ਮੁੱਲਾਂ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।

print(cmath.rect(1, 1))
# (0.5403023058681398+0.8414709848078965j)

print(cmath.rect(1, 0))
# (1+0j)

print(cmath.rect(cmath.polar(c)[0], cmath.polar(c)[1]))
# (1.0000000000000002+1j)

ਅਸਲ ਅਤੇ ਕਾਲਪਨਿਕ ਹਿੱਸੇ ਕੋਸਾਈਨ math.cos() ਅਤੇ sine math.sin() ਦੁਆਰਾ ਸੰਪੂਰਨ ਮੁੱਲਾਂ ਅਤੇ ਗਿਰਾਵਟ ਦੇ ਕੋਣਾਂ ਤੋਂ ਗਣਨਾ ਕੀਤੇ ਨਤੀਜਿਆਂ ਦੇ ਬਰਾਬਰ ਹਨ।

r = 2
ph = math.pi

print(cmath.rect(r, ph).real == r * math.cos(ph))
# True

print(cmath.rect(r, ph).imag == r * math.sin(ph))
# True

ਕੰਪਲੈਕਸ ਨੰਬਰਾਂ ਦੀ ਗਣਨਾ (ਚਤੁਰਭੁਜ, ਸ਼ਕਤੀਆਂ, ਵਰਗ ਜੜ੍ਹ)

ਚਾਰ ਗਣਿਤ ਕਿਰਿਆਵਾਂ ਅਤੇ ਪਾਵਰ ਗਣਨਾ ਆਮ ਗਣਿਤ ਦੇ ਓਪਰੇਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।

c1 = 3 + 4j
c2 = 2 - 1j

print(c1 + c2)
# (5+3j)

print(c1 - c2)
# (1+5j)

print(c1 * c2)
# (10+5j)

print(c1 / c2)
# (0.4+2.2j)

print(c1 ** 3)
# (-117+44j)

ਵਰਗ ਰੂਟ ਦੀ ਗਣਨਾ **0.5 ਨਾਲ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ, ਪਰ ਇਹ ਗਲਤੀ ਪੇਸ਼ ਕਰਦਾ ਹੈ। cmath.sqrt() ਨੂੰ ਸਹੀ ਮੁੱਲ ਦੀ ਗਣਨਾ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ।

print((-3 + 4j) ** 0.5)
# (1.0000000000000002+2j)

print((-1) ** 0.5)
# (6.123233995736766e-17+1j)

print(cmath.sqrt(-3 + 4j))
# (1+2j)

print(cmath.sqrt(-1))
# 1j

ਇਹ ਗੁੰਝਲਦਾਰ ਕਿਸਮਾਂ, ਇੰਟ ਕਿਸਮਾਂ, ਅਤੇ ਫਲੋਟ ਕਿਸਮਾਂ ਨਾਲ ਅੰਕਗਣਿਤ ਦੀਆਂ ਕਾਰਵਾਈਆਂ ਵੀ ਕਰ ਸਕਦਾ ਹੈ।

print(c1 + 3)
# (6+4j)

print(c1 * 0.5)
# (1.5+2j)