DESCRIPTION.

Créer un objet numérique contenant un nombre complexe. 

SYNTAXE.

Nombre = reel + imaginaire

Nombre = imaginaire + reel

Nombre ⇨ Nom de la variable [ OBLIGATOIRE ]

= ⇨ affectation du nombre à la variable [ OBLIGATOIRE ]

reel ⇨ valeur numérique réelle [ OBLIGATOIRE ]

imaginaire ⇨ valeur numérique imaginaire [ OBLIGATOIRE ]

Nombre = complex ( reel , imaginaire )

Nombre ⇨ Nom de la variable [ OBLIGATOIRE ]

= ⇨ affectation du nombre à la variable [ OBLIGATOIRE ]

complex ( ) ⇨ appel du constructeur de classe [ OBLIGATOIRE ]

reel ⇨ valeur numérique réelle [ optionnel ]

imaginaire ⇨ valeur numérique imaginaire [ optionnel ]

Nombre = complex ( chaine )

Nombre ⇨ Nom de la variable [ OBLIGATOIRE ]

= ⇨ affectation du nombre à la variable [ OBLIGATOIRE ]

complex ( ) ⇨ appel du constructeur de classe [ OBLIGATOIRE ]

chaine ⇨ Chaine de caractères valide [ optionnel ]

REMARQUES.

reel doit un float ( ) ou un int ( ).

imaginaire se présente comme un float ( ) ou un int ( ). suffixée de la lettre j.

chaine est un str ( ) composé : de la partie réelle ; d'un signe + ; de la valeur de la partie imaginaire et enfin de la lettre j.

Python gère, nativement, trois types de valeurs numériques, les nombres entiers (int ( )), les nombres réels, dits à virgule flotante (float ( )) et les nombres complexes (complex ( )). 

Un point important, à ne pas oublier, est que, pour Python, les valeurs numériques,  quelque soit leur type, sont des objets, et que les instances définies à l'aide des constructeurs de classes int ( ), float ( ) ou complex ( ) ne font que pointer vers l'un de ces objets.

Un nombre complexe, pour Python, est constitué d'un nombre réel et de son complément imaginaire. La partie réelle reel sera, de préférence un float ( ), bien qu'un int ( ) soit tout à fait accepté. la partie imaginaire imaginaire est composée de chiffres, séparés éventuellement en 2 séries par un d'un point décimal, suivie de la lettre j minuscule, sans aucun espacement.

CREATION DE NOMBRE COMPLEX.

Pour créer une variable numérique complexe, il suffit de lui affecter une valeur.

Valeur = 54.3 + 2j

print ( Valeur ) retourne (54.3+2j)

print ( type ( Valeur ) ) retourne <class 'complex'>

Valeur = 54 + 3.2j

print ( Valeur ) retourne (54+3.2j)

print ( type ( Valeur ) ) retourne <class 'complex'>

Les partie réelle et imaginaire peuvent être inversées.

Valeur = 54.6 + 3.2j

Inverse = 3.2j + 54.6

print ( Valeur ) retourne (54.6+3.2j)

print ( Inverse ) retourne (54.6+3.2j)

print ( type ( Valeur ) ) retourne <class 'complex'>

print ( type ( Inverse ) ) retourne <class 'complex'>

print ( Valeur == Inverse ) retourne True

print ( 54.6 + 3.2j == 3.2j + 54.6 ) retourne True

La création d'un nombre complexe est aussi possible avec le constructeur de classe complex ( ). dans ce cas, la partie imaginaire, ne doit pas être suffixée de la lettre j.

Valeur = complex ( 54.3 , 3.2 )

print ( Valeur ) retourne (54.3+3.2j)

print ( type ( Valeur ) ) retourne <class 'complex'>

La présence de la lettre j, retourne une valeur non attendue.

Valeur = complex ( 54.3 , 3.2j )

print ( Valeur ) retourne (51.099999999999994+0j)

print ( type ( Valeur ) ) retourne <class 'complex'>

Valeur = complex ( 3.2j , 54.3 )

print ( Valeur ) retourne (complex (57.5j))

print ( type ( Valeur ) ) retourne <class 'complex'>

Sans valeur spécifiée, le constructeur de classe complex ( ), affecte 0j par défaut à l'instance créée.

Valeur = complex ( )

print ( Valeur ) retourne 0j

print ( type ( Valeur ) ) retourne <class 'complex'>

Il est possible de créer une instance d'un nombre complexe depuis une chaine de caractères (str ( )) en utilisant le constructeur de classe complex ( ). Le str ( ) indiquera la partie réelle en premier, suivie de la partie imaginaire suffixée de la lettre j. en séparant les deux parties par un signe +.

Valeur = complex ( "54.3+3.2j" )

print ( Valeur ) retourne (54.3+3.2j)

print ( type ( Valeur ) ) retourne <class 'complex'>

Dans le str ( ) de construction, la partie imaginaire doit toujours être présentée à la suite de la partie réelle.

print ( complex ( "3.2j+54.3" ) ) retourne complex() arg is a malformed string

Attention cependant, car le str ( ) ne doit comporter aucun espacement entre les parties numéraires.

print ( complex ( "54.3+3.2j" ) ) retourne (54.3+3.2j)

print ( complex ( " 54.3+3.2j" ) ) retourne (54.3+3.2j)

print ( complex ( "54.3+3.2j " ) ) retourne (54.3+3.2j)

print ( complex ( "54.3 + 3.2j ") ) retourne complex() arg is a malformed string

EXEMPLES.

Les nombres complexes étant utilisés dans des cas bien particuliers, vous trouverez, ci-dessous, quelques exemples d'utilisations couramment rencontrées dans des problèmes, utilisant ce type numérique, pour que les usagers puissent avoir un aperçu général.

print ( 0 + 3.2j ) retourne 3.2j

print ( 3.2j ) retourne 3.2j

print ( 0 - 3.2j ) retourne -3.2j

print ( -3.2j ) retourne (-0-3.2j)

print ( -54.6 + 3.2j ) retourne (-54.6+3.2j)

print ( 54.6 - 3.2j ) retourne (54.6-3.2j)

print ( 54.6 + ( -3.2j ) ) retourne (54.6-3.2j)

print ( -3.2j + 54.6 ) retourne (54.6-3.2j)

print ( ( 5 + .7j ) + ( 4.6 + 1.2j ) ) retourne (9.6+1.9j)

print ( 5 + .7j + 4.6 + 1.2j ) retourne (9.6+1.9j)

print ( ( 5 + .7j ) - ( 4.6 + 1.2j ) ) retourne (0.40000000000000036-0.5j)

print ( 5 + .7j - 4.6 + 1.2j ) retourne (0.40000000000000036+1.9j)

print ( complex ( 54.6 , complex ( 2.3 , 3.2 ) ) ) retourne (51.4+2.3j)

print ( complex ( complex ( 2.3 , 3.2 ) , 54.6 ) ) retourne (2.3+57.800000000000004j)

print ( complex ( complex ( 5.4 , 2.7 ) , complex ( 2.3 , 3.2 ) ) ) retourne (2.2+5j)