4.1 Listas (`list`)

1️⃣ ¿Qué es una lista y para qué sirve?

En Python, una lista es un tipo de dato complejo que permite almacenar varios valores en una sola variable. A diferencia de los tipos simples (como un número o una cadena), una lista puede contener una colección ordenada de elementos, y cada uno de ellos puede ser de un tipo diferente.

Las listas se utilizan constantemente en programación: para guardar nombres de usuarios, números de una secuencia, resultados de una operación o incluso otras listas dentro de ellas. Constituyen una herramienta básica para trabajar con grupos de datos dinámicos.

Las características principales de una lista son:

Ordenadas: mantienen el orden en que se introducen los elementos.
Mutables: se pueden modificar (añadir, eliminar o cambiar elementos).
Heterogéneas: pueden incluir datos de distintos tipos (números, cadenas, booleanos, etc.).
Permiten duplicados: se pueden repetir valores sin problema.

Ejemplo de declaración de una lista
mi_lista = [25, "hola", 3.14, True]
print(mi_lista)

# [25, 'hola', 3.14, True]

en este ejemplo

En este caso, la lista mi_lista contiene cuatro elementos de distintos tipos. Python no exige que todos los elementos sean del mismo tipo, lo que hace que las listas sean muy flexibles.

2️⃣ Cómo crear una lista

Existen varias formas de crear listas en Python. La más habitual es usando corchetes [] y separando los elementos por comas.

🟩 Creación literal

Declaración literal de una lista
frutas = ["manzana", "pera", "uva"]

en este ejemplo

Se crea una lista con tres cadenas de texto. El orden en el que se escriben será el orden que mantendrá la lista.

También se pueden crear listas vacías, para rellenarlas después:

Creación de una lista vacía
vacia = []

🟦 A partir de otro iterable

También podemos construir una lista a partir de otros tipos de datos que sean “recorribles” (iterables), como cadenas o rangos.

Declaración de una lista a partir de una cadena
letras = list("Python")
print(letras)     # ['P', 'y', 't', 'h', 'o', 'n']

en este ejemplo

La función list() convierte una cadena en una lista, separando cada carácter.

Otro ejemplo, a partir de un rango numérico:

Declaración de una lista a partir de un rango numérico
numeros = list(range(3, 8))
print(numeros)    # [3, 4, 5, 6, 7]

3️⃣ Acceso a los elementos de una lista

Cada elemento de una lista tiene una posición numérica, llamada índice, que comienza en 0.

Acceso a los elementos de una lista por medio de su índice
colores = ["rojo", "verde", "azul"]
print(colores[0])   # rojo
print(colores[1])   # verde
print(colores[2])   # azul

en este ejemplo

El índice permite acceder directamente a un elemento. colores[0] devuelve el primer valor. Si intentamos acceder a un índice inexistente, Python mostrará un error.

🟩 Índices negativos

Python permite contar desde el final usando índices negativos.

Acceso a los elementos de una lista por medio de índice negativo
print(colores[-1])  # azul
print(colores[-2])  # verde

en este ejemplo

El índice -1 se refiere al último elemento, -2 al penúltimo, y así sucesivamente.

4️⃣ Rebanado o slicing

El slicing permite obtener una porción de la lista, es decir, una sublista formada por los elementos que se encuentran entre dos posiciones. Esto nos permite, por ejemplo, imprimirla o crear una copia de una sección de la lista.

slicing de una lista
numeros = [10, 20, 30, 40, 50, 60]
print(numeros[1:4])   # [20, 30, 40]
print(numeros[:3])    # [10, 20, 30]
print(numeros[3:])    # [40, 50, 60]

en este ejemplo

El primer número es el inicio (incluido).
El segundo es el final (excluido).
Si se omite el primero, se empieza desde el principio; si se omite el segundo, se llega hasta el final.

También se puede modificar valores en bloque mediante slicing:

Asignación de valores mediante slicing
nums = [1, 2, 3, 4, 5]
nums[1:4] = [20, 30]     # reemplaza 2,3,4 por dos elementos
print(nums)              # [1, 20, 30, 5]

nums[2:2] = [100, 200]   # inserta sin eliminar
print(nums)              # [1, 20, 100, 200, 30, 5]

5️⃣ Modificación de listas

