Módulo 3: Colecciones especializadas e iteradores

Las listas, los diccionarios, los conjuntos y las tuplas resuelven una gran cantidad de problemas. Sin embargo, algunas tareas frecuentes obligan a escribir siempre el mismo código auxiliar:

conteos = {}

for categoria in categorias:
    if categoria not in conteos:
        conteos[categoria] = 0

    conteos[categoria] += 1

Python incluye una colección creada específicamente para contar:

from collections import Counter

conteos = Counter(categorias)

La segunda solución no sustituye tu razonamiento. Primero debes reconocer que el problema es un conteo. Después eliges una estructura cuya operación principal coincide con esa necesidad.

En este módulo trabajarás con tres colecciones especializadas:

Necesito contar o crear un ranking     → Counter
Necesito agrupar sin inicializar       → defaultdict
Necesito una cola eficiente            → deque

También utilizarás herramientas seleccionadas de itertools para encadenar, limitar, combinar y agrupar recorridos sin construir estructuras intermedias innecesarias.

Principio del módulo: una estructura especializada merece utilizarse cuando simplifica una operación central del problema, no solamente porque existe.

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

• Reconocer cuándo una colección común exige demasiado código auxiliar.
• Contar elementos y crear rankings mediante Counter.
• Actualizar, combinar y consultar conteos.
• Agrupar registros y acumular valores con defaultdict.
• Comparar defaultdict con dict.get() y setdefault().
• Administrar colas FIFO mediante deque.
• Insertar y retirar elementos eficientemente en ambos extremos.
• Conservar historiales limitados mediante deque(maxlen=...).
• Encadenar recorridos con itertools.chain().
• Obtener una parte de un iterable con islice().
• Crear productos cartesianos, combinaciones y permutaciones cuando el problema lo requiera.
• Agrupar elementos consecutivos mediante groupby() después de ordenar por la misma clave.
• Identificar iteradores consumibles y decidir cuándo materializarlos.
• Construir un sistema de análisis y priorización de solicitudes.

Necesitas poder:

• recorrer listas y diccionarios;
• crear funciones;
• trabajar con comprensiones;
• utilizar expresiones generadoras;
• ordenar mediante sorted(..., key=...);
• utilizar enumerate(), zip(), any() y all().

Estos conocimientos se aplicarán desde el inicio y no volverán a explicarse desde cero.

Desarrollarás un centro local que combine solicitudes pendientes y nuevas, analice su contenido y organice la atención según prioridad:

CENTRO DE SOLICITUDES
============================================================================
Solicitudes recibidas:       14
Categorías líderes:          acceso, contenido
Prioridad más frecuente:     normal
Responsables con más casos:  Ana, Carlos

PRÓXIMAS SOLICITUDES
----------------------------------------------------------------------------
1. SOP-004 | urgente | Error al iniciar sesión
2. SOP-011 | urgente | Cobro duplicado
3. SOP-013 | urgente | Cuenta bloqueada antes de evaluación

HISTORIAL RECIENTE
----------------------------------------------------------------------------
Últimas cinco solicitudes atendidas: ...

El programa deberá preservar el orden de llegada dentro de cada prioridad, conservar un historial limitado, agrupar información y generar parejas de revisión.

Los recursos complementarios y los retos opcionales pueden ampliar el tiempo de estudio.

Elegir una colección especializada

No preguntes primero “¿qué estructura nueva puedo utilizar?”. Pregunta:

• ¿Qué operación se repite?
• ¿Cuál es el costo de escribirla manualmente?
• ¿La estructura especializada comunica mejor la intención?
• ¿Otra persona reconocerá fácilmente su comportamiento?

Ejemplos:

Para tres elementos que solo se recorren una vez, una lista continúa siendo adecuada. Para un único acceso con valor predeterminado, dict.get() puede ser suficiente.

Evita introducir una estructura que:

• no simplifica la operación principal;
• obliga a convertir constantemente a otro tipo;
• oculta una regla de negocio;
• resulta más difícil de explicar que la solución común;
• se utiliza una sola vez sin beneficio apreciable.

from collections import Counter, defaultdict, deque
from itertools import chain, combinations, groupby, islice, product

Importa únicamente lo que utilizas. Evita:

from collections import *

Las importaciones con * dificultan saber de dónde procede cada nombre y pueden producir colisiones.

Conteos y rankings con Counter

from collections import Counter

