Structures de contrôle en Python

Introduction

Dans cet atelier, vous allez explorer les structures de contrôle fondamentales de Python : les instructions conditionnelles et les boucles. En vous appuyant sur vos connaissances des ateliers précédents, vous apprendrez à diriger le flux de vos programmes à l'aide des instructions if-else, des boucles for et des boucles while. Cette expérience pratique approfondira votre compréhension des concepts clés de Python et vous préparera à rédiger des programmes plus complexes et dynamiques.

Comprendre les instructions conditionnelles

Dans cette étape, vous allez découvrir les instructions conditionnelles en Python, et plus particulièrement la structure if-else.

Ouvrez l'interpréteur Python en tapant la commande suivante dans votre terminal :

python

Vous devriez voir l'invite de commande Python (>>>), indiquant que vous êtes maintenant dans le shell interactif Python.

Commençons par une instruction if simple. Dans l'interpréteur Python, tapez ce qui suit :

age = 20
if age >= 18:
    print("You are an adult.")

Résultat :

You are an adult.

Conseils : Faites attention à l'indentation, elle est primordiale en Python. Il est recommandé d'utiliser quatre espaces pour l'indentation.

L'instruction if vérifie si la condition age >= 18 est vraie. Si c'est le cas, le bloc de code indenté est exécuté.

Ajoutons maintenant une clause else :

age = 15
if age >= 18:
    print("You are an adult.")
else:
    print("You are a minor.")

Résultat :

You are a minor.

La clause else permet de définir une action alternative lorsque la condition est fausse.

Pour des conditions plus complexes, nous pouvons utiliser des clauses elif (contraction de "else if") :

age = 65
if age < 13:
    print("You are a child.")
elif age < 20:
    print("You are a teenager.")
elif age < 65:
    print("You are an adult.")
else:
    print("You are a senior citizen.")

Résultat :

You are a senior citizen.

Les clauses elif vous permettent de vérifier plusieurs conditions à la suite.

N'oubliez pas que l'indentation est cruciale en Python. C'est elle qui définit les blocs de code associés à chaque condition.

Explorer les boucles "For"

Dans cette étape, vous allez apprendre à utiliser les boucles for, qui servent à parcourir des séquences (comme des listes, des chaînes de caractères ou des plages de nombres) en Python.

Commençons par une boucle for simple utilisant une plage de valeurs. Dans l'interpréteur Python, tapez :

for i in range(5):
    print(i)

Résultat :

0
1
2
3
4

La fonction range(5) génère une séquence de nombres allant de 0 à 4, et la boucle parcourt chaque nombre.

La fonction range() peut prendre plusieurs arguments pour spécifier le début, la fin et le pas (l'incrément). Essayons une plage différente :

for i in range(1, 10, 2):
    print(i)

Résultat :

1
3
5
7
9

• La fonction range(1, 10, 2) génère une séquence de nombres commençant à 1, allant jusqu'à 10 (exclu), avec un pas de 2.

Maintenant, parcourons une liste :

fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(f"I like {fruit}")

Résultat :

I like apple
I like banana
I like cherry

Ici, la boucle parcourt chaque élément de la liste fruits.

Vous pouvez également utiliser les boucles for avec des chaînes de caractères :

for char in "Python":
    print(char.upper())

Résultat :

P
Y
T
H
O
N

Cette boucle parcourt chaque caractère de la chaîne "Python".

Combinons une boucle for avec des instructions conditionnelles :

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
for num in numbers:
    if num % 2 == 0:
        print(f"{num} is even")
    else:
        print(f"{num} is odd")

Résultat :

1 is odd
2 is even
3 is odd
4 is even
5 is odd
6 is even
7 is odd
8 is even
9 is odd
10 is even

Cette boucle vérifie chaque nombre de la liste et affiche s'il est pair (even) ou impair (odd).

Comprendre l'opérateur modulo (%) : Le symbole % est appelé l'opérateur modulo. Il renvoie le reste d'une division entière. Par exemple :

• 5 % 2 vaut 1 (car 5 divisé par 2 donne 2, avec un reste de 1)
• 4 % 2 vaut 0 (car 4 divisé par 2 donne 2, avec un reste de 0)
• 10 % 3 vaut 1 (car 10 divisé par 3 donne 3, avec un reste de 1)

Lorsque nous vérifions num % 2 == 0, nous demandons : "Est-ce que la division de ce nombre par 2 laisse un reste de 0 ?". Si la réponse est oui, le nombre est pair. Si le reste est 1, le nombre est impair. L'opérateur == est l'opérateur de comparaison d'égalité qui vérifie si deux valeurs sont identiques.

Comprendre les boucles "While"

Dans cette étape, vous allez découvrir les boucles while, qui permettent de répéter un bloc de code tant qu'une condition est vraie.

Commençons par une boucle while simple. Dans l'interpréteur Python, tapez :

count = 0
while count < 5:
    print(count)
    count += 1

Résultat :

0
1
2
3
4

Cette boucle continue de s'exécuter tant que la variable count est inférieure à 5.

Les boucles while sont souvent utilisées lorsque vous ne savez pas à l'avance combien de fois vous devrez itérer. Voici un exemple :

import random
number = random.randint(1, 10)
guess = 0
while guess != number:
    guess = int(input("Guess a number between 1 and 10: "))
    if guess < number:
        print("Too low!")
    elif guess > number:
        print("Too high!")
    else:
        print(f"Congratulations! You guessed the number {number}!")

Cela crée un jeu de devinettes simple où l'utilisateur continue de proposer des nombres jusqu'à ce qu'il trouve le bon. Lorsque la proposition de l'utilisateur correspond au nombre généré, la clause else s'exécute et affiche le message de félicitations.

Soyez prudent avec les boucles while : si la condition ne devient jamais fausse, vous créerez une boucle infinie. Voici un exemple (ne l'exécutez pas réellement) :

while True:
    print("This will print forever!")

Si vous lancez accidentellement une boucle infinie, vous pouvez l'arrêter en appuyant sur Ctrl+C.

Vous pouvez utiliser l'instruction break pour quitter une boucle prématurément :

count = 0
while True:
    print(count)
    count += 1
    if count >= 5:
        break

Résultat :

0
1
2
3
4

Cette boucle devrait normalement tourner indéfiniment, mais l'instruction break l'interrompt dès que count atteint 5.

Boucles imbriquées et instructions de contrôle de boucle

Dans cette étape, vous allez découvrir les boucles imbriquées et d'autres instructions de contrôle de boucle.

Les boucles imbriquées sont des boucles placées à l'intérieur d'autres boucles. Voici un exemple de boucles for imbriquées :

for i in range(3):
    for j in range(2):
        print(f"i: {i}, j: {j}")

Résultat :

i: 0, j: 0
i: 0, j: 1
i: 1, j: 0
i: 1, j: 1
i: 2, j: 0
i: 2, j: 1

La boucle intérieure effectue toutes ses itérations pour chaque itération de la boucle extérieure.

En plus de break, Python propose l'instruction continue, qui permet de sauter le reste de l'itération actuelle et de passer directement à la suivante :

for num in range(10):
    if num % 2 == 0:
        continue
    print(num)

Résultat :

1
3
5
7
9

Cette boucle n'affiche que les nombres impairs, en sautant les nombres pairs.

Comprendre l'opérateur modulo dans ce contexte : Ici, num % 2 == 0 vérifie si le nombre est pair. Lorsque cette condition est vraie, l'instruction continue ignore la ligne print(num) et passe à l'élément suivant. Ainsi, seuls les nombres impairs atteignent l'instruction d'affichage.

Vous pouvez également utiliser des clauses else avec les boucles. Le bloc else est exécuté si la boucle se termine normalement (c'est-à-dire sans avoir rencontré d'instruction break) :

for num in range(2, 10):
    for i in range(2, num):
        if num % i == 0:
            print(f"{num} is not prime")
            break
    else:
        print(f"{num} is prime")

Résultat :

2 is prime
3 is prime
4 is not prime
5 is prime
6 is not prime
7 is prime
8 is not prime
9 is not prime

Cette boucle imbriquée permet d'identifier les nombres premiers. La clause else (associée à la boucle for i) n'est exécutée que si aucun diviseur n'a été trouvé, signifiant que le nombre est premier.

Mise en pratique globale

Dans cette dernière étape, vous allez créer un programme simple qui utilise les structures de contrôle apprises au cours de cet atelier.

Quittez l'interpréteur Python en tapant exit() ou en appuyant sur Ctrl+D.

Ouvrez l'interface WebIDE dans l'environnement virtuel LabEx.

Créez un nouveau fichier nommé number_analyzer.py dans le répertoire ~/project à l'aide de la commande suivante :

touch ~/project/number_analyzer.py

Ouvrez le fichier fraîchement créé dans l'éditeur WebIDE.

Copiez et collez le code suivant dans le fichier :

def analyze_numbers():
    numbers = []
    while True:
        user_input = input("Enter a number (or 'done' to finish): ")
        if user_input.lower() == 'done':
            break
        try:
            number = float(user_input)
            numbers.append(number)
        except ValueError:
            print("Invalid input. Please enter a number or 'done'.")

    if not numbers:
        print("No numbers entered.")
        return

    total = sum(numbers)
    average = total / len(numbers)
    maximum = max(numbers)
    minimum = min(numbers)

    print(f"\nAnalysis of {len(numbers)} numbers:")
    print(f"Total: {total}")
    print(f"Average: {average:.2f}")
    print(f"Maximum: {maximum}")
    print(f"Minimum: {minimum}")

    print("\nNumber distribution:")
    for num in numbers:
        if num < average:
            print(f"{num} is below average")
        elif num > average:
            print(f"{num} is above average")
        else:
            print(f"{num} is equal to average")

if __name__ == "__main__":
    analyze_numbers()

Ce programme illustre l'utilisation des boucles while, des boucles for, des instructions conditionnelles et de la gestion des exceptions.

Enregistrez le fichier (la sauvegarde automatique est activée) et exécutez-le à l'aide de la commande suivante dans le terminal :

python ~/project/number_analyzer.py

Saisissez quelques nombres lorsque vous y êtes invité, puis tapez 'done' pour voir l'analyse. Vous devriez obtenir un résultat similaire à celui-ci :

Enter a number (or 'done' to finish): 10
Enter a number (or 'done' to finish): 20
Enter a number (or 'done' to finish): 30
Enter a number (or 'done' to finish): 40
Enter a number (or 'done' to finish): done

Analysis of 4 numbers:
Total: 100.0
Average: 25.00
Maximum: 40.0
Minimum: 10.0

Number distribution:
10.0 is below average
20.0 is below average
30.0 is above average
40.0 is above average

Si vous faites une erreur lors de la saisie des données, vous pouvez relancer le programme. C'est une excellente occasion de s'entraîner à exécuter des scripts Python plusieurs fois avec des entrées différentes.

Résumé

Dans cet atelier, vous avez exploré les structures de contrôle fondamentales de Python : les instructions conditionnelles (if-else), les boucles for et les boucles while. Vous avez appris à diriger le flux de vos programmes, à prendre des décisions basées sur des conditions et à parcourir des séquences de données. Vous vous êtes également exercé à utiliser des boucles imbriquées et des instructions de contrôle comme break et continue.

Ces structures de contrôle constituent l'épine dorsale de la programmation en Python, vous permettant de créer des programmes plus complexes et dynamiques. Vous avez vu comment ces concepts peuvent être combinés pour créer un programme utile capable d'analyser un ensemble de nombres saisis par l'utilisateur.

Au fil de votre apprentissage de Python, vous constaterez que ces structures de contrôle sont essentielles pour résoudre une grande variété de problèmes de programmation. N'oubliez pas de pratiquer ces concepts régulièrement, en expérimentant différentes combinaisons et cas d'utilisation pour renforcer votre compréhension.