A diferencia de otros tipos de datos, las listas pueden modificarse después de crearse.

frutas = ["manzana", "pera", "uva"]
frutas[1] = "plátano"
print(frutas)    # ['manzana', 'plátano', 'uva']

en este ejemplo

Se reemplaza el valor en la posición 1. Las listas son mutables, por lo que se pueden alterar sin crear una nueva.

6️⃣ Operaciones básicas con listas

Python permite realizar operaciones comunes con las listas. Este tipo de operaciones las hemos estudiado previamente con el empleo de cadenas de texto que, en cierto modo, se comportan como listas de caracteres.

Operaciones de longitud, pertenencia, concatenación y producto
numeros = [1, 2, 3]
print(len(numeros))       # longitud -> 3
print(2 in numeros)       # True (está en la lista)
print([1, 2] + [3, 4])    # concatenación -> [1, 2, 3, 4]
print(["a"] * 3)          # repetición -> ['a', 'a', 'a']

en este ejemplo

len() devuelve cuántos elementos contiene la lista.
El operador in comprueba si un valor está dentro.
El operador + une dos listas.
El operador * repite la lista varias veces.

7️⃣ Métodos más comunes de las listas

Además de permitir almacenar y acceder a elementos, las listas de Python incluyen una serie de métodos incorporados que facilitan enormemente su manipulación. Estos métodos permiten añadir, eliminar, buscar, ordenar o copiar elementos sin necesidad de escribir mucho código.

A continuación se estudian uno a uno los métodos más importantes...

Método	Descripción	Modifica la lista
`append(x)`	Añade un elemento al final	✅
`extend(iterable)`	Añade varios elementos	✅
`insert(i, x)`	Inserta en la posición `i`	✅
`remove(x)`	Elimina la primera aparición de `x`	✅
`pop([i])`	Elimina y devuelve el elemento en `i` o el último	✅
`clear()`	Vacía la lista	✅
`index(x)`	Devuelve la posición del primer `x`	❌
`count(x)`	Cuenta cuántas veces aparece `x`	❌
`sort()`	Ordena los elementos	✅
`reverse()`	Invierte el orden de los elementos	✅
`copy()`	Devuelve una copia superficial	❌

🟩 `append()`

El método append() se utiliza para añadir un solo elemento al final de la lista. Este método modifica la lista original y no devuelve ningún valor (su resultado es None).

Ejemplo de uso de append()
frutas = ["manzana", "pera"]
frutas.append("uva")
print(frutas)

# ['manzana', 'pera', 'uva']

en este ejemplo

Se añade el nuevo elemento "uva" al final de la lista. El resultado es ['manzana', 'pera', 'uva'].

🟦 `extend()`

Mientras que append() añade un solo elemento, extend() sirve para añadir varios elementos de otra colección (como otra lista, tupla o conjunto).

Ejemplo de uso de extend()
numeros = [1, 2, 3]
numeros.extend([4, 5, 6])
print(numeros)      

# [1, 2, 3, 4, 5, 6]

en este ejemplo

Cada elemento de la lista [4, 5, 6] se añade individualmente al final de numeros. El resultado es [1, 2, 3, 4, 5, 6].

Error común:

Si usamos append([4,5,6]) en lugar de extend([4,5,6]), se añade una lista dentro de la lista, no sus elementos:

numeros = [1, 2, 3]
numeros.append([4, 5, 6])
print(numeros)  

# [1, 2, 3, [4, 5, 6]]

🟨 `insert(posicion, elemento)`

Permite insertar un nuevo elemento en una posición concreta de la lista. El primer parámetro indica el índice donde se colocará el elemento, desplazando el resto hacia la derecha.

Ejemplo de uso de insert()
colores = ["rojo", "verde", "azul"]
colores.insert(1, "amarillo")
print(colores)

# ['rojo', 'amarillo', 'verde', 'azul']

en este ejemplo

El elemento "amarillo" se inserta en la posición 1. El resultado es ['rojo', 'amarillo', 'verde', 'azul'].

🟧 `remove(elemento)`

El método remove() busca el primer elemento que coincida con el valor indicado y lo elimina. Si el elemento no existe, se produce un error (ValueError).

