Mis apuntes · Aprende Python desde PHP

Se guardan solos en este navegador mientras escribes. Puedes usar Markdown. Al descargarlos, la primera línea es tu enlace personal al curso.

Lección 31 de 47 · Errores y funciones ✦ WebMCP implementado

Generadores: yield y yield from

10 min de lectura 4 retos

Una función normal devuelve todo de golpe y se acaba. Un generador devuelve los valores de uno en uno, pausándose entre medias, y por eso puede manejar millones de tareas sin llenar la memoria. PHP también tiene generators, así que aquí compararás los dos: se parecen mucho, con una trampa que solo tiene Python.

¿De dónde vienen los nombres?

yield = inglés yield (ceder, dar, producir)
«Te cedo este valor y me paro aquí.» La función se queda en pausa hasta que pidas el siguiente. Es el mismo yield de PHP.
generador = del verbo generar (producir)
Una función con yield: no calcula todo de golpe, genera los valores según se piden.
next = inglés next (siguiente)
Pide el siguiente valor a un generador. En PHP sería $gen->current() seguido de $gen->next().
StopIteration = inglés stop (parar) + iteration (iteración)
El aviso que lanza next() cuando ya no quedan valores. El for lo atrapa solo y termina el bucle.
yield from = inglés yield + from (desde)
«Cede todos los valores desde esta otra colección o generador.» En PHP también existe con el mismo nombre.
En 4 ideas
1/4

Un generador es una función con yield: devuelve los valores de uno en uno y se pausa entre medias (PHP también tiene yield, y se escribe igual).

1 · Qué es un generador: yield en vez de return

Piensa en un dispensador de pañuelos. No te da la caja entera: te da un pañuelo cada vez que tiras. Una función normal con return te da la caja; un generador, un pañuelo por tirón.

Pythonmain.py
def cuenta_tareas():
    print("  (arranco)")
    yield "Comprar pan"
    print("  (sigo)")
    yield "Llamar al banco"
    print("  (último)")
    yield "Repasar Python"
    print("  (fin)")


tareas = cuenta_tareas()
print("generador creado, aún no ha corrido nada")
print(next(tareas))
print(next(tareas))
print(next(tareas))

Mira lo que pasa: crear el generador no ejecuta nada. Cada next() hace correr la función hasta el siguiente yield y la deja en pausa ahí, con todas sus variables.

Normalmente no usas next() a mano: un for lo hace por ti y se para solo cuando se acaban:

Pythonmain.py
def prioridades():
    yield 1
    yield 2
    yield 3


for p in prioridades():
    print("prioridad", p)

generador = prioridades()
print(list(generador))

vacio = prioridades()
list(vacio)
try:
    next(vacio)
except StopIteration:
    print("StopIteration: ya no quedan")
PHP 8.5index.php
<?php
declare(strict_types=1);

function prioridades(): Generator
{
    yield 1;
    yield 2;
    yield 3;
}

foreach (prioridades() as $p) {
    echo "prioridad $p" . PHP_EOL;
}

$todas = iterator_to_array(prioridades());
print_r($todas);
Pythonmain.py
def prioridades():
    yield 1
    yield 2
    yield 3


for p in prioridades():
    print("prioridad", p)

todas = list(prioridades())
print(todas)
Quiero…PHPPython
Definir un generadorFunción con yield (tipo Generator)Función con yield
Recorrerloforeach (gen() as $v)for v in gen():
Pedir el siguiente a mano$g->current() + $g->next()next(g)
Pasarlo a listaiterator_to_array($g)list(g)
AcabarseEl foreach terminaStopIteration (el for lo atrapa)
Claves con yieldyield $clave => $valorNo hay: se usa yield (clave, valor)

2 · Perezosos: la memoria que te ahorras

Una lista guarda todos los elementos a la vez. Un generador guarda solo dónde se quedó. Con un millón de tareas, la diferencia es enorme.