categorias = [
    "acceso",
    "contenido",
    "acceso",
    "facturación",
    "acceso",
    "contenido",
]

conteo = Counter(categorias)
print(conteo)

Salida aproximada:

Counter({'acceso': 3, 'contenido': 2, 'facturación': 1})

Counter es una subclase de dict. Sus claves son los elementos contados y sus valores son las frecuencias.

print(conteo["acceso"])
print(conteo["desconocida"])

Una clave ausente devuelve 0 en lugar de generar KeyError. Eso es conveniente para conteos, pero no significa que la clave exista:

print("desconocida" in conteo)

categorias = ["Acceso", "acceso", " ACCESO ", "Contenido"]

conteo = Counter(
    categoria.strip().casefold()
    for categoria in categorias
)

Si cuentas antes de normalizar, valores equivalentes aparecerán como categorías separadas.

print(conteo.most_common())
print(conteo.most_common(2))

most_common(2) devuelve las dos parejas con mayor frecuencia:

[('acceso', 3), ('contenido', 1)]

Si existe un empate, no debes inventar que una categoría es “más importante”. Puedes mostrar todas las empatadas:

if conteo:
    frecuencia_maxima = max(conteo.values())
    categorias_lideres = sorted(
        categoria
        for categoria, frecuencia in conteo.items()
        if frecuencia == frecuencia_maxima
    )
else:
    categorias_lideres = []

conteo = Counter(["acceso", "contenido"])
conteo.update(["acceso", "facturación", "acceso"])

print(conteo)

update() suma frecuencias. No reemplaza el contador completo.

También acepta un mapeo de incrementos:

conteo.update({"acceso": 2, "contenido": 1})

disponibles = Counter({"licencia": 5, "cuenta": 3})
asignadas = Counter({"licencia": 2, "cuenta": 4})

resultado = disponibles - asignadas
print(resultado)

La operación - conserva únicamente conteos positivos. Si necesitas observar ceros o negativos, utiliza subtract() y revisa el resultado:

disponibles.subtract(asignadas)
print(disponibles)

No utilices operaciones aritméticas sin decidir qué significa un conteo negativo en tu dominio.

turno_manana = Counter({"acceso": 4, "contenido": 2})
turno_tarde = Counter({"acceso": 1, "facturación": 3})

total_dia = turno_manana + turno_tarde
print(total_dia)

Otras operaciones permiten intersección y unión de frecuencias, pero no deben confundirse con sumar. Consulta su significado antes de usarlas.

conteo = Counter({"urgente": 2, "normal": 3})
print(list(conteo.elements()))

elements() repite cada elemento según su frecuencia positiva. No representa necesariamente el orden original de llegada; utiliza una cola si ese orden importa.

Agrupaciones con defaultdict

Con un diccionario común:

por_responsable = {}

for solicitud in solicitudes:
    responsable = solicitud["responsable"]

    if responsable not in por_responsable:
        por_responsable[responsable] = []

    por_responsable[responsable].append(solicitud)

Con defaultdict(list):

from collections import defaultdict

por_responsable = defaultdict(list)

for solicitud in solicitudes:
    por_responsable[solicitud["responsable"]].append(solicitud)

list se entrega sin paréntesis porque es la fábrica que defaultdict llamará cuando falte una clave.

grupos = defaultdict(list)
totales = defaultdict(int)
etiquetas = defaultdict(set)

Comportamiento al acceder a una clave ausente:

Ejemplos:

duracion_por_categoria = defaultdict(int)

for solicitud in solicitudes:
    categoria = solicitud["categoria"]
    duracion_por_categoria[categoria] += solicitud["minutos_estimados"]

etiquetas_por_categoria = defaultdict(set)

for solicitud in solicitudes:
    etiquetas_por_categoria[solicitud["categoria"]].update(
        solicitud["etiquetas"]
    )

get() devuelve un valor, pero no lo inserta:

datos = {}
lista = datos.get("acceso", [])
lista.append("SOP-001")

print(datos)

Salida:

{}

Esto es un error común:

datos.get("acceso", []).append("SOP-001")

La lista temporal se pierde. Para una consulta aislada, get() es apropiado. Para agrupar repetidamente, defaultdict(list) comunica mejor la intención.

por_categoria = {}

for solicitud in solicitudes:
    categoria = solicitud["categoria"]
    por_categoria.setdefault(categoria, []).append(solicitud)