Ejemplo de uso de remove()
nombres = ["Ana", "Luis", "María", "Luis"]
nombres.remove("Luis")
print(nombres)

# ['Ana', 'María', 'Luis']

en este ejemplo

Solo se elimina la primera aparición de "Luis".

Consejo

Antes de usar remove(), es recomendable comprobar si el elemento existe:

if "Pedro" in nombres:
    nombres.remove("Pedro")

🟥 `pop([índice])`

El método pop() elimina un elemento por su posición y además lo devuelve. Si no se especifica el índice, elimina el último elemento.

Ejemplo de uso de pop() sin índice
numeros = [10, 20, 30, 40]
ultimo = numeros.pop()
print("Elemento eliminado:", ultimo)
print("Lista actual:", numeros)

# Elemento eliminado: 40
# Lista actual: [10, 20, 30]

en este ejemplo

pop() elimina el último valor (40) y lo devuelve.

También se puede usar un índice concreto:

Ejemplo de uso de pop() con índice
primero = numeros.pop(0)
print(primero)   # 10

🟪 `clear()`

El método clear() elimina todos los elementos de la lista, dejándola vacía.

Ejemplo de uso de clear()
datos = [1, 2, 3]
datos.clear()
print(datos)   # []

en este ejemplo

Después de ejecutar clear(), la lista sigue existiendo, pero ya no contiene elementos.

🟫 `index(elemento[, inicio[, fin]])`

El método index() devuelve el índice del primer elemento que coincida con el valor buscado. Opcionalmente se puede indicar un rango de búsqueda con los parámetros inicio y fin.

Ejemplo de uso de index()
letras = ["a", "b", "c", "a", "b"]
pos = letras.index("b")
print(pos)  # 1

en este ejemplo

Devuelve la posición del primer "b", que es el índice 1.

aviso

Si el valor no se encuentra, se genera un error:

# ValueError: 'x' is not in list

Para evitarlo, se puede comprobar antes:

if "x" in letras:
    pos = letras.index("x")

🟩 `count(elemento)`

Este método cuenta cuántas veces aparece un elemento dentro de la lista.

Ejemplo de uso de count()
numeros = [1, 2, 3, 2, 2, 4]
print(numeros.count(2))   # 3

en este ejemplo

Devuelve 3 porque el número 2 aparece tres veces.

8️⃣ Copia de listas

Cuando se trabaja con colecciones (listas, tuplas o diccionarios), es importante entender cómo funcionan las copias de los objetos. En Python, asignar una variable a otra no crea una copia, sino que ambas apuntan al mismo objeto en memoria. Para evitar modificar datos por error, Python ofrece dos formas de copiar: copias superficiales (copy) y copias profundas (deepcopy).

🟩 Asignación simple (sin copia)

Ejemplo de asignación simple
a = [1, 2, 3]
b = a        # b no es una copia, es la misma lista
b.append(4)
print("a:", a)
print("b:", b)

# a: [1, 2, 3, 4]
# b: [1, 2, 3, 4]

en este ejemplo

Tanto a como b apuntan al mismo objeto en memoria. Modificar uno afecta al otro.

🟦 Copia superficial (`copy()`)

Una copia superficial crea un nuevo contenedor, pero no copia los objetos internos (solo sus referencias). Esto significa que si la lista contiene otras listas u objetos, esos elementos seguirán compartiéndose.

Ejemplo de copia superficial con listas anidadas

original = [[1, 2], [3, 4]]
copia = original.copy()

copia[0][0] = 99

print("Original:", original)
print("Copia:", copia)

# Original: [[99, 2], [3, 4]]
# Copia: [[99, 2], [3, 4]]

en este ejemplo

Aunque copia es una lista distinta, las sublistas internas son las mismas. Por eso, cambiar un elemento interno también afecta al original.

Atención:

Si la lista contiene otras listas dentro, la copia no será totalmente independiente (para eso se necesita una copia profunda usando copy.deepcopy() del módulo copy).

🟨 Copia profunda (`deepcopy()`)

Una copia profunda crea un nuevo contenedor y también copias independientes de todos los objetos internos, de forma recursiva. Esto garantiza que los cambios en la copia no afecten al original.

Ejemplo de copia profunda con listas anidadas
import copy

original = [[1, 2], [3, 4]]
copia_profunda = copy.deepcopy(original)

