Python har en standardtyp för att hantera komplexa tal, COMPLEX-typen. Om du bara vill göra enkla beräkningar behöver du inte importera några moduler, men om du importerar standardbiblioteket cmath kan du också använda matematiska funktioner (exponentiella, logaritmiska, trigonometriska osv.) som motsvarar komplexa tal.
Följande innehåll förklaras här med exempelkod.
- Generera komplexa variabler
- Få fram reella och imaginära delar:
real,imagattribut - Få konjugerade komplexa tal:
conjugate()metod - Hämta absolut värde (magnitud):
abs()funktion (t.ex. matematik, programmering, programmering) - Skaffa deklination (fas):
math,cmathmodul - Polar koordinattransformation (representation i polarform):
math,cmathmodul - Beräkning av komplexa tal (kvadratur, potenser, kvadratrötter)
- Generera komplexa variabler
- Få fram reella och imaginära delar av komplexa tal: real, imagattribut
- Få konjugerade komplexa tal: conjugate()
- Få fram det absoluta värdet (magnituden) av ett komplext tal.: abs()
- Upptäcka deklinationen (fasen) för ett komplext tal.: math, cmathmodul
- Polär koordinattransformation av komplexa tal (polär formell representation): math, cmathmodul
- Beräkning av komplexa tal (kvadratur, potenser, kvadratrötter)
Generera komplexa variabler
Beteckna den imaginära enheten med j och skriv följande, observera att den inte är i.
c = 3 + 4j
print(c)
print(type(c))
# (3+4j)
# <class 'complex'>
Om den imaginära delen är 1 resulterar utelämnande av den i ett NameError. Om en variabel som heter j definieras först anses den vara den variabeln.
1j
Det bör uttryckligen anges på detta sätt.
# c = 3 + j
# NameError: name 'j' is not defined
c = 3 + 1j
print(c)
# (3+1j)
Om den reella delen är 0 kan den utelämnas.
c = 3j
print(c)
# 3j
Om du vill definiera ett värde med en imaginär del på 0 som en komplex komplex komplex typ, skriv 0 uttryckligen. Såsom beskrivs nedan kan operationer utföras mellan den komplexa typen och heltalstypen eller flyttalstypen.
c = 3 + 0j
print(c)
# (3+0j)
Real- och imaginärdelar kan anges som floating point float-typ. Exponentiell notation är också acceptabel.
c = 1.2e3 + 3j
print(c)
# (1200+3j)
Den kan också genereras av en konstruktör av typen ”complex”, som i ”complex(reell del, imaginär del)”.
c = complex(3, 4)
print(c)
print(type(c))
# (3+4j)
# <class 'complex'>
Få fram reella och imaginära delar av komplexa tal: real, imagattribut
Den reella och imaginära delen av en komplex komplex komplex typ kan erhållas med attributen real respektive imag. Båda är floating point float-typer.
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'>
Den är skrivskyddad och kan inte ändras.
# c.real = 5.5
# AttributeError: readonly attribute
Få konjugerade komplexa tal: conjugate()
För att få fram konjugerade komplexa tal använder du metoden conjugate().
c = 3 + 4j
print(c.conjugate())
# (3-4j)
Få fram det absoluta värdet (magnituden) av ett komplext tal.: abs()
För att få fram det absoluta värdet (magnituden) av ett komplext tal använder du den inbyggda funktionen abs().
c = 3 + 4j
print(abs(c))
# 5.0
c = 1 + 1j
print(abs(c))
# 1.4142135623730951
Upptäcka deklinationen (fasen) för ett komplext tal.: math, cmathmodul
För att få fram deklinationen (fasen) för ett komplext tal använder du modulen math eller cmath.
Modulen cmath är en matematisk funktionsmodul för komplexa tal.
Den kan beräknas med den omvända tangentfunktionen math.atan2() enligt definitionen, eller med cmath.phase(), som returnerar deklinationen (fasen).
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
I båda fallen är enheten för den vinkel som kan erhållas radianer. För att konvertera till grader använder du math.degrees().
print(math.degrees(cmath.phase(c)))
# 45.0
Polär koordinattransformation av komplexa tal (polär formell representation): math, cmathmodul
Som nämnts ovan kan man få fram det absoluta värdet (magnitud) och deklinationen (fas) för ett komplext tal, men med hjälp av cmath.polar() kan man få fram dem tillsammans som en tupel (absolut värde, deklination).
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
Konvertering från polära koordinater till kartesiska koordinater görs med hjälp av cmath.rect(). cmath.rect(absolut värde, avvikelse) och liknande argument kan användas för att erhålla värden av motsvarande komplexa komplexa komplexa komplexa typ.
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)
De reella och imaginära delarna är likvärdiga med de resultat som beräknas med cosinus math.cos() och sinus math.sin() från absoluta värden och deklinationsvinklar.
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
Beräkning av komplexa tal (kvadratur, potenser, kvadratrötter)
Fyra aritmetiska operationer och effektberäkningar kan utföras med hjälp av de vanliga aritmetiska operatörerna.
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)
Kvadratroten kan beräknas med **0,5, men det medför fel. cmath.sqrt() kan användas för att beräkna det exakta värdet.
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
Den kan också utföra aritmetiska operationer med komplexa typer, int-typer och float-typer.
print(c1 + 3)
# (6+4j)
print(c1 * 0.5)
# (1.5+2j)
