Python ប្រភេទកុំផ្លិចដើម្បីធ្វើការជាមួយចំនួនកុំផ្លិច (តម្លៃដាច់ខាត ការធ្លាក់ចុះ ការបំប្លែងរាងប៉ូល ។ល។)

Python មានប្រភេទស្តង់ដារសម្រាប់ដោះស្រាយចំនួនកុំផ្លិច គឺប្រភេទ 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 នោះការលុបវាបណ្តាលឱ្យមានកំហុសឈ្មោះ។ ប្រសិនបើអថេរដែលមានឈ្មោះ 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()

ដើម្បីទទួលបានលេខកុំផ្លិច ប្រើវិធី 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() ពួកគេអាចទទួលបានរួមគ្នាជា (តម្លៃដាច់ខាត ការថយចុះ) tuple ។

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

ការបំប្លែងពីកូអរដោនេប៉ូលទៅជាកូអរដោណេ Cartesian ត្រូវបានធ្វើដោយប្រើ 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)

ផ្នែកពិត និងស្រមើលស្រមៃគឺស្មើនឹងលទ្ធផលដែលគណនាដោយ cosine 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)