copia_profunda[0][0] = 99

print("Original:", original)
print("Copia profunda:", copia_profunda)

# Original: [[1, 2], [3, 4]]
# Copia profunda: [[99, 2], [3, 4]]

en este ejemplo

deepcopy() ha creado copias completamente nuevas de las sublistas internas, por lo que los cambios en una no afectan a la otra.

📊 Comparativa rápida

Tipo de copia	Crea nuevo objeto externo	Crea nuevos objetos internos	Independencia completa	Ejemplo típico
Asignación `b = a`	❌ No	❌ No	❌ No	Referencia directa
`copy.copy(a)`	✅ Sí	❌ No	❌ No	Copia “superficial”
`copy.deepcopy(a)`	✅ Sí	✅ Sí	✅ Sí	Copia totalmente independiente

9️⃣ Recorrido de listas

Una de las operaciones más comunes que se realizan con listas es recorrer sus elementos uno a uno, lo que se denomina iterar. Iterar significa ejecutar una acción repetida para cada elemento de la lista: mostrarlo, modificarlo, aplicar una operación o comprobar una condición.

Python ofrece distintas formas de recorrer listas de manera clara y eficiente. En este apartado se estudian todas ellas.

🟩 Recorrido básico con el bucle `for`

La forma más directa de recorrer una lista es utilizando un bucle for, que permite acceder a cada elemento directamente sin preocuparse por su posición.

Ejemplo de uso de 'for' para recorrer listas
frutas = ["manzana", "pera", "naranja"]

for fruta in frutas:
    print(fruta)

# manzana
# pera
# naranja

en este ejemplo

El bucle recorre toda la lista frutas y, en cada repetición, la variable fruta toma el valor de uno de los elementos. En la primera vuelta vale "manzana", luego "pera", y finalmente "naranja". Cuando ya no quedan más elementos, el bucle termina automáticamente.

👉 Este tipo de recorrido es ideal cuando solo necesitas el valor de cada elemento y no te importa su posición en la lista.

🟦 Recorrido por índice con `range()` y `len()`

En algunas situaciones puede interesar acceder al índice (posición) de cada elemento además de su valor. Para ello, se puede usar la función range() junto con len(), que devuelve la longitud de la lista.

Recorrido de lista mediante índice
numeros = [10, 20, 30, 40]

for i in range(len(numeros)):
    print(f"Índice {i} -> Valor {numeros[i]}")

# Índice 0 -> Valor 10
# Índice 1 -> Valor 20
# Índice 2 -> Valor 30
# Índice 3 -> Valor 40

en este ejemplo

len(numeros) devuelve 4, porque la lista tiene cuatro elementos.
range(len(numeros)) genera la secuencia [0, 1, 2, 3].
En cada iteración, la variable i representa el índice actual, y numeros[i] el valor correspondiente.

👉 Este método es útil cuando se necesita modificar los valores de la lista mientras se recorren, ya que permite acceder a ellos mediante su posición.

🟨 Recorrido con `enumerate()`

Python ofrece una forma más cómoda y legible de obtener índices y valores a la vez mediante la función integrada enumerate().

Uso de enumerate() para recorrer una lista
animales = ["gato", "perro", "loro"]

for indice, animal in enumerate(animales):
    print(f"{indice}: {animal}")

# 0: gato
# 1: perro
# 2: loro

en este ejemplo

enumerate(animales) devuelve pares (índice, valor).
En la primera iteración, indice = 0 y animal = "gato", luego (1, "perro"), etc.
Este método es más legible y evita errores comunes con range(len(...)).

Consejo:

enumerate() permite además especificar el número desde el que se quiere empezar a contar:

for i, animal in enumerate(animales, start=1):
    print(f"{i}. {animal}")

En este caso, los índices comienzan en 1.

🟧 Recorrido en paralelo con `zip()`

En ocasiones se necesitan recorrer varias listas al mismo tiempo, tomando un elemento de cada una en cada vuelta del bucle. Para esto se utiliza la función zip(), que “empareja” los elementos de las listas según su posición.

Uso de zip() para recorrer varias listas
nombres = ["Ana", "Luis", "Marta"]
edades = [20, 22, 21]

