Tuplas con Python

Las tuplas en Python contienen una secuencia de datos relacionados, separados entre ellos mediante comas y metidos entre paréntesis ( ):

  • Son inmutables.
  • Pueden contener diferentes tipos de elementos.
  • Son una secuencia en Python, como las listas, rangos y strings..

Los elementos de una tupla están indexados, su primer valor comienza con índice 0 y el último con -1.

Tuple en Python

Vamos a escribir algunos sencillos ejemplos de tuplas en Python.

mi_tupla = (1, 2, 3, 4, 5)
mi_tupla = ('a', 'e', 'i', 'o', 'u')
mi_tupla = ('Hola', 123, 14.2432, 'Hasta otra', False)

Al igual que las listas en Python, las tuplas en Python pueden contener diferentes elementos en su interior, incluso tuplas.

Vamos a crear una tupla con otra tupla en su interior y mostrar los valores accediendo mediante su posición al primer valor indexado como 0 y al último indexado como -1.

mi_tupla = ('Hola', 123, 14.2432, ('verde', 'azul'))

print(mi_tupla[0])
# Hola

print(mi_tupla[-1])
# ('verde', 'azul')

En cualquier momento podemos verificar que se trata de una tupla de Python si realizamos una consulta con type().

mi_tupla = ('Hola', 123, 14.2432, ('verde', 'azul'))
print(f'Soy de tipo {type(mi_tupla)}')

# Soy de tipo <class 'tuple'>

Si tuviéramos que crear una tupla en Python que tuviese un único elemento, tendríamos que colocar una coma después de este para que Python la considerase tupla y no string.

Puedes ver la documentación oficial sobre las tuplas en Python.

objeto = ('elemento')
print(f'Soy de tipo {type(objeto)}')
# Soy de tipo <class 'str'>

objeto = ('elemento',)
print(f'Soy de tipo {type(objeto)}')
# Soy de tipo <class 'tuple'>

Es posible crear una tupla vacía.

tupla_vacia = ()
print(f'Soy de tipo {type(tupla_vacia)}')
# Soy de tipo <class 'tuple'>

Podemos conocer el número de elementos de nuestra tupla con len().

mi_tupla = ('Hola', 123, 14.2432, ('verde', 'azul'))
print(f'Tengo {len(mi_tupla)} elementos')

# Tengo 4 elementos

Cada elemento de una tupla está separado por comas. En el ejemplo de tupla anterior podemos ver de forma clara que el último elemento es de clase tupla.

  • Elemento 1 → Hola
  • Elemento 2 → 123
  • Elemento 3 → 14.2432
  • Elemento 4 → (‘verde’, ‘azul’)

Vamos a consultar qué tipo de datos contiene la última posición de nuestra tupla.

mi_tupla = ('Hola', 123, 14.2432, ('verde', 'azul'))
print(f'Soy de tipo {type(mi_tupla[-1])}')

# Soy de tipo <class 'tuple'>

Existe una forma muy curiosa de almacenar los valores de una tupla en diferentes variables. Se llama «desempaquetar nuestra tupla».

Veámoslo con un ejemplo muy sencillo:

Crearemos una tupla con cinco valores, y después desempaquetaremos nuestra tupla en diferentes variables.

mi_tupla = ('Hola', 123, 14.2432, ('verde', 'azul'), False)
(v1, v2, v3, v4, v5) = mi_tupla

print(v1)
# Hola

print(v2)
# 123

print(v3)
# 14.2432

print(v4)
# ('verde', 'azul')

print(v5)
# False

Constructor tuple en Python

Como en el caso de las listas, para las tuplas también existe un constructor: tuple(). Vamos a crear una tupla uilizando este constructor de Python.

No podemos olvidar que, si queremos utilizar este constructor para crear una tupla, debemos hacerlo con doble paréntesis.

mi_tupla = tuple(('Hola', False, 12.542, 'verde'))
print(f'Soy de tipo {type(mi_tupla)}')

# Soy de tipo <class 'tuple'>

Es posible crear una tupla directamente con un string.

mi_tupla = tuple('Badajoz')
print(f'Soy de tipo {type(mi_tupla)}')
# Soy de tipo <class 'tuple'>

print(mi_tupla)
# ('B', 'a', 'd', 'a', 'j', 'o', 'z')

Accediendo a elementos de una tupla

La forma más común de acceder a los valores de una tupla es mediante su índice, que comienza en 0 para la primera posición y termina en -1 para la última.

mi_tupla = tuple('Badajoz')

print(mi_tupla[4])
# j

print(mi_tupla[-1])
# z

