5.2 Tuplas

El concepto de tupia es muy similar al de lista. Aunque hay algunas diferencias menores, lo fundamental es que, mientras una lista es mutable y se puede modificar, una tupia no admite cambios y por lo tanto, es inmutable.

Podemos pensar en crear tupias tal y como lo hacíamos con listas, pero usando paréntesis en lugar de corchetes:

Tupias de un elemento

Hay que prestar especial atención cuando vamos a crear una tupia de un único elemento. La intención primera sería hacerlo de la siguiente manera:

Realmente, hemos creado una variable de tipo str (cadena de texto). Para crear una tupla de un elemento debemos añadir una coma al final:

Tupias sin paréntesis

Según el caso, hay veces que nos podemos encontrar con tuplas que no llevan paréntesis. Quizás no está tan extendido, pero a efectos prácticos tiene el mismo resultado. Veamos algunos ejemplos de ello:

Como ya hemos comentado previamente, las tuplas con estructuras de datos inmutables. Una vez que las creamos con un valor, no podemos modificarlas. Veamos qué ocurre si lo intentamos:

Para convertir otros tipos de datos en una tupla podemos usar la función tuple():

Esta conversión es válida para aquellos tipos de datos que sean iterables: cadenas de caracteres, listas, diccionarios, conjuntos, etc. Un ejemplo que no funciona es intentar convertir un número en una tupla:

El uso de la función tuple() sin argumentos equivale a crear una tupla vacía:

Truco: Para crear una tupla vacía, se suele recomendar el uso de () frente a tuple(), no sólo por ser más pitónico sino por tener (en promedio) un mejor rendimiento en tiempos de ejecución.

Con las tupias podemos realizar todas las operaciones que vimos con listas salvo las que conlleven una modificación «in-situ» de la misma:

• reverse()
• append()
• extend()
• remove()
• clear()
• sort()

El desempaquetado es una característica de las tuplas que nos permite asignar una tupia a variables independientes:

Figura 5: Desempaquetado de tuplas Veamos un ejemplo con código:

Python proporciona la función «built-in» divmod() que devuelve el cociente y el resto de una división usando una única llamada. Lo interesante (para el caso que nos ocupa) es que se suele utilizar el desempaquetado de tuplas para obtener los valores:

Intercambio de valores

A través del desempaquetado de tuplas podemos llevar a cabo el intercambio de los valores de dos variables de manera directa:

Desempaquetado extendido

No tenemos que ceñirnos a realizar desempaquetado uno a uno. También podemos extenderlo e indicar ciertos «grupos» de elementos mediante el operador *.

Veamos un ejemplo:

Desempaquetado genérico

El desempaquetado de tuplas es extensible a cualquier tipo de datos que sea iterable. Veamos algunos ejemplos de ello.

Sobre cadenas de texto:

Sobre listas:

Los tipos de datos mutables (listas, diccionarios y conjuntos) sí permiten comprensiones pero no así los tipos de datos inmutables como cadenas de texto y tupias.

Si intentamos crear una tupia por comprensión utilizando paréntesis alrededor de la expresión, vemos que no obtenemos ningún error al ejecutarlo:

Sin embargo no hemos conseguido una tupla por comprensión sino un generador:

Aunque puedan parecer estructuras de datos muy similares, sabemos que las tuplas carecen de ciertas operaciones, especialmente las que tienen que ver con la modificación de sus valores, ya que no son inmutables. Si las listas son más flexibles y potentes, ¿por qué íbamos a necesitar tuplas? Veamos 4 potenciales ventajas del uso de tuplas frente a las listas:

1. Las tuplas ocupan menos espacio en memoria.
2. En las tuplas existe protección frente a cambios indeseados.
3. Las tuplas se pueden usar como claves de diccionarios (son «hashables»).
4. Las namedtuples son una alternativa sencilla a los objetos.