Listas en Python: Qué son, cómo usarlas y sus métodos más útiles

Si las variables son cajas individuales donde guardas un dato, las listas son estanterías: pueden guardar muchos datos al mismo tiempo, en orden, todos juntos en una sola estructura.

Las listas son la estructura de datos más usada en Python. Están en absolutamente todos los proyectos: desde scripts de automatización hasta modelos de inteligencia artificial. Dominarlas no es opcional.

En este artículo vas a aprender qué son, cómo usarlas y todos los métodos que necesitas conocer para trabajar con ellas como un profesional, con ejemplos reales en cada paso.

¿Qué es una lista en Python?

Una lista es una colección ordenada de elementos que se guarda en una sola variable. Los elementos pueden ser de cualquier tipo: números, textos, booleanos, otras listas, o una mezcla de todo.

# Lista de números
precios = [10.99, 25.50, 8.75, 99.00]

# Lista de textos
frutas = ["manzana", "banana", "naranja", "uva"]

# Lista mixta
perfil = ["Ana García", 25, True, 1.68]

# Lista vacía (se rellena después)
carrito = []

print(type(frutas))  # <class 'list'>

Las listas tienen cuatro características clave que las hacen tan útiles:

📋 Ordenadas — los elementos mantienen el orden en que los insertas
✏️ Mutables — puedes cambiar, agregar y eliminar elementos después de crearla
🔢 Indexadas — cada elemento tiene una posición (índice) para acceder directamente a él
🔁 Permiten duplicados — puedes tener el mismo valor varias veces

Crear listas en Python

La forma estándar: corchetes

# Con valores desde el inicio
numeros     = [1, 2, 3, 4, 5]
lenguajes   = ["Python", "JavaScript", "SQL"]
mezclada    = [42, "hola", True, 3.14]

# Lista vacía
vacia = []

# También se puede usar el constructor list()
desde_string = list("Python")
print(desde_string)  # ['P', 'y', 't', 'h', 'o', 'n']

desde_range = list(range(1, 6))
print(desde_range)   # [1, 2, 3, 4, 5]

Acceder a los elementos: índices

Cada elemento de una lista tiene una posición llamada índice. En Python, los índices empiezan en 0, no en 1. Este es uno de los conceptos que más confunde a los principiantes.

frutas = ["manzana", "banana", "naranja", "uva", "kiwi"]
#           [0]        [1]       [2]        [3]    [4]

print(frutas[0])   # manzana  ← primer elemento
print(frutas[1])   # banana
print(frutas[4])   # kiwi     ← último elemento
print(frutas[-1])  # kiwi     ← también el último (índice negativo)
print(frutas[-2])  # uva      ← penúltimo elemento

Los índices negativos cuentan desde el final. -1 es el último elemento, -2 el penúltimo, y así. Son muy útiles cuando no sabes cuántos elementos tiene la lista.

Modificar elementos por índice

precios = [10.99, 25.50, 8.75]
print(precios)       # [10.99, 25.5, 8.75]

precios[1] = 30.00   # cambia el segundo elemento
print(precios)       # [10.99, 30.0, 8.75]

Slicing — extraer partes de una lista

El slicing (rebanado) te permite extraer una porción de la lista usando la notación [inicio:fin:paso]. Es una de las características más poderosas de Python.

numeros = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# [inicio:fin] — fin NO incluido
print(numeros[2:5])    # [2, 3, 4]
print(numeros[:4])     # [0, 1, 2, 3]   ← desde el inicio
print(numeros[6:])     # [6, 7, 8, 9]   ← hasta el final
print(numeros[:])      # [0, 1, 2, ..., 9] ← copia completa

# Con paso
print(numeros[::2])    # [0, 2, 4, 6, 8]  ← de 2 en 2
print(numeros[1::2])   # [1, 3, 5, 7, 9]  ← impares
print(numeros[::-1])   # [9, 8, 7, ..., 0] ← invertida

💡 Truco para recordar el slicing: Piensa en los índices como marcadores entre los elementos, no sobre ellos. El [2:5] corta entre la posición 2 y la 5, dando los elementos en posiciones 2, 3 y 4.

Recorrer listas con bucles

lenguajes = ["Python", "JavaScript", "SQL", "Java"]

# Forma simple — accede directo al valor
for lenguaje in lenguajes:
    print(f"Estoy aprendiendo {lenguaje}")

# Con índice — cuando necesitas la posición
for i, lenguaje in enumerate(lenguajes):
    print(f"{i + 1}. {lenguaje}")
