Summary  
This chapter covers generator functions and how the `yield` keyword pauses and resumes execution to produce values lazily and maintain state across iterations without storing the entire sequence in memory.

General domain of usage  
Data streaming and large-sequence processing

Une **fonction génératrice** est un type particulier de fonction qui utilise le mot-clé `yield` au lieu de `return` pour générer une séquence de valeurs. Lorsqu'une fonction génératrice est appelée, elle retourne un objet itérateur, qui peut être parcouru pour récupérer les valeurs une à une.

Définition

Un **objet itérateur** est un objet qui implémente le protocole d'itérateur en définissant les méthodes `__iter__()` et `__next__()`. Cela permet de récupérer les éléments un par un avec `next()`, rendant possible la boucle sur des éléments dans des séquences ou des fonctions génératrices.

Le principal avantage des fonctions génératrices est leur **efficacité mémoire**. Au lieu de générer toute la séquence à l'avance et de la stocker en mémoire, les générateurs produisent les valeurs **à la volée** lorsqu'elles sont nécessaires.

## Fonctionnement de `yield`

Contrairement à `return`, qui quitte complètement la fonction, `yield` **met en pause** la fonction et sauvegarde son état. Lors du prochain appel à `next()`, le générateur reprend exactement là où il s'était arrêté :


def count_up(start, stop):
    while start <= stop:
        yield start  # Pause and return the current value
        start += 1   # Resume from here on the next call

counter = count_up(1, 3)

print(next(counter))  # 1
print(next(counter))  # 2
print(next(counter))  # 3

Il est également possible d’itérer sur un générateur à l’aide d’une boucle `for` – celle-ci appelle automatiquement `next()` jusqu’à ce que le générateur soit épuisé :

def count_up(start, stop):
    while start <= stop:
        yield start
        start += 1

for value in count_up(1, 5):
    print(value)  # 1, 2, 3, 4, 5

Lorsqu'un générateur est épuisé (plus aucune valeur à produire), appeler `next()` dessus déclenchera une exception `StopIteration`. Une boucle `for` gère cela automatiquement.

Remarque

import unittest
import re

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

class TestEvenNumbers(unittest.TestCase):

    def test_even_numbers_is_generator(self):
        import user_code
        import types
        try:
            result = user_code.even_numbers(1, 10)
            condition = isinstance(result, types.GeneratorType)
            failure_message = "Expected `even_numbers` to return a generator object."
        except AttributeError:
            condition = False
            failure_message = "The function `even_numbers` is not defined."
        _dynamic_test(self, condition, "The `even_numbers` function returns a generator object.", failure_message)

    def test_even_numbers_correct_values(self):
        import user_code
        try:
            result = list(user_code.even_numbers(1, 10))
            expected = [2, 4, 6, 8, 10]
            condition = result == expected
            failure_message = f"Expected `{expected}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `even_numbers` is not defined."
        _dynamic_test(self, condition, f"The `even_numbers` generator yields `[2, 4, 6, 8, 10]` for range 1 to 10.", failure_message)

    def test_even_numbers_no_odd_values(self):
        import user_code
        try:
            result = list(user_code.even_numbers(1, 10))
            condition = all(n % 2 == 0 for n in result)
            failure_message = f"Expected only even numbers, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `even_numbers` is not defined."
        _dynamic_test(self, condition, "The `even_numbers` generator yields only even numbers.", failure_message)

    def test_even_numbers_different_range(self):
        import user_code
        try:
            result = list(user_code.even_numbers(5, 20))
            expected = [6, 8, 10, 12, 14, 16, 18, 20]
            condition = result == expected
            failure_message = f"Expected `{expected}` for range 5 to 20, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `even_numbers` is not defined."
        _dynamic_test(self, condition, f"The `even_numbers` generator correctly handles the range 5 to 20.", failure_message)

if __name__ == '__main__':
    unittest.main()

test_main.py

Acquérir une compréhension approfondie de l'influence des fonctions sur la programmation Python. Maîtriser la définition et l'appel de fonctions, la gestion des arguments, le traitement des valeurs de retour et la création de code flexible et efficace à l'aide de la récursivité et des expressions lambda.

Découvrez ce que sont les fonctions et pourquoi elles sont essentielles en Python. Apprenez à créer des fonctions, à définir des arguments, à gérer les valeurs de retour et à utiliser efficacement les fonctions intégrées.

Découvrez le fonctionnement des arguments positionnels et optionnels en Python. Concevez des fonctions adaptables capables de gérer différents types d’entrées et d’améliorer la flexibilité de votre code.

Comprendre comment utiliser les arguments arbitraires et nommés pour gérer des tailles d'entrée variables.
Découvrir comment ces techniques rendent vos fonctions plus dynamiques et organisées.

Découvrez comment les valeurs de retour représentent la sortie d'une fonction. Apprenez à retourner une ou plusieurs valeurs, à utiliser None et à explorer les générateurs pour un contrôle plus avancé du flux de données.

Découvrez des concepts avancés de fonctions avec la récursivité et les fonctions lambda. Comprenez comment la récursivité permet de résoudre des problèmes répétitifs et comment les expressions lambda créent des fonctions concises en une seule ligne.

Fonctions Génératrices

Fonctionnement de `yield`

Solution

Fonctions Génératrices

Fonctionnement de yield

Solution

Fonctionnement de `yield`