Tuplas en Python: cuándo y por qué usar secuencias inmutables

Principiante20 min5 ejercicios60 XP

Esta lección es una traducción del original en inglés.Read in English Avisar de un error de traducción

Antes de empezar

Listas en Python: cómo crearlas, modificarlas y recorrerlas

0/5 ejercicios

Piensa en unas coordenadas GPS. Una ubicación como (40.7128, -74.0060) representa la ciudad de Nueva York. Si cambiaras uno de esos números por accidente, la ubicación apuntaría a un lugar completamente distinto. Hay datos que no deberían cambiar una vez creados.

Con las fechas pasa lo mismo. El 1 de enero de 2025 es un hecho fijo. No querrías que tu código cambiara esa fecha por accidente al 37 de febrero. Cuando los datos tienen que quedarse fijos, Python te ofrece las tuplas.

Una tupla se parece muchísimo a una lista, pero con una diferencia clave: una vez que creas una tupla, no puedes cambiarla. No puedes añadir, quitar ni sustituir elementos. En esta lección verás por qué esa limitación es en realidad un superpoder.

Cómo crear tuplas en Python

Para crear una tupla, escribe los elementos entre paréntesis (), separados por comas. También puedes crear una tupla sin paréntesis: lo que de verdad la convierte en tupla son las comas.

Crear tuplas

# Tuple with parentheses

coordinates = (40.7128, -74.0060)

print(coordinates)

# Tuple without parentheses (commas do the work)

colors = 'red', 'green', 'blue'

print(colors)

# Single-item tuple NEEDS a trailing comma

single = (42,)

print(single) # (42,)

print(type(single)) # <class 'tuple'>

Salida

(40.7128, -74.006)
('red', 'green', 'blue')
(42,)
<class 'tuple'>

Tupla de un elemento frente a expresión entre paréntesis

# This is NOT a tuple

not_a_tuple = (42)

print(type(not_a_tuple)) # <class 'int'>

# This IS a tuple

is_a_tuple = (42,)

print(type(is_a_tuple)) # <class 'tuple'>

# Empty tuple

empty = ()

print(empty) # ()

print(len(empty)) # 0

Salida

<class 'int'>
<class 'tuple'>
()
0

También puedes convertir otras secuencias en tuplas con el constructor tuple(). Es práctico cuando tienes una lista y quieres congelarla para que nadie pueda modificarla.

Usar el constructor tuple()

# Convert a list to a tuple

fruit_list = ['apple', 'banana', 'cherry']

fruit_tuple = tuple(fruit_list)

print(fruit_tuple) # ('apple', 'banana', 'cherry')

# Convert a string to a tuple of characters

letters = tuple('hello')

print(letters) # ('h', 'e', 'l', 'l', 'o')

Salida

('apple', 'banana', 'cherry')
('h', 'e', 'l', 'l', 'o')

Acceder a los elementos de una tupla y sacar porciones

Acceder a los elementos de una tupla funciona exactamente igual que con las listas. Usas corchetes con un número de índice. Los índices positivos cuentan desde el principio y los negativos, desde el final.

Índices en tuplas

months = ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun')

# Positive indexing

print(months[0]) # Jan

print(months[3]) # Apr

# Negative indexing

print(months[-1]) # Jun

print(months[-2]) # May

# Length

print(len(months)) # 6

Salida

Jan
Apr
Jun
May
6

Las porciones (slicing) también funcionan igual. Puedes tomar una parte de una tupla con tuple[start:end]. El resultado es una tupla nueva.

Porciones de tuplas

months = ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun')

# Slice from index 1 to 4 (not including 4)

print(months[1:4]) # ('Feb', 'Mar', 'Apr')

# First three

print(months[:3]) # ('Jan', 'Feb', 'Mar')

# Last two

print(months[-2:]) # ('May', 'Jun')

# Every other month

print(months[::2]) # ('Jan', 'Mar', 'May')

Salida

('Feb', 'Mar', 'Apr')
('Jan', 'Feb', 'Mar')
('May', 'Jun')
('Jan', 'Mar', 'May')

Pero aquí es donde las tuplas se diferencian de las listas. Si intentas cambiar un elemento, Python lanzará un TypeError. Las tuplas son inmutables: no se pueden modificar después de crearlas.

Las tuplas son inmutables

colors = ('red', 'green', 'blue')