for nombre, edad in zip(nombres, edades):
    print(f"{nombre} tiene {edad} años")

# Ana tiene 20 años
# Luis tiene 22 años
# Marta tiene 21 años

en este ejemplo

zip() crea tuplas con un elemento de cada lista. En este caso, produce: ("Ana", 20), ("Luis", 22) y ("Marta", 21).

aviso

Si las listas no tienen la misma longitud, zip() se detiene cuando la más corta termina.

🟥 Recorrido inverso

También es posible recorrer una lista desde el último elemento hasta el primero. Para ello se puede usar slicing inverso [::-1] o la función reversed().

Uso de reversed() para recorrido inverso
dias = ["lunes", "martes", "miércoles"]

for dia in reversed(dias):
    print(dia)

# miércoles
# martes
# lunes

en este ejemplo

reversed(dias) devuelve un iterador que recorre la lista en sentido contrario sin modificarla.

🟪 Modificar los elementos durante la iteración

Cuando se necesita actualizar los valores de una lista, se debe recorrer por índices, no directamente por los elementos. De este modo se puede acceder y reemplazar cada posición.

Actualizando valores mediante índice
numeros = [1, 2, 3, 4, 5]

for i in range(len(numeros)):
    numeros[i] = numeros[i] * 2

print(numeros) #[2, 4, 6, 8, 10]

en este ejemplo

Cada elemento se multiplica por 2 y se guarda de nuevo en su posición.

🟫 Errores comunes al iterar listas

Modificar la lista mientras se recorre directamente.
```
for n in numeros:
    if n < 0:
        numeros.remove(n)  # ⚠️ Puede saltar elementos
```
💡 Solución: Recorrer una copia (for n in numeros[:]) o crear una nueva lista con los valores filtrados.
Confundir índices y valores. Recordar que for n in lista itera por los valores, no por las posiciones.
Olvidar que zip() se detiene en la lista más corta.

📊 Tabla resumen

Método de recorrido	Qué ofrece	Sintaxis básica	Modifica la lista	Ideal cuando…
`for elemento in lista`	Valor de cada elemento	`for x in lista:`	❌ No	Solo interesa el contenido
`for i in range(len(lista))`	Índices y valores	`lista[i]`	✅ Posible	Necesitas modificar elementos
`for i, x in enumerate(lista)`	Índice y valor simultáneo	`enumerate(lista)`	❌ No	Quieres numerar o mostrar posiciones
`for a, b in zip(lista1, lista2)`	Elementos de varias listas en paralelo	`zip(lista1, lista2)`	❌ No	Combinas datos de varias listas
`for x in reversed(lista)`	Recorre en sentido inverso	`reversed(lista)`	❌ No	Quieres procesar del final al principio
Doble bucle `for`	Recorre listas anidadas	`for fila in matriz:`	❌ No	Trabajas con matrices o tablas

🔟 Ordenación de listas

En Python, las listas pueden reorganizarse gracias a métodos y funciones integradas como sort(), sorted() y reverse(). Estos permiten controlar el orden de los elementos y seleccionar solo aquellos que cumplan ciertas condiciones.

🟩 `sort(key=None, reverse=False)`

El método sort() ordena los elementos en orden ascendente por defecto. Modifica la lista original y no devuelve una nueva lista.

Ejemplo básico de sort()
notas = [7.5, 3.2, 9.0, 5.8]
notas.sort()
print(notas)  # [3.2, 5.8, 7.5, 9.0]

Se puede invertir el orden con el parámetro reverse=True:

Orden descendente
notas.sort(reverse=True)
print(notas)  # [9.0, 7.5, 5.8, 3.2]

Y se puede usar el parámetro key para indicar cómo comparar los elementos.

🟦 `reverse()`

El método reverse() invierte los elementos sin realizar una comparación de valores.

Ejemplo de reverse()
dias = ["lunes", "martes", "miércoles"]
dias.reverse()
print(dias)  # ['miércoles', 'martes', 'lunes']

reverse con slicing

También puede obtenerse el mismo efecto usando slicing:

invertida = dias[::-1]

🟨 `sorted()`

Si se desea mantener la lista original, puede usarse la función integrada sorted().

Uso de sorted()
nombres = ["Carlos", "Ana", "Bea"]
ordenados = sorted(nombres)
print("Original:", nombres)
print("Ordenados:", ordenados)

