Módulo 2: Iteración y transformación expresiva

En Python casi todos los programas recorren colecciones: productos, estudiantes, tareas, pedidos, archivos o resultados. Saber utilizar un ciclo for es suficiente para resolver muchos problemas, pero no siempre produce la solución más clara.

Observa este recorrido:

posicion = 1

for producto in productos:
    print(posicion, producto)
    posicion += 1

Python ya incluye una herramienta que expresa directamente la intención:

for posicion, producto in enumerate(productos, start=1):
    print(posicion, producto)

La segunda solución no es mejor simplemente porque tenga menos líneas. Es mejor porque evita administrar manualmente un contador y comunica que cada elemento necesita una posición.

En este módulo aprenderás a reconocer patrones parecidos:

Necesito posiciones                 → enumerate()
Necesito recorrer datos paralelos  → zip()
Necesito transformar una colección → comprensión
Necesito sumar sin crear una lista → expresión generadora
Necesito ordenar por una regla     → sorted(..., key=...)
Necesito una función muy breve     → lambda, si sigue siendo legible

Principio del módulo: escribir código expresivo no significa comprimirlo. Significa elegir una estructura que revele con claridad qué transformación se está realizando.

Al completar el módulo serás capaz de:

• Recorrer colecciones con posiciones útiles mediante enumerate().
• Procesar varias colecciones en paralelo con zip().
• Detectar longitudes incompatibles y utilizar zip(..., strict=True) cuando la relación lo requiera.
• Desempaquetar pares, tuplas y registros con claridad.
• Crear listas, diccionarios y conjuntos mediante comprensiones.
• Incorporar transformación y filtrado sin producir expresiones difíciles de leer.
• Utilizar expresiones generadoras cuando no sea necesario construir una lista completa.
• Aplicar sum(), any(), all(), min() y max() directamente sobre generadores.
• Ordenar registros por uno o varios criterios mediante key y reverse.
• Comprender el comportamiento de map() y filter().
• Utilizar funciones lambda únicamente cuando mantengan la claridad.
• Comparar varias soluciones correctas y justificar cuál es más mantenible.
• Construir un analizador de inventario y pedidos utilizando transformaciones expresivas.

Este módulo supone que ya puedes:

• recorrer listas y diccionarios con ciclos;
• crear y llamar funciones;
• acceder a valores mediante índices y claves;
• utilizar condicionales;
• trabajar con tuplas, conjuntos y diccionarios;
• aplicar las herramientas de texto y validación del Módulo 1.

No volverás a estudiar esos fundamentos. Los utilizarás para comparar soluciones y elegir mejores formas de expresar una operación.

Desarrollarás un programa que reciba datos de inventario y pedidos, combine colecciones relacionadas, compruebe su consistencia y produzca un reporte como este:

ANÁLISIS DE PEDIDOS
============================================================================
N.º  PEDIDO     CLIENTE              ESTADO       TOTAL       PRIORIDAD
----------------------------------------------------------------------------
1    PED-005    Panadería Central    COMPLETO     ₡28,500.00  urgente
2    PED-002    Librería Norte       FALTANTES    ₡17,250.00  alta
...

RESUMEN
----------------------------------------------------------------------------
Pedidos procesados:       8
Pedidos completos:        5
Pedidos con faltantes:    3
Valor aceptado:           ...
¿Existen códigos desconocidos?: Sí
Pedido de mayor valor:    PED-005

El programa deberá transformar los datos sin modificar las colecciones originales y explicar por qué un pedido no puede completarse.

Los tiempos corresponden al recorrido esencial. Si decides añadir retos opcionales o crear el proyecto desde una estructura completamente distinta, necesitarás tiempo adicional.

Recorridos con intención

Cuando necesitas el elemento y su posición, evita administrar un contador por separado:

cursos = ["Python Básico", "Python Intermedio", "Python Práctico"]

for posicion, curso in enumerate(cursos, start=1):
    print(f"{posicion}. {curso}")

