Introduction aux générateurs

Les générateurs sont un type particulier d'itérateur en Python qui vous permettent de parcourir des données de manière différée. Au lieu de renvoyer toutes les données en une seule fois, ils produisent un élément à la fois, ce qui permet d'utiliser efficacement la mémoire.

Dans cette leçon, vous apprendrez à créer et à utiliser des générateurs en Python.

Qu’est-ce qu’un générateur ?

Un générateur est une fonction qui utilise le mot-clé yield pour renvoyer des valeurs une par une. Chaque appel à la méthode next() du générateur reprend l’exécution là où la dernière valeur a été produite.

# Basic generator example
def my_generator():
    yield 1
    yield 2
    yield 3

# Using the generator
gen = my_generator()
print(next(gen))  # Outputs: 1
print(next(gen))  # Outputs: 2
print(next(gen))  # Outputs: 3

Fonctionnement des générateurs

Les générateurs enregistrent l'état de la fonction afin de pouvoir reprendre l'exécution exactement là où elle s'était arrêtée. Ils utilisent ainsi efficacement la mémoire et conviennent parfaitement aux grands ensembles de données.

# Example: Generating a range of numbers
def range_generator(start, end):
    while start < end:
        yield start
        start += 1

for number in range_generator(1, 5):
    print(number)  # Outputs: 1, 2, 3, 4

Expressions génératrices

Les expressions génératrices ressemblent aux compréhensions de listes, mais utilisent des parenthèses au lieu de crochets. Elles créent des générateurs plutôt que des listes.

# Generator expression
gen_exp = (x * x for x in range(5))

for value in gen_exp:
    print(value)  # Outputs: 0, 1, 4, 9, 16

Générateurs et listes

Les générateurs utilisent plus efficacement la mémoire que les listes, car ils ne stockent pas toutes les données en mémoire. Ils génèrent plutôt les données à la volée.

# Comparing lists and generators
# List comprehension
list_comp = [x * x for x in range(1000000)]

# Generator expression
gen_exp = (x * x for x in range(1000000))

# List comprehension uses more memory
print(type(list_comp))  # Outputs: <class 'list'>
print(type(gen_exp))    # Outputs: <class 'generator'>

Cas d'utilisation des générateurs

Les générateurs sont idéaux pour :

• Traiter de grands ensembles de données qui ne tiennent pas en mémoire.
• Générer des séquences infinies.
• Évaluer les données de manière différée.

Générateurs infinis

Les générateurs peuvent produire des séquences infinies, comme une suite de nombres sans fin. Veillez à arrêter la boucle pour éviter une exécution infinie.

# Infinite generator example
def infinite_sequence():
    num = 0
    while True:
        yield num
        num += 1

# Using the infinite generator
for i in infinite_sequence():
    if i > 5:
        break
    print(i)  # Outputs: 0, 1, 2, 3, 4, 5

Fonctions génératrices avec plusieurs productions

Les fonctions génératrices peuvent contenir plusieurs instructions yield, ce qui vous permet de créer des séquences complexes :

# Multiple yields in a generator
def multi_yield():
    yield "First"
    yield "Second"
    yield "Third"

for value in multi_yield():
    print(value)  # Outputs: First, Second, Third

Erreurs courantes avec les générateurs

Voici quelques erreurs à éviter :

• Utiliser return au lieu de yield dans une fonction génératrice.
• Ne pas parcourir le générateur avec une boucle ou next().
• Utiliser des générateurs pour de petits ensembles de données, alors que les listes conviennent mieux.

Qu’avez-vous appris ?

Dans cette leçon, vous avez appris :

• Ce que sont les générateurs et comment ils fonctionnent en Python.
• À utiliser yield pour créer des fonctions génératrices.
• Les différences entre les générateurs et les listes.
• Les cas d’utilisation des générateurs, comme les séquences infinies et les grands ensembles de données.

Excellent travail ! Passons au sujet suivant.