Chapitre 3 Opérations sur les variables

March 7, 2021

1 Introduction
Nous rappelons qu’une opérations est une combinaison d’opérateurs et opérandes selon des règles
bien définies. Les opérateurs sont des fonctions simples et spécifiques qui agissent sur les types de
données primitifs, comme les entiers et les chaînes. Nous distinguons deux catégories d’opérateurs
:
• Opérateurs mathématiques : opérateurs qui exécutent des fonctions mathématiques, telles
que l’addition de nombres ou l’attribution de valeurs à des variables (opérateur d’affection
déjà vu).
• Opérateurs logiques : opérateurs qui effectuent des opérations logiques, telles que la com-
paraison de valeurs, la vérification de l’égalité, la vérification de l’appartenance à un ensemble
ou l’évaluation de combinaisons d’autres opérateurs logiques.

2 Opérateurs logiques
Les opérateurs logiques jouent un rôle très important dans la programmation. Certains opérateurs
logiques sont utilisés pour des comparaisons (Opérateurs relationnels). D’autres sont utilisés pour
enchaîner des décisions logiques (opérateurs booléens) telle que la vérification si plusieurs condi-
tions sont vraies. Les opérateurs logiques sont fondamentaux pour contrôler l’exécution de nos
programmes.

2.1 Opérateurs relationnels

Les opérateurs relationnels vérifient les relations entre plusieurs variables, comme vérifier si elles
sont égales ou si l’une est supérieure à une autre.

2.1.1 Comparaison des valeurs numériques

Pour comparer des valeurs numériques, la syntaxe est très simples. Il suffit d’écrire les nombres
(ou les variables contenant les nombres) à comparer avec l’opérateur de compaison entre eux. Le
résultat d’une comparaison est booléen, c’est à dire, vrai (True) ou faux (False).
Exemples
[1]: a=5
b=3
c=5
print('3 == 5',3 == 5) # L'égalité

1
 print('a == b',a == b)
print('5 == 5',5 == 5)
print('a == c',a == c)
print('3 != 5',3 != 5) # la différence
print('a != b',a != b)
print('5 != 5',5 != 5)
print('a != c',a != c)
print('5 < 5',5 < 5) # strictement inférieur
print('a <= c',a <= c) # inférieur ou égale
print('5 > 3',5 > 3) # strictement supérieur
print('a >= b',a >= b) # supérieur ou égale

3 == 5 False
a == b False
5 == 5 True
a == c True
3 != 5 True
a != b True
5 != 5 False
a != c False
5 < 5 False
a <= c True
5 > 3 True
a >= b True
Attention !!! Il ne faut pas confondre entre l’opérateur d’affectation “=” est celui de comparaison
“==”.
[2]: a=6
b=5
c=8
print('a==b',a==b)
a=c
print('la valeur de a est',a)
print('a=b',a=b)

a==b False
la valeur de a est 8

---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-2-6396dc0eb502> in <module>
5 a=c
6 print('la valeur de a est',a)
----> 7 print('a=b',a=b)

TypeError: 'a' is an invalid keyword argument for print()

2
 • Les écritures suivantes engendrent des erreurs.
[3]: print(5=<6)

File "<ipython-input-3-f37a6ea9b8df>", line 1

print(5=<6)
^
SyntaxError: invalid syntax

[4]: print(5=>6)

File "<ipython-input-4-152843dc4758>", line 1

print(5=>6)
^
SyntaxError: invalid syntax

[5]: print(5=!6)

File "<ipython-input-5-a047ec53e942>", line 1

print(5=!6)
^
SyntaxError: invalid syntax

[6]: print(5=6)

File "<ipython-input-6-985effb8d309>", line 1

print(5=6)
^
SyntaxError: expression cannot contain assignment, perhaps you meant "=="?

2.1.2 Comparaison des valeurs non numériques

En Python, il est possible de comparer également les chaînes de caractères. Ce processus fonctionne
en triant les chaînes par ordre alphabétique. Les chaînes qui pécèdent dans l’ordre alphabétique
sont traitées comme «inférieures» aux chaînes qui succèdent. Cependant, cette méthode traite les
lettres majuscules et minuscules séparément, ce qui signifie que “Z” majuscule serait triée comme
«inférieure» que “a”.
Exemples

3
[7]: a='Bonjour'
b='bonjour'
print("'x'=='x'",'x'=='x')
print("'x'=='y'",'x'=='y')
print("'Z'<'a'",'Z'<'a')
print("a==b",a==b)
print("a>b",a>b)