Salida:

1. Python Básico
2. Python Intermedio
3. Python Práctico

Sin start=1, la numeración comienza en cero:

for indice, curso in enumerate(cursos):
    print(indice, curso)

Utiliza el nombre adecuado:

• indice cuando accederás a una posición real de la colección;
• numero, fila o posicion cuando solo mostrarás una numeración.

No utilices el índice para volver a buscar el elemento que enumerate() ya entregó:

Evita esta redundancia

for indice, curso in enumerate(cursos): print(cursos[indice])

La forma directa es más clara:

for indice, curso in enumerate(cursos): print(curso)

## 1.2 Modificar una lista mientras se recorre

Tener un índice no convierte en segura cualquier modificación:

for indice, producto in enumerate(productos): if producto["existencia"] == 0: productos.pop(indice)

Eliminar elementos desplaza las posiciones y puede provocar que algunos no se revisen. Para filtrar, crea una nueva colección:

disponibles = [ producto for producto in productos if producto["existencia"] > 0 ]

Las comprensiones se estudiarán en la siguiente sección.

## 1.3 `zip()` recorre colecciones relacionadas

Supón que un sistema entrega nombres y precios en colecciones separadas:

nombres = ["Teclado", "Ratón", "Monitor"] precios = [18000, 9500, 85000]

for nombre, precio in zip(nombres, precios): print(f"{nombre:<12} ₡{precio:>10,.2f}")

En cada iteración, `zip()` produce una tupla con los elementos correspondientes:

("Teclado", 18000) ("Ratón", 9500) ("Monitor", 85000)

También puede combinar más de dos colecciones:

codigos = ["PRD-01", "PRD-02", "PRD-03"] existencias = [8, 15, 3]

for codigo, nombre, precio, existencia in zip( codigos, nombres, precios, existencias, ): print(codigo, nombre, precio, existencia)

## 1.4 El truncamiento silencioso de `zip()`

Por defecto, `zip()` se detiene cuando se agota la colección más corta:

codigos = ["PRD-01", "PRD-02", "PRD-03"] precios = [18000, 9500]

print(list(zip(codigos, precios)))

Salida:

[('PRD-01', 18000), ('PRD-02', 9500)]

`PRD-03` desaparece sin producir un error. Esto puede ser correcto cuando deseas procesar únicamente pares disponibles, pero es peligroso si las colecciones representan columnas que deben coincidir.

Desde Python 3.10 puedes exigir longitudes iguales:

pares = zip(codigos, precios, strict=True)

Al consumir `pares`, Python genera `ValueError` si las longitudes son diferentes. El manejo completo de excepciones se estudiará en el Módulo 6. Por ahora, comprueba las longitudes antes de utilizarlo:

colecciones = [codigos, nombres, precios, existencias] misma_longitud = len({len(coleccion) for coleccion in colecciones}) == 1

if misma_longitud: for datos in zip(codigos, nombres, precios, existencias, strict=True): print(datos) else: print("Las columnas del inventario tienen longitudes diferentes")

El conjunto contiene las longitudes distintas. Si su tamaño es uno, todas coinciden.

## 1.5 Desempaquetado

Python permite asignar los elementos de una secuencia a nombres separados:

producto = ("PRD-01", "Teclado", 18000) codigo, nombre, precio = producto

También puedes capturar una parte variable:

primero, *intermedios, ultimo = [10, 20, 30, 40, 50]

print(primero) print(intermedios) print(ultimo)

Salida:

10 [20, 30, 40] 50

El desempaquetado es útil cuando la estructura es conocida. Si la cantidad de elementos puede variar por errores de entrada, valida antes.

## 1.6 Crear un diccionario con `zip()`

codigos = ["PRD-01", "PRD-02", "PRD-03"] precios = [18000, 9500, 85000]

precios_por_codigo = dict(zip(codigos, precios, strict=True)) print(precios_por_codigo)

