Python tem um tipo padrão para lidar com números complexos, o tipo COMPLEXO. Se quiser apenas fazer cálculos simples, não precisa de importar quaisquer módulos, mas se importar a biblioteca padrão cmath, pode também utilizar funções matemáticas (exponencial, logarítmica, trigonométrica, etc.) correspondentes a números complexos.
O conteúdo seguinte é explicado aqui com o código da amostra.
- Gerar variáveis complexas
- Obter peças reais e imaginárias:
real,imagatributo - Obter números complexos conjugados:
conjugate()método - Obter valor absoluto (magnitude):
abs()função (por exemplo, matemática, programação, programação) - Obter a declinação (fase):
math,cmathmódulo - Transformação de coordenadas polares (representação de formas polares):
math,cmathmódulo - Computação de números complexos (quadratura, poderes, raízes quadradas)
- Gerar variáveis complexas
- Obter partes reais e imaginárias de números complexos: real, imagatributo
- Obter números complexos conjugados: conjugate()
- Obter o valor absoluto (magnitude) de um número complexo: abs()
- Obter a declinação (fase) de um número complexo: math, cmathmódulo
- Transformação de coordenadas polares de números complexos (representação formal polar): math, cmathmódulo
- Computação de números complexos (quadratura, poderes, raízes quadradas)
Gerar variáveis complexas
Denotar a unidade imaginária por j e escrever o seguinte, notar que não é i.
c = 3 + 4j
print(c)
print(type(c))
# (3+4j)
# <class 'complex'>
Se a parte imaginária for 1, omiti-la resulta num NameError. Se uma variável chamada j for definida primeiro, é considerada como sendo essa variável.
1j
Deve ser declarado explicitamente desta forma.
# c = 3 + j
# NameError: name 'j' is not defined
c = 3 + 1j
print(c)
# (3+1j)
Se a parte real for 0, pode ser omitida.
c = 3j
print(c)
# 3j
Se quiser definir um valor com uma parte imaginária de 0 como um tipo complexo, escreva 0 explicitamente. Como descrito abaixo, as operações podem ser realizadas entre o tipo complexo e o tipo inteiro ou tipo de ponto flutuante.
c = 3 + 0j
print(c)
# (3+0j)
As peças reais e imaginárias podem ser especificadas como flutuantes. A notação exponencial também é aceitável.
c = 1.2e3 + 3j
print(c)
# (1200+3j)
Pode também ser gerado por um construtor do tipo “complexo”, como em “complexo(parte real, parte imaginária)”.
c = complex(3, 4)
print(c)
print(type(c))
# (3+4j)
# <class 'complex'>
Obter partes reais e imaginárias de números complexos: real, imagatributo
As partes real e imaginária de um tipo complexo podem ser obtidas com os atributos real e imaginário, respectivamente. Ambos são tipos de flutuadores de ponto flutuante.
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'>
É apenas lido e não pode ser alterado.
# c.real = 5.5
# AttributeError: readonly attribute
Obter números complexos conjugados: conjugate()
Para obter números complexos conjugados, usar o método conjugate().
c = 3 + 4j
print(c.conjugate())
# (3-4j)
Obter o valor absoluto (magnitude) de um número complexo: abs()
Para obter o valor absoluto (magnitude) de um número complexo, utilizar a função abs() incorporada.
c = 3 + 4j
print(abs(c))
# 5.0
c = 1 + 1j
print(abs(c))
# 1.4142135623730951
Obter a declinação (fase) de um número complexo: math, cmathmódulo
Para obter a declinação (fase) de um número complexo, utilizar o módulo matemático ou cmath.
O módulo cmath é um módulo de função matemática para números complexos.
Pode ser calculado com a função tangente inversa matemática.atan2() como definida, ou utilizar cmath.phase(), que retorna a declinação (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
Em ambos os casos, a unidade de ângulo que pode ser obtida são os radianos. Para converter para graus, utilizar graus matemáticos().
print(math.degrees(cmath.phase(c)))
# 45.0
Transformação de coordenadas polares de números complexos (representação formal polar): math, cmathmódulo
Como mencionado acima, o valor absoluto (magnitude) e a declinação (fase) de um número complexo podem ser obtidos, mas utilizando cmath.polar(), podem ser obtidos juntos como um tuple (valor absoluto, declinação).
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 conversão de coordenadas polares para coordenadas cartesianas é feita usando cmath.rect(). cmath.rect(valor absoluto, desvio) e argumentos semelhantes podem ser usados 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 reais e imaginárias são equivalentes aos resultados calculados por cosine mathema.cos() e sine mathema.sin() a partir de valores absolutos e ângulos de declinação.
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
Computação de números complexos (quadratura, poderes, raízes quadradas)
Quatro operações aritméticas e cálculos de potência podem ser efectuados 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 raiz quadrada pode ser calculada com **0,5, mas introduz erro. cmath.sqrt() pode ser usado 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
Também pode realizar operações aritméticas com tipos complexos, tipos int, e tipos float.
print(c1 + 3)
# (6+4j)
print(c1 * 0.5)
# (1.5+2j)
