Python

Tuplas vs Listas en Python: parecen lo mismo, pero no

A primera vista, tuplas y listas son casi idénticas. Ambas guardan colecciones ordenadas de elementos. La única diferencia visual es que una usa [] y otra ().

# Lista
mi_lista = [1, 2, 3]

# Tupla
mi_tupla = (1, 2, 3)

Pero esa pequeña diferencia de sintaxis esconde una diferencia conceptual enorme. Y elegir la equivocada te costará horas de debugging, o peor, escribirás código que parece funcionar pero se rompe de formas inesperadas.

La diferencia clave: las listas son mutables, las tuplas no. Eso significa que con las tuplas se pueden hacer cosas que con las listas es posible. Y viceversa.

En esta entrada vamos a ver:

Por qué tuplas y listas son distintas (aunque parezcan iguales).
Qué puedes hacer con tuplas que no puedes con listas.
Cuándo es cada una la opción correcta.
Cómo te ahorran problemas.

Un ejemplo que lo muestra todo

Imagina que guardas coordenadas de ubicaciones:

# Usando listas
coordenadas_lista = [40.4168, -3.7038]  # Madrid

# Usando tuplas
coordenadas_tupla = (40.4168, -3.7038)  # Madrid

Superficialmente, lo mismo. Pero ahora intenta usarlas de formas distintas:

# Puedes modificar una lista
coordenadas_lista[0] = 40.4169
print(coordenadas_lista)  # [40.4169, -3.7038] Funciona

# Intentar modificar una tupla... falla
coordenadas_tupla[0] = 40.4169
# TypeError: 'tuple' object does not support item assignment

Hasta aquí, parece que las listas son simplemente “mejores” porque son flexibles. Pero espera:

# Usa una lista como clave de diccionario
ubicaciones = {}
ubicaciones[coordenadas_lista] = "Oficina"
# TypeError: unhashable type: 'list'

# Usa una tupla como clave de diccionario
ubicaciones = {}
ubicaciones[coordenadas_tupla] = "Oficina"
print(ubicaciones)  # {(40.4168, -3.7038): 'Oficina'} Funciona

Ahí está: las tuplas pueden ser claves de diccionarios, las listas no.

Las 4 diferencias fundamentales entre Tuplas y Listas

A la hora de trabajar con Tuplas o Listas en Python es fundamental tener en cuenta las cuatro diferencias claves entre ambas.

Mutabilidad: ¿puedes cambiar los elementos?

Listas: sí. Puedes cambiar, añadir, quitar elementos cuando quieras.

numeros = [1, 2, 3]

# Cambiar
numeros[0] = 10
print(numeros)  # [10, 2, 3]

# Añadir
numeros.append(4)
print(numeros)  # [10, 2, 3, 4]

# Quitar
numeros.pop()
print(numeros)  # [10, 2, 3]

Tuplas: no. Una vez creada, es fija. Para siempre.

numeros = (1, 2, 3)

# Intentar cambiar
numeros[0] = 10
# TypeError: 'tuple' object does not support item assignment

# Intentar añadir
numeros.append(4)
# AttributeError: 'tuple' object has no attribute 'append'

¿Por qué importa?

Si necesitas que tu colección sea flexible, listas.
Si necesitas que sea protegida contra cambios, tuplas.

Claves de diccionarios: ¿puedes usarlas?

Aquí está la diferencia más importante prácticamente.

Listas: no pueden ser claves.

mi_diccionario = {}
mi_diccionario[[1, 2]] = "valor"
# TypeError: unhashable type: 'list'

Tuplas: sí pueden ser claves.

mi_diccionario = {}
mi_diccionario[(1, 2)] = "valor"
print(mi_diccionario)  # {(1, 2): 'valor'}

¿Por qué?

Internamente, Python usa una técnica llamada hashing. Para que algo sea clave de diccionario, debe ser “hashable” (convertible a hash). Las tuplas lo son, las listas no.

¿Cuándo lo necesitas?

Más de lo que crees. Algunos ejemplos reales:

# Cachear resultados de cálculos costosos
# (la clave es las coordenadas de un punto)
cache = {}
cache[(10, 20)] = resultado_calculado

# Contar ocurrencias de pares (x, y)
puntos = [(1, 2), (3, 4), (1, 2), (3, 4), (1, 2)]
contador = {}
for punto in puntos:
    contador[punto] = contador.get(punto, 0) + 1