Salida:

{'PRD-01': 18000, 'PRD-02': 9500, 'PRD-03': 85000}

Esta técnica es adecuada cuando cada clave aparece una sola vez. Si existen códigos duplicados, el último valor reemplazará al anterior. Valida la unicidad cuando el dominio la requiera.

---

Comprensiones y legibilidad

Solución tradicional:

precios = [18000, 9500, 85000, 42000]
precios_con_impuesto = []

for precio in precios:
    precios_con_impuesto.append(precio * 1.13)

Comprensión equivalente:

precios_con_impuesto = [precio * 1.13 for precio in precios]

Lee una comprensión en este orden:

[resultado          for elemento in colección]
 precio * 1.13      for precio   in precios

Una comprensión construye una colección nueva. No modifica precios.

Para conservar únicamente precios mayores a 10 000:

precios_altos = [precio for precio in precios if precio > 10000]

Para filtrar y transformar:

precios_altos_con_impuesto = [
    precio * 1.13
    for precio in precios
    if precio > 10000
]

La lectura es:

Para cada precio de precios,
si el precio supera 10 000,
guarda el precio multiplicado por 1.13.

El salto de líneas mejora la legibilidad cuando la expresión no cabe cómodamente en una sola.

No confundas filtrar con elegir entre dos resultados:

estados = [
    "sin existencia" if existencia == 0 else "disponible"
    for existencia in [4, 0, 8, 0]
]

Aquí cada entrada produce una salida. La condición aparece antes de for porque forma parte de la transformación.

Comparación:

Filtra: algunos elementos no aparecen

[numero for numero in numeros if numero > 0]

Transforma: todos producen una salida

["positivo" if numero > 0 else "no positivo" for numero in numeros]

## 2.4 Comprensiones de diccionario

productos = [ {"codigo": "PRD-01", "nombre": "Teclado"}, {"codigo": "PRD-02", "nombre": "Ratón"}, {"codigo": "PRD-03", "nombre": "Monitor"}, ]

productos_por_codigo = { producto["codigo"]: producto for producto in productos }

La parte anterior a `for` contiene `clave: valor`.

También puedes transformar claves o valores:

nombres_por_codigo = { producto["codigo"]: producto["nombre"].casefold() for producto in productos }

Si dos elementos producen la misma clave, el último reemplaza al anterior. Una comprensión no detecta automáticamente duplicados.

## 2.5 Comprensiones de conjunto

categorias = ["Accesorios", "pantallas", "ACCESORIOS", "Audio"]

categorias_unicas = { categoria.casefold() for categoria in categorias }

El conjunto elimina duplicados normalizados. No conserva un orden contractual para presentación. Si necesitas mostrar categorías ordenadas:

categorias_ordenadas = sorted(categorias_unicas)

## 2.6 Comprensiones anidadas

Puedes recorrer colecciones internas:

pedidos = [ {"id": "PED-01", "lineas": [("PRD-01", 2), ("PRD-02", 1)]}, {"id": "PED-02", "lineas": [("PRD-03", 1)]}, ]

codigos_solicitados = [ codigo for pedido in pedidos for codigo, cantidad in pedido["lineas"] ]

Esta expresión aún puede leerse con facilidad. Pero agregar varias transformaciones y condiciones la volvería difícil de revisar.

## 2.7 Cuándo regresar a un ciclo normal

Evita una comprensión cuando:

- modifica objetos existentes;
- contiene varios niveles de condiciones;
- necesita registrar errores diferentes;
- realiza efectos secundarios como imprimir o escribir archivos;
- requiere comentarios para descifrar la expresión;
- produce una línea muy extensa;
- sería más clara como una función con nombre.

Ejemplo difícil de mantener:

resultado = [ (p["codigo"], p["precio"] * 1.13 if p["activo"] else 0) for p in productos if p.get("codigo") and p.get("precio") is not None and p.get("categoria") != "oculta" ]

