Ciclos anidados 🔄 — Python: Listas

• ¿Por qué necesitamos flatten?
• Mejora: sacar la lógica repetida a una función
• ¿Y los ciclos anidados… son malos?
• Errores típicos (y cómo evitarlos)
• Versión usando métodos de lista

En proyectos reales a veces recibes listas con listas dentro. Queremos una función que aplane la lista (solo un nivel) para trabajar más cómodo.

Una lista aplanada es una lista que ya no tiene listas dentro: todos los elementos están al mismo nivel.

Antes: [1, [2, 3], 4] ⮕ Después: [1, 2, 3, 4]

¿Por qué necesitamos flatten?

• Para unir resultados que llegaron por partes.
• Para limpiar datos antes de contarlos/ordenarlos.
• Para evitar bucles repetidos en todos lados.

Ejemplo:

La función recibe (entrada) una lista con elementos mezclados, revisa uno por uno (proceso), y devuelve (salida) una lista plana.

Entrada:

[3, 2, [], [3, 4, 2], 3, [123, 3]]

Salida esperada:

[3, 2, 3, 4, 2, 3, 123, 3]

Cómo lo hacemos en código

def flatten(coll):
    result = []                     # acumulamos aquí
    for item in coll:               # recorremos cada elemento
        if isinstance(item, list):  # si es una lista, la "revelamos"
            for sub_item in item:   # bucle anidado SOLO cuando toca
                result.append(sub_item)
        else:                       # si NO es lista, lo agregamos tal cual
            result.append(item)
    return result


print(flatten([3, 2, [], [3, 4, 2], 3, [123, 3]]))
# => [3, 2, 3, 4, 2, 3, 123, 3]

👉 El bucle anidado aparece solo cuando encontramos una sublista.

Mejora: sacar la lógica repetida a una función

Para que el código sea más claro, extraemos “agregar todos los elementos de otra lista” a un helper.

def extend_list(dst, src):
    """Agrega todos los elementos de src dentro de dst (modifica dst)."""
    for item in src:
        dst.append(item)

def flatten(coll):
    result = []
    for item in coll:
        if isinstance(item, list):
            extend_list(result, item)  # usamos el helper
        else:
            result.append(item)
    return result


print(flatten([3, [1, 2], ['a', 'b'], [], 5]))
# => [3, 1, 2, 'a', 'b', 5]

💡 Nota: nuestro extend_list() es solo un helper educativo. El método real list.extend(...) existe en Python y hace lo mismo más eficientemente.

¿Y los ciclos anidados… son malos?

Los ciclos anidados aparecen en muchos programas. No siempre son un error, pero sí pueden:

• hacer el código más difícil de leer,
• aumentar la cantidad de variables que cambian al mismo tiempo,
• y, a veces, indicar un algoritmo poco eficiente.

Errores típicos (y cómo evitarlos)

❌ Sobrescribir nombres confusos: no crees def append(...) ⮕ Usa extend_list o llama directamente a result.extend(sublista).

❌ Modificar la lista que recorres en el mismo bucle (agregar/eliminar del iterable actual) ⮕ Acumula en result y deja la original en paz.

❌ Aplanar más de lo que toca: esta versión no es recursiva ⮕ Si necesitas todos los niveles, tendrás que usar recursión o un stack (tema avanzado).

Versión usando métodos de lista

def flatten(coll):
    result = []
    for item in coll:
        if isinstance(item, list):
            result.extend(item)  # equivalente a nuestro extend_list()
        else:
            result.append(item)
    return result