en este ejemplo

sorted() devuelve una nueva lista ordenada, mientras que sort() modifica la existente.

🟧 Criterios de ordenación con `key`

El parámetro key del método sort() (y también de sorted()) permite indicar una función integrada que transforme cada elemento antes de compararlo. De esta forma se pueden aplicar criterios de ordenación personalizados sin necesidad de definir funciones propias.

🔹 `str.lower` — Ignorar mayúsculas y minúsculas

Ordenar cadenas ignorando mayúsculas
palabras = ["Sol", "luna", "Estrella", "mar"]
palabras.sort(key=str.lower)
print(palabras)  # ['Estrella', 'luna', 'mar', 'Sol']

en este ejemplo

La función integrada str.lower convierte todas las cadenas a minúsculas antes de compararlas, evitando que las letras mayúsculas aparezcan antes en el orden ASCII.

🔹 `abs` — Ordenar por valor absoluto

Ordenar números por valor absoluto
numeros = [-5, 3, -2, 8, -1]
numeros.sort(key=abs)
print(numeros)  # [-1, -2, 3, -5, 8]

en este ejemplo

abs() devuelve el valor absoluto. Así, los números se ordenan según su magnitud, sin importar el signo.

🔹 `len` — Ordenar por longitud de cadenas o listas

Ordenar por longitud
palabras = ["luz", "estrella", "sol", "planeta"]
palabras.sort(key=len)
print(palabras)  # ['sol', 'luz', 'planeta', 'estrella']

en este ejemplo

len() devuelve la longitud de cada elemento. Los más cortos aparecen primero.

🔹 `str` — Convertir a cadena antes de ordenar

Ordenar elementos convertidos a cadena
valores = [10, 2, 33, 21, 5]
valores.sort(key=str)
print(valores)  # [10, 2, 21, 33, 5]

en este ejemplo

Los números se convierten en texto antes de compararse, por lo que se ordenan alfabéticamente en lugar de numéricamente.

🔹 `int` — Convertir cadenas a números

Ordenar números almacenados como texto
valores = ["20", "3", "100", "45"]
valores.sort(key=int)
print(valores)  # ['3', '20', '45', '100']

en este ejemplo

La función int() transforma las cadenas en enteros antes de compararlas, obteniendo un orden numérico correcto.

🔹 `float` — Ordenar textos con números decimales

Ordenar números decimales en texto
valores = ["3.14", "2.5", "10.0", "0.9"]
valores.sort(key=float)
print(valores)  # ['0.9', '2.5', '3.14', '10.0']

en este ejemplo

Convierte cada cadena a número decimal antes de ordenar, garantizando un orden correcto por valor numérico.

info

El parámetro key adquiere una gran utilidad cuando se combina con funciones lambda o funciones personalizadas definidas por el desarrollador, ya que permiten crear criterios de ordenación más complejos. Estos casos, junto con el filtrado de elementos de secuencias o iterables, se estudiarán con detalle en la unidad dedicada a las funciones más adelante en el curso.

1️⃣1️⃣ Listas anidadas

Una lista puede contener otras listas, lo que permite representar estructuras más complejas, como tablas o matrices.

Ejemplo de lista bidimensional
matriz = [[1, 2, 3],
          [4, 5, 6],
          [7, 8, 9]]

print(matriz[1][2])  # 6

en este ejemplo

Cada fila de la matriz es una lista. El primer índice selecciona la fila y el segundo el elemento dentro de ella.

1️⃣2️⃣ Comprensión de listas

Hasta ahora hemos visto cómo crear y recorrer listas utilizando bucles for. Python, sin embargo, ofrece una forma mucho más concisa, rápida y expresiva de construir listas a partir de otras secuencias: las comprensiones de listas (list comprehensions).

Este mecanismo permite generar nuevas listas aplicando transformaciones o filtros sobre los elementos de una secuencia existente, en una sola línea de código, sin renunciar a la claridad.

🟩 Qué es una comprensión de lista

Una comprensión de lista es una expresión compacta que combina un bucle for (y, opcionalmente, un if) dentro de corchetes [] para crear listas de manera más directa.

✍️ sintaxis general
[expresion for elemento in iterable if condicion]

