Nombres complexes dans Python

Python est un langage incroyablement flexible pour travailler avec des données numériques. La capacité de travailler avec des nombres réels et fictifs est également soutenu. Nous devons souvent exécuter des calculs sur les types de données numériques, y compris des nombres complexes, lorsque vous nous engagez dans la science des données, l'apprentissage en profondeur ou les calculs scientifiques. Plus d'informations sur les nombres imaginaires et comment les utiliser dans Python sont couverts dans cette session.

Les nombres complexes sont fréquemment observés par paires et sont utilisés pour trouver les racines carrées des nombres négatifs. Python peut gérer efficacement les nombres et leurs fonctions associées en plus des nombres réels en utilisant le fichier «cmath». Python offre des capacités utiles pour gérer et modifier les nombres complexes qui sont utiles dans de nombreuses applications liées aux mathématiques.

Syntaxe du nombre complexe dans Python

La syntaxe suivante du nombre complexe est utilisée dans la langue Python:

complexe ([réel [, imag]])

Il n'y a pas beaucoup de différence entre la création et le travail avec les nombres complexes dans Python par rapport aux autres types de données intégrés, en particulier les types numériques. Il est possible car la langue leur accorde la citoyenneté de première classe. Cela implique qu'il n'y a pas beaucoup de frais généraux impliqués dans l'expression des calculs mathématiques avec les nombres complexes.

De la même manière que vous appelleriez les fonctions sur les autres nombres de Python, les nombres complexes sont pris en charge dans les expressions arithmétiques. Il produit une belle syntaxe qui ressemble à un manuel de mathématiques de plusieurs manières.

Exemple 1: Programme pour convertir le numéro complexe en un nombre réel

Le «x + yi» est le symbole d'un nombre complexe. En utilisant la fonction complexe, Python transforme X et Y des valeurs réelles en valeurs complexes (x, y). En utilisant la fonction réelle (), la partie réelle peut être récupérée et la fonction imag () peut être utilisée pour représenter la partie imaginaire.

