OPERATEURS D'AFFECTATION.

= : Affectation.

Voir les variables pour plus d'informations sur l'opérateur d'affectation =.

_ : Valeur de la dernière expression évaluée dans Python.

Le caractère _ (underscore / soulignement ) sert de variable, à l'interpréteur Python, pour retourner le résultat de l'évaluation d'une expression. On peut donc rappeler cette valeur en utilisant le symbole _.

>>> NombreA = 17

>>> NombreB = 14

>>> NombreA + NombreB

31

>>> _

31

>>> for kvaleur in range ( 3 ) :

print ( kvaleur + kvaleur )

print ( "_ = ", _ )

NombreB + kvaleur

print ( "_ maintenant vaut : " , _ )

0

_ =  31

14

_ maintenant vaut :  14

2

_ =  14

15

_ maintenant vaut :  15

4

_ =  15

16

_ maintenant vaut :  16

>>> 

On remarquera que _ n'est pas affecté quand l'expression kvaleur + kvaleur est évaluée dans la fonction print ( kvaleur + kvaleur ), mais qu'il est affecté quand l'expression est évaluée en dehors d'une fonction NombreB + kvaleur.

OPERATEURS MATHEMATIQUES.

+ : addition, concaténation de chaines de caractères.

Le symbole de l'addition sous Python est + (plus).

a = 7 + 2

print ( a ) retourne 9

a = a + 4

print ( a ) retourne 13

a = 12

b = 6

a = a + b

print ( a ) retourne 18

print ( type ( a ) ) retourne <class 'int'>

print ( type ( b ) ) retourne <class 'int'>

a = 4

print ( type ( a ) ) retourne <class 'int'>

b = .7

print ( type ( b ) ) retourne <class 'float'>

a = a + b

print ( a ) retourne 4.7

print ( type ( a ) ) retourne <class 'float'>

La variable qui reçoit l'affectation peut changer de type.

a = 8

a +=

print ( a ) retourne 9 

a += corresponds à a = a + 1. Cela ce nomme l'incrémentation. 

a = 4

a += 7

print ( a ) retourne 11