'x'=='x' True
'x'=='y' False
'Z'<'a' True
a==b False
a>b False

2.1.3 Les opérateurs d’appartenance et d’identité

Parmis les opérateurs reltionnels, on distingue deux opérateurs qui ne manquent pas d’importances.
Ces deux opératreurs sont :
• in : permet de tester l’appartenannce d’un élément à une liste d’éléments.
• is : permet de tester l’identiter.
Exemples
[8]: print("'a' in 'bonjour'",'a' in 'bonjour')

'a' in 'bonjour' False

[9]: print("'on' in 'bonjour'",'on' in 'bonjour')

'on' in 'bonjour' True

[10]: print("'O' in 'bonjour'",'O' in 'bonjour')

'O' in 'bonjour' False

[11]: a=2
b=5
ch1='abc'
ch2='abc'
l1=['a','b','c']
l2=['a','b','c']
print('a==b',a==b)
print('a is b',a is b)
print('ch1==ch2',ch1==ch2)
print('ch1 is ch2',ch1 is ch2)
print('l==l2',l1==l2)
print('l1 is l2',l1 is l2)

4
 a==b False
a is b False
ch1==ch2 True
ch1 is ch2 True
l==l2 True
l1 is l2 False

2.2 Opérateurs booléens

Tandis que les opérateurs relationnels vérifient les relations entre plusieurs variables pour aboutir à
des résultats booléens, les opérateurs booléens combinent des variables booléennes (True ou False)
pour aboutir à des résultats booléens.
En Python, on distingue les trois opérateurs, qui sont pratiquement connus, and, or et not.

2.2.1 And
L’opérateur and agit sur deux valeurs booléennes (True ou False) et prend la valeur True si et
seulement si les deux sont True. L’opérateur and est commutatif.
Exemples
On suppose les variables var1Vrai, var2Vrai, var3Faux et var4Faux qui prennent les valeurs
booléennes, respequtivement, True, True, False et False.
[12]: var1Vrai=True
var2Vrai=True
var3Faux=False
var4Faux=False
Res1=var1Vrai and var2Vrai
Res2=var1Vrai and var3Faux
Res3=var3Faux and var4Faux
print('{} and {} = {}'.format(var1Vrai, var2Vrai,Res1))
print('{} and {} = {}'.format(var1Vrai, var3Faux,Res2))
print('{} and {} = {}'.format(var3Faux, var4Faux,Res3))

True and True = True

True and False = False
False and False = False
Evaluation d’une série d’opérations “and” sous Python
L’objectif de ce paragraphe est de comprendre la manière d’évaluation d’une succession d’opérations
and. Pour se faire, on propose les exemples suivants :
[13]: #Eval1
var1Vrai=True
var2Vrai=True
Res=var1Vrai and varNonDeclarer and var2Vrai
print(Res)

5
 ---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-13-05c8b68b7da3> in <module>
2 var1Vrai=True
3 var2Vrai=True
----> 4 Res=var1Vrai and varNonDeclarer and var2Vrai
5 print(Res)

NameError: name 'varNonDeclarer' is not defined

[14]: #Eval2
var1Vrai=True
var2Vrai=True
Res=var1Vrai and var2Vrai and varNonDeclarer
print(Res)

---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-14-1ca97353655d> in <module>
2 var1Vrai=True
3 var2Vrai=True
----> 4 Res=var1Vrai and var2Vrai and varNonDeclarer
5 print(Res)

NameError: name 'varNonDeclarer' is not defined

[15]: #Eval3
var1Vrai=True
var3Faux=False
Res=var3Faux and varNonDeclarer and var1Vrai
print(Res)

False

[16]: #Eval4
var1Vrai=True
var3Faux=False
Res=var1Vrai and var3Faux and varNonDeclarer
print(Res)

False
On remarque, pour Eval1 Python a décecté une erreur. Cette dernière est de type NameError.
Elle est relative à la variable varNonDeclarer qui est non déclarée. On peut dégager, que Python
commence son évalutation de gauche vers la droite, il Commence par l’évéluation de var1Vrai and
varNonDeclarer et ainsi de suite. Eval2 confirme cette hypothèse. Par contre, au niveau de Eval3,

6
 Python n’a pas détecté l’erreur précédemment citée, malgrés que la variable varNonDeclarer est,
toujours, non déclarée. Ceci entraine une nouvelle hypothèse. Elle se base sur le fait qu’une seule
valeur False dans une série d’opérations and évalue à False la série. Alors, Python arrête son
évaluation d’une série d’opérations and une fois il atteint la valeur False. En effet, Eval4 confirme
les deux hipothèses citées auparavant.