Si quisiésemos acceder a un solo valor del cuarto elemento, es decir, a uno de los valores de la tupla dentro de la tupla, lo haríamos de la siguiente forma:

mi_tupla = ('Hola', 123, 14.2432, ('verde', 'azul'))
print(f'Soy el valor que está dentro de la tupla que está dentro de otra tupla: {mi_tupla[3][1]}')

# Soy el valor que está dentro de la tupla que está dentro de otra tupla: azul

Accediendo a un rango de valores de nuestra tupla

En este ejemplo vamos a indicar la posición desde la que queremos comenzar seguida de dos puntos para después indicarle la posición final que necesitamos.

mi_tupla = ('Hola', True, 12, False, 'Adios')
print(mi_tupla[2:4])

# (12, False)

Es posible indicarle un número determinado de posiciones. Con los dos puntos y sin indicar ningún valor a la izquierda, estaremos indicando que se empieza en el índice 0. Y con el valor a la derecha de los dos puntos, indicaremos hasta qué posición del índice queremos llegar.

mi_tupla = ('Hola', True, 12, False, 'Adios')
print(mi_tupla[:2])

# ('Hola', True)

Podemos consultar la posición que ocupa algún valor dentro de nuestra tupla de Python. Para que devuelva un valor debe existir como True; de lo contrario, devolverá False.

Para ver si determinado valor existe en nuestra tupla, vamos a ver el siguiente ejemplo:

mi_tupla = (1, 2, 3, 4, 5, 6)

print(3 in mi_tupla)
# True

print(12 in mi_tupla)
# False

Una vez que hemos verificado que el valor que buscamos está en nuestra tupla, vamos a ver qué posición ocupa determinado valor. Veamos en el siguiente ejemplo qué posición ocupan algunos valores dentro de la tupla mediante index().

mi_tupla = (1, 2, 3, 4, 5, 6)

print(f'El valor 2 ocupa la posición {mi_tupla.index(2)}')
# El valor 2 ocupa la posición 1

print(f'El valor 5 ocupa la posición {mi_tupla.index(5)}')
# El valor 5 ocupa la posición 4

Si buscásemos la posición de un valor que no existe en nuestra tupla obtendríamos el siguiente error:

mi_tupla = (1, 2, 3, 4, 5, 6)
print(f'El valor 9 ocupa la posición {mi_tupla.index(9)}')
# ValueError: tuple.index(x): x not in tuple

Cuando estemos trabajando con tuplas que contengan solo cadenas de texto o solo números, podemos utilizar las funciones max() y min(). En el caso de los números, no tendríamos que tener nada en cuenta, ya que el número mínimo es el más pequeño y el máximo es el más grande.

mi_tupla = (1, 2, 3, 4)
print(f'Menor de la tupla {min(mi_tupla)}')
# Menor de la tupla 1

mi_tupla = (1, 2, 3, 4)
print(f'Mayor de la tupla {max(mi_tupla)}')
# Mayor de la tupla 4

En cambio, si en nuestro proyecto estamos trabajando una tupla que contiene elementos de tipo string, debemos tener en cuenta el valor de la posición del carácter en la tabla ASCII. Puedes ver estos valores en cualquier tabla ASCII en internet. Para este ejemplo bastará con conocer los siguientes valores:

CarácterASCII
149
553
A65
G71
a97
b98
c99

Se puede ver claramente que el valor de la letra a minúscula es mayor que el de la letra G mayúscula. Por esta razón, si hacemos un min() o un max(), el resultado puede ser diferente al esperado.

Siempre tendrá en cuenta el valor ASCII.

mi_tupla = ('1', '5', 'A', 'C', 'a', 'b', 'c')
print(f'Menor de la tupla {min(mi_tupla)}')
# Menor de la tupla 1

print(f'Mayor de la tupla {max(mi_tupla)}')
# Mayor de la tupla c

De la misma forma que para las cadenas de texto, se tiene en cuenta el valor del primer carácter de la cadena.

mi_tupla = ['arboleda de castaños', 'Casa de un amigo que vive en Jerez']
print(min(mi_tupla))
# Casa de un amigo que vive en Jerez

print(max(mi_tupla))
# arboleda de castaños

Modificar valor de una tupla

Una de las características de las tuplas es que son inmutables, es decir, no se pueden modificar, agregar o eliminar elementos a una tupla ya creada.

¿Qué pasa si necesitamos sí o sí realizar una de estas operaciones que no permiten las tuplas?

Antes de explicar la forma de hacerlo, es conveniente que pensemos bien qué tipo de objeto necesitamos realmente, pues quizás convenga más utilizar una lista o diccionario.