expresion → indica qué valor se añadirá a la lista resultante.
elemento → es la variable que toma los valores del iterable (lista, cadena, rango…).
iterable → es la secuencia de datos que se recorre.
if condicion → es opcional; sirve para filtrar los elementos que cumplan cierta condición.

🟦 Ejemplo básico

Creación de un alista mediante list comprehension
numeros = [1, 2, 3, 4, 5]
cuadrados = [n**2 for n in numeros]
print(cuadrados)   # [1, 4, 9, 16, 25]

en este ejemplo

El bucle recorre la lista numeros y eleva al cuadrado cada elemento. Cada resultado se añade automáticamente a una nueva lista.

Este código produce el mismo resultado que:

cuadrados = []
for n in numeros:
    cuadrados.append(n**2)

Pero en una sola línea, mucho más legible.

🟨 Añadir una condición (`if`)

Podemos incluir un filtro para que solo algunos elementos se añadan a la nueva lista.

Compresión de lista con condición
numeros = [3, 8, 1, 6, 5, 2]
pares = [n for n in numeros if n % 2 == 0]
print(pares)

# [8, 6, 2]

en este ejemplo

El if hace que solo se añadan los números pares. El resto se ignoran, sin necesidad de escribir un if completo dentro de un bucle.

🟧 Usar una transformación y un filtro juntos

La comprensión puede transformar los valores y filtrarlos al mismo tiempo.

compresión de lista mediante transformación y filtrado
temperaturas = [15, 22, 19, 30, 12, 25]
altas = [t + 1 for t in temperaturas if t >= 20]
print(altas)

# [23, 31, 26]

en este ejemplo

De la lista original se toman solo los valores mayores o iguales que 20, y se les suma 1 antes de añadirlos a la nueva lista.

🟥 Comprensiones con cadenas de texto

Las comprensiones no solo sirven para números: también son muy útiles con cadenas de texto.

Compresión de una cadena de texto
palabras = ["sol", "luna", "estrella", "mar"]
mayusculas = [p.upper() for p in palabras]
print(mayusculas)

# ['SOL', 'LUNA', 'ESTRELLA', 'MAR']

en este ejemplo

Cada palabra se convierte en mayúsculas mediante el método .upper() antes de añadirse a la nueva lista.

🟪 Comprensiones anidadas (dobles bucles)

También es posible incluir más de un bucle for dentro de una comprensión, para combinar elementos de varias secuencias o recorrer estructuras anidadas.

📘 Ejemplo 1: Producto cartesiano

colores = ["rojo", "verde"]
tallas = ["S", "M", "L"]
combinaciones = [(c, t) for c in colores for t in tallas]
print(combinaciones)

# [('rojo', 'S'), ('rojo', 'M'), ('rojo', 'L'), ('verde', 'S'), ('verde', 'M'), ('verde', 'L')]

en este ejemplo

Se generan todas las combinaciones posibles entre los colores y las tallas.

📘 Ejemplo 2: Aplanar una lista de listas

matriz = [[1, 2, 3], [4, 5], [6]]
plana = [x for fila in matriz for x in fila]
print(plana)

# [1, 2, 3, 4, 5, 6]

en este ejemplo

El primer for recorre las filas y el segundo los elementos dentro de cada fila, generando una lista “plana”.

🟫 Cuándo evitar las comprensiones

Aunque son muy útiles, las comprensiones deben usarse con moderación:

❌ Si la expresión es muy larga o compleja, es preferible usar un bucle tradicional.
❌ Si la lógica requiere varias condiciones anidadas o pasos intermedios, un bucle for es más legible.
✅ Utiliza comprensiones para operaciones simples y directas, donde la intención sea clara.

🧩 Practica las compresiones

La conpresión de listas es un recurso muy util pero requiere práctica.

Prueba a realizar estas compresiones y mejora tu habilidad ... Descarga el archivo para practicar

Puedes consultar las soluciones aquí

1️⃣ ¿Qué es una lista y para qué sirve?​

2️⃣ Cómo crear una lista​

🟩 Creación literal​

🟦 A partir de otro iterable​

3️⃣ Acceso a los elementos de una lista​

🟩 Índices negativos​

4️⃣ Rebanado o slicing​

