Python, kompleksityypit kompleksilukujen käsittelyä varten (absoluuttiset arvot, deklinaatio, polaarimuunnokset jne.).

liiketoiminta

Pythonissa on standardityyppi kompleksilukujen käsittelyyn, COMPLEX-tyyppi. Jos haluat tehdä vain yksinkertaisia laskutoimituksia, sinun ei tarvitse tuoda mitään moduuleja, mutta jos tuot standardikirjaston cmath, voit käyttää myös matemaattisia funktioita (eksponentiaalisia, logaritmisia, trigonometrisia jne.), jotka vastaavat kompleksilukuja.

Seuraavat sisällöt selitetään tässä esimerkkikoodin avulla.

  • Monimutkaisten muuttujien luominen
  • Hanki todelliset ja kuvitteelliset osat:real,imagattribuutti
  • Hae konjugoidut kompleksiluvut:conjugate()menetelmä
  • Hae absoluuttinen arvo (suuruus):abs()toiminto (esim. matematiikka, ohjelmointi, ohjelmointi)
  • Hanki deklinaatio (vaihe):math,cmathmoduuli
  • Polaarikoordinaattimuunnos (polaarimuotoinen esitys):math,cmathmoduuli
  • Kompleksilukujen laskeminen (kvadratuuri, potenssit, neliöjuuret)

Monimutkaisten muuttujien luominen

Merkitään imaginääriyksikköä j:llä ja kirjoitetaan seuraava, huomaa, että se ei ole i.

c = 3 + 4j

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

Jos imaginääriosa on 1, sen poisjättäminen aiheuttaa NameError-virheen. Jos muuttuja nimeltä j on määritelty ensin, sen katsotaan olevan kyseinen muuttuja.

1j
Se olisi ilmaistava nimenomaisesti näin.

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

c = 3 + 1j

print(c)
# (3+1j)

Jos reaaliosa on 0, se voidaan jättää pois.

c = 3j

print(c)
# 3j

Jos haluat määritellä arvon, jonka imaginääriosa on 0, kompleksiseksi kompleksityypiksi, kirjoita 0 nimenomaisesti. Kuten jäljempänä kuvataan, kompleksityypin ja kokonaislukutyypin tai liukulukutyypin välillä voidaan suorittaa operaatioita.

c = 3 + 0j

print(c)
# (3+0j)

Reaali- ja imaginaariosat voidaan määrittää liukulukutyyppisinä liukulukuna. Eksponentiaalinen merkintätapa on myös hyväksyttävä.

c = 1.2e3 + 3j

print(c)
# (1200+3j)

Se voidaan luoda myös konstruktorilla, jonka tyyppi on ”complex”, kuten ”complex(real part, imaginary part)”.

c = complex(3, 4)

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

Kompleksilukujen reaali- ja imaginääriosien saaminen: real, imagattribuutti

Kompleksisen kompleksityypin reaali- ja imaginääriosat saadaan real- ja imag-attribuuttien avulla. Molemmat ovat liukulukutyyppejä.

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'>

Se on vain luettavissa, eikä sitä voi muuttaa.

# c.real = 5.5
# AttributeError: readonly attribute

Hae konjugoidut kompleksiluvut: conjugate()

Jos haluat saada konjugoituja kompleksilukuja, käytä conjugate()-menetelmää.

c = 3 + 4j

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

Kompleksiluvun absoluuttisen arvon (suuruuden) saaminen.: abs()

Kompleksiluvun absoluuttinen arvo (suuruus) saadaan käyttämällä sisäänrakennettua funktiota abs().

c = 3 + 4j

print(abs(c))
# 5.0

c = 1 + 1j

print(abs(c))
# 1.4142135623730951

Kompleksiluvun deklinaation (vaiheen) saaminen: math, cmathmoduuli

Jos haluat saada kompleksiluvun deklinaation (vaiheen), käytä math- tai cmath-moduulia.

cmath-moduuli on matemaattinen funktiomoduuli kompleksilukuja varten.

Se voidaan laskea käänteisellä tangenttifunktiolla math.atan2(), kuten määritelty, tai käyttämällä cmath.phase(), joka palauttaa deklinaation (vaiheen).

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

Molemmissa tapauksissa kulman yksikkö, joka saadaan, on radiaani. Voit muuntaa asteiksi käyttämällä math.degrees().

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

Kompleksilukujen polaarikoordinaattimuunnos (polaarimuotoinen esitys): math, cmathmoduuli

Kuten edellä mainittiin, kompleksiluvun absoluuttinen arvo (magnitudi) ja deklinaatio (vaihe) voidaan saada, mutta käyttämällä cmath.polar() -toimintoa ne voidaan saada yhdessä (absoluuttinen arvo, deklinaatio) -tuplina.

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

Muunnos polaarikoordinaateista kartesiankoordinaatteihin tehdään käyttämällä cmath.rect(). cmath.rect(absoluuttinen arvo, poikkeama) ja vastaavia argumentteja voidaan käyttää vastaavan kompleksikompleksityypin arvojen saamiseksi.

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)

Reaali- ja imaginääriosat vastaavat tuloksia, jotka lasketaan absoluuttisista arvoista ja deklinaatiokulmista cosinus math.cos() ja sinus math.sin() avulla.

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

Kompleksilukujen laskeminen (kvadratuuri, potenssit, neliöjuuret)

Neljä aritmeettista operaatiota ja potenssilaskut voidaan suorittaa tavallisilla aritmeettisilla operaattoreilla.

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)

Neliöjuuri voidaan laskea **0.5:llä, mutta se aiheuttaa virheen. cmath.sqrt():n avulla voidaan laskea tarkka arvo.

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

Se voi myös suorittaa aritmeettisia operaatioita kompleksityypeillä, int-tyypeillä ja float-tyypeillä.

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

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