2.2.2 OR
L’opérateur or agit sur deux valeurs booléennes (True ou False) et prend la valeur True si et
seulement si au moins une est True. Autrement dit, il prend la valeur False uniquement lorsque les
deux valeurs sont False. L’opérateur or est commutatif.
Exemples
On suppose les variables var1Vrai, var2Vrai, var3Faux et var4Faux qui prennent les valeurs
booléennes, respequtivement, True,True, False et False.
[17]: var1Vrai=True
var2Vrai=True
var3Faux=False
var4Faux=False
Res1=var1Vrai or var2Vrai
Res2=var1Vrai or var3Faux
Res3=var3Faux or var4Faux
print('{} or {} = {}'.format(var1Vrai, var2Vrai,Res1))
print('{} or {} = {}'.format(var1Vrai, var3Faux,Res2))
print('{} or {} = {}'.format(var3Faux, var4Faux,Res3))

True or True = True

True or False = True
False or False = False
Evaluation d’une série d’opérations “or” sous Python
L’objectif de ce paragraphe est de comprendre la manière d’évaluation d’une succession d’opérations
or. Pour se faire, on propose les exemples suivants :
[18]: #Eval1
var1Faux=False
var2Faux=False
Res=var1Faux or varNonDeclarer or var2Faux
print(Res)

---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-18-ede9a0aee63c> in <module>
2 var1Faux=False
3 var2Faux=False
----> 4 Res=var1Faux or varNonDeclarer or var2Faux
5 print(Res)

7
 NameError: name 'varNonDeclarer' is not defined

[19]: #Eval2
var1Faux=False
var2Faux=False
Res=var1Faux or var2Faux or varNonDeclarer
print(Res)

---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-19-6bdcda876e64> in <module>
2 var1Faux=False
3 var2Faux=False
----> 4 Res=var1Faux or var2Faux or varNonDeclarer
5 print(Res)

NameError: name 'varNonDeclarer' is not defined

[20]: #Eval3
var1Vrai=True
var1Faux=False
Res=var1Vrai or varNonDeclarer or var1Faux
print(Res)

True

[21]: #Eval4
var1Vrai=True
var1Faux=False
Res=var1Faux or var1Vrai or varNonDeclarer
print(Res)

True
L’évaluation se fait toujours de gauche vers la droite. Ceci est confirmé, essentiellement, par Eval1,
Eval2 et Eval4. Par Eval3 et Eval4, on dégage, d’une manière similaire à une série d’opérations
and, que pour une série d’opérations or Python arrête l’évaluation une fois il atteint la valeur True.

2.2.3 Not
L’opérateur not agit sur une valeur booléenne (True ou False) et l’évalue à la valeur opposée (False
devient True et True devient False).
Exemple
[22]: varVrai=True
varFaux=False

8
 ResNotVarVrai=not varVrai
ResNotVarFalse=not varFaux
print('le résultat de not {} est {}.'.format(varVrai, ResNotVarVrai))
print('le résultat de not {} est {}.'.format(varFaux, ResNotVarFalse))

le résultat de not True est False.

le résultat de not False est True.

2.3 Expression Logique

Une expression logique est une combinaisons d’opérandes (variable ou constante) et d’opérateurs
logiques. Les opérateurs logiques sont des opérateurs relationnels et booléens. Ceci se fait selon
des règles bien définies. Ces règles peuvent se résumer en :
1. Si l’opératreur est binaire, donc, il doit être cerner par deux opérandes.
2. Les types des opérandes et les opérateurs doivent être compatible.
3. L’évalution se fait par ordre de priorité des opérateurs et de gauche vers la droite.
4. Pour les opérateurs booléens “not” est le plus prioritaire ensuite “and” et enfin “or”.
5. Les parenthèses sont plus prioritaires.
Exemple
[23]: a=5
b=6
d=5
Res1= not a > b and a != d or a != d
Res2= not (a > b) and (a != d) or (a != d)
Res3= (not (a > b) and (a != d)) or (a != d)
Res4= not ((a > b) and (a != d)) or (a != d)
Res5= not((a > b) and (a != d) or (a != d))
print(Res1)
print(Res2)
print(Res3)
print(Res4)
print(Res5)

False
False
False
True
True
On constate, par l’exemple précédent, que les parenthèses ajoutées dans les instructions associées à
Res2 et Res3, n’ont rien changé au niveau des résultats. En effet, ces parenthèses n’ont pas modifié
l’odre d’exécution des opérations. Elles offrent, peut être une lisibilité meilleurs, mais elles n’ont
aucun effet sur l’exécution. Res1, Res2 et Res3 sont équivalentes. L’évalution se fait toujour dans
l’odre suivant :
- eval1 : a > b => False
- eval2 : not eval1 => True