a += x corresponds à a = a + x (avec n'importe quelle valeur compatible avec a pour x ).

a = 5

a += a

print ( a ) retourne 10

a += a corresponds à a = a + a. 

a = 121

b = 97

a += b

print ( a ) retourne 218

a += b corresponds à a = a + b. 

A = "abc" + "def"

print ( A ) retourne abcdef

A = A  + "ghi"

print ( A ) retourne abcdefghi

A = "abc" 

B = "def"

A = A + B

print ( A ) retourne abcdef

C = A + B

print ( C ) retourne abcdefdef

Il existe d'autres types d' "additions" selon le type de l'objet (list ( ), dict ( ), set ( ), tuple ( ), ... ). Ces types spécifiques sont alors développés à la définition de l'objet.  Dans les faits, il faut bien comprendre que la présence du symbole +, dans un script, appel et exécute la méthode de classe __add__ ( ) des l'objets liés par le signe +. Si les méthodes de classe __add__ ( ) de ces objets ne sont pas "compatibles", Python lèvera une exception.

- : soustraction.

Le symbole de la soustraction sous Python est - (moins).

a = 7 - 2

print ( a ) retourne 5

a = a - 4

print ( a ) retourne 1

a = 12

b = 5

a = a - b

print ( a ) retourne 7

print ( type ( a ) ) retourne <class 'int'>

print ( type ( b ) ) retourne <class 'int'>

a = 8

print ( type ( a ) ) retourne <class 'int'>

b = .7

print ( type ( b ) ) retourne <class 'float'>

a = a - b

print ( a ) retourne 7.3

print ( type ( a ) ) retourne <class 'float'>

La variable qui reçoit l'affectation peut changer de type.

a = 14

a -= 5

print ( a ) retourne 9

a -= x corresponds à a = a - x (avec n'importe quelle valeur compatible avec a pour x).

Comme la soustraction est moins prioritaire que les autres opérations, elle est évaluée en dernier. Si l'on souhaite travailler avec un nombre négatif, il est impératif de mettre entre parenthèses pour qu'il soit évalué en priorité. Il est important dans tenir compte dans l'écriture des opérations. par exemple :

print ( - 7 ** 4 ) retourne -2401

C'est à l'inverse de 7 à la puissante 4.

print ( ( -7 ) ** 4 ) retourne 2401

C'est dire - 7 à la puissance 4.

Il peut exister d'autres types de "soustration" selon la nature ou le type d'objet. Ces types spécifiques sont alors développés à la définition de l'objet.  Dans les faits, il faut bien comprendre que la présence du symbole -, dans un script, appel et exécute la méthode de classe __sub__ ( ) des l'objets liés par le signe -. Si les méthodes de classe __sub__ ( ) de ces objets ne sont pas "compatibles", Python lèvera une exception.

* : multiplication.

Le symbole de la multiplication sous Python est * (étoile).

a = 7 * 2

print ( a ) retourne 14

a = a * 4

print ( a ) retourne 56

a = 3

b = 6

a = a * b

print ( a ) retourne 18

print ( type ( a ) ) retourne <class 'int'>

print ( type ( b ) ) retourne <class 'int'>

a = 4

print ( type ( a ) ) retourne <class 'int'>

b = .2

print ( type ( a ) ) retourne <class 'float'>

a = a * b

print ( a ) retourne .8

Les zéros non significatifs ne sont pas affichés.

print ( type ( a ) ) retourne <class 'float'>

La variable qui reçoit l'affectation peut changer de type.

A = "abc" * 3

print ( A ) retourne abcabcabc (concaténation de 3 fois la chaîne abc dans la variable A) Équivaut à A = "abc" + "abc" + "abc"

La multiplication est prioritaire sur l'addition, la soustraction, les types de divisions, c'est a dire que dans une chaine de calculs, les termes (nombres ou variables) de chaque cotés du symbole * seront multipliez entre eux.

Il peut exister d'autres types de "multiplication" selon la nature ou le type d'objet. Ces types spécifiques sont alors développés à la définition de l'objet. Dans les faits, il faut bien comprendre que la présence du symbole *, dans un script, appel et exécute la méthode de classe __mul__ ( ) des l'objets liés par le signe *. Si les méthodes de classe __mul__ ( ) de ces objets ne sont pas "compatibles", Python lèvera une exception.

/ : division euclidienne (classique).

Le symbole de la division euclidienne sous Python est / (slach).

a = 12 / 2

print ( a ) retourne 6

a = a / 3

print ( a ) retourne 2

a = 35

b = 7

a = a / b

print ( a ) retourne 5

print ( type ( a ) ) retourne <class 'int'>

print ( type ( b ) ) retourne <class 'int'>

a = 5

print ( type ( a ) ) retourne <class 'int'>

b = 2

print ( type ( b ) ) retourne <class 'int'>

a = a / b

print ( a ) retourne 2.5

print ( type ( a ) ) retourne <class 'float'>

La variable qui reçoit l'affectation peut changer de type.

a = 9

a /= 4

print ( a ) retourne 2.25

a /= x corresponds à a = a / x (avec n'importe quelle valeur compatible avec a pour x).

Le deuxième terme, celui après le symbole /, doit toujours être différent de 0 (zéro), sinon Python lèvera une exception.

Il existe d'autres types de division : // pour la division entière et % pour le modulo (qui retourne le reste d'une division entière). Ainsi que la méthode native divmod ( a , b ) qui retourne un tuple contenant partie entière et le reste de la division de a par b.Dans les faits, il faut bien comprendre que la présence du symbole /, dans un script, appel et exécute la méthode de classe __truediv__ ( ) des l'objets liés par le signe /. Si les méthodes de classe __truediv__ ( ) de ces objets ne sont pas "compatibles", Python lèvera une exception.

// : division entière.

Python propose une opération arithmétique nommée division entière. Le symbole de cette division est // (deux slash).

a = 12 // 5

print ( a ) retourne 2

Seule la partie entier est retournée.

a = 9

a //= 4

print ( a ) retourne 2

a //= x corresponds à a = a // x (avec n'importe quelle valeur compatible avec a pour x).

Le deuxième terme, celui après le symbole //, doit toujours être différent de 0 (zéro), sinon Python lèvera une exception.

Il existe d'autres types de division : / pour la division euclidienne et % pour le modulo (qui retourne le reste d'une division entière). Ainsi que la méthode native divmod ( a , b ) qui retourne un tuple contenant partie entière et le reste de la division de a par b.Dans les faits, il faut bien comprendre que la présence du symbole //, dans un script, appel et exécute la méthode de classe __floordiv__ ( ) des l'objets liés par le signe //. Si les méthodes de classe __floordiv__ ( ) de ces objets ne sont pas "compatibles", Python lèvera une exception.

% : modulo.

Python propose une opération nommée modulo dont le symbole est % (pour cent). Cette opération retourne le reste d'une division.

a = 14 % 5

print ( a ) retourne 4

L'affectation se fait comme suit : 

- 14 divisé par 5 donne 2.8 (2.8 est le quotient);

- la partie entière du quotient est 2 ;

- le diviseur multiplié par la partie entière du quotient (5 x 2) donne 10 ;

- le dividende moins 10 (14 - 10) donne 4

- la variable a reçoit 4.

a = 9

a %= 4

print ( a ) retourne 1

a %= x corresponds à a = a % x (avec n'importe quelle valeur compatible avec a pour x).

Le deuxième terme, celui après le symbole %, doit toujours être différent de 0 (zéro), sinon Python lèvera une exception.

Il existe d'autres types de division : / pour la division euclidienne et // pour la division entier. Ainsi que la méthode native divmod ( a , b ) qui retourne un tuple contenant partie entière et le reste de la division de a par b. Dans les faits, il faut bien comprendre que la présence du symbole %, dans un script, appel et exécute la méthode de classe __mod__ ( ) des l'objets liés par le signe %. Si les méthodes de classe __mod__ ( ) de ces objets ne sont pas "compatibles", Python lèvera une exception.

** : puissance et racines.

Sous Python, pour élever un nombre x à une puissance y on utilise ** (deux étoiles).

a = 7 ** 2

print ( a ) retourne 49

Le carré de 7.

a = 3 ** 5

print ( a ) retourne 243

3 élevé à la puissance 5 (3 x 3 x 3 x 3 x 3).

a = 4

print  ( type ( a ) ) retourne <class 'int'>

b = 1.4

a = a ** b

print ( a ) retourne 6.964404506368993113090160139838

print (type ( a ) ) retourne <class 'float'>

La variable qui reçoit l'affectation peut changer de type.

Dans les faits, il faut bien comprendre que la présence du symbole **, dans un script, appel et exécute la méthode de classe __pow__ ( ) des l'objets liés par le signe **. Si les méthodes de classe __pow__ ( ) de ces objets ne sont pas "compatibles", Python lèvera une exception.

Calculer une racine à l'aide des puissances.

L'élévation à une puissance fractionnaire revient à calculer une racine (selon le théorème : la puissance fractionnaire est une racine). D'où le fait que Python ne possède pas nativement d'opérateur pour le calcul de racine.

a = 9 ** ( 1 / 2 )

print ( a ) retourne 3.0

9 élevé à la puissance un demi, revient à demander la racine carrée de 9.

La fraction doit être exprimée entre parenthèse, sinon seul le premier terme sera pris en compte pour le calcul de la puissance.

a = 9 ** .5 

print ( a ) retourne 3.0

La fraction peut s'exprimer sous la autre forme d'un float ( ).

Attention cependant à la précision retournée. Par exemple : a = 64 ** ( 1 / 3 )

print ( a ) retourne 3.9999999999999996

au lieu de 4.

OPERATEURS DE COMPARAISON.

a == b : a est égal à b

a != b : a est différent de b

a > b : a est strictement supérieur à b

a < b : a est strictement inférieur à b

a >= b : a est supérieur ou identique à b

a <= b : a est inférieur ou identique à b

a < x < b : x est dans intervalle entre a et b

a > x > b : x est dans intervalle entre a et b

a in b : a est présent dans b

a in not b : a est absent de b

a is b : a est identique à b

a is not b : a est dissemblable de b

OPERATEURS LOGIQUES.

and : Et logique

or : Ou logique

not : Non logique