Pythonmain.py
import sys


def tareas_de_prueba(cantidad):
    for numero in range(cantidad):
        yield f"Tarea {numero}"


como_lista = [f"Tarea {n}" for n in range(100_000)]
como_generador = tareas_de_prueba(100_000)

print("la lista pesa más que 100 KB:", sys.getsizeof(como_lista) > 100_000)
print("el generador pesa menos que 1 KB:", sys.getsizeof(como_generador) < 1_000)
print("primeras tres:", [next(como_generador) for _ in range(3)])

El generador pesa lo mismo con 10 tareas que con 10 000 millones, porque no las guarda: las crea cuando las pides. Y como es perezoso, puede ser infinito:

Pythonmain.py
def ids_nuevos(inicio=1):
    numero = inicio
    while True:
        yield numero
        numero += 1


ids = ids_nuevos()
print(next(ids), next(ids), next(ids))

from itertools import islice
print(list(islice(ids_nuevos(100), 4)))

¿Por qué? · En PHP no existe

¿Por qué existen los generadores si ya tengo listas?

Memoria. Leer un fichero de 5 GB entero a una lista revienta el ordenador. Leerlo línea a línea con un generador usa unos pocos KB. Es el mismo motivo por el que en PHP se usan generators (o fgets en un bucle) en vez de file().

Velocidad al empezar. Con una lista esperas a calcularlo todo antes de ver el primero. Con un generador tienes el primero al instante, y si solo necesitas los 3 primeros, nunca se calculan los demás.

Valores sin fin. Una lista infinita no cabe en memoria; un generador infinito (ids, ticks, lecturas de un sensor) sí.

3 · yield from: delegar en otro generador

Si quieres repetir todo lo que da otra colección, puedes hacer un for con yield dentro. Pero yield from lo hace en una línea:

Pythonmain.py
def tareas_de_hoy():
    yield "Comprar pan"
    yield "Llamar al banco"


def tareas_de_manana():
    yield "Entregar informe"


def todas_las_tareas():
    yield from tareas_de_hoy()
    yield from tareas_de_manana()
    yield from ["Repasar Python", "Regar plantas"]


for titulo in todas_las_tareas():
    print(titulo)

Funciona con cualquier cosa recorrible: otro generador, una lista, una tupla. Es el yield from de PHP, que se llama igual. Sirve mucho para recorrer árboles (subtareas dentro de tareas):

Pythonmain.py
def recorre(tarea):
    yield tarea["titulo"]
    for sub in tarea.get("subtareas", []):
        yield from recorre(sub)


proyecto = {
    "titulo": "Mudanza",
    "subtareas": [
        {"titulo": "Cajas", "subtareas": [{"titulo": "Libros"}, {"titulo": "Ropa"}]},
        {"titulo": "Furgoneta"},
    ],
}

print(list(recorre(proyecto)))

4 · Expresiones generadoras: una comprensión sin lista

Ya conoces la lista por comprensión: [x for x in ...]. Si cambias los corchetes por paréntesis, no obtienes una lista sino un generador: calcula cada valor al pedirlo.

Pythonmain.py
tareas = [
    {"titulo": "Comprar pan", "minutos": 15, "hecha": True},
    {"titulo": "Entregar informe", "minutos": 90, "hecha": False},
    {"titulo": "Llamar al banco", "minutos": 10, "hecha": False},
]

# En PHP: array_sum(array_map(fn($t) => $t["minutos"], array_filter(...)))
pendientes = sum(t["minutos"] for t in tareas if not t["hecha"])
print("Minutos pendientes:", pendientes)

hay_larga = any(t["minutos"] > 60 for t in tareas)
print("¿hay alguna larga?", hay_larga)