# 1. Python
# 2. JavaScript
# 3. SQL
# 4. Java

Los métodos más útiles de las listas

Aquí está la guía de referencia que vas a consultar muchas veces. Todos son métodos del objeto lista, por lo que se usan con la sintaxis mi_lista.metodo().

📥 Agregar elementos

append() — agregar al final

carrito = ["laptop", "mouse"]
carrito.append("teclado")
print(carrito)  # ['laptop', 'mouse', 'teclado']

insert() — agregar en una posición específica

carrito = ["laptop", "mouse", "teclado"]
carrito.insert(1, "monitor")  # insertar en posición 1
print(carrito)  # ['laptop', 'monitor', 'mouse', 'teclado']

extend() — agregar todos los elementos de otra lista

lista1 = [1, 2, 3]
lista2 = [4, 5, 6]

lista1.extend(lista2)
print(lista1)  # [1, 2, 3, 4, 5, 6]

# ⚠️ Diferencia con append:
lista3 = [1, 2, 3]
lista3.append([4, 5, 6])  # append agrega la lista COMO un elemento
print(lista3)  # [1, 2, 3, [4, 5, 6]] ← lista dentro de lista

🗑️ Eliminar elementos

remove() — eliminar por valor

frutas = ["manzana", "banana", "naranja", "banana"]
frutas.remove("banana")  # elimina la PRIMERA aparición
print(frutas)  # ['manzana', 'naranja', 'banana']

pop() — eliminar por índice y devolver el elemento

frutas = ["manzana", "banana", "naranja"]

ultimo  = frutas.pop()     # elimina y devuelve el último
print(ultimo)              # naranja
print(frutas)              # ['manzana', 'banana']

primero = frutas.pop(0)    # elimina y devuelve el de índice 0
print(primero)             # manzana
print(frutas)              # ['banana']

pop() es muy útil cuando necesitas procesar y eliminar elementos al mismo tiempo. Por ejemplo, para simular una pila (stack) o una cola (queue).

del — eliminar por índice o rango

numeros = [10, 20, 30, 40, 50]

del numeros[2]       # elimina el elemento en índice 2
print(numeros)       # [10, 20, 40, 50]

del numeros[1:3]     # elimina el rango [1:3]
print(numeros)       # [10, 50]

clear() — vaciar la lista completamente

carrito = ["laptop", "mouse", "teclado"]
carrito.clear()
print(carrito)  # []

🔍 Buscar elementos

index() — encontrar la posición de un elemento

frutas = ["manzana", "banana", "naranja", "uva"]

posicion = frutas.index("naranja")
print(posicion)  # 2

# Si el elemento no existe, lanza ValueError
# Mejor verificar primero:
if "kiwi" in frutas:
    print(frutas.index("kiwi"))
else:
    print("kiwi no está en la lista")

count() — contar cuántas veces aparece un elemento

notas = [7, 8, 9, 7, 10, 7, 6, 8]

print(notas.count(7))   # 3  ← el 7 aparece 3 veces
print(notas.count(10))  # 1
print(notas.count(5))   # 0  ← no aparece

in — verificar si un elemento existe

frutas = ["manzana", "banana", "naranja"]

print("banana" in frutas)    # True
print("kiwi" in frutas)      # False
print("kiwi" not in frutas)  # True

# Muy útil en condicionales:
if "manzana" in frutas:
    print("Tenemos manzanas 🍎")

🔄 Ordenar y reorganizar

sort() — ordenar la lista (modifica la original)

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

numeros.sort()              # ascendente por defecto
print(numeros)              # [1, 1, 2, 3, 4, 5, 6, 9]

numeros.sort(reverse=True)  # descendente
print(numeros)              # [9, 6, 5, 4, 3, 2, 1, 1]

# Ordenar textos (alfabético)
frutas = ["naranja", "manzana", "banana", "uva"]
frutas.sort()
print(frutas)  # ['banana', 'manzana', 'naranja', 'uva']

# Ordenar con criterio personalizado
palabras = ["Python", "es", "increíble", "y", "divertido"]
palabras.sort(key=len)   # ordenar por longitud
print(palabras)          # ['es', 'y', 'Python', 'increíble', 'divertido']

sorted() — ordenar sin modificar la original

original = [3, 1, 4, 1, 5, 9]
ordenada = sorted(original)

print(original)  # [3, 1, 4, 1, 5, 9]  ← sin cambios
print(ordenada)  # [1, 1, 3, 4, 5, 9]  ← nueva lista ordenada

