Introduction aux générateurs

Les générateurs sont un type particulier d'itérateur en Python qui vous permettent de parcourir les données avec une évaluation différée. Au lieu de renvoyer toutes les données en une seule fois, ils produisent un élément à la fois, ce qui économise 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ù il avait produit sa dernière valeur.

# 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 économisent ainsi la mémoire et sont particulièrement adaptés 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 ou listes

Les générateurs utilisent moins de mémoire que les listes, car ils ne stockent pas toutes les données en mémoire. Ils les produisent plutôt à 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 particulièrement adaptés 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 interminable de nombres. 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 consommer 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 sont plus adaptées.

Qu'avez-vous appris

Dans cette leçon, vous avez appris :

• Ce que sont les générateurs et comment ils fonctionnent dans Python.
• Comment 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, notamment les séquences infinies et les grands ensembles de données.

Excellent travail ! Passons au sujet suivant.