Esta solución es correcta. defaultdict suele ser más claro cuando toda la estructura comparte el mismo valor predeterminado. setdefault() puede ser conveniente para una operación localizada dentro de un diccionario común.

grupos = defaultdict(list)
print(grupos["inexistente"])
print(grupos)

El acceso mediante corchetes crea la clave:

defaultdict(<class 'list'>, {'inexistente': []})

Si solo quieres comprobar, utiliza:

if "inexistente" in grupos:
    ...

o:

valor = grupos.get("inexistente")

La representación de defaultdict incluye la fábrica. Si necesitas un diccionario común:

resultado_final = dict(por_responsable)

Las listas y objetos internos continúan siendo los mismos. Esta conversión no crea una copia profunda.

Una función puede crear estructuras más completas:

def crear_resumen():
    return {
        "cantidad": 0,
        "minutos": 0,
        "identificadores": [],
    }


resumen_por_categoria = defaultdict(crear_resumen)

for solicitud in solicitudes:
    resumen = resumen_por_categoria[solicitud["categoria"]]
    resumen["cantidad"] += 1
    resumen["minutos"] += solicitud["minutos_estimados"]
    resumen["identificadores"].append(solicitud["id"])

Utiliza una fábrica personalizada solo cuando la estructura repetida lo justifique.

Colas e historiales con deque

cola = ["SOP-001", "SOP-002", "SOP-003"]
primero = cola.pop(0)

Al retirar el primer elemento, los restantes deben desplazarse. Para una cola con muchas operaciones en ambos extremos, utiliza deque:

from collections import deque

cola = deque(["SOP-001", "SOP-002", "SOP-003"])
primero = cola.popleft()

cola = deque()

cola.append("SOP-001")
cola.append("SOP-002")
cola.appendleft("SOP-URGENTE")

primero = cola.popleft()
ultimo = cola.pop()

Cola FIFO: el primero en entrar es el primero en salir.

cola.append(solicitud)
solicitud_actual = cola.popleft()

Pila LIFO: el último en entrar es el primero en salir.

pila.append(accion)
ultima_accion = pila.pop()

La estructura no decide la política. La combinación de operaciones define el comportamiento.

Insertar cada urgente con appendleft() puede invertir el orden entre urgentes:

cola.appendleft("URGENTE-1")
cola.appendleft("URGENTE-2")

El segundo quedará antes que el primero. Para preservar FIFO dentro de cada prioridad, utiliza colas separadas:

colas = {
    "urgente": deque(),
    "alta": deque(),
    "normal": deque(),
}

for solicitud in solicitudes:
    colas[solicitud["prioridad"]].append(solicitud)

Para atender:

if colas["urgente"]:
    siguiente = colas["urgente"].popleft()
elif colas["alta"]:
    siguiente = colas["alta"].popleft()
elif colas["normal"]:
    siguiente = colas["normal"].popleft()
else:
    siguiente = None

Una política que siempre atiende urgentes puede postergar indefinidamente solicitudes normales si continúan llegando urgentes. En un sistema real debes analizar reglas contra la inanición. El proyecto trabajará con un conjunto finito para concentrarse en las estructuras.

historial = deque(maxlen=3)

historial.append("SOP-001")
historial.append("SOP-002")
historial.append("SOP-003")
historial.append("SOP-004")

print(historial)

Salida:

deque(['SOP-002', 'SOP-003', 'SOP-004'], maxlen=3)

Al alcanzar el límite, añadir un elemento descarta automáticamente el más antiguo. Utilízalo solo cuando esa pérdida sea parte explícita del diseño.

Puedes consultar el primer elemento:

if cola:
    siguiente = cola[0]

Para obtener varios elementos sin retirar, islice() resulta útil:

from itertools import islice

proximas_tres = list(islice(cola, 3))

Recorrer una deque mediante islice() no elimina elementos de la cola.

turnos = deque(["Ana", "Luis", "María"])
turnos.rotate(-1)
print(turnos)

Salida:

deque(['Luis', 'María', 'Ana'])

rotate() puede apoyar una asignación circular, pero no reemplaza reglas más complejas de carga, disponibilidad o especialidad.

Herramientas prácticas de itertools

itertools reúne funciones que construyen iteradores eficientes. No necesitas memorizar todo el módulo. Aprende a reconocer los problemas que resuelven las herramientas más útiles.

from itertools import chain

pendientes = ["SOP-001", "SOP-002"]
nuevas = ["SOP-003", "SOP-004"]

