5 Les structures de contrôle

Les structures de contrôle servent à structurer l’exécution du code. Elles permettent de définir des blocs qui vont être exécutés de manière conditionnelle ou en boucle.

Le bloc est un ensemble d’instructions qui est précédé d’un en tête. Un en tête est une ligne qui commence par un mot clef et se termine par deux points (:).

En Python, il n’y a pas de délimiteur pour le bloc d’instructions comme les accolades. Un bloc est défini par l’indentation par rapport à la déclaration. Cette indentation est un retrait de 4 espaces (PEP8).

5.1 Les structures

5.1.1 Les blocs

Les blocs sont donc un ensemble d’instructions exécutées en fonction de l’en tête qui le précède. Ces instructions sont indentées par rapport à la déclaration, c’est à dire qu’ils sont en retrait. Ce retrait est défini par la pep 8 comme étant de 4 espaces.

Veillez donc à vous assurer que votre éditeur de code convertisse les tabulations en 4 espaces.

5.1.2 L’instruction `pass`

L’instruction pass est une instruction que ne fait… rien. Après une déclaration de bloc (que ce soit une structure de contrôle, une déclaration de fonction ou de classe), l’interpréteur attends une ligne indentée. Si vous n’avez aucune instruction à déclarer dans le bloc (voir les cas lors de la formation), l’instruction pass permet de ne pas avoir d’erreur d’interprétation.

if True:
    pass

5.1.3 Exécution conditionnelle avec `if`

L’instruction if permet d’exécuter un bloc d’instructions de manière conditionnelle.

if knight == "Arthur":
    print("Is the King")

Une ou plusieurs conditions alternatives peuvent être déclarées avec l’instruction elif. L’instruction else permet de gérer tous les autres cas.

if knight == "Arthur":
    print("Is the King")
 elif knight == "Robin":
    print("He's not that brave")
 else:
    print("Who's that lad ?")

Les différentes conditions sont exclusives. À la première condition évaluée à vrai (True), l’interpréteur exécute le bloc puis sort de la structure conditionnelle.

La condition, aussi appelée structure de contrôle, doit retourner une expression booléenne. Cette expression peut aussi bien être le retour d’une fonction que le résultat d’un opérateur de comparaison ou d’un opérateur logique.

5.1.4 Les opérateurs de comparaison

Les opérateurs de comparaisons entre deux déclarations sont :

<	Strictement inférieur à
>	Strictement supérieur à
<=	Inférieur ou égal à
>=	Supérieur ou égal à
==	Égal à
!=	Différent de

Python permet également l’évaluation de l’identité par le mot réservé is. Attention, is doit être utilisé avec des valeurs comme None, True ou False car il s’agit de comparer avec ces types et non des valeurs.

5.1.5 Les valeurs booléennes

N’importe quel objet en Python peut être évalué à vrai ou faux. Le type booléen (bool) est le seul à représenter cette notion, mais pour tous les autres types, Python peut reconnaitre que certaines valeurs auront le sens de faux. Dans le cas des types de base, voici le comportement :

Type	FAUX
Bool	False
int	0
float	0.0
string	“”
tuple	()
list	[]
dict	{}
None Type	None

Ainsi en Python, il n’est pas nécessaire d’écrire certaines comparaisons.

5.1.6 Les opérateurs logiques

Les opérateurs logiques, nom utilisé pour les valeurs de vérité de l’algèbre de Bool, sont la conjonction (et), la disjonction (ou) et la négation (non). En Python, les mots-clef respectifs sont and, or et not.

Soient X et Y deux expressions qui retournent une valeur booléenne.

Conjonction : X ET Y est vrai si et seulement si X est vrai et Y est vrai
En python, elle s’écrit X and Y
Disjonction : X OU Y est vrai si et seulement si X est vrai ou Y est vrai
En python, elle s’écrit X or Y
Négation : la négation de X est vrai si et seulement si X est faux
En python, elle s’écrit not X

En python, les fonctions de conjonction et de disjonction sont des opérations paresseuses. Si l’évaluation du premier terme ne laisse aucun doute sur le résultat de l’opération (si X est faux pour une conjonction ou X est vrai pour une disjonction), le second terne n’est pas évalué. Gardez ceci à l’esprit si les expressions sont des appels de fonctions.

5.1.7 Chainage des opérateurs de comparaison

Au lieu d’utiliser l’opérateur logique and, il est possible dans certains cas de chainer les opérateurs.

In [1]: x = 10                                                                  

In [2]: x > 0 and x < 10                                                        
Out[2]: False

In [3]: 0 < x < 10                                                              
Out[3]: False

Ceci permet une syntaxe similaire à ce que nous écrivons.

5.1.8 Comparaison de tuples

Dans le même ordre d’idée, les tuples pouvant être comparés, la comparaison est similaire à l’opérateur logique and.

In [8]: x1 == y1 and x2 == y2                                                   
Out[8]: True

In [9]: (x1, x2) == (y1, y2)                                                    
Out[9]: True