print(contador)  # {(1, 2): 3, (3, 4): 2}

# Usar coordenadas como clave de un grafo
grafo = {
    (0, 0): [(1, 0), (0, 1)],
    (1, 0): [(0, 0), (1, 1)],
}

Con listas, todo esto sería imposible.

Rendimiento: ¿cuál es más rápida?

Tuplas son más rápidas. Algo más rápidas no, la diferencia entre ambas puede ser realmente notablemente en algunos casos.

import timeit

# Tiempo para crear una lista 1 millón de veces
tiempo_lista = timeit.timeit(
    '[1, 2, 3]',
    number=1_000_000
)

# Tiempo para crear una tupla 1 millón de veces
tiempo_tupla = timeit.timeit(
    '(1, 2, 3)',
    number=1_000_000
)

print(f"Lista: {tiempo_lista:.3f}s")  # ~0.050s
print(f"Tupla: {tiempo_tupla:.3f}s")  # ~0.005s

Las tuplas son 10 veces más rápidas.

¿Por qué? Porque son inmutables, Python puede optimizarlas mejor. No necesita mantener espacio para cambios futuros.

¿Cuándo importa?

Normalmente, no. Si creas una tupla una vez, la diferencia es imperceptible. Pero si estás en una operación en loop millones de veces, la diferencia suma.

Lo que puedes meter dentro

Aquí está lo raro.

Listas: puedes meter casi cualquier cosa, incluyendo listas dentro de listas.

lista = [1, "texto", [1, 2, 3], {"clave": "valor"}]
print(lista)  # Todo bien

Tuplas: lo mismo, PERO si quieres usar la tupla como clave de diccionario, los elementos dentro también deben ser hashables (inmutables).

# Tupla con elementos hashables (válida como clave)
tupla_buena = (1, 2, "texto")
diccionario = {tupla_buena: "valor"}  # Funciona

# Tupla que contiene una lista (NO válida como clave)
tupla_mala = (1, [2, 3])
diccionario = {tupla_mala: "valor"}
# TypeError: unhashable type: 'list'

¿Por qué importa?

Si planeas usar una tupla como clave de diccionario, no puede contener listas ni diccionarios dentro.

# Esto funciona
coordenadas = (40.4168, -3.7038)
ubicaciones = {coordenadas: "Oficina"}

# Esto NO funciona
punto_con_metadata = (40.4168, -3.7038, [metadata])
ubicaciones = {punto_con_metadata: "Oficina"}
# TypeError

Tabla resumen rápida

Aspecto	Lista	Tupla
Sintaxis	`[1, 2, 3]`	`(1, 2, 3)`
Mutabilidad	✅ Puedes cambiar	❌ Inmutable
Clave de dict	❌ No	✅ Sí
Performance	Más lenta	Más rápida
Métodos	Muchos: append, pop, sort, etc.	Pocos: count, index
Caso de uso	Colecciones flexibles	Datos fijos, claves

Cuándo usar cada una

Usa listas cuando:

Necesitas modificar los datos: añadir, quitar, cambiar elementos.
Los datos cambian con el tiempo (lista de tareas, historial, cola).
Necesitas métodos mutables como append(), sort(), extend().
Quieres una estructura flexible que crezca o se reduzca.

Ejemplos: lista de compras, resultados de búsqueda, historial de eventos, registros de una tabla en BD.

Usa tuplas cuando:

Los datos son fijos y no cambiarán: coordenadas, fechas, IDs compuestos.
Necesitas usar como clave de diccionario.
Quieres proteger los datos contra cambios accidentales.
Necesitas performance en operaciones repetidas.
Vas a desempaquetar: x, y = tupla.

Ejemplos: coordenadas GPS, claves compuestas, retorno de múltiples valores, configuración inmutable.

Ejemplos prácticos

Ejemplo 1: Retornar múltiples valores

Las tuplas son la forma pythónica de retornar varios valores:

def obtener_datos_usuario(user_id):
    # Retorna una tupla
    return (25, "Juan", "juan@gmail.com")

edad, nombre, email = obtener_datos_usuario(1)
print(nombre)  # Juan

Si usases una lista:

def obtener_datos_usuario(user_id):
    return [25, "Juan", "juan@gmail.com"]

