Las Tuplas en Python

Las Tuplas son uno de los cuatro tipos de datos que podemos encontrar en Python, lo otros tres son las listas, los conjuntos y los diccionarios.

Son un tipo de dato inmutable, lo que significa que una vez creadas no se pueden cambiar, añadir o eliminar elementos. Por contra si son iterables, es decir permiten recorrerlas y sus datos están ordenados.

Las tuplas se escriben entre paréntesis (), aunque una sucesión de elementos asignados a una variable, aunque no lleven paréntesis, también se consideran como una tupla.

>>> tupla1 = ('a',4,'cuadrado')
>>> tupla2 = 'a', 4, 'cuadrado'
>>> print(type(tupla1), type(tupla2))
<class 'tuple'> <class 'tuple'>

Sin embargo, tienes que tener en cuenta que para crear una tupla con un solo elemento tienes que añadir una coma después del elemento ya que sino Python no lo considerará como otro tipo de dato.

>>> estoesunaTupla = ("manzana",)
>>> print(type(estoesunaTupla))
<class 'tuple'>

#No es una Tupla
>>> EstaOtra = ("manzana")
>>> print(type(EstaOtra))
<class 'string'>

Existen constructores para convertir las listas en tuplas y viceversa. Para convertir algo en una tupla podemos usar el constructor tuple().

>>> miLista=[1,2,3]
>>> miTupla=tuple(miLista)
>>> print(miTupla)
(1, 2, 3)

Comandos útiles para trabajar con Tuplas u otras secuencias.

.count()        

Usamos este método para determinar cuantas veces un elemento se encuentra dentro de una Tupla.

>>> mi_tupla = 1, 5, 6, 1, 0, 3, 2, 1
>>> print(mi_tupla.count(1))
3

len()

Usamos la función len() para determinar el número de elementos hay en una tupla.

>>> mi_tupla = 1, 5, 6, 1, 0, 3, 2, 1
>>> print(len(mi_tupla))
8

in 

Usamos el comando in, que tambien vimos en las listas, para determinar si un elemento esta en la tupla.

>>> mi_tupla = 1, 5, 6, 1, 0, 3, 2, 1
>>> print(1 in mi_tupla)
True
>>> print(9 in mi_tupla)
False

not in

Usamos el comando not in, que también vimos en las listas, para determinar si un elemento no esta en la secuencia.

>>> mi_tupla = 1, 5, 6, 1, 0, 3, 2, 1
>>> print(1 not in mi_tupla)
False
>>> print(9 not in mi_tupla)
True

secuencia1 + secuencia2

Podemos unir varias secuencias, en este caso tuplas, usando el operador +

>>> tupla1 = 1,2,3
>>> tupla2 = 4,5,6
>>> tupla3 = tupla1 + tupla2
>>> print(tupla3)
(1, 2, 3, 4, 5, 6)

enumerate(secuencia, <nº inicio=0>)

Crea un objeto en el que cada uno de los elementos de la secuencia esta enumerado. Si no especificamos el número de inicio, que es opcional, comienza en el 0.

>>> tupla1 = 'patata'
>>> print(tuple(enumerate(tupla1)))
((0, 'p'), (1, 'a'), (2, 't'), (3, 'a'), (4, 't'), (5, 'a'))

.index()

Usamos el método index para saber la posición de un elemento dentro de un iterable, en este caso, una tupla. Recuerda que los elementos se empiezan a contar en el cero.

>>> mi_tupla = 1, 5, 6, 1, 0, 3, 2, 1
>>> print(mi_tupla.index(5))
1

zip()

Genera un objeto con la unión de secuencias con elementos que ocupan la misma posición. Veámoslo con un ejemplo uniendo dos tuplas.

>>> t1 = ('p','t','t')
>>> t2 = ('a','a','a')
>>> t3=zip(t1,t2)
>>> print(t3)
<zip object at 0x7f3bb9d6ce80>
>>> print(tuple(t3))
(('p', 'a'), ('t', 'a'), ('t', 'a'))

Podemos aplicar a las Tuplas otras funciones que vimos en las listas como min(), max(), sum().

Como acceder a los elementos de una Tupla.

Podemos acceder a los elementos de una Tupla indicando su posición dentro de corchetes [].

>>> mi_tupla = ('peras','platanos','manzanas')
>>> # Imprimimos las manzanas accediendo a su posición
>>> print(mi_tupla[2])
manzanas

Nota: ten en cuenta que el primer elemento tiene como indice el 0.

Índices Negativos.

Cuando usamos índices negativos significa que empezamos a contar por el final.

-1 hace referencia al último elemento, -2 al penúltimo y así sucesivamente.

>>> mi_tupla = ('peras','platanos','manzanas')
>>> # Imprimimos el penúltimo elemento de la tupla.
>>> print(mi_tupla[-2])
platanos

Rango de Índices.

