Métodos de listas en Python: append, remove y list comprehensions

Tienes la lista. Los artículos del carrito de esa tienda del tutorial anterior. La creaste, la recorriste con for, comprobaste si algo estaba dentro con in. Todo bien. Y entonces el usuario añade un producto, elimina otro, quieres saber cuántas veces aparece “camiseta” en su historial de pedidos. Y ahí te das cuenta de que saber crear una lista no es lo mismo que saber trabajar con ella.

Los métodos son la parte donde las listas dejan de ser un contenedor estático y se vuelven útiles de verdad.

Añadir elementos

El más frecuente de todos es append() — añade un elemento al final de la lista:

carrito = ["camiseta", "pantalón"]

carrito.append("zapatillas")
print(carrito)   # ["camiseta", "pantalón", "zapatillas"]

Si necesitas añadir en una posición específica, insert(índice, valor):

carrito.insert(1, "calcetines")   # Insert at index 1
print(carrito)   # ["camiseta", "calcetines", "pantalón", "zapatillas"]

Aquí entra la primera trampa con la que, si eres como yo cuando empecé, caerás exactamente una vez y nunca más: append() vs extend().

extend() añade todos los elementos de otro iterable, uno por uno. append() añade el objeto como un elemento único — si le pasas una lista, mete esa lista entera como un solo elemento anidado:

carrito = ["camiseta", "pantalón"]

carrito.extend(["zapatillas", "gorro"])
print(carrito)   # ["camiseta", "pantalón", "zapatillas", "gorro"] ✅

carrito2 = ["camiseta", "pantalón"]
carrito2.append(["zapatillas", "gorro"])
print(carrito2)  # ["camiseta", "pantalón", ["zapatillas", "gorro"]] ❌ — nested list

La regla es directa: ¿quieres añadir un elemento? append(). ¿Quieres fusionar dos listas? extend().

Eliminar elementos

Python te da cuatro formas de eliminar elementos y cada una cubre un caso ligeramente distinto. No es que el lenguaje esté roto — es que los casos de uso son genuinamente diferentes.

remove(valor) elimina la primera ocurrencia de un valor concreto:

frutas = ["manzana", "pera", "uva", "pera"]

frutas.remove("pera")
print(frutas)   # ["manzana", "uva", "pera"] — only the first one removed

⚠️ Si el valor no existe, remove() lanza un ValueError. Comprueba con in antes si no estás seguro de que el elemento está ahí:

if "kiwi" in frutas:
    frutas.remove("kiwi")

pop(índice) elimina por posición y devuelve el elemento eliminado. Sin índice, elimina el último:

frutas = ["manzana", "pera", "uva"]

ultimo = frutas.pop()        # Removes "uva" and returns it
print(ultimo)   # "uva"
print(frutas)   # ["manzana", "pera"]

primero = frutas.pop(0)      # Removes "manzana"
print(primero)  # "manzana"

La diferencia clave con remove(): pop() trabaja con índices y te devuelve lo que eliminó. Útil cuando necesitas el elemento antes de tirarlo — procesar y eliminar en el mismo paso.

del es una sentencia del lenguaje (no un método). Elimina por índice o por slice, sin devolver nada:

frutas = ["manzana", "pera", "uva", "kiwi", "naranja"]

del frutas[1]       # Removes "pera"
del frutas[1:3]     # Removes a slice — "uva" and "kiwi" after the previous del
print(frutas)       # ["manzana", "naranja"]

Y si necesitas vaciar la lista completamente conservando la misma referencia, clear():

carrito = ["camiseta", "pantalón", "zapatillas"]
carrito.clear()
print(carrito)   # []

Esto no es lo mismo que hacer carrito = []. Con carrito = [] creas una lista nueva y abandonas la original — si algo más apuntaba a la misma lista, no se entera. Con clear() vacías la que ya tienes, sin crear nada nuevo.

Modificar elementos directamente

Acceder a un índice y asignarle un valor nuevo:

frutas = ["manzana", "pera", "uva"]

frutas[0] = "melocotón"
print(frutas)   # ["melocotón", "pera", "uva"]