edad, nombre, email = obtener_datos_usuario(1)  # Funciona igual, pero...

Funciona, pero tupla es más clara: el que lee el código sabe que estos valores no cambiarán.

Ejemplo 2: Cachear resultados costosos

cache = {}

def calcular_distancia(punto1, punto2):
    # Punto1 y punto2 son tuplas
    if (punto1, punto2) in cache:
        return cache[(punto1, punto2)]

    # Cálculo costoso
    distancia = ((punto1[0] - punto2[0])**2 + 
                 (punto1[1] - punto2[1])**2)**0.5

    cache[(punto1, punto2)] = distancia
    return distancia

# Usar
d1 = calcular_distancia((0, 0), (3, 4))
d2 = calcular_distancia((0, 0), (3, 4))  # Del cache, instantáneo

Con listas no puedes hacer esto porque no son hashables.

Ejemplo 3: Diccionario con claves compuestas

# Inventario de una tienda: qué cantidad de cada producto en cada almacén
inventario = {
    ("producto_a", "almacen_1"): 50,
    ("producto_a", "almacen_2"): 30,
    ("producto_b", "almacen_1"): 100,
}

# Buscar
print(inventario[("producto_a", "almacen_1")])  # 50

# Actualizar
inventario[("producto_a", "almacen_1")] = 45

# Contar total de un producto
total_a = sum(cant for (prod, almacen), cant in inventario.items() 
              if prod == "producto_a")
print(total_a)  # 80

Las tuplas como claves hacen esto limpio y eficiente.

Ejemplo 4: Proteger datos contra cambios

# Función que recibe una tupla de configuración
def procesar_datos(config):
    # Si config fuera una lista, podrías modificarla sin querer
    # config[0] = "NUEVO VALOR"  # Ops, cambié la config global

    # Con tupla, accidentales imposible
    # config[0] = "NUEVO VALOR"  # TypeError, no puedes

    # Así que la función está "segura" de que config no cambiará
    return config[0] * config[1]

config = (10, 20)
resultado = procesar_datos(config)

Ejemplo 5: Desempaquetar (muy pythónico)

# Las tuplas se desempaquetan naturalmente
punto = (10, 20)
x, y = punto
print(f"Coordenadas: {x}, {y}")

# Swap (intercambiar valores)
a, b = 1, 2
a, b = b, a  # Python crea una tupla temporalmente
print(a, b)  # 2, 1

# Iterar sobre pares
pares = [(1, 'a'), (2, 'b'), (3, 'c')]
for numero, letra in pares:
    print(f"{numero}: {letra}")

La trampa: tuplas dentro de tuplas

Una cosa confusa:

# Esto es una tupla de un elemento
tupla = (1)
print(type(tupla))  # <class 'int'> ← ¡No es tupla!

# Para una tupla de un elemento, necesitas una coma
tupla = (1,)
print(type(tupla))  # <class 'tuple'>

Sin la coma, Python lo interpreta como un paréntesis para agrupar expresiones, no como tupla. Con la coma, es tupla.

Conversión entre tuplas y listas

A veces tienes una y necesitas la otra:

# Lista a tupla
mi_lista = [1, 2, 3]
mi_tupla = tuple(mi_lista)
print(mi_tupla)  # (1, 2, 3)

# Tupla a lista
mi_tupla = (1, 2, 3)
mi_lista = list(mi_tupla)
print(mi_lista)  # [1, 2, 3]

Útil, pero cuidado: si la tupla contiene listas, la conversión copia referencias, no hace deep copy.

Conclusión

Tuplas y listas parecen lo mismo, pero son herramientas distintas:

Listas cuando necesitas flexibilidad: modificar, añadir, quitar.
Tuplas cuando necesitas inmutabilidad y claves: datos fijos, diccionarios, protección.

La mayoría de principiantes usan listas para todo. Está bien al principio. Pero cuando pasas a nivel intermedio, entender tuplas te ahorra:

Bugs de “cambios accidentales”.
Código más ineficiente (listas donde tuplas bastarían).
Soluciones complicadas para cachear o usar claves compuestas.

Pregúntate: “¿Estos datos van a cambiar?” Si no, usa tupla. Te lo agradecerás cuando necesites cachear resultados o usar como clave de diccionario, y descubras que las tuplas estaban hechas exactamente para eso.

Imagen de Gerd Altmann en Pixabay