importer cmath
n1 = 6
n2 = 1
res = complexe (n1, n2);
print ("Numéro réel complexe:", end = "")
imprimer (res.réel)
Print ("Numéro de complexe imaginaire:", end = "")
imprimer (res.imaginer

Dans l'exemple précédent, nous avons importé le module CMATH pour travailler avec les nombres complexes. Ensuite, nous avons déclaré deux variables sous le nom de N1 et N2. Ces variables sont définies avec les valeurs entières. La fonction complexe prend ces deux variables en entrée à l'intérieur. La fonction complexe est appelée dans la variable RES. L'instruction d'impression appelée prend les nombres réels et d'image comme paramètre avec la variable RES.

Ils peuvent voir les nombres complexes réels et imaginaires dans l'image suivante:

Exemple 2: Programme de la phase numérique complexe

L'angle entre le vecteur de représentation du nombre complexe et l'axe réel positif est connu comme la phase du nombre complexe en géométrie. Le terme «argument d'un nombre complexe» peut également être utilisé pour décrire cela. Phase (), qui accepte un nombre complexe comme entrée, renvoie la phase.

importer cmath
a = -5.0
b = 0.0
C = complexe (a, b);
Print ("Numéro de complexe de phase:", end = "")
imprimer (cmath.phase (c))

Ici, après avoir importé le module CMATH, nous avons défini les deux variables comme a et b. La variable A est initialisée avec la valeur numérique négative et la variable B est initialisée avec la valeur numérique positive. Nous avons déclaré une autre variable comme C où la fonction complexe est invoquée. Pour la fonction complexe, nous avons fourni la variable A et B pour la conversion en nombres complexes. Ensuite, nous avons imprimé les nombres complexes en utilisant la fonction de phase.

Le numéro de complexe de phase est généré sur l'écran de la console suivant:

Exemple 3: Programme pour convertir le nombre complexe en coordonnées rectangulaires

En utilisant la fonction polaire () qui renvoie une paire (R, pH) indiquant le module R et le pH de l'angle de phase, les données polaires sont converties. ABS () et la phase sont les deux fonctions qui peuvent être utilisées pour afficher le module ().

Le rect (r, pH), où r est le module et le pH est l'angle de phase, traduit un entier complexe en coordonnées rectangulaires. Il rend un nombre qui équivaut à r * (mathématiques.cos (ph) + mathématiques.sin (pH) * 1J).

importer cmath
mathématiques d'importation
i = 3.0
j = 3.0
z = complexe (i, j);
c = cmath.polaire (z)
Print ("Module et argument du numéro Polar Complex:", end = "")
Imprimer (c)
c = cmath.rect (4.242640687119285, 0.7853981633974483)
Print ("Numéro de complexe rectangulaire:", end = "")
Imprimer (c)

Nous avons inclus le module CMATH et MATH pour les opérations de nombre complexes. Ensuite, nous avons déclaré les deux variables I et J qui ont des nombres réels. Les nombres réels sont transmis à la fonction complexe et la fonction complexe est définie dans la variable z. Nous avons appelé la fonction polaire pour convertir les nombres complexes en polaire. Après cela, nous avons la fonction rect () pour la conversion du nombre complexe en coordonnées rectangulaires.

Les résultats des nombres complexes polaires et rectangulaires sont présentés comme suit:

Exemple 4: Programme de fonctions de fonctions trigonométriques Nombres complexes

Ici, nous expliquons le nombre complexe de fonctions trigonométriques:

1. sin (): le nombre complexe fourni comme argument et renvoyé par cette fonction est son sinus.
2. cos (): Lorsqu'un nombre complexe est fourni comme argument, cette méthode renvoie son cosinus.
3. tan (): le nombre complexe spécifié comme argument reçoit sa tangente de cette fonction.

importer cmath
p = 4.0
Q = 4.0
r = complexe (p, q);
print ("Numéro de complexe sinusoïdal:", end = "")
imprimer (cmath.péché (r))
Print ("Cosine Complex Number:", end = "")
imprimer (cmath.cos (r))
print ("Numéro de complexe tangent:", end = "")
imprimer (cmath.tan (r))

Nous avons simplement passé le nombre réel défini à l'intérieur de la fonction complexe. Ensuite, les nombres complexes sont passés à l'intérieur des fonctions trigonométriques. La déclaration d'impression affiche les nombres complexes trigonométriques.

La sortie obtenue à partir du script Python précédent est la suivante:

Exemple 5: Programme de numéro complexe d'exposons et de journaux

Ici, nous avons discuté de certaines opérations du nombre complexe qui incluent la fonction exp () et la fonction log ().

exp (): le nombre complexe indiqué dans l'exposant de son argument est renvoyé par cette fonction.

Log (A, B): Lorsque les deux entrées de cette fonction sont spécifiées, elle donne le résultat logarithmique de "A" avec "Base B". Le journal naturel de «A» est produit en l'absence d'un argument de base.

importer cmath
mathématiques d'importation
u = 8.0
v = 8.0
w = complexe (u, v);
print ("Log10 Numéro complexe:", end = "")
imprimer (cmath.log10 (w))
Print ("Numéro de complexe de racine carrée:", end = "")
imprimer (cmath.SQRT (W))

Nous avons passé les nombres réels spécifiés à l'intérieur de la fonction complexe. Ensuite, nous avons imprimé le Log10 du numéro complexe en invoquant la fonction log10 à l'intérieur de l'instruction PRINT. De plus, nous avons imprimé la racine carrée des nombres complexes.

Le résultat du script précédent est le suivant:

Conclusion

Les méthodes par lesquelles Python permet la mise en œuvre et le stockage de données numériques sont des nombres complexes. Il est considéré comme crucial pour la programmation Python. Il existe de nombreuses façons de gérer les nombres complexes en utilisant le langage de programmation Python. Nous avons couvert quelques-unes de ces méthodes dans cet article.