titulos = ", ".join(t["titulo"] for t in tareas)
print(titulos)
  1. Cuando una expresión generadora es el único argumento de una función, los paréntesis de la función bastan: sum(x for x in ...).
  2. any(...) y all(...) se paran en cuanto saben la respuesta: any en el primer True, all en el primer False. Con una lista habría calculado todo antes.
  3. Si necesitas recorrer dos veces o saber la longitud, usa una lista: el generador se gasta.
PHP 8.5index.php
<?php
declare(strict_types=1);

$tareas = [
    ["titulo" => "Comprar pan", "minutos" => 15, "hecha" => true],
    ["titulo" => "Entregar informe", "minutos" => 90, "hecha" => false],
];

$pendientes = array_sum(array_map(
    fn(array $t): int => $t["minutos"],
    array_filter($tareas, fn(array $t): bool => !$t["hecha"]),
));
echo "Minutos pendientes: $pendientes" . PHP_EOL;
Pythonmain.py
tareas = [
    {"titulo": "Comprar pan", "minutos": 15, "hecha": True},
    {"titulo": "Entregar informe", "minutos": 90, "hecha": False},
]

pendientes = sum(t["minutos"] for t in tareas if not t["hecha"])
print(f"Minutos pendientes: {pendientes}")

5 · La trampa: un generador se gasta

Un generador es como una canción en la radio: cuando acaba, acaba. Si quieres oírla otra vez no puedes rebobinar: hay que ponerla de nuevo. Los generadores solo se recorren una vez.

Pythonmain.py
tareas = ["Comprar pan", "Llamar al banco", "Repasar Python"]
en_mayusculas = (t.upper() for t in tareas)

print("primera vez:", list(en_mayusculas))
print("segunda vez:", list(en_mayusculas))
print("¿alguna?", any(True for _ in en_mayusculas))

La segunda vez no da error: da una lista vacía. Es el fallo más traicionero: tu programa sigue y muestra «0 tareas» en silencio.

¿Por qué? · En PHP no existe

¿Por qué Python no avisa? En PHP sí lo hace

Para Python, un generador agotado es un iterador normal que ya no tiene nada más: un for sobre él simplemente no entra. Es coherente con el resto, y por eso no hay error.

PHP es más estricto: recorrer otra vez un generator ya terminado lanza Exception: Cannot traverse an already closed generator. Está comprobado con PHP 8.5. Un error visible es más fácil de encontrar que una lista vacía en silencio.

Quiero…UsaPor qué
Recorrer una sola vezGenerador o expresión generadoraNo guarda nada en memoria
Recorrer varias vecesLista (list(...))Se puede volver a recorrer
Saber cuántos hayListalen() no existe en un generador
Elegir el elemento 5Listag[5] da TypeError

Hora de practicar

Retos · 0/4 resueltos

Reto 1 de 4

Solo las pendientes

Escribe el generador pendientes(tareas): recibe una lista de diccionarios {"titulo": ..., "hecha": ...} y cede (con yield) el título de cada tarea no hecha. Es un foreach con if y yield de PHP.

Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.

Pythonmain.py · editable

Resumen

Lo que te llevas de esta lección

  1. yield convierte una función en un generador: da los valores de uno en uno y se pausa (en PHP, el mismo yield).
  2. Es perezoso: sirve para millones de tareas o para flujos infinitos sin llenar la memoria, como un generator frente a un array.
  3. yield from cede todos los valores de otra colección o generador (igual que en PHP); (x for x in ...) es una comprensión sin lista.
  4. any() y all() con una expresión generadora se paran en cuanto saben la respuesta.
  5. Un generador se gasta: la segunda pasada da vacío sin error (PHP lanza «Cannot traverse an already closed generator»).

Para recordarlo: «Cede, Pausa, Gasta»

CCede
yield entrega un valor
PPausa
la función se queda esperando el siguiente next()
GGasta
se recorre una sola vez

Un generador Cede un valor, Pausa y, cuando termina, está Gastado. Como el pañuelo del dispensador: no puedes volver a sacar el mismo.