Podemos especificar los elementos de un iterable especificando donde iniciar y donde terminar el rango. Al especificar un rango, el valor que se nos retorna será una nueva tupla con los valores especificados.

>>> mi_tupla = (1,2,3,4,5,6,7,8,9,10,11,12)
>>> print(mi_tupla[2:7])
(3, 4, 5, 6, 7)

 Nota: la selección comienza en el elemento con el índice 2 (incluido) y finaliza en el elemento con índice 7 (sin incluir).

Recuerda que el primer elemento tiene como índice 0.

Si no especificamos el primer valor, la selección comenzará con el primer valor:

>>> mi_tupla = (1,2,3,4,5,6,7,8,9,10,11,12)
>>> print(mi_tupla[:7])
(1, 2, 3, 4, 5, 6, 7)

Si no especificamos el valor final, la selección se extenderá hasta el final del iterable:

>>> mi_tupla = (1,2,3,4,5,6,7,8,9,10,11,12)
>>> print(mi_tupla[5:])
(6, 7, 8, 9, 10, 11, 12)

Selección con Índices Negativos:

Usamos índices negativos cuando queremos empezar la selección o rango desde el final de una tupla.

Por ejemplo:

>>> mi_tupla = (1,2,3,4,5,6,7,8,9,10,11,12)
>>> print(mi_tupla[-4:-1])
(9, 10, 11)

¿Actualizar los datos de una Tupla?

Como ya dijimos, una vez que se crea una Tupla, no podemos cambiar sus valores. Por eso se dice que son Inmutables. 

Entonces, ¿Cómo podemos cambiar sus valores? Pues no podemos hacerlo hacerlo directamente, pero si dando un pequeño rodeo. El truco está en cambiar temporalmente la Tupla a una Lista, hacer la modificación, y volver a convertirla en una Tupla. 

>>> mi_tupla=('pera','naranja','piña')>>> mi_lista=list(mi_tupla)>>> mi_lista[1]='trufa'>>> mi_tupla=tuple(mi_lista)>>> print(mi_tupla)('pera', 'trufa', 'piña')

Y tendríamos que utilizar el mismo truco si quisiéramos añadir o eliminar más elementos a la tupla una vez creada.

Empaquetado y Desempaquetado de Tuplas.

Cuando creamos una tupla y la asignamos a una variable, normalmente le asignamos unos valores, como hemos hecho hasta ahora en todos los ejemplos previos. Esto es lo que se conoce como empaquetado de Tuplas. (aunque por extensión se utiliza en todos los datos que admiten secuencias)

Pero, en Python, también podemos desempaquetar las secuencias, es decir, realizar una asignación múltiple a partir de estructuras de tipo secuencial (cadenas, listas, tuplas)

>>> numeros = (1,2,3)
>>> x, y, x = numeros
>>> print(x)
1
>>> print(y)
2
>>> print(z)
3

o

>>> lista = [('David',1),('Pepe',2),('Domitilo',3)]
>>> for x,y in lista:
>>>   print(x,y)
David 1
Pepe 2
Domitilo 3

Nota: El número de variables debe coincidir con el número de valores de la Tupla; de lo contrario debes utilizar un * para recopilar los valores restantes como una lista.

Veamos un ejemplo de una tupla que tiene más valores que las variables a las que las vamos a asignar.

>>> mi_tupla = (1,2,3,4,5,6,7,8,9,10,11,12)
>>> x, y, *z = mi_tupla
>>> print(x)
1
>>> print(y)
2
>>> print(z)
[3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

Como veis la variable z recoge, en forma de lista, todos los valores que no se pueden asignar a las otras variable.

Tuplas con nombres.

Una librería útil de la biblioteca estándar de Python es collections. En ella encontramos un método útil como es namedtuple. Nos sirve para acceder a los elementos de una tupla usando un nombre en vez de como hemos visto hasta ahora, en la que accedemos a los elementos de la tupla por posición. (aunque tambien se puede seguir accediendo a los datos por posición si prefieres). Esto es muy útil porque cuando un programa es algo complejo se hace complicado recordar que posición correspondía a que dato, es más sencillo ponerles nombre. Por ejemplo, si creamos una variable llamada circulo y con una tupla le pasamos los puntos (x, y) y un radio, para acceder a sus valores haremos:

>>> circulo = (3, 4, 7)
>>> circulo[0] # x
3
>>> circulo[1] # y
4
>>> circulo[2] # radio
7

Usando las tuplas con nombre se podría hacer de las siguiente forma:

>>> from collections import namedtuple
>>> circulo = namedtuple('circulo', "x y radio")
>>> circulo1 = circulo(3,4,7)
>>> print(circulo1.x)
3
>>> print(circulo1.y)
4
>>> print(circulo1.radio)
7

Es decir usamos nametupled('nombre_subclase', "argumentos como strings  separados por espacios")