Summary  
This chapter covers generator functions that use `yield` to pause and resume execution for memory-efficient, on-the-fly value production and support iteration via `next()` or `for` loops.

General domain of usage  
data stream 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

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 termine complètement la fonction, `yield` **met en pause** la fonction et sauvegarde son état. Lors de l'appel suivant à `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’à l’épuisement du générateur.

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éclenche une erreur `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 solide 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.

Apprenez comment fonctionnent les 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 les arguments nommés pour gérer des tailles d'entrée variables. Apprendre 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 explorez 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. Apprenez 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`