💡 Cuándo usar cada uno: usa sort() cuando no necesitas conservar el orden original (más eficiente). Usa sorted() cuando necesitas la lista ordenada pero también la original sin cambios.

reverse() — invertir el orden

letras = ["a", "b", "c", "d", "e"]
letras.reverse()
print(letras)  # ['e', 'd', 'c', 'b', 'a']

📊 Información sobre la lista

numeros = [10, 20, 30, 40, 50]

print(len(numeros))   # 5     ← cantidad de elementos
print(min(numeros))   # 10    ← valor mínimo
print(max(numeros))   # 50    ← valor máximo
print(sum(numeros))   # 150   ← suma de todos

📋 Copiar listas

Este es uno de los errores más frecuentes y más confusos para los principiantes. Cuando asignas una lista a otra variable, no estás haciendo una copia: las dos variables apuntan al mismo objeto en memoria.

# ❌ Error común: esto NO es una copia real
lista1 = [1, 2, 3]
lista2 = lista1         # lista2 es solo otro nombre para lista1

lista2.append(4)
print(lista1)           # [1, 2, 3, 4] ← ¡también cambió!
print(lista2)           # [1, 2, 3, 4]

# ✅ Formas correctas de copiar una lista
lista1 = [1, 2, 3]

# Opción 1: método copy()
lista2 = lista1.copy()

# Opción 2: slicing completo
lista3 = lista1[:]

# Opción 3: constructor list()
lista4 = list(lista1)

lista2.append(4)
print(lista1)  # [1, 2, 3]  ← no cambió
print(lista2)  # [1, 2, 3, 4]

List Comprehension — la forma pythónica de crear listas

La comprensión de listas (list comprehension) es una forma elegante y concisa de crear listas a partir de otras listas o secuencias. Es una de las características más queridas de Python.

# Forma tradicional con bucle for
cuadrados = []
for n in range(1, 6):
    cuadrados.append(n ** 2)
print(cuadrados)  # [1, 4, 9, 16, 25]

# Forma pythónica con list comprehension — exactamente lo mismo
cuadrados = [n ** 2 for n in range(1, 6)]
print(cuadrados)  # [1, 4, 9, 16, 25]

También puedes agregar condiciones:

# Solo los números pares del 1 al 10
pares = [n for n in range(1, 11) if n % 2 == 0]
print(pares)  # [2, 4, 6, 8, 10]

# Convertir todos los textos a mayúsculas
frutas    = ["manzana", "banana", "naranja"]
mayusculas = [f.upper() for f in frutas]
print(mayusculas)  # ['MANZANA', 'BANANA', 'NARANJA']

# Filtrar y transformar a la vez
precios    = [10, 250, 45, 899, 30, 150]
caros      = [p * 0.9 for p in precios if p > 100]  # 10% descuento en caros
print(caros)  # [225.0, 809.1, 135.0]

Listas anidadas — listas dentro de listas

# Matriz 3x3
matriz = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

print(matriz[0])       # [1, 2, 3]   ← primera fila
print(matriz[1][2])    # 6           ← fila 1, columna 2
print(matriz[2][0])    # 7           ← fila 2, columna 0

# Recorrer una matriz
for fila in matriz:
    for elemento in fila:
        print(elemento, end=" ")
    print()
# 1 2 3
# 4 5 6
# 7 8 9

Tabla resumen: todos los métodos

Método	¿Qué hace?	¿Modifica la lista?
`append(x)`	Agrega `x` al final	✅ Sí
`insert(i, x)`	Inserta `x` en el índice `i`	✅ Sí
`extend(lista)`	Agrega todos los elementos de otra lista	✅ Sí
`remove(x)`	Elimina la primera aparición de `x`	✅ Sí
`pop(i)`	Elimina y devuelve el elemento en índice `i`	✅ Sí
`clear()`	Vacía la lista	✅ Sí
`sort()`	Ordena la lista	✅ Sí
`reverse()`	Invierte el orden	✅ Sí
`index(x)`	Devuelve el índice de `x`	❌ No
`count(x)`	Cuenta las apariciones de `x`	❌ No
`copy()`	Devuelve una copia de la lista	❌ No
`sorted(lista)`	Devuelve una nueva lista ordenada	❌ No (función)
`len(lista)`	Número de elementos	❌ No (función)
`min(lista)`	Valor mínimo	❌ No (función)
`max(lista)`	Valor máximo	❌ No (función)
`sum(lista)`	Suma de todos los elementos	❌ No (función)