9
 - eval3 : a != d => False
- eval4: eval1 and eval3 => False
- eval5 : a != d => False
- eval6 : eval4 or eval5 => False
- résultat : eval6 => False
Par contre, pour les instructions associées à Res4 et Res5, les parenthèses ont modifié l’ordre
d’exécition. Par la suite, elles ont, même, modifié le résultat. Ainsi, l’ordre d’exécution des opéra-
tions est devenu :
1. Res4 : not ((a > b) and (a != d)) or (a != d)
1. eval1 : a > b => False
2. eval2 : a != d => False
3. eval3 : eval1 and eval2 => False
4. eval4 : not (eval3) => True
5. Res4 : eval4 => True
2. Res5 : not((a > b) and (a != d) or (a != d))
1. eval1 : a > b => False
2. eval2 : a != d => False
3. eval3 : eval1 and eval2 => False
4. eval4 : a != d => False
5. eval5 : eval3 or eval4 => False
6. eval6 : not eval5 => True
7. Res5 : eval6 => True

3 Opérateurs mathématiques
Les opérateurs mathématiques imitent les fonctions mathématiques de base, comme l’addition et
la multiplication. Parmis les opérateurs mathématiques, on a, déjà, vu l’opérateur d’affectation.
Dans cette section, on verra de plus près les autres opérateurs mathématiques fournis par Python.
Ces opérateurs obéissent au règles de priorité que vous connaissez en mathématique.

3.1 les Opérateurs de base

Les opérateurs mathématiques de base sont l’addition, la soustraction, la multiplication et la divi-
sion. Ils fonctionnent comme vous les connaissez en mathématique.
Exemple
[24]: cinq = 5
trois = 3
addition = cinq + trois
soustraction = cinq - trois
multiplication = cinq * trois
division = cinq / trois
print('cinq + trois = {}'.format(addition))
print('cinq - trois = {}'.format(soustraction))
print('cinq * trois = {}'.format(multiplication))

10
 print('cinq / trois = {}'.format(division))

cinq + trois = 8
cinq - trois = 2
cinq * trois = 15
cinq / trois = 1.6666666666666667

3.2 Autres opérateurs

Python, fournit d’autres opérateurs mathématiques. Ces opérateurs sont le reste de la division
entière (modulo), la division entière et la puissance. L’opérateur modulo en Python est symbolisé
par ” % “. Le double slash” // ” symbolise la divison entière. Pour exprimer l’opérateur puissance,
Python utilise le double étoile ” ** ”.
Exemple
[25]: cinq = 5
trois = 3
modulo = cinq % trois
divisionEntière = cinq // trois
puissance = cinq ** trois
print('cinq % trois = {}'.format(modulo))
print('cinq // trois = {}'.format(divisionEntière))
print('cinq ** trois = {}'.format(puissance))

cinq % trois = 2
cinq // trois = 1
cinq ** trois = 125

3.3 Raccourcis d’auto-affectation

L’auto-affectation est souvent utilisée dans la programmation. Ceci consiste à utiliser une seule
variable pour suivre l’évolution d’une valeur. Le changement de cette valeur soit basée d’une
manière ou d’une autre sur sa valeur actuelle. Compter, incrémenter et plusieurs autres tâches
impliqueront une auto-affectation. Python, comme plusieurs autres langages de programmation,
offre un raccourcis pour ce genre d’opération. Dans l’exemple qui suit, on verra la syntaxe fournie
par Python pour les raccourcis d’auto-affectation.
Exemple
[26]: varInt = 5
varInt+=1 # <==> (varInt = varInt + 1)
print(varInt)
varInt-=2 # <==> (varInt = varInt - 2)
print(varInt)
varInt*=10 # <==> (varInt = varInt * 10)
print(varInt)
varInt//=2 # <==> (varInt = varInt // 2)
print(varInt)

11
varInt%=7 # <==> (varInt = varInt %3)
print(varInt)
varInt/=2 # <==> (varInt = varInt / 2)
print(varInt)
varInt**=-5 # <==> (varInt = varInt ** -5)
print(varInt)

6
4
40
20
6
3.0
0.00411522633744856
Remarque : L’évalution d’une expression mathématique, qui est une combinaison d’opérandes et
opérateurs mathématiques, dépend du contexte. C’est-à-dire du type de données sur lesquelles les
opérateurs agissent.

12