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

Una **función generadora** es un tipo especial de función que utiliza la palabra clave `yield` en lugar de `return` para generar una secuencia de valores. Cuando se llama a una función generadora, devuelve un objeto iterador, que puede ser recorrido para obtener los valores uno a uno.

Definición

Un **objeto iterador** es un objeto que implementa el protocolo de iterador definiendo los métodos `__iter__()` y `__next__()`. Esto permite recuperar elementos uno a uno con `next()`, haciendo posible recorrer elementos en secuencias o funciones generadoras.

La principal ventaja de las funciones generadoras es su **eficiencia de memoria**. En lugar de generar toda la secuencia de antemano y almacenarla en memoria, los generadores producen los valores **en el momento** según se necesitan.

## Cómo funciona `yield`

A diferencia de `return`, que sale completamente de la función, `yield` **pausa** la función y guarda su estado. La próxima vez que se llama a `next()`, el generador se reanuda exactamente desde donde se detuvo:


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

También se puede iterar sobre un generador usando un bucle `for`; este llama automáticamente a `next()` hasta que el generador se agota:

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

Una vez que un generador se agota (no quedan más valores para producir), llamar a `next()` sobre él generará una excepción `StopIteration`. Un bucle `for` maneja esto automáticamente.

Nota

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

Adquiera una comprensión sólida de cómo las funciones estructuran la programación en Python. Domine la definición y llamada de funciones, el trabajo con argumentos, el manejo de valores de retorno y la creación de código flexible y eficiente utilizando recursión y expresiones lambda.

Explora qué son las funciones y por qué son esenciales en Python. Aprende a crear funciones, definir argumentos, manejar valores de retorno y utilizar funciones integradas de manera efectiva.

Aprenda cómo funcionan los argumentos posicionales y opcionales en Python. Cree funciones adaptables que gestionen diferentes entradas y mejoren la flexibilidad en su código.

Comprender cómo trabajar con argumentos arbitrarios y argumentos de palabra clave para manejar tamaños de entrada variables.
Aprender cómo estas técnicas hacen que las funciones sean más dinámicas y organizadas.

Descubra cómo los valores de retorno representan la salida de una función. Aprenda a retornar valores únicos o múltiples, utilizar None y explorar generadores para un control de flujo de datos más avanzado.

Descubre conceptos avanzados de funciones con recursión y funciones lambda. Aprende cómo la recursión resuelve problemas repetitivos y cómo las expresiones lambda permiten crear funciones concisas en una sola línea.

Funciones Generadoras

Cómo funciona `yield`

Solución

Funciones Generadoras

Cómo funciona yield

Solución

Cómo funciona `yield`