Una alternativa más clara:

def producto_publicable(producto): return all([ producto.get("codigo"), producto.get("precio") is not None, producto.get("categoria") != "oculta", ])

resultado = []

for producto in productos: if not producto_publicable(producto): continue

precio_publicado = producto["precio"] * 1.13 if producto["activo"] else 0 resultado.append((producto["codigo"], precio_publicado))

La comprensión más corta no siempre es la solución más expresiva.

## 2.8 No utilices comprensiones solo por sus efectos

Evita:

[print(producto) for producto in productos]

La comprensión crea una lista llena de valores `None` que no necesitas. Si quieres ejecutar una acción por elemento, utiliza un ciclo:

for producto in productos: print(producto)

---

Expresiones generadoras

Una comprensión de lista construye todos sus resultados:

cuadrados = [numero ** 2 for numero in range(1, 6)]

Una expresión generadora utiliza paréntesis y produce valores conforme se solicitan:

cuadrados = (numero ** 2 for numero in range(1, 6))

La diferencia se vuelve importante con grandes cantidades de datos o cuando una función puede consumir los valores directamente.

No necesitas crear una lista solo para sumarla:

lineas = [
    {"precio": 18000, "cantidad": 2},
    {"precio": 9500, "cantidad": 1},
]

total = sum(
    linea["precio"] * linea["cantidad"]
    for linea in lineas
)

También puedes utilizar generadores con any(), all(), min() y max():

hay_faltantes = any(
    linea["solicitada"] > linea["disponible"]
    for linea in lineas
)

todos_validos = all(
    linea["cantidad"] > 0
    for linea in lineas
)

Cuando una expresión generadora es el único argumento, no necesitas dos pares de paréntesis:

total = sum(numero for numero in numeros)

valores = (numero * 2 for numero in range(3))

print(list(valores))
print(list(valores))

Salida:

[0, 2, 4]
[]

Después del primer recorrido no quedan valores pendientes. Si necesitas recorrer los resultados varias veces, crea una lista o vuelve a construir el generador.

any() se detiene al encontrar el primer valor verdadero. all() se detiene al encontrar el primer valor falso. Una expresión generadora permite aprovechar ese comportamiento sin calcular los elementos restantes.

hay_codigo_desconocido = any(
    codigo not in inventario
    for codigo, cantidad in pedido["lineas"]
)

Esta expresión comunica una pregunta y puede finalizar tan pronto como encuentre un código desconocido.

Ordenamiento y selección con key

precios = [18000, 9500, 85000, 42000]

ascendente = sorted(precios)
descendente = sorted(precios, reverse=True)

sorted() devuelve una lista nueva y acepta cualquier iterable. .sort() modifica una lista existente y devuelve None.

productos = [
    {"codigo": "PRD-01", "precio": 18000},
    {"codigo": "PRD-02", "precio": 9500},
    {"codigo": "PRD-03", "precio": 85000},
]

por_precio = sorted(
    productos,
    key=lambda producto: producto["precio"],
)

key no transforma el resultado. Solo produce el valor utilizado para comparar.

pedidos = [
    {"estado": "FALTANTES", "total": 15000, "id": "PED-03"},
    {"estado": "COMPLETO", "total": 25000, "id": "PED-02"},
    {"estado": "COMPLETO", "total": 12000, "id": "PED-01"},
]

ordenados = sorted(
    pedidos,
    key=lambda pedido: (
        pedido["estado"],
        -pedido["total"],
        pedido["id"],
    ),
)

Python compara la primera parte de la tupla, después la segunda si existe empate y finalmente la tercera. El signo negativo ordena el total de mayor a menor dentro de un orden general ascendente.

Para prioridades que no siguen el orden alfabético, crea un mapa:

ORDEN_PRIORIDAD = {
    "urgente": 0,
    "alta": 1,
    "normal": 2,
}

ordenados = sorted(
    pedidos,
    key=lambda pedido: ORDEN_PRIORIDAD[pedido["prioridad"]],
)