combinadas = chain(pendientes, nuevas)

for solicitud in combinadas:
    print(solicitud)

chain() recorre una fuente y después la siguiente sin crear primero una lista combinada.

Si necesitas procesar los datos varias veces, puedes materializarlos una vez:

todas = list(chain(pendientes, nuevas))

No confundas esto con ordenar o mezclar. chain() conserva el orden de cada fuente y las coloca una después de otra.

chain.from_iterable()

Cuando ya tienes una colección de colecciones:

grupos = [
    ["SOP-001", "SOP-002"],
    ["SOP-003"],
    ["SOP-004", "SOP-005"],
]

todas = chain.from_iterable(grupos)

Esto evita tener que conocer cuántos grupos existen para pasarlos como argumentos separados.

from itertools import islice

primeras_tres = list(islice(solicitudes, 3))

También acepta inicio, fin y paso de forma parecida a un segmento:

seleccion = list(islice(solicitudes, 2, 8, 2))

La diferencia es que funciona con iteradores que no permiten índices.

islice() consume el iterador que recibe. Si se utiliza sobre una lista o una deque, la colección permanece; si se utiliza sobre un generador guardado, ese generador avanzará.

from itertools import product

equipos = ["Soporte", "Contenido"]
turnos = ["mañana", "tarde"]

asignaciones = list(product(equipos, turnos))
print(asignaciones)

Salida:

[
    ('Soporte', 'mañana'),
    ('Soporte', 'tarde'),
    ('Contenido', 'mañana'),
    ('Contenido', 'tarde'),
]

product() produce todas las parejas posibles tomando un elemento de cada colección. La cantidad de resultados crece multiplicando los tamaños. Antes de materializar, estima:

cantidad = len(equipos) * len(turnos)

from itertools import combinations

responsables = ["Ana", "Luis", "María", "Carlos"]
parejas = list(combinations(responsables, 2))

Cada pareja aparece una sola vez:

('Ana', 'Luis')
('Ana', 'María')
('Ana', 'Carlos')
('Luis', 'María')
('Luis', 'Carlos')
('María', 'Carlos')

('Ana', 'Luis') y ('Luis', 'Ana') representan el mismo grupo y no se repiten.

from itertools import permutations

pasos = ["validar", "aprobar", "publicar"]
ordenes = list(permutations(pasos, 3))

Las permutaciones crecen muy rápido. Tres elementos producen seis órdenes; diez elementos producen millones. No materialices resultados sin estimar su cantidad.

En procesos reales, la mayoría de los órdenes posibles pueden ser inválidos por dependencias. No utilices permutations() si las reglas ya determinan un orden.

from itertools import groupby

solicitudes_ordenadas = sorted(
    solicitudes,
    key=lambda solicitud: solicitud["categoria"],
)

for categoria, grupo in groupby(
    solicitudes_ordenadas,
    key=lambda solicitud: solicitud["categoria"],
):
    elementos = list(grupo)
    print(categoria, len(elementos))

groupby() no reúne automáticamente todas las apariciones separadas. Agrupa elementos consecutivos con la misma clave.

Ejemplo incorrecto:

categorias = ["acceso", "contenido", "acceso"]

Sin ordenar, groupby() produce tres grupos, no dos.

La regla segura es:

Ordena por la misma clave que utilizarás para agrupar.

for categoria, grupo in groupby(datos, key=clave):
    print(list(grupo))
    print(list(grupo))

La segunda lista queda vacía porque el grupo ya fue consumido. Además, debes procesar el grupo dentro de la iteración principal. Si necesitas conservarlo, materialízalo una vez.

itertools incluye cycle(), repeat(), count(), tee(), takewhile(), dropwhile() y otras funciones. Son útiles en contextos concretos, pero añadirlas sin práctica suficiente convertiría el módulo en un catálogo. Consulta la documentación cuando un problema real sugiera su necesidad.

Materializa con list() cuando:

• necesitas recorrer varias veces;
• necesitas conocer todos los valores;
• necesitas ordenar;
• necesitas acceder por índice;
• necesitas entregar una estructura concreta.

Mantén el iterador cuando:

• lo consumirás una sola vez;
• una función puede consumirlo directamente;
• la cantidad de resultados puede ser grande;
• producir cada valor bajo demanda es suficiente.

Videos recomendados

Ejecuta los ejemplos y adapta al menos uno al proyecto.

• 📖`Counter` del módulo `collections` — The Dojo MX
• 📖`defaultdict` del módulo `collections` — The Dojo MX
• 📖Procesar recorridos con `itertools` — Juan Bosh García

Para deque, utiliza la documentación oficial y reproduce las operaciones con una cola pequeña antes de integrarlas.

Documentación y recursos de lectura

• 📖`collections`: contenedores especializados
• 📖`Counter`
• 📖`defaultdict`
• 📖`deque`

• 📖`itertools`: funciones para crear iteradores
• 📖Recetas de `itertools`
• 📖Guía oficial de programación funcional

• 📖Guía del módulo `collections` — Real Python
• 📖Python Tutor: ejecución paso a paso

Busca deque y responde:

1. ¿Qué complejidad aproximada tienen append() y popleft()?
2. ¿Qué ocurre al añadir a una deque llena con maxlen?
3. ¿Qué diferencia existe entre extend() y extendleft()?
4. ¿Qué signo de rotate() mueve elementos hacia la izquierda?
5. ¿Qué operaciones de lista no son la fortaleza principal de deque?

Material descargable

El módulo incluye:

• datos_solicitudes.py: fuentes, responsables y turnos.
• plantilla_proyecto.py: estructura funcional sin solución.
• GUIA_COLECCIONES_ITERTOOLS.md: mapa de decisión y advertencias.
• CHECKLIST_PROYECTO.md: comprobación previa a la entrega.

raise NotImplementedError funciona únicamente como marcador en la plantilla. Sustituye cada marcador antes de ejecutar el proyecto completo.

⬇️Descargar todos los materiales del Módulo 3

⬇️Descargar datos_solicitudes.py

⬇️Descargar plantilla_proyecto.py

⬇️Descargar GUIA_COLECCIONES_ITERTOOLS.md

⬇️Descargar CHECKLIST_PROYECTO.md

Errores comunes

"Acceso", "acceso" y " ACCESO " se convierten en claves diferentes si no se normalizan.

Devuelve un elemento, aunque varias claves compartan la frecuencia máxima. Detecta líderes si el empate importa.

update() suma frecuencias a las existentes.

Reconstruye repeticiones positivas, no el orden de llegada original.

defaultdict(list)    # correcto
defaultdict(list())  # incorrecto

La fábrica debe ser invocable.

grupos["ausente"] crea una clave en defaultdict. Utiliza in o get() si solo necesitas comprobar.

datos.get(clave, []).append(valor) no guarda la lista cuando la clave falta.

Para una cola con muchas retiradas al inicio, utiliza deque.popleft().

Cada nueva inserción queda antes de las urgentes anteriores. Utiliza colas separadas si necesitas FIFO por prioridad.

El elemento más antiguo se descarta sin confirmación cuando la deque está llena.

chain(), islice() y los grupos de groupby() producen iteradores consumibles.

Solo agrupa coincidencias consecutivas. Ordena por la misma clave.

En combinaciones el orden no crea un grupo nuevo; en permutaciones sí.

Estima el número de resultados antes de llamar a list().

Glosario

Resumen del módulo

Aprendiste que una colección especializada resulta útil cuando su operación central coincide con el problema:

• Counter elimina código auxiliar de conteo y facilita rankings;
• defaultdict simplifica agrupaciones y acumulaciones;
• deque permite colas, pilas e historiales limitados;
• itertools permite encadenar, limitar, combinar y agrupar recorridos.

También identificaste los riesgos: contar datos sin normalizar, crear claves accidentalmente, invertir una prioridad, perder historial por maxlen, consumir iteradores y utilizar groupby() sin ordenar.

• Conteo y ranking de datos.
• Agrupación y acumulación por claves.
• Diseño de colas FIFO con prioridades.
• Conservación de ventanas e historiales limitados.
• Combinación eficiente de fuentes.
• Formación de parejas y matrices de posibilidades.
• Agrupación correcta de datos ordenados.
• Selección razonada de estructuras especializadas.

• Puedo explicar cuándo Counter aporta valor.
• Sé agrupar con defaultdict(list).
• Comprendo cuándo una lectura crea una clave.
• Puedo implementar FIFO con deque.
• Sé preservar el orden dentro de prioridades.
• Comprendo la pérdida automática de maxlen.
• Puedo utilizar chain() e islice() sin consumir resultados necesarios.
• Distingo producto, combinación y permutación.
• Sé ordenar antes de groupby().
• 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 4: Archivos y rutas con la biblioteca estándar.