# This works fine - reading

print(colors[0]) # red

# This will CRASH - writing

# colors[0] = 'yellow' # TypeError: 'tuple' object does not support item assignment

# Uncomment the line above and run it to see the error!

Salida

red

Empaquetar y desempaquetar tuplas

Empaquetar (packing) es crear una tupla asignando varios valores a una sola variable. Desempaquetar (unpacking) es lo contrario: sacar los valores de una tupla y guardarlos en variables separadas. El desempaquetado es una de las características más útiles de Python.

Empaquetar y desempaquetar

# Packing - multiple values into one tuple

person = 'Alice', 25, 'Engineer'

print(person) # ('Alice', 25, 'Engineer')

# Unpacking - one tuple into multiple variables

name, age, job = person

print(name) # Alice

print(age) # 25

print(job) # Engineer

Salida

('Alice', 25, 'Engineer')
Alice
25
Engineer

El número de variables de la izquierda tiene que coincidir con el número de elementos de la tupla. Si no coinciden, Python lanza un ValueError.

Un uso clásico del desempaquetado es intercambiar dos variables sin necesidad de una variable temporal. La mayoría de los demás lenguajes necesitan tres líneas para esto; Python lo hace en una.

Intercambiar variables con el desempaquetado de tuplas

a = 10

b = 20

print(f'Before: a={a}, b={b}')

# Swap using tuple unpacking

a, b = b, a

print(f'After: a={a}, b={b}')

Salida

Before: a=10, b=20
After:  a=20, b=10

Al desempaquetar, también puedes usar un asterisco * para capturar los elementos sobrantes. Esto se llama desempaquetado extendido (extended unpacking) y te da una lista con los elementos restantes.

Desempaquetado extendido con el operador asterisco

scores = (95, 87, 72, 68, 91)

# Grab the first, last, and everything in between

first, *middle, last = scores

print(first) # 95

print(middle) # [87, 72, 68]

print(last) # 91

Salida

95
[87, 72, 68]
91

Desempaquetar tuplas en un bucle for

students = [

('Alice', 95),

('Bob', 87),

('Charlie', 72),

]

for name, score in students:

print(f'{name} scored {score}')

Salida

Alice scored 95
Bob scored 87
Charlie scored 72

Tuplas frente a listas: cuándo usar cada una

Si las tuplas son solo listas que no se pueden cambiar, ¿para qué molestarse con ellas? Hay tres buenas razones: seguridad, rendimiento y claridad.

Seguridad: cuando los datos no deberían cambiar, una tupla evita modificaciones accidentales. Coordenadas GPS, valores de color RGB, registros de una base de datos: son datos fijos. Una tupla deja clara tu intención.

Rendimiento: las tuplas son un poco más rápidas que las listas y usan menos memoria. En colecciones pequeñas apenas se nota, pero con millones de registros la diferencia se acumula.

Claves de diccionario: las tuplas se pueden usar como claves de un diccionario porque son inmutables. Las listas no. Esto será importante cuando aprendas sobre los diccionarios.

Usa una lista cuando...

# Data that changes over time
shopping = ['milk', 'eggs']
shopping.append('bread')

# Collections you sort or filter
scores = [85, 92, 78]
scores.sort()

Usa una tupla cuando...

# Fixed data that shouldn't change
coords = (40.7128, -74.0060)
rgb_red = (255, 0, 0)

# Returning multiple values
def get_name_age():
    return 'Alice', 25

Por dentro: por qué las tuplas son más rápidas que las listas

Como las tuplas son inmutables, Python puede aplicar optimizaciones internas. El tamaño de una tupla queda fijo al crearla, así que Python no necesita reservar memoria extra por si crece, como hace con las listas.

Comparar el uso de memoria

import sys

# Compare memory usage

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

my_tuple = (1, 2, 3, 4, 5)

print(f'List size: {sys.getsizeof(my_list)} bytes')

print(f'Tuple size: {sys.getsizeof(my_tuple)} bytes')

Salida

List size:  52 bytes
Tuple size: 40 bytes

Las tuplas también admiten todas las operaciones que no modifican la secuencia. Puedes usar count() para contar cuántas veces aparece un valor, index() para encontrar su posición, in para comprobar si un elemento está en la tupla y + para concatenar.

Métodos y operaciones de las tuplas

numbers = (1, 2, 3, 2, 4, 2)

# count() - how many times a value appears

print(numbers.count(2)) # 3

# index() - position of first occurrence

print(numbers.index(3)) # 2

# in - membership check

print(4 in numbers) # True

# Concatenation creates a NEW tuple

combined = (1, 2) + (3, 4)

print(combined) # (1, 2, 3, 4)

Salida

3
2
True
(1, 2, 3, 4)

Ejercicios de práctica

¡Hora de practicar! Estos ejercicios cubren la creación de tuplas, el desempaquetado y la inmutabilidad.

Ejercicio 1: crea una tupla y accede a sus elementos

Escribe el código

Crea una tupla llamada seasons que contenga las cuatro estaciones como cadenas: 'Spring', 'Summer', 'Fall', 'Winter'.

Después, imprime la primera y la última estación, cada una en su propia línea.

Salida esperada:

Spring
Winter

# Create the seasons tuple

# Print the first season

# Print the last season

Ejercicio 2: predice la salida (tupla de un solo elemento)

Predice la salida

Lee este código con atención. ¿Qué va a imprimir? Piensa en qué hace que algo sea una tupla y no solo un número entre paréntesis.

Escribe la salida exacta.

a = (5)

b = (5,)

print(type(a).__name__)

print(type(b).__name__)

Ejercicio 3: desempaqueta una tupla

Escribe el código

Tienes una tupla que representa el registro de un estudiante. Desempaquétala en tres variables: name, age y grade.

Después, imprime cada variable en su propia línea.

Salida esperada:

Emma
16
A

student = ('Emma', 16, 'A')

# Unpack the tuple into name, age, grade

# Print each variable

Ejercicio 4: corrige el error al modificar una tupla

Corrige el error

Este código intenta cambiar un color de una tupla, pero las tuplas son inmutables. Corrígelo para que el programa imprima los colores actualizados sin cambiar la tupla original. En su lugar, crea una tupla nueva.

Salida esperada:

('red', 'yellow', 'blue')

colors = ('red', 'green', 'blue')

colors[1] = 'yellow'

print(colors)

Ejercicio 5: recorre y desempaqueta las notas de los estudiantes

Escribe el código

Tienes una lista de tuplas en la que cada tupla contiene el nombre de un estudiante y su nota. Recorre la lista, desempaqueta cada tupla e imprime el resultado de cada estudiante con este formato:

Alice: 92
Bob: 85
Charlie: 78

students = [

('Alice', 92),

('Bob', 85),

('Charlie', 78),

]

# Loop through and print each student's result

Resumen: lo que aprendiste sobre las tuplas en Python

Este es un repaso de todo lo que ya sabes sobre las tuplas:

Concepto	Qué hace	Ejemplo
Crear una tupla	Guarda elementos fijos	`point = (3, 4)`
Coma final	Crea una tupla de un solo elemento	`solo = (42,)`
Indexación	Accede por posición	`point[0]`, `point[-1]`
Porciones (slicing)	Obtiene una parte	`months[1:4]`
Desempaquetado	Extrae los valores en variables	`x, y = point`
Desempaquetado extendido	Captura los sobrantes con `*`	`first, *rest = items`
`count()`	Cuenta las apariciones	`t.count(2)`
`index()`	Encuentra la posición	`t.index(3)`
Inmutabilidad	No se puede modificar tras crearla	Lanza `TypeError`

Las tuplas son perfectas para colecciones fijas de datos: coordenadas, colores, registros y valores de retorno de funciones. Su inmutabilidad hace que tu código sea más seguro y tus intenciones, más claras.

¿Qué sigue?

En la siguiente lección, [Diccionarios en Python](/python/python-dictionaries), aprenderás a guardar datos como pares clave-valor. En lugar de acceder a los elementos por su posición, accederás a ellos por su nombre.

Los diccionarios son una de las estructuras de datos más potentes de Python. Junto con las listas y las tuplas, te permiten representar casi cualquier dato del mundo real.

Cómo crear tuplas en Python

Acceder a los elementos de una tupla y sacar porciones

Empaquetar y desempaquetar tuplas

Tuplas frente a listas: cuándo usar cada una

Por dentro: por qué las tuplas son más rápidas que las listas

Ejercicios de práctica

Resumen: lo que aprendiste sobre las tuplas en Python

¿Qué sigue?

Tutoriales relacionados