pedido_mayor = max(
    pedidos,
    key=lambda pedido: pedido["total"],
    default=None,
)

El resultado es el pedido completo. default=None evita un error si no hay pedidos.

Si solo necesitas el total mayor, puedes generar los números:

total_mayor = max(
    (pedido["total"] for pedido in pedidos),
    default=0,
)

La elección depende de lo que necesites después: el registro o únicamente su valor.

Si el criterio necesita varias decisiones, utiliza una función con nombre:

def clave_de_orden(pedido):
    prioridad = ORDEN_PRIORIDAD.get(pedido["prioridad"], 99)
    esta_incompleto = pedido["estado"] != "COMPLETO"
    return esta_incompleto, prioridad, -pedido["total"], pedido["id"]


ordenados = sorted(pedidos, key=clave_de_orden)

El nombre permite probar y explicar la regla por separado.

lambda, map() y filter() con criterio

Una lambda crea una función anónima de una sola expresión:

calcular_subtotal = lambda precio, cantidad: precio * cantidad

Aunque funciona, una función normal suele ser más apropiada si necesita nombre, documentación o reutilización:

def calcular_subtotal(precio, cantidad):
    return precio * cantidad

Las lambda resultan útiles como argumentos breves:

productos_ordenados = sorted(
    productos,
    key=lambda producto: producto["precio"],
)

precios = [1000, 2500, 4000]
precios_con_impuesto = map(lambda precio: precio * 1.13, precios)

map() devuelve un iterador. Puedes consumirlo directamente o convertirlo:

print(list(precios_con_impuesto))

Comprensión equivalente:

precios_con_impuesto = [precio * 1.13 for precio in precios]

La comprensión suele ser más directa cuando la transformación es específica. map() puede ser especialmente claro cuando ya existe una función con nombre:

def normalizar_codigo(codigo):
    return codigo.strip().upper()


codigos_limpios = list(map(normalizar_codigo, codigos))

def tiene_existencia(producto):
    return producto["existencia"] > 0


disponibles = list(filter(tiene_existencia, productos))

Comprensión equivalente:

disponibles = [
    producto
    for producto in productos
    if producto["existencia"] > 0
]

Ambas son correctas. Elige la que exprese mejor la regla dentro del contexto.

datos = ["Python", "", None, "SQL", 0]
resultado = list(filter(None, datos))

Esto elimina todos los valores falsos, no solo cadenas vacías. Puede borrar 0 aunque sea válido. Una regla explícita es más segura:

resultado = [dato for dato in datos if dato is not None]

No existe una obligación profesional de utilizar map() o filter(). La habilidad importante es comprenderlos, leer código que los utilice y escoger con criterio.

Videos recomendados

Los videos son complementarios. Ejecuta los ejemplos y modifica al menos uno después de cada video.

• 📖For con `enumerate()` y `zip()` — OMES
• 📖Comprensión de listas en Python — UskoKruM2010
• 📖`lambda`, `map()` y `filter()` en Python — Sklyvan

Después del tercer video, reescribe un ejemplo con una comprensión y decide cuál versión leerías con mayor facilidad dentro de seis meses.

Documentación y recursos de lectura

• 📖Técnicas de iteración: `enumerate()` y `zip()`
• 📖Comprensiones de listas
• 📖Funciones integradas: `enumerate`, `zip`, `map`, `filter` y `sorted`

• 📖Guía de programación funcional
• 📖Expresiones generadoras
• 📖Comprensiones de listas con ejemplos — Real Python
• 📖Python Tutor: ejecución paso a paso

Busca zip() en la documentación oficial y responde:

1. ¿Qué devuelve?
2. ¿Cuándo se evalúan las longitudes con strict=True?
3. ¿Qué excepción se produce si no coinciden?
4. ¿Desde qué versión existe strict?
5. ¿Qué ejemplo ofrece la documentación para agrupar elementos?

