PYTHON pour les DÉBUTANTS #10#

Les boucles avancées en Python#

Maintenant que vous maîtrisez les bases des boucles, découvrons les techniques avancées qui vous permettront d’écrire du code plus efficace et élégant.

Boucles imbriquées#

Explication

Les boucles imbriquées permettent de traiter des structures de données complexes comme des matrices, des tableaux à deux dimensions, ou des listes de listes.

Exemple de base#

1
# Table de multiplication
2
for i in range(1, 4):
3
    for j in range(1, 4):
4
        print(f"{i} x {j} = {i * j}")
5
    print()  # Ligne vide entre les tables

Traitement de matrices#

1
# Matrice 3x3
2
matrice = [
3
    [1, 2, 3],
4
    [4, 5, 6],
5
    [7, 8, 9]
6
]
7

8
# Parcourir la matrice
9
for ligne in range(len(matrice)):
10
    for colonne in range(len(matrice[ligne])):
11
        print(f"Position [{ligne}][{colonne}] = {matrice[ligne][colonne]}")

Recherche dans une liste de listes#

1
# Liste d'étudiants avec leurs notes
2
etudiants = [
3
    ["Alice", [15, 18, 12]],
4
    ["Bob", [14, 16, 19]],
5
    ["Charlie", [17, 13, 16]]
6
]
7

8
# Calculer la moyenne de chaque étudiant
9
for nom, notes in etudiants:
10
    moyenne = sum(notes) / len(notes)
11
    print(f"{nom}: {moyenne:.2f}")

Contrôle de flux avec break et continue#

L’instruction `break`#

Définition

break permet de sortir complètement d’une boucle, interrompant toutes les itérations restantes.

1
# Recherche d'un élément dans une liste
2
nombres = [1, 3, 5, 7, 9, 11, 13, 15]
3
recherche = 7
4
trouve = False
5

6
for nombre in nombres:
7
    if nombre == recherche:
8
        trouve = True
9
        print(f"Trouvé ! {recherche} est dans la liste")
10
        break
11
    print(f"Vérification de {nombre}...")
12

13
if not trouve:
14
    print(f"{recherche} n'est pas dans la liste")

L’instruction `continue`#

Définition

continue permet de passer à l’itération suivante sans exécuter le reste du code dans la boucle actuelle.

1
# Afficher seulement les nombres pairs
2
nombres = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
3

4
for nombre in nombres:
5
    if nombre % 2 != 0:  # Si impair
6
        continue  # Passer au suivant
7
    print(f"{nombre} est pair")

Exemple combiné#

1
# Traitement de données avec conditions
2
donnees = [10, -5, 0, 15, -3, 20, 0, -8]
3

4
for valeur in donnees:
5
    if valeur == 0:
6
        print("Valeur nulle ignorée")
7
        continue
8

9
    if valeur < 0:
10
        print(f"Valeur négative trouvée: {valeur}")
11
        break
12

13
    print(f"Traitement de: {valeur}")

Boucles avec `else`#

Conseil

En Python, les boucles peuvent avoir une clause else qui s’exécute si la boucle se termine normalement (sans break). C’est une fonctionnalité unique à Python !

Exemple avec recherche#

1
# Recherche avec `python:else`
2
nombres = [1, 3, 5, 7, 9]
3
recherche = 4
4

5
for nombre in nombres:
6
    if nombre == recherche:
7
        print(f"Trouvé ! {recherche}")
8
        break
9
else:
10
    print(f"{recherche} n'a pas été trouvé dans la liste")

Vérification de primalité#

1
# Vérifier si un nombre est premier
2
def est_premier(n):
3
    if n < 2:
4
        return False
5

6
    for i in range(2, int(n ** 0.5) + 1):
7
        if n % i == 0:
8
            return False
9
    return True
10

11
# Test de primalité
12
nombre = 17
13
if est_premier(nombre):
14
    print(f"{nombre} est premier")
15
else:
16
    print(f"{nombre} n'est pas premier")

Compréhensions de listes avancées#

Explication

Les compréhensions de listes sont une syntaxe concise et élégante pour créer des listes en Python. Elles remplacent souvent les boucles for traditionnelles pour créer des listes.

Compréhensions imbriquées#

1
# Matrice de multiplication
2
table = [[i * j for j in range(1, 4)] for i in range(1, 4)]
3
print(table)
4
# [[1, 2, 3], [2, 4, 6], [3, 6, 9]]
5

6
# Aplatir une liste de listes
7
matrice = [[1, 2], [3, 4], [5, 6]]
8
aplatie = [element for ligne in matrice for element in ligne]
9
print(aplatie)  # [1, 2, 3, 4, 5, 6]

Compréhensions avec conditions#

1
# Nombres pairs au carré
2
nombres = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
3
carres_pairs = [x**2 for x in nombres if x % 2 == 0]
4
print(carres_pairs)  # [4, 16, 36, 64, 100]
5

6
# Mots de plus de 3 caractères en majuscules
7
mots = ["chat", "chien", "poisson", "oiseau", "lapin"]
8
mots_longs = [mot.upper() for mot in mots if len(mot) > 3]
9
print(mots_longs)  # ['CHIEN', 'POISSON', 'OISEAU', 'LAPIN']

Fonctions avec `enumerate()` et `zip()`#

`enumerate()` - Parcourir avec index#

Conseil

enumerate() est parfaite quand vous avez besoin à la fois de l’élément et de son index lors du parcours d’une séquence.

1
# Parcourir une liste avec l'index
2
fruits = ["pomme", "banane", "orange"]
3

4
for index, fruit in enumerate(fruits):
5
    print(f"{index + 1}. {fruit}")
6

7
# enumerate avec start
8
for index, fruit in enumerate(fruits, start=1):
9
    print(f"{index}. {fruit}")

`zip()` - Parcourir plusieurs listes#

1
# Parcourir plusieurs listes simultanément
2
noms = ["Alice", "Bob", "Charlie"]
3
ages = [25, 30, 35]
4
villes = ["Paris", "Lyon", "Marseille"]
5

6
for nom, age, ville in zip(noms, ages, villes):
7
    print(f"{nom}, {age} ans, habite à {ville}")
8

9
# Créer un dictionnaire avec zip
10
personnes = dict(zip(noms, zip(ages, villes)))
11
print(personnes)

Optimisation des boucles#

Important

L’optimisation des boucles peut grandement améliorer les performances de votre code, surtout quand vous traitez de grandes quantités de données.

Éviter les recalculs#

1
# ❌ Inefficace - recalcul à chaque itération
2
nombres = [1, 2, 3, 4, 5]
3
for i in range(len(nombres)):
4
    if len(nombres) > 3:  # Recalculé à chaque fois
5
        print(nombres[i])
6

7
# ✅ Efficace - calcul une seule fois
8
nombres = [1, 2, 3, 4, 5]
9
longueur = len(nombres)
10
if longueur > 3:
11
    for i in range(longueur):
12
        print(nombres[i])

Utiliser les méthodes intégrées#

1
# ❌ Boucle manuelle
2
nombres = [1, 2, 3, 4, 5]
3
total = 0
4
for nombre in nombres:
5
    total += nombre
6

7
# ✅ Méthode intégrée
8
nombres = [1, 2, 3, 4, 5]
9
total = sum(nombres)

Boucles avec générateurs#

Explication

Les générateurs permettent de créer des itérateurs de manière efficace en termes de mémoire. Ils génèrent les valeurs à la demande avec yield au lieu de les stocker toutes en mémoire.

Générateurs simples#

1
# Générateur de nombres pairs
2
def nombres_pairs(maximum):
3
    for i in range(0, maximum, 2):
4
        yield i
5

6
# Utilisation
7
for nombre in nombres_pairs(10):
8
    print(nombre)  # 0, 2, 4, 6, 8

Générateurs avec conditions#

1
# Générateur de nombres premiers
2
def nombres_premiers(maximum):
3
    for nombre in range(2, maximum):
4
        if est_premier(nombre):
5
            yield nombre
6

