पाइथनसँग जटिल संख्याहरू ह्यान्डल गर्नको लागि मानक प्रकार छ, COMPLEX प्रकार। यदि तपाइँ केवल साधारण गणनाहरू गर्न चाहनुहुन्छ भने, तपाइँले कुनै मोड्युलहरू आयात गर्न आवश्यक पर्दैन, तर यदि तपाइँ मानक पुस्तकालय cmath आयात गर्नुहुन्छ भने, तपाइँ जटिल संख्याहरूसँग सम्बन्धित गणितीय प्रकार्यहरू (घातांक, लॉगरिदमिक, त्रिकोणमितीय, आदि) प्रयोग गर्न सक्नुहुन्छ।
निम्न सामग्रीहरू यहाँ नमूना कोडको साथ व्याख्या गरिएको छ।
- जटिल चर उत्पन्न गर्नुहोस्
- वास्तविक र काल्पनिक भागहरू प्राप्त गर्नुहोस्:
real,imagविशेषता - संयुग्मित जटिल संख्याहरू प्राप्त गर्नुहोस्:
conjugate()विधि - निरपेक्ष मान प्राप्त गर्नुहोस् (परिमाण):
abs()प्रकार्य (जस्तै गणित, प्रोग्रामिङ, प्रोग्रामिङ) - अस्वीकार प्राप्त गर्नुहोस् (चरण):
math,cmathमोड्युल - ध्रुवीय समन्वय रूपान्तरण (ध्रुवीय रूप प्रतिनिधित्व):
math,cmathमोड्युल - जटिल संख्याहरूको गणना (चतुर्भुज, शक्ति, वर्गमूल)
- जटिल चर उत्पन्न गर्नुहोस्
- जटिल संख्याहरूको वास्तविक र काल्पनिक भागहरू प्राप्त गर्नुहोस्:real,imagविशेषता
- संयुग्मित जटिल संख्याहरू प्राप्त गर्नुहोस्:conjugate()
- जटिल संख्याको निरपेक्ष मान (परिमाण) प्राप्त गर्नुहोस्:abs()
- जटिल संख्याको अस्वीकरण (चरण) प्राप्त गर्नुहोस्:math,cmathमोड्युल
- जटिल संख्याहरूको ध्रुवीय समन्वय रूपान्तरण (ध्रुवीय औपचारिक प्रतिनिधित्व):math,cmathमोड्युल
- जटिल संख्याहरूको गणना (चतुर्भुज, शक्ति, वर्गमूल)
जटिल चर उत्पन्न गर्नुहोस्
काल्पनिक एकाइलाई j द्वारा बुझाउनुहोस् र निम्न लेख्नुहोस्, यो i होइन भनेर ध्यान दिनुहोस्।
c = 3 + 4j
print(c)
print(type(c))
# (3+4j)
# <class 'complex'>
यदि काल्पनिक भाग १ हो भने, यसलाई छोड्दा NameError हुन्छ। यदि j नामक चरलाई पहिले परिभाषित गरिएको छ भने, यो चर मानिन्छ।
1j
यसलाई यसरी स्पष्ट रूपमा भन्नु पर्छ।
# c = 3 + j
# NameError: name 'j' is not defined
c = 3 + 1j
print(c)
# (3+1j)
यदि वास्तविक भाग ० छ भने, यसलाई हटाउन सकिन्छ।
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()
conjugate जटिल संख्याहरू प्राप्त गर्न, 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 मोड्युल जटिल संख्याहरूको लागि गणितीय प्रकार्य मोड्युल हो।
यसलाई व्युत्क्रम ट्यान्जेन्ट प्रकार्य 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
यसले जटिल प्रकारहरू, int प्रकारहरू, र फ्लोट प्रकारहरूसँग अंकगणितीय कार्यहरू पनि गर्न सक्छ।
print(c1 + 3)
# (6+4j)
print(c1 * 0.5)
# (1.5+2j)