⚠️ Importante: Los métodos que modifican la lista (sort, reverse, append...) no devuelven la lista modificada. Devuelven None. Este es uno de los errores más comunes:

numeros = [3, 1, 2]

# ❌ Error clásico
resultado = numeros.sort()
print(resultado)  # None ← sort() no devuelve la lista

# ✅ Correcto
numeros.sort()
print(numeros)    # [1, 2, 3]

Ejemplo final: gestor de tareas con listas

# ============================================
# GESTOR DE TAREAS CON LISTAS
# ============================================

tareas = []

def agregar_tarea(descripcion):
    tarea = {
        "id":          len(tareas) + 1,
        "descripcion": descripcion,
        "completada":  False
    }
    tareas.append(tarea)
    print(f"✅ Tarea '{descripcion}' agregada")

def completar_tarea(id_tarea):
    for tarea in tareas:
        if tarea["id"] == id_tarea:
            tarea["completada"] = True
            print(f"🎉 Tarea '{tarea['descripcion']}' completada")
            return
    print(f"⚠️ No se encontró tarea con id {id_tarea}")

def listar_tareas():
    pendientes  = [t for t in tareas if not t["completada"]]
    completadas = [t for t in tareas if t["completada"]]

    print(f"\n📋 TAREAS PENDIENTES ({len(pendientes)}):")
    for t in pendientes:
        print(f"  [{t['id']}] {t['descripcion']}")

    print(f"\n✅ COMPLETADAS ({len(completadas)}):")
    for t in completadas:
        print(f"  [{t['id']}] {t['descripcion']}")

def eliminar_completadas():
    antes  = len(tareas)
    tareas[:] = [t for t in tareas if not t["completada"]]
    eliminadas = antes - len(tareas)
    print(f"🗑️ {eliminadas} tarea(s) eliminada(s)")

# Usando el gestor
agregar_tarea("Aprender listas en Python")
agregar_tarea("Practicar con ejercicios")
agregar_tarea("Hacer el test de Python")
agregar_tarea("Construir un proyecto real")

completar_tarea(1)
completar_tarea(2)

listar_tareas()
eliminar_completadas()
listar_tareas()

Errores comunes con listas en Python

IndexError — acceder a un índice que no existe

frutas = ["manzana", "banana"]

print(frutas[5])  # ❌ IndexError: list index out of range

# Verificar antes de acceder:
if len(frutas) > 5:
    print(frutas[5])

Confundir append() con extend()

lista = [1, 2, 3]

lista.append([4, 5])    # ❌ agrega la lista como un elemento
print(lista)            # [1, 2, 3, [4, 5]]

lista = [1, 2, 3]
lista.extend([4, 5])    # ✅ agrega los elementos individualmente
print(lista)            # [1, 2, 3, 4, 5]

Modificar una lista mientras la recorres

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

# ❌ Peligroso: puede saltar elementos
for n in numeros:
    if n % 2 == 0:
        numeros.remove(n)

# ✅ Seguro: trabajar con una copia
numeros = [1, 2, 3, 4, 5]
numeros = [n for n in numeros if n % 2 != 0]
print(numeros)  # [1, 3, 5]

Resumen: lo que aprendiste hoy

✅ Una lista es una colección ordenada, mutable e indexada que admite duplicados
✅ Los índices empiezan en 0; los negativos cuentan desde el final
✅ El slicing [inicio:fin:paso] extrae partes de la lista
✅ append() agrega al final; insert() en posición específica; extend() agrega otra lista
✅ remove() elimina por valor; pop() elimina por índice y devuelve el elemento
✅ sort() modifica la lista; sorted() devuelve una nueva sin modificar la original
✅ Copiar con = no hace una copia real; usa .copy() o [:]
✅ La list comprehension es la forma pythónica de crear listas a partir de otras
✅ Los métodos que modifican la lista devuelven None, no la lista modificada

🧪 ¿Ya tienes bien claros los fundamentos de Python?

Las listas son uno de los temas centrales de cualquier evaluación de Python. Si quieres saber qué tan sólidos están tus conocimientos antes de seguir avanzando, estos tests son el siguiente paso natural.

👉 Test: Python Básico 👉 Test: Python Intermedio

¿Cuál método de listas no conocías antes de leer este artículo? ¿Ya usabas list comprehension o es la primera vez que lo ves? Cuéntanos en los comentarios 👇 — respondemos todos. 🐍