Python ten un tipo estándar para manexar números complexos, o tipo COMPLEX. Se só queres facer cálculos sinxelos, non necesitas importar ningún módulo, pero se importas a biblioteca estándar cmath, tamén podes utilizar funcións matemáticas (exponenciais, logarítmicas, trigonométricas, etc.) correspondentes a números complexos.
Os seguintes contidos explícanse aquí con código de exemplo.
- Xerar variables complexas
- Obtén partes reais e imaxinarias:
real,imagatributo - Obter números complexos conxugados:
conjugate()método - Obter o valor absoluto (magnitude):
abs()función (por exemplo, matemáticas, programación, programación) - Obter declinación (fase):
math,cmathmódulo - Transformación de coordenadas polares (representación en forma polar):
math,cmathmódulo - Cálculo de números complexos (cuadratura, potencias, raíces cadradas)
- Xerar variables complexas
- Obtén partes reais e imaxinarias de números complexos:real,imagatributo
- Obter números complexos conxugados:conjugate()
- Obter o valor absoluto (magnitude) dun número complexo:abs()
- Obter a declinación (fase) dun número complexo:math,cmathmódulo
- Transformación de coordenadas polares de números complexos (representación formal polar):math,cmathmódulo
- Cálculo de números complexos (cuadratura, potencias, raíces cadradas)
Xerar variables complexas
Sinala a unidade imaxinaria con j e escribe o seguinte, observa que non é i.
c = 3 + 4j
print(c)
print(type(c))
# (3+4j)
# <class 'complex'>
Se a parte imaxinaria é 1, omitila provoca un NameError. Se unha variable chamada j se define primeiro, considérase que é esa variable.
1j
Deste xeito debería expresarse expresamente.
# c = 3 + j
# NameError: name 'j' is not defined
c = 3 + 1j
print(c)
# (3+1j)
Se a parte real é 0, pódese omitir.
c = 3j
print(c)
# 3j
Se queres definir un valor cunha parte imaxinaria de 0 como un tipo complexo complexo, escribe 0 explícitamente. Como se describe a continuación, pódense realizar operacións entre o tipo complexo e o tipo enteiro ou o tipo de coma flotante.
c = 3 + 0j
print(c)
# (3+0j)
As partes reais e imaxinarias pódense especificar como tipo flotante de coma flotante. A notación exponencial tamén é aceptable.
c = 1.2e3 + 3j
print(c)
# (1200+3j)
Tamén pode ser xerado por un construtor de tipo “complexo”, como en “complexo(parte real, parte imaxinaria)”.
c = complex(3, 4)
print(c)
print(type(c))
# (3+4j)
# <class 'complex'>
Obtén partes reais e imaxinarias de números complexos:real,imagatributo
As partes reais e imaxinarias dun tipo complexo complexo pódense obter cos atributos real e imag, respectivamente. Ambos son tipos flotantes de coma flotante.
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'>
É só de lectura e non se pode cambiar.
# c.real = 5.5
# AttributeError: readonly attribute
Obter números complexos conxugados:conjugate()
Para obter números complexos conxugados, use o método conxugate().
c = 3 + 4j
print(c.conjugate())
# (3-4j)
Obter o valor absoluto (magnitude) dun número complexo:abs()
Para obter o valor absoluto (magnitude) dun número complexo, use a función incorporada abs().
c = 3 + 4j
print(abs(c))
# 5.0
c = 1 + 1j
print(abs(c))
# 1.4142135623730951
Obter a declinación (fase) dun número complexo:math,cmathmódulo
Para obter a declinación (fase) dun número complexo, utiliza o módulo matemático ou cmath.
O módulo cmath é un módulo de funcións matemáticas para números complexos.
Pódese calcular coa función de tanxente inversa math.atan2() tal e como se define, ou usar cmath.phase(), que devolve a declinación (fase).
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
En ambos casos, a unidade de ángulo que se pode obter son os radiáns. Para converterse en graos, use math.degrees().
print(math.degrees(cmath.phase(c)))
# 45.0
Transformación de coordenadas polares de números complexos (representación formal polar):math,cmathmódulo
Como se mencionou anteriormente, pódese obter o valor absoluto (magnitude) e a declinación (fase) dun número complexo, pero usando cmath.polar(), pódense obter xuntos como unha tupla (valor absoluto, declinación).
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
A conversión de coordenadas polares a coordenadas cartesianas realízase mediante cmath.rect(). cmath.rect(valor absoluto, desviación) e argumentos similares pódense utilizar para obter valores do tipo complexo complexo equivalente.
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)
As partes real e imaxinaria son equivalentes aos resultados calculados por coseno math.cos() e seno math.sin() a partir de valores absolutos e ángulos de declinación.
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
Cálculo de números complexos (cuadratura, potencias, raíces cadradas)
Pódense realizar catro operacións aritméticas e cálculos de potencia utilizando os operadores aritméticos habituais.
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)
A raíz cadrada pódese calcular con **0,5, pero introduce un erro. cmath.sqrt() pódese usar para calcular o valor exacto.
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
Tamén pode realizar operacións aritméticas con tipos complexos, tipos int e tipos flotantes.
print(c1 + 3)
# (6+4j)
print(c1 * 0.5)
# (1.5+2j)