5️⃣ Modificación de listas​

6️⃣ Operaciones básicas con listas​

7️⃣ Métodos más comunes de las listas​

🟩 append()​

🟦 extend()​

🟨 insert(posicion, elemento)​

🟧 remove(elemento)​

🟥 pop([índice])​

🟪 clear()​

🟫 index(elemento[, inicio[, fin]])​

🟩 count(elemento)​

8️⃣ Copia de listas​

🟩 Asignación simple (sin copia)​

🟦 Copia superficial (copy())​

🟨 Copia profunda (deepcopy())​

📊 Comparativa rápida​

9️⃣ Recorrido de listas​

🟩 Recorrido básico con el bucle for​

🟦 Recorrido por índice con range() y len()​

🟨 Recorrido con enumerate()​

🟧 Recorrido en paralelo con zip()​

🟥 Recorrido inverso​

🟪 Modificar los elementos durante la iteración​

🟫 Errores comunes al iterar listas​

📊 Tabla resumen​

🔟 Ordenación de listas​

🟩 sort(key=None, reverse=False)​

🟦 reverse()​

🟨 sorted()​

🟧 Criterios de ordenación con key​

🔹 str.lower — Ignorar mayúsculas y minúsculas​

🔹 abs — Ordenar por valor absoluto​

🔹 len — Ordenar por longitud de cadenas o listas​

🔹 str — Convertir a cadena antes de ordenar​

🔹 int — Convertir cadenas a números​

🔹 float — Ordenar textos con números decimales​

1️⃣1️⃣ Listas anidadas​

1️⃣2️⃣ Comprensión de listas​

🟩 Qué es una comprensión de lista​

🟦 Ejemplo básico​

🟨 Añadir una condición (if)​

🟧 Usar una transformación y un filtro juntos​

🟥 Comprensiones con cadenas de texto​

🟪 Comprensiones anidadas (dobles bucles)​

🟫 Cuándo evitar las comprensiones​

🧩 Practica las compresiones​

1️⃣ ¿Qué es una lista y para qué sirve?

2️⃣ Cómo crear una lista

🟩 Creación literal

🟦 A partir de otro iterable

3️⃣ Acceso a los elementos de una lista

🟩 Índices negativos

4️⃣ Rebanado o slicing

5️⃣ Modificación de listas

6️⃣ Operaciones básicas con listas

7️⃣ Métodos más comunes de las listas

🟩 `append()`

🟦 `extend()`

🟨 `insert(posicion, elemento)`

🟧 `remove(elemento)`

🟥 `pop([índice])`

🟪 `clear()`

🟫 `index(elemento[, inicio[, fin]])`

🟩 `count(elemento)`

8️⃣ Copia de listas

🟩 Asignación simple (sin copia)

🟦 Copia superficial (`copy()`)

🟨 Copia profunda (`deepcopy()`)

📊 Comparativa rápida

9️⃣ Recorrido de listas

🟩 Recorrido básico con el bucle `for`

🟦 Recorrido por índice con `range()` y `len()`

🟨 Recorrido con `enumerate()`

🟧 Recorrido en paralelo con `zip()`

🟥 Recorrido inverso

🟪 Modificar los elementos durante la iteración

🟫 Errores comunes al iterar listas

📊 Tabla resumen

🔟 Ordenación de listas

🟩 `sort(key=None, reverse=False)`

🟦 `reverse()`

🟨 `sorted()`

🟧 Criterios de ordenación con `key`

🔹 `str.lower` — Ignorar mayúsculas y minúsculas

🔹 `abs` — Ordenar por valor absoluto

🔹 `len` — Ordenar por longitud de cadenas o listas

🔹 `str` — Convertir a cadena antes de ordenar

🔹 `int` — Convertir cadenas a números

🔹 `float` — Ordenar textos con números decimales

1️⃣1️⃣ Listas anidadas

1️⃣2️⃣ Comprensión de listas

🟩 Qué es una comprensión de lista

🟦 Ejemplo básico

🟨 Añadir una condición (`if`)

🟧 Usar una transformación y un filtro juntos

🟥 Comprensiones con cadenas de texto

🟪 Comprensiones anidadas (dobles bucles)

🟫 Cuándo evitar las comprensiones

🧩 Practica las compresiones