Vamos a crear un ejemplo para modificar el valor de una posición de nuestra tupla, para esto haremos lo siguiente:

  • Crear la tupla.
  • Transformar la tupla en una lista.
  • Modificar el valor de la posición que necesitamos.
  • Crear una tupla con los valores de la lista.

Lo veremos muy claro sobre el código con un ejemplo:

mi_tupla = ('a', 'b', 'c', 'd')
lista_aux = list(mi_tupla)
lista_aux[0] = 'A'
mi_tupla = tuple(lista_aux)

print(mi_tupla)
# ('A', 'b', 'c', 'd')

De forma parecida, trabajaremos si lo que necesitamos es añadir un nuevo elemento a la tupla o eliminar.

Añadiendo elemento a una tupla mediante la transformación de tupla a lista.

mi_tupla = ('a', 'b', 'c', 'd')
lista_aux = list(mi_tupla)
lista_aux.append('E')
mi_tupla = tuple(lista_aux)

print(mi_tupla)
# ('a', 'b', 'c', 'd', 'E')

Eliminando elemento de una tupla mediante la transformación de tupla a lista.

mi_tupla = ('a', 'b', 'c', 'd')
lista_aux = list(mi_tupla)
lista_aux.remove('c')
mi_tupla = tuple(lista_aux)

print(mi_tupla)
# ('a', 'b', 'd')

Eliminando tupla con del

Para las tuplas no existe el método clear() como para vaciar las listas, ya que las tuplas son inmutables y no se pueden vaciar directamente. Sí podemos, en cambio, eliminarla completamente mediante del().

mi_tupla = ('a', 'b', 'c', 'd')
del mi_tupla

print(mi_tupla)
# NameError: name 'mi_tupla' is not defined

O recurrir de nuevo al truco que hemos visto anteriormente para modificar valores con las listas.

mi_tupla = ('a', 'b', 'c', 'd')
lista_aux = list(mi_tupla)
lista_aux.clear()
mi_tupla = tuple(lista_aux)

print(mi_tupla)
# ()

Recorriendo tuplas con Python

Las tuplas en Python sepueden recorrer mediante la estructura de control for, while y Comprehension. Puedes echar un vistazo a la entrada específica sobre el for en Python si todavía tienes alguna duda de su funcionamiento.

Recorriendo tupla con for

En este ejemplo recorreremos mediante un bucle for todos los elementos de esta tupla.

mi_tupla = ('a', 'b', 'c', 'd', 'e')
for letra in mi_tupla:
    print(letra, end=', ')

# a, b, c, d, e,

Es posible recorrer la tupla que hemos creado mediante la posición de los elementos. Para esto vamos a tener que utilizar los rangos y buscar el valor que contiene cada posición.

mi_tupla = ('a', 'b', 'c', 'd', 'e')
for i in range(len(mi_tupla)):
    print(f'Índice es i → {i} | Valor de {mi_tupla[i]}')

# Índice es i → 0 | Valor de a
# Índice es i → 1 | Valor de b
# Índice es i → 2 | Valor de c
# Índice es i → 3 | Valor de d
# Índice es i → 4 | Valor de e

Recorrer tupla con Comprehension

Al recorrer los valores de una tupla mediante Comprehension para Python, puede crearse un nueva lista con los valores de la tupla modificados y transformar nuestra lista en tupla, de la misma forma que hicimos cuando modificábamos los valores de una tupla.

Sigo sin verle mucho sentido a esto, ya que, si necesitamos modificar los valores de una tupla, deberíamos pensar nuevamente si realmente necesitamos una tupla; aun así, veamos un ejemplo:

mi_tupla = (1, 2, 3, 4, 5)
lista_aux = [valor*2 for valor in mi_tupla]
nueva_tupla = tuple(lista_aux)

print(nueva_tupla)
# (2, 4, 6, 8, 10)

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

Recorrer tupla con while

mi_tupla = (1, 2, 3, 4, 5)
i = 0
while i < len(mi_tupla):
    print(f'El valor de la posición {i} es → {mi_tupla[i]}')
    i = i + 1

# El valor de la posición 0 es → 1
# El valor de la posición 1 es → 2
# El valor de la posición 2 es → 3
# El valor de la posición 3 es → 4
# El valor de la posición 4 es → 5

Copiar tuplas

Podemos copiar varias tuplas y transformarlas en una sola.

mi_tupla = (1, 2, 3, 4, 5)
otra_tupla = (False, 2, 'Hola', 12.34)
tuplas = mi_tupla + otra_tupla
print(tuplas)

# (1, 2, 3, 4, 5, False, 2, 'Hola', 12.34)

Dejar un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *