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'} FuncionaAhí 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.005sLas 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 bienTuplas: 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"}
# TypeErrorTabla 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", "[email protected]")
edad, nombre, email = obtener_datos_usuario(1)
print(nombre) # JuanSi usases una lista:
def obtener_datos_usuario(user_id):
return [25, "Juan", "[email protected]"]
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áneoCon 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) # 80Las 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
Deja una respuesta