Tutoriel 2: Structure de contrôle

2.2.1. Tutoriel 2: Structure de contrôle#

La première chose à savoir est que les programmes Python (ou scripts Python) sont généralement exécutés de manière séquentielle et qu’une instruction de code ne sera pas exécutée plusieurs fois sauf indication contraire.

Dans la pratique, vous aurez souvent besoin d’exécuter un bloc de code plusieurs fois, ou d’exécuter une partie d’un code en fonction de différentes conditions. Nous utilisons les structures de contrôle pour gérer ces cas plus complexes.

Dans cette section, nous aborderons les points suivants:

Les instructions conditionnelles – if, else et elif
Instructions de boucle – for, while
Instructions de contrôle de boucle – break, continue, pass
Indentation

Référence:

IBM Congnitive Class - Intro to Python (computationalcore/introduction-to-python)
CUSP UCSL bootcamp 2017 (Mohitsharma44/ucsl17)

2.2.1.1. Les instructions conditionnelles#

Nous combinons ici les opérateurs relationnels et logiques pour permettre à un programme de suivre différents flux d’exécution. En d’autres termes, certains extraits de code ne sont exécutés que si certaines conditions sont remplies.

La logique des déclarations conditionnelles est simple. if (si) ➡ condition remplie ➡ faire quelque chose. if (si) ➡ condition non remplie ➡ faire autre chose.

x = 100
if x > 0:
    print('Nombre positif')
elif x < 0:
    print('Nombre négatif')
else:
    print ('Zéro!')

Nombre positif

# l'indentation est OBLIGATOIRE
# les blocs sont fermés par un niveau d'indentation
if x > 0:
    print('Nombre positif')
    if x >= 100:
        print('Nombre élevé!')

Nombre positif
Nombre élevé!

2.2.1.2. Instructions de boucle#

Nous utilisons les instructions de boucle lorsque nous voulons exécuter plusieurs fois certaines instructions de code. Voici un exemple de cas où il serait approprié d’utiliser des instructions de boucle :

Si nous avons plusieurs fichiers de données à traiter.
Nous utilisons une instruction de boucle pour lire les fichiers en mémoire de manière itérative.
Dans les instructions de boucle, nous exécutons le même algorithme de traitement sur les données importées.

En langage Python, il existe deux types principaux d’instructions de boucle : Les boucles “while” et les boucles “for”.

# utiliser la gamme [range(5)==[0,1,2,3,4]]
for i in range(5):
    print(i)

Tip

Ici, nous utilisons la fonction range() pour créer une séquence de nombres afin de piloter la boucle for.

range(N) crée une liste de N nombres qui commence par 0. range(A,B) crée une liste de nombres commençant par A et se terminant par B-1.\N- **range(A,B,B) crée une liste de nombres commençant par A et se terminant par B-1. range(A,B,step) commence et se termine par les mêmes nombres que range(A,B). La seule différence est que la différence entre les nombres passe de 1 à pas

Nous pouvons également utiliser des itérateurs non numériques pour piloter des boucles for !

# itérer sur une liste que nous créons, et accéder à la fois aux indices et aux éléments avec enumerate()
for index,pet in enumerate(['dog', 'cat', 'fish']):
    print(index, pet, len(pet))

dog 3
cat 3
fish 4

Comme nous pouvons le voir, la boucle for est appropriée si vous voulez répéter les opérations dans la boucle pour un nombre fixe de fois N. Mais que se passe-t-il si vous n’avez aucune idée du nombre de fois que vous souhaitez répéter un extrait de code ? Ce n’est pas un problème trivial et il se produit souvent dans les problèmes d’optimisation numérique.

Pour ces problèmes, nous allons renoncer à la boucle for et utiliser la boucle while à la place. La fin d’une boucle while dépend de la satisfaction ou non d’une condition. En théorie, la boucle peut fonctionner indéfiniment si la condition que vous avez fixée est toujours vraie.

# faire une boucle
count = 0
while count < 10:
    # mauvaise manière
    # count = count + 1
    # meilleure manière
    count += 1
print(count)

2.2.1.3. Instructions de contrôle de boucle#

Il arrive que l’on veuille faire dévier l’exécution d’une boucle de son comportement normal. Nous voulons peut-être quitter la boucle lorsque certaines conditions sont remplies pour gagner du temps. Nous pouvons aussi vouloir que la boucle saute du code si les données satisfont à certaines conditions.

Deux instructions de contrôle sont très utiles dans ce cas : break et continue. Nous utiliserons une boucle for comme exemple :

for i in range(1, 10):
    if i == 5:
        print('Condition satisfaite')
        break
    print(i)  # Que se passerait-il si cette condition était placée avant la condition "if" ?

1
2
3
4
Condition satisfaite

for i in range(1, 10):
    if i == 5:
        print('Condition satisfaite')
        continue
        print("Quoi qu'il en soit. De toute façon, je ne serai pas imprimé.")
    print(i)

1
2
3
4
Condition satisfaite
6
7
8
9

for i in range(1, 10):
    if i == 5:
        print('Condition satisfaite')
        pass
    print(i)

1
2
3
4
Condition satisfaite
5
6
7
8
9

2.2.1.4. Indentation#

L’indentation est un aspect fondamental de la programmation Python qui détermine la structure et le flux d’exécution de votre code. Contrairement à d’autres langages de programmation qui utilisent des accolades {} ou des mots-clés tels que begin et end pour définir des blocs de code, Python s’appuie sur l’indentation.

Pourquoi l’indentation ? L’indentation rend le code plus lisible et assure une structure propre et cohérente. Elle permet également d’identifier visuellement la portée des instructions dans les structures de contrôle telles que les boucles et les conditionnelles.

Règles de base :

Espaces, pas les tabulations: Utilisez des espaces pour l’indentation, pas des tabulations. Python est sensible au nombre d’espaces utilisés pour l’indentation, et le mélange de tabulations et d’espaces peut entraîner des erreurs.
Indentation cohérente: Respectez le nombre d’espaces utilisés pour l’indentation dans l’ensemble de votre code. La convention courante est d’utiliser quatre espaces.
Indentation dans les blocs: Toutes les instructions d’un bloc doivent être indentées de la même manière. Cela définit la portée du bloc.

# Exemple d'indentation correcte
if True:
    print("Cette déclaration est à l'intérieur du bloc if.")
    print("Tout comme celle-ci.")

# Exemple d'indentation incorrecte
if True:
  print("Cette déclaration a une indentation incohérente.")
    print("Celle-ci provoquera une erreur.")

  Cell In[9], line 9
    print("Celle-ci provoquera une erreur.")
    ^
IndentationError: unexpected indent

2.2.1.4.1. Structures de contrôle :#

Instructions if-else:

Indentez le code à l'intérieur des blocs `if` et `else`.

x = 10
if x > 5:
    print("x est supérieur à 5")
else:
    print("x n'est pas supérieur à 5")

Boucles for :

Indentez le code à l'intérieur du bloc de la boucle for.

for i in range(5):
    print("Itération :", i)

Boucles while :

Indentez le code à l'intérieur du bloc de la boucle while.

compte = 0
while compte < 5:
    print("Compte :", compte)
    compte += 1

Comprendre et suivre les bonnes pratiques d’indentation est essentiel pour écrire un code Python propre et lisible. Cela aide à éviter les erreurs de syntaxe et contribue à la maintenabilité globale de vos programmes.

N’hésitez pas à expérimenter avec ces exemples dans votre environnement Python pour obtenir une expérience pratique de l’indentation !