Vidéo 6 : Comparaisons

\(\newcommand{\ds}{\displaystyle}\) \(\newcommand{\Frac}{\ds\frac}\) \(\renewcommand{\r}{\mathbb{ R}}\) \(\newcommand{\C}{\mathbb{ C}}\) \(\newcommand{\n}{\mathbb{ N}}\) \(\newcommand{\z}{\mathbb{ Z}}\) \(\newcommand{\Q}{\mathbb{ Q}}\) \(\newcommand{\N}{\mathbb{ N}}\) \(\newcommand{\n}{\mathbb{ N}}\) \(\newcommand{\ol}{\overline}\) \(\newcommand{\abs}[1]{\left| \,{#1} \right|}\) \(\newcommand{\pv}{\;;\;}\) \(\newcommand{\ens}[1]{\left\{ {#1} \right\}}\) \(\newcommand{\mens}[1]{\setminus\left\{ {#1} \right\}}\) \(\newcommand{\Par}[1]{\left({#1}\right)}\)

Vidéo 6 : Comparaisons

Opérateurs « égale à » et « différent de »

Opérateur ==

On peut tester l’égalité de valeur de deux objets avec l’opérateur == :

1
2
print(42 == 21 + 21)
print(42 == 10 + 10)

3
4
True
False
  • Lignes 3 : si les valeurs sont égales l’opérateur == ligne 1 renvoie la valeur logique True
  • Ligne 4 : si les valeurs comparées ne sont pas égales (42 et 20) l’opérateur == renvoie False.

Il faut effectivement écrire deux fois de suite le signe =, sans espace entre les deux.

Quand on lit True (ligne 1, ligne 4), il faut comprendre que l’expression 42 == 21 + 21 est un « machin » (un objet pour être correct) qui vaut True. Le code ci-dessous permet peut-être de mieux le comprendre :

1
2
machin = (42 == 21 + 21)
print(machin)

3
True

Opérateur !=

Pour tester si deux objets ont des valeurs distinctes, on utilise l’opérateur != (lire : différent de). C’est l’opérateur « contraire » de == :

1
2
print(42 != 21 + 21)
print(42 != 10 + 10)

3
4
False
True

Comparaison de nombres

Le langage Python dispose d’opérateurs permettant d’effectuer des comparaisons de nombres :

1
2
3
4
print(42 > 24)
print(42 <= 24)
print(3.14159 < 2.71828)
print(24 >= 2 * 12)

5
6
7
8
True
False
False
True

On peut comparer des nombres au sens des opérateurs mathématiques suivants :

\(< \quad \leq \quad >\quad \geq\)

En Python, on utilise les opérateurs suivants :

<, <=, > et >=

Une comparaison renvoie un booléen True ou False (Vrai ou Faux) qui précise si l’inégalité écrite est vraie ou fausse.

Encadrement

On peut utiliser les opérateurs de comparaison en les enchaînant, comme on le fait usuellement en mathématiques :

1
2
print(42 < 81 < 100 <= 512)
print(42 < 81 < 100 < 100)

3
4
True
False

Comparaison de flottants

L’arithmétique en nombres flottants est approchée. L’exemple ci-dessous illustre le type de problème rencontré :

1
print(6 * 0.7 == 4.2)

2
False
  • Ligne 1: mathématiquement, \(6\times 0,7 = 4,2\)
  • Ligne 2 : pourtant, Python ne considère pas les deux nombres comme identiques !

De même :

1
print(42/6==4.2/0.6)

2
False

Cette limitation provient l’impossibilité de représenter exactement en base 2 et avec un nombre limité de bits certains nombre réels.

D’où la conséquence suivante :

Règle fondamentale : on n’utilise jamais l’opérateur == pour comparer deux flottants.

Confusion entre égalité et affectation

Le signe = est le signe de l’affectation. Il ne faut pas le confondre avec l’opérateur == d’égalité de valeurs. C’est un source fréquente d’erreur d’inattention, y compris chez les programmeurs non débutants.

Assez souvent, la confusion déclenche un message d’erreur :

1
2
x == 42
print(x)

2
3
4
5
Traceback (most recent call last):
  File "_.py", line 1, in <module>
    x == 42
NameError: name 'x' is not defined
  • Ligne 1 : confusion de == avec = : la ligne examine si les valeurs de x et 42 sont égales mais x n’a pas été défini.
  • Ligne 6 : la nature de l’erreur est confirmée par le message.

Autre erreur possible :

1
2
x = 42
print(x = 421)

2
3
4
5
Traceback (most recent call last):
  File "egalite_vs_affectation.py", line 2, in <module>
    print(x = 421)
TypeError: 'x' is an invalid keyword argument for this function
  • Ligne 2 : confusion de = avec == (une affectation n’est pas une expression donc on ne peut pas l’afficher)
  • Lignes 3-6 : l’erreur est plus difficile à interpréter et nécessite des connaissances plus poussées sur la fonction print et les fonctions en général.

Mais parfois, il n’y a aucun déclenchement d’erreur :

1
2
3
4
x = 42
print(x)
x == 100
print(x)

5
6
42
42
  • Ligne 3 : sans doute le programmeur voulait-il écrire une nouvelle affectation x = 100. Mais cette erreur de programmation ne déclenche aucune erreur d’exécution.