Python possède un type standard pour la gestion des nombres complexes, le type COMPLEX. Si vous souhaitez simplement effectuer des calculs simples, vous n'avez pas besoin d'importer de modules, mais si vous importez la bibliothèque standard cmath, vous pouvez également utiliser des fonctions mathématiques (exponentielles, logarithmiques, trigonométriques, etc.) correspondant aux nombres complexes.
Les contenus suivants sont expliqués ici avec un exemple de code.
- Générer des variables complexes
- Obtenir les parties réelles et imaginaires:
real,imagattribut - Obtenir des nombres complexes conjugués:
conjugate()méthode - Obtenir la valeur absolue (magnitude):
abs()fonction (par exemple, mathématiques, programmation, programmation) - Obtenir la déclinaison (phase):
math,cmathmodule - Transformation des coordonnées polaires (représentation sous forme polaire):
math,cmathmodule - Calcul des nombres complexes (quadrature, puissances, racines carrées)
- Générer des variables complexes
- Obtenir les parties réelles et imaginaires des nombres complexes: real, imagattribut
- Obtenir des nombres complexes conjugués: conjugate()
- Obtenir la valeur absolue (magnitude) d'un nombre complexe: abs()
- Obtenir la déclinaison (phase) d'un nombre complexe: math, cmathmodule
- Transformation en coordonnées polaires des nombres complexes (représentation formelle polaire): math, cmathmodule
- Calcul des nombres complexes (quadrature, puissances, racines carrées)
Générer des variables complexes
Dénotez l'unité imaginaire par j et écrivez ce qui suit, notez que ce n'est pas i.
c = 3 + 4j
print(c)
print(type(c))
# (3+4j)
# <class 'complex'>
Si la partie imaginaire est 1, son omission entraîne une NameError. Si une variable nommée j est définie en premier, elle est considérée comme étant cette variable.
1j
Il devrait être explicitement indiqué de cette manière.
# c = 3 + j
# NameError: name 'j' is not defined
c = 3 + 1j
print(c)
# (3+1j)
Si la partie réelle est égale à 0, elle peut être omise.
c = 3j
print(c)
# 3j
Si vous voulez définir une valeur avec une partie imaginaire de 0 comme un type complexe, écrivez 0 explicitement. Comme décrit ci-dessous, des opérations peuvent être effectuées entre le type complexe et le type entier ou le type à virgule flottante.
c = 3 + 0j
print(c)
# (3+0j)
Les parties réelles et imaginaires peuvent être spécifiées comme des flottants. La notation exponentielle est également acceptable.
c = 1.2e3 + 3j
print(c)
# (1200+3j)
Il peut également être généré par un constructeur de type “complexe”, comme dans “complexe(partie réelle, partie imaginaire)”.
c = complex(3, 4)
print(c)
print(type(c))
# (3+4j)
# <class 'complex'>
Obtenir les parties réelles et imaginaires des nombres complexes: real, imagattribut
Les parties réelles et imaginaires d'un type complexe peuvent être obtenues avec les attributs real et imag, respectivement. Ces deux types sont des types à virgule flottante.
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'>
Il est en lecture seule et ne peut être modifié.
# c.real = 5.5
# AttributeError: readonly attribute
Obtenir des nombres complexes conjugués: conjugate()
Pour obtenir des nombres complexes conjugués, utilisez la méthode conjugate().
c = 3 + 4j
print(c.conjugate())
# (3-4j)
Obtenir la valeur absolue (magnitude) d'un nombre complexe: abs()
Pour obtenir la valeur absolue (magnitude) d'un nombre complexe, utilisez la fonction intégrée abs().
c = 3 + 4j
print(abs(c))
# 5.0
c = 1 + 1j
print(abs(c))
# 1.4142135623730951
Obtenir la déclinaison (phase) d'un nombre complexe: math, cmathmodule
Pour obtenir la déclinaison (phase) d'un nombre complexe, utilisez le module math ou cmath.
Le module cmath est un module de fonction mathématique pour les nombres complexes.
Elle peut être calculée avec la fonction de tangente inverse math.atan2() telle que définie, ou utiliser cmath.phase(), qui renvoie la déclinaison (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
Dans les deux cas, l'unité d'angle que l'on peut obtenir est le radians. Pour convertir en degrés, utilisez math.degrees().
print(math.degrees(cmath.phase(c)))
# 45.0
Transformation en coordonnées polaires des nombres complexes (représentation formelle polaire): math, cmathmodule
Comme mentionné ci-dessus, la valeur absolue (magnitude) et la déclinaison (phase) d'un nombre complexe peuvent être obtenues, mais en utilisant cmath.polar(), elles peuvent être obtenues ensemble comme un tuple (valeur absolue, déclinaison).
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
La conversion des coordonnées polaires en coordonnées cartésiennes se fait à l'aide de cmath.rect(). cmath.rect(valeur absolue, déviation) et des arguments similaires peuvent être utilisés pour obtenir des valeurs du type complexe équivalent.
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)
Les parties réelles et imaginaires sont équivalentes aux résultats calculés par cosinus math.cos() et sinus math.sin() à partir des valeurs absolues et des angles de déclinaison.
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
Calcul des nombres complexes (quadrature, puissances, racines carrées)
Quatre opérations arithmétiques et des calculs de puissance peuvent être effectués à l'aide des opérateurs arithmétiques habituels.
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)
La racine carrée peut être calculée avec **0.5, mais cela introduit une erreur. cmath.sqrt() peut être utilisé pour calculer la valeur exacte.
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
Il peut également effectuer des opérations arithmétiques avec des types complexes, des types int et des types float.
print(c1 + 3)
# (6+4j)
print(c1 * 0.5)
# (1.5+2j)