También funciona con slices — puedes reemplazar un rango completo de una vez:

frutas[1:3] = ["mango", "papaya"]
print(frutas)   # ["melocotón", "mango", "papaya"]

Buscar dentro de una lista

index(valor) devuelve la posición de la primera ocurrencia:

frutas = ["manzana", "pera", "uva", "pera"]

print(frutas.index("pera"))   # 1 — first occurrence

⚠️ Como remove(), lanza ValueError si el elemento no existe. Protégete con in antes de llamarlo.

count(valor) cuenta cuántas veces aparece un elemento:

votos = ["sí", "no", "sí", "sí", "no", "sí"]

print(votos.count("sí"))   # 4
print(votos.count("no"))   # 2

List comprehensions: la primera vez que Python te sorprende

Llegamos al momento en que Python hace algo que, la primera vez que lo ves, parece que no debería ser tan limpio — pero funciona, y no entiendes por qué no todos los lenguajes hacen lo mismo.

Imagina que tienes una lista de números y quieres otra con todos esos números elevados al cuadrado. La forma larga:

numeros = [1, 2, 3, 4, 5]

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

print(cuadrados)   # [1, 4, 9, 16, 25]

Funciona. Cuatro líneas. Y ahora la misma operación con una list comprehension:

cuadrados = [n ** 2 for n in numeros]

print(cuadrados)   # [1, 4, 9, 16, 25]

Una línea. Misma semántica. Léela de izquierda a derecha: “dame n ** 2 para cada n en numeros”. Si eso suena casi a lenguaje natural, es porque Python lo diseñó exactamente así.

La sintaxis es [expresión for variable in iterable]. Y puedes añadir una condición para filtrar:

pares = [n for n in numeros if n % 2 == 0]

print(pares)   # [2, 4]

[expresión for variable in iterable if condición]. Solo los elementos que cumplan la condición entran en la lista resultante.

¿Sensación de que eso no debería ser tan cómodo? Normal. Los que vienen de Java o C++ se quedan mirando esto con una mezcla de desconcierto y envidia (los de JavaScript también, aunque ellos tienen el map y el filter, que hacen lo mismo pero más barrocamente). No te agobies si al principio te parece magia — escríbela despacio, léela en voz alta, y en una semana te preguntarás cómo vivías sin ellas.

Por ahora quédate con los casos simples: transformar elementos y filtrar listas. Las comprehensions pueden volverse más complejas, pero el patrón es siempre el mismo.

---

Conceptos clave de esta lección

• append(valor) añade un elemento al final; extend(iterable) fusiona dos listas elemento a elemento
• remove(valor) elimina por valor (primera ocurrencia); lanza ValueError si no existe
• pop(índice) elimina por posición y devuelve el elemento; sin índice, elimina el último
• del lista[índice] elimina por posición sin devolver nada; también admite slices
• clear() vacía la lista conservando la referencia; distinto de lista = []
• index(valor) devuelve la posición de la primera ocurrencia
• count(valor) cuenta cuántas veces aparece un elemento
• List comprehension: [expresión for variable in iterable if condición]

---

Con esto cierra el módulo de Control Flow. Has pasado de condicionales a bucles, de listas básicas a métodos completos y list comprehensions — y ya tienes las herramientas para manejar colecciones de datos reales. En el próximo tutorial empieza un módulo nuevo: las funciones. Aprenderás a definir bloques de lógica reutilizable con def, a pasar parámetros y devolver valores — el primer paso para que tu código no sea un bloque monolítico de instrucciones que hay que releer entero cada vez que algo falla.

¡Nunca dejes de programar!

---

💡 Reto: Tienes una lista de tareas: ["email", "llamada", "email", "reunión", "email"]. Resuelve lo siguiente paso a paso: (1) añade "informe" al final con append(); (2) elimina la primera tarea de la lista con pop(0) y guárdala en una variable; (3) elimina todas las ocurrencias de "email" usando un bucle con while y remove(); (4) crea una nueva lista con todas las tareas que tengan más de 5 letras usando una list comprehension. Imprime el resultado después de cada paso.