7
# Utilisation
8
for premier in nombres_premiers(20):
9
    print(premier)  # 2, 3, 5, 7, 11, 13, 17, 19

Cas d’usage pratiques#

Traitement de fichiers#

1
# Lire un fichier ligne par ligne
2
def lire_fichier(nom_fichier):
3
    try:
4
        with open(nom_fichier, 'r', encoding='utf-8') as fichier:
5
            for numero_ligne, ligne in enumerate(fichier, start=1):
6
                ligne = ligne.strip()
7
                if ligne:  # Ignorer les lignes vides
8
                    print(f"Ligne {numero_ligne}: {ligne}")
9
    except FileNotFoundError:
10
        print(f"Le fichier {nom_fichier} n'existe pas")

Simulation de jeu#

1
# Simulation de lancers de dés
2
import random
3

4
def simuler_des(nb_lancers):
5
    resultats = []
6
    for _ in range(nb_lancers):
7
        de1 = random.randint(1, 6)
8
        de2 = random.randint(1, 6)
9
        resultats.append((de1, de2, de1 + de2))
10
    return resultats
11

12
# Simulation
13
lancers = simuler_des(10)
14
for i, (de1, de2, total) in enumerate(lancers, start=1):
15
    print(f"Lancer {i}: {de1} + {de2} = {total}")

Exercices pratiques#

Conseil

Table de multiplication : Créez une table de multiplication complète avec des boucles imbriquées.
Recherche dans une matrice : Trouvez un élément dans une matrice et affichez sa position.
Analyse de données : Traitez une liste de notes et calculez les statistiques.
Générateur de mots de passe : Créez un générateur de mots de passe aléatoires.

Conclusion#

Les boucles avancées en Python offrent une grande flexibilité :

Boucles imbriquées : Pour traiter des structures complexes
Contrôle de flux : break et continue pour une logique fine
Clause else : Pour des cas de sortie normale
Compréhensions : Pour un code plus concis et lisible
Fonctions intégrées : enumerate() et zip() pour plus d’efficacité
Générateurs : Pour une utilisation mémoire optimisée avec yield

Maîtrisez ces techniques et vous écrirez des boucles Python plus efficaces et élégantes !

1. Introduction à Python

2. Installer Python

3. Introduction à PyCharm

4. Variables et Types en Python

5. Conditions et Structures de Contrôle en Python

6. Boucles en Python

7. Fonctions en Python

8. Structures de données en Python

9. Les fonctions avancées en Python

10. Les boucles avancées en Python

10. Les boucles avancées en Python

PYTHON pour les DÉBUTANTS #10#

Les boucles avancées en Python#

Boucles imbriquées#

Exemple de base#

Traitement de matrices#

Recherche dans une liste de listes#

Contrôle de flux avec break et continue#

L’instruction break#

L’instruction continue#

Exemple combiné#

Boucles avec else#

Exemple avec recherche#

Vérification de primalité#

Compréhensions de listes avancées#

Compréhensions imbriquées#

Compréhensions avec conditions#

Fonctions avec enumerate() et zip()#

enumerate() - Parcourir avec index#

zip() - Parcourir plusieurs listes#

Optimisation des boucles#

Éviter les recalculs#

Utiliser les méthodes intégrées#

Boucles avec générateurs#

Générateurs simples#

Générateurs avec conditions#

Cas d’usage pratiques#

Traitement de fichiers#

Simulation de jeu#

Exercices pratiques#

Conclusion#

RESSOURCES

Formation

Python 101 : Le guide ultime pour débutants

1. Introduction à Python

2. Installer Python

3. Introduction à PyCharm

4. Variables et Types en Python

5. Conditions et Structures de Contrôle en Python

6. Boucles en Python

7. Fonctions en Python

8. Structures de données en Python

9. Les fonctions avancées en Python

10. Les boucles avancées en Python

L’instruction `break`#

L’instruction `continue`#

Boucles avec `else`#

Fonctions avec `enumerate()` et `zip()`#

`enumerate()` - Parcourir avec index#

`zip()` - Parcourir plusieurs listes#