No memorices las respuestas. Practica el proceso de localizarlas.

Material descargable

El módulo incluye:

• datos_inventario.py: inventario y pedidos del proyecto.
• plantilla_proyecto.py: estructura funcional sin solución.
• GUIA_DECISION_ITERACION.md: comparación entre ciclos, comprensiones, generadores, map() y filter().
• CHECKLIST_PROYECTO.md: comprobación previa a la entrega.

En la plantilla, raise NotImplementedError funciona únicamente como un marcador visible. Sustituye cada marcador por tu implementación antes de ejecutar el proyecto completo; no necesitas manejar esa excepción.

⬇️Descargar todos los materiales del Módulo 2

⬇️Descargar datos_inventario.py

⬇️Descargar plantilla_proyecto.py

⬇️Descargar GUIA_DECISION_ITERACION.md

⬇️Descargar CHECKLIST_PROYECTO.md

Errores comunes

Si necesitas el elemento y una posición, enumerate() evita sincronizar otra variable.

for indice, producto in enumerate(productos):
    print(productos[indice])

Utiliza directamente producto.

Cuando las colecciones representan columnas relacionadas, valida longitudes y utiliza strict=True.

La última clave reemplaza las anteriores. Valida la unicidad si no se permiten duplicados.

Eliminar elementos desplaza las posiciones. Crea una nueva colección filtrada.

Si necesitas descifrarla, utiliza un ciclo o funciones auxiliares.

Una comprensión construye una colección. Para efectos como print(), utiliza un ciclo.

Después del primer recorrido puede quedar vacío. Materialízalo solo si necesitas reutilizar los resultados.

La conversión elimina el beneficio de producir valores bajo demanda. Pregunta si realmente necesitas almacenar y recorrer varias veces.

key decide cómo comparar; sorted() devuelve los elementos originales ordenados.

Cuando la regla tiene varias decisiones, una función con nombre es más clara y comprobable.

En Python 3 devuelve un iterador. Consúmelo o conviértelo según la necesidad.

Puede eliminar 0, False y cadenas vacías aunque algunos sean datos válidos.

Recuerda all([]) == True y utiliza default con min() y max() cuando corresponda.

Glosario

Resumen del módulo

Aprendiste a reemplazar recorridos accidentales por estructuras que comunican intención:

• enumerate() relaciona posiciones y elementos;
• zip() relaciona colecciones paralelas;
• las comprensiones construyen colecciones transformadas o filtradas;
• las expresiones generadoras producen valores bajo demanda;
• sorted(), min() y max() aceptan criterios personalizados;
• map(), filter() y lambda son opciones que deben elegirse por claridad, no por obligación.

También aprendiste que una herramienta breve puede esconder riesgos: zip() puede truncar, una comprensión puede volverse ilegible, un generador puede agotarse y filter(None, ...) puede descartar datos válidos.

• Recorridos numerados y paralelos.
• Validación de colecciones relacionadas.
• Transformación expresiva de listas, diccionarios y conjuntos.
• Uso de generadores con funciones integradas.
• Ordenamiento por reglas de negocio.
• Comparación razonada entre ciclos, comprensiones y funciones de orden superior.
• Construcción de un analizador de inventario y pedidos.

• Puedo utilizar enumerate() sin administrar un contador manual.
• Comprendo cuándo zip() puede perder información.
• Sé utilizar strict=True después de validar longitudes.
• Puedo escribir comprensiones legibles de lista, diccionario y conjunto.
• Sé cuándo regresar a un ciclo normal.
• Comprendo que un generador se consume.
• Puedo ordenar por varios criterios con una función key.
• Puedo comparar map() y filter() con comprensiones.
• Completé las actividades obligatorias.
• Obtuve al menos 70% en la evaluación.
• El proyecto fue aprobado.

Cuando cumplas estas condiciones, estarás preparado para el Módulo 3: Colecciones especializadas e iteradores.