Tutorial de tuplas en Python

Tuplas frente a listas

Como habrás notado, las tuplas son muy similares a las listas. De hecho, podrías decir que son listas inmutables: una vez creada una tupla no puedes borrar ni cambiar los valores de los elementos que contiene. Tampoco puedes añadir valores nuevos. Mira:

numbers_tuple = (1,2,3,4,5)
numbers_list = [1,2,3,4,5]

# Intentar añadir un número a la tupla
numbers_tuple.append(6)

---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

<ipython-input-26-e47776d745ce> in <module>()
      3 
      4 # Append a number to the tuple
----> 5 numbers_tuple.append(6)


AttributeError: 'tuple' object has no attribute 'append'

Da un error porque no puedes eliminar ni añadir elementos en una tupla, cosa que sí puedes hacer con una lista.

# Añadir números a la lista
numbers_list.append(6)
numbers_list.append(7)
numbers_list.append(8)

# Eliminar un número de la lista
numbers_list.remove(7)
print(numbers_list)

[1, 2, 3, 4, 5, 6, 8]

Pero, ¿por qué usar tuplas si son inmutables?

Porque, además de ofrecer acceso de solo lectura a los datos, son más rápidas que las listas. Fíjate en este código:

import timeit
timeit.timeit('x=(1,2,3,4,5,6,7,8,9)', number=100000)

0.0018976779974764213

timeit.timeit('x=[1,2,3,4,5,6,7,8,9]', number=100000)

0.019868606992531568

¿Qué significa exactamente inmutable en el caso de las tuplas?

Según la documentación oficial de Python, inmutable es «un objeto con un valor fijo», pero «valor» es un término algo vago; el término correcto para tuplas sería «id». «id» es la identidad de la ubicación de un objeto en memoria.

Veámoslo con más detalle:

# Tupla 'n_tuple' con una lista como uno de sus elementos.
n_tuple = (1, 1, [3,4])

# Elementos con el mismo valor tienen el mismo id.
id(n_tuple[0]) == id(n_tuple[1])

True

# Elementos con distinto valor tienen distinto id.
id(n_tuple[0]) == id(n_tuple[2])

False

id(n_tuple[0])

4297148528

id(n_tuple[2])

4359711048

n_tuple.append(5)

---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

<ipython-input-40-3cd258e024ff> in <module>()
----> 1 n_tuple.append(5)


AttributeError: 'tuple' object has no attribute 'append'

No podemos añadir elementos a una tupla, por eso aparece el error anterior. De ahí que se diga que una tupla es inmutable. Pero sí puedes hacer esto:

n_tuple[2].append(5)
n_tuple

(1, 1, [3, 4, 5])

Así, en la práctica estás mutando la tupla original. Entonces, ¿por qué se sigue considerando inmutable?

Porque el id de la lista dentro de la tupla sigue siendo el mismo aunque le hayas añadido el 5.

id(n_tuple[2])

4359711048

En resumen, por ahora quédate con esto:

Algunas tuplas (las que contienen solo objetos inmutables: strings, etc.) son inmutables y otras tuplas (las que contienen uno o más objetos mutables: listas, etc.) pueden cambiar. Aun así, esto suele ser motivo de debate entre pythonistas, y necesitarás más base para comprenderlo del todo. Este artículo profundiza en el tema. Por ahora, digamos que las tuplas son inmutables en general.

• No puedes añadir elementos a una tupla por su propiedad de inmutabilidad. No existen los métodos append() ni extend() para tuplas,
• Tampoco puedes eliminar elementos de una tupla. Las tuplas no tienen métodos remove() ni pop(),
• Puedes buscar elementos en una tupla porque eso no cambia la tupla,
• También puedes usar el operador in para comprobar si un elemento existe en la tupla.

Así que, si defines un conjunto constante de valores y solo vas a iterar sobre él, usa una tupla en lugar de una lista. Será más rápida que trabajar con listas y también más segura, ya que las tuplas protegen los datos frente a escritura.

Si quieres saber más sobre listas en Python, no dejes de leer este tutorial.

Operaciones comunes con tuplas

Python te ofrece varias formas de trabajar con tuplas. Vamos a ver algunas de las más importantes con ejemplos.

Slicing de tuplas

El primer valor de una tupla tiene índice 0. Ig igual que con las listas de Python, puedes usar los valores de índice junto con corchetes [] para acceder a elementos de una tupla:

numbers = (0,1,2,3,4,5)
numbers[0]

0

También puedes usar índices negativos con tuplas:

numbers[-1]

5

Mientras que el indexado se usa para obtener elementos individuales, el slicing te permite obtener un subconjunto de elementos. Cuando indicas un rango que quieres extraer, se llama slicing por rango. El formato general es:

[Índice de inicio (incluido):índice de fin (excluido):incremento]

Aquí incremento es un parámetro opcional; por defecto es 1.

# El elemento en el índice 4 queda excluido
numbers[1:4]

(1, 2, 3)

# Devuelve todos los elementos de la tupla
numbers[:]

(0, 1, 2, 3, 4, 5)

# Incremento = 2
numbers[::2]

(0, 2, 4)

Truco: también puedes usar un incremento negativo para invertir la tupla.

numbers[::-1]

(5, 4, 3, 2, 1, 0)

Suma de tuplas

Puedes combinar tuplas para formar una nueva. La operación de suma simplemente concatena tuplas.

x = (1,2,3,4)
y = (5,6,7,8)

# Combinar dos tuplas para formar una nueva
z = x + y 

print(z)

(1, 2, 3, 4, 5, 6, 7, 8)

y = [5,6,7,8]
z = x + y
print(z)

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-55-d352c6414a4c> in <module>()
      1 y = [5,6,7,8]
----> 2 z = x + y
      3 print(z)


TypeError: can only concatenate tuple (not "list") to tuple

Solo puedes sumar o combinar tipos de datos iguales. Por eso, combinar una tupla y una lista da error.

Multiplicación de tuplas

La multiplicación de una tupla simplemente repite su contenido.

x = (1,2,3,4)
z = x*2
print(z)

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

Funciones para tuplas

A diferencia de las listas de Python, las tuplas no tienen métodos como append(), remove(), extend(), insert() o pop() debido a su carácter inmutable. Sin embargo, hay muchas funciones integradas para trabajar con tuplas:

count() y len()

count() devuelve el número de veces que aparece un elemento en una tupla.

a = [1,2,3,4,5,5]
a.count(5)

2

Con la función len() puedes obtener la longitud de la tupla:

a = (1,2,3,4,5)
print(len(a))

5

any()

Puedes usar any() para saber si algún elemento de una tupla es «verdadero». Devuelve True si es el caso; en caso contrario devuelve False.

a = (1,)
print(any(a))

True

Fíjate en la , en la declaración de la tupla a de arriba. Si no añades la coma al inicializar una tupla de un solo elemento, Python asume que has puesto paréntesis de más (inofensivo), pero el tipo de dato no es una tupla. Así que recuerda incluir la coma al declarar un único elemento en una tupla.

Volviendo a any(): en un contexto booleano, el valor del elemento es irrelevante. Una tupla vacía es falsa; cualquier tupla con al menos un elemento es verdadera.

b = ()
print(any(b))

False

Esta función puede ser útil cuando en tu programa recibes una tupla y quieres asegurarte de que tiene contenido.

tuple()

Usa tuple() para convertir otro tipo de dato en una tupla. Por ejemplo, en el siguiente fragmento conviertes una lista de Python en tupla.

a_list = [1,2,3,4,5]
b_tuple = tuple(a_list)
print(type(b_tuple))

<class 'tuple'>

min() y max()

max() devuelve el elemento más grande de la tupla y min() devuelve el más pequeño. Observa este ejemplo:

print(max(a))
print(min(a))

5
A

También puedes usarlo con tuplas que contienen strings.

# La cadena 'Apple' se convierte automáticamente en una secuencia de caracteres. 
a = ('Apple') 
print(max(a))

p

sum()

Con esta función obtienes la suma total de los elementos de una tupla. Solo puede usarse con valores numéricos.

sum(a)

28

sorted()

Para devolver los elementos en orden ascendente, usa sorted(), como en el siguiente ejemplo:

a = (6,7,4,2,1,5,3)
sorted(a)

[1, 2, 3, 4, 5, 6, 7]

Ten en cuenta que el tipo de retorno es una lista, no una tupla. La secuencia de la tupla original «a» no cambia y su tipo sigue siendo tupla.

Bonus: asignación de múltiples valores

Algo muy útil que puedes hacer con tuplas es usarlas para asignar varios valores de una vez. Mira:

a = (1,2,3)
(one,two,three) = a
print(one)

1

a es una tupla de tres elementos y (one,two,three) es una tupla de tres variables. Asignar (one,two,three) a la tupla a asigna cada uno de los valores de a a cada una de las variables, en orden: one, two y three. Es muy práctico cuando necesitas asignar una serie de valores a una secuencia almacenada en una tupla.

¡Enhorabuena!

Has llegado al final de este tutorial sobre tuplas. Por el camino has aprendido qué son las tuplas en Python, cómo inicializarlas, cuáles son las operaciones más comunes para trabajar con ellas y qué funciones conviene conocer para sacarle más partido a estas estructuras de datos de Python. Como extra, has visto que también puedes asignar varios valores a la vez con tuplas.