Tuplas

Las tuplas en Python son estructuras de datos que permiten el almacenamiento fijo de una secuencia de objetos relacionados o no entre sí, del mismo o diferente tipo de datos. En esto son iguales a las listas, salvo que los elementos almacenados en una tupla son de carácter inmutables. Por lo tanto, a diferencia de las listas, no se pueden agregar, modificar ni eliminar elementos. Aunque si se puede comprobar si un elemento se encuentra en ella y también es posible extraer un rango o porción de la tupla (esta operación no modifica la tupla).

Dentro de las ventajas que tiene el uso de tuplas esta la mayor velocidad de procesamiento de los datos que la conforman. Con lo cual se deduce que si una lista de datos secuenciales no se van a modificar durante la ejecución de un programa, siempre es mejor usar una tupla que una lista. Otra ventaja de las tuplas es que se pueden usar como claves en un diccionario, mientras que las listas no lo permiten.

Al igual que las listas, para crear una variable tipo tupla basta con asignar al identificador de la variable una secuencia de elementos separados con coma pero encerrado entre paréntesis () en  lugar de corchetes. Es importante destacar que los paréntesis son opcionales, aunque es muy recomendado usarlos para evitar confusiones.

Veamos el siguiente ejemplo:

tFrutas = ('Manzana','Pera','Uva','Sandia','Banana')

print(f'''

Contenido del objeto tFrutas: {tFrutas}

Tipo de dato del objeto tFrutas: {type(tFrutas)}''')

Resultado:

Contenido del objeto tFrutas: ('Manzana', 'Pera', 'Uva', 'Sandia', 'Banana')

Tipo de dato del objeto tFrutas: <class 'tuple'>

En el siguiente ejemplo podemos comprobar que la colocación de paréntesis es opcional para a declaración de tuplas, aunque no sea un método recomendado.

miTupla= "Cesar","Gamboa",39

print(type(miTupla))

Resultado:

<class 'tuple'>

Como podemos ver por defecto Python ha creado el objeto miTupla a partir de la clase tupla, al no usar ni paréntesis ni corchetes en su definición. Esto es lo que se conoce como empaquetado de una tupla.

Como podemos ver se ha creado un objeto perteneciente a la clase tupla.

Las tuplas al igual que las listas poseen un índice que indica la posición del elemento dentro de la estructura. Los indices igualmente empiezan en cero y van incrementando de uno en uno hasta llegar a n-1 siendo n el total de elementos de la tupla.

Para acceder a un elemento de una tupla el procedimiento es igual que en las listas, por medio del índice podemos acceder al elemento deseado. Veamos el siguiente ejemplo:

miTupla=("Cesar","Gamboa",39)

print(f'El elemento de indice 1 de la tupla \"miTupla\" es {miTupla[1]}')

Resultado:

El elemento de indice 1 de la tupla "miTupla" es Gamboa

Con este ejemplo podemos comprobar el acceso a un elemento de una tupla sabiendo su índice.

Convertir una lista a tupla

También es posible crear una tupla a partir de una lista a través del método TUPLE(), el funcionamiento es exactamente el inverso al método LIST() visto con anterioridad. Veamos el siguiente ejemplo:

miTupla=('Lunes','Martes','Miercoles','Jueves','Viernes','Sabado','Domingo')

miLista=list(miTupla)

print(f'''

Contenido de miTupla:

{miTupla}

Contenido de miLista:

{miLista}

Tipo del objeto miLista:

{type(miLista)}''')

Resultado:

Contenido de miTupla:

('Lunes', 'Martes', 'Miercoles', 'Jueves', 'Viernes', 'Sabado', 'Domingo')

Contenido de miLista:

['Lunes', 'Martes', 'Miercoles', 'Jueves', 'Viernes', 'Sabado', 'Domingo']

Tipo del objeto miLista:

<class 'list'>

Como podemos comprobar se ha creado una lista en base a una tupla creada previamente. El tipo de objeto lo podemos comprobar al ver el resultado que devuelve la función TYPE() al enviarle como argumento el objeto miLista confirmando que pertenece a la clase lista.

Convertir una tupla a lista

El proceso inverso lo podemos hacer con la función TUPLE(). Es decir convertir una lista a tupla. Veamos el siguiente ejemplo:

miLista=['Lunes','Martes','Miercoles','Jueves','Viernes','Sabado','Domingo']

miTupla=tuple(miLista)

print(f'''

Contenido de miLista:

{miLista}

Contenido de miTupla:

{miTupla}

Tipo del objeto miTupla:

{type(miTupla)}''')

Resultado:

Contenido de miLista:

['Lunes', 'Martes', 'Miercoles', 'Jueves', 'Viernes', 'Sabado', 'Domingo']

Contenido de miTupla:

('Lunes', 'Martes', 'Miercoles', 'Jueves', 'Viernes', 'Sabado', 'Domingo')

Tipo del objeto miTupla:

<class 'tuple'>

Como podemos comprobar hemos realizado el proceso contrario, o sea hemos creado una tupla a partir de una lista pudiendo demostrar que el objeto obtenido es una tupla con la instrucción TYPE() al final del código, donde el resultado indica que pertenece a la clase tupla.

Conocer la presencia de un elemento en una lista

Al igual que en las listas, también existe una manera de comprobar si un elemento esta presente en una tupla. La instrucción IN funciona de igual manera que en las listas. Veamos el siguiente ejemplo:

miTupla=('Lunes','Martes','Miercoles','Jueves','Viernes','Sabado','Domingo')

print({'Miercoles' in miTupla})

print({'Enero' in miTupla})

Resultado:

{True}

{False}

Como podemos comprobar la instrucción IN devuelve True al verificar la presencia del elemento 'Miercoles' en la tupla, pero devuelve False con la cadena 'Enero' ya que ésta última no se encuentra presente en el objeto.

Método COUNT

A través de este método se puede saber la cantidad de ocurrencias de un elemento que hay en una tupla.

su sintaxis es como sigue:

<nombre de la tupla>.COUNT('<elemento por el cual se desea consultar>')

Veamos el siguiente ejemplo:

miTupla=('Lunes','Martes','Miercoles','Miercoles','Jueves','Viernes','Sabado','Domingo')

print(f'Miercoles se repite {miTupla.count("Miercoles")} veces')

print(f'Martes se repite {miTupla.count("Martes")} veces')

print(f'Septiembre se repite {miTupla.count("Septiembre")} veces')

Resultado:

Miercoles se repite 2 veces

Martes se repite 1 veces

Septiembre se repite 0 veces

Podemos comprobar por el resultado que el método COUNT() de la clase tupla funciona correctamente.

Función LEN

El método LEN (abreviatura de longitud en inglés length) devuelve la cantidad de elementos presentes en una tupla. Veamos su uso con el siguiente ejemplo práctico:

miTupla=('Lunes','Martes','Miercoles','Jueves','Viernes','Sabado','Domingo')

print(f'''

La tupla miTupla tiene {len(miTupla)} elementos

por lo tanto el último valor del índice es de {len(miTupla)-1}

y el último elemento de la tupla es {miTupla[len(miTupla)-1]}

''')

Resultado:

La tupla miTupla tiene 7 elementos

por lo tanto el último valor del índice es de 6

y el último elemento de la tupla es Domingo

Como podemos comprobar gracias a la función LEN() aplicada a una tupla podemos saber la cantidad de elementos que la conforman y por ende el número del índice superior (n-1 donde n es la cantidad de elementos que conforman la tupla). Siempre es bueno recordar que para acceder a un elemento a través de su índice en una tupla o lista se usa corchetes[].

Tuplas unitarias

Hay situaciones en donde resulta conveniente crear una tupla de un solo elemento o tupla unitaria, para ello basta con definir la tupla como lo hemos venido haciendo hasta ahora pero es importante colocar una coma luego del único elemento definido para que Python reconozca el objeto como una tupla, ya que en caso contrario lo tomará como un string o cadena.

Veamos el siguiente ejemplo:

miTupla1=('abc')

miTupla2=('abc',)

print(f'El objeto miTupla1 es del tipo: {type(miTupla1)}')

print(f'El objeto miTupla2 es del tipo: {type(miTupla2)} de {len(miTupla2)} elemento')

Resultado:

El objeto miTupla1 es del tipo: <class 'str'>

El objeto miTupla2 es del tipo: <class 'tuple'> de 1 elemento

Como se puede comprobar por el resultado Python ha reconocido como tupla solamente al objeto llamado miTupla2 ya que es el único que se le ha colocado la coma luego del único elemento que lo compone.

Empaquetado y desempaquetado de tuplas

Ya se ha mencionado con anterioridad que las tuplas se pueden definir sin necesidad de usar paréntesis aunque no es un método recomendado. Sin embargo en caso de omitirse los paréntesis, Python automáticamente se los asigna y realiza lo que se conoce como empaquetado de tupla, es decir, Python ha empaquetado cada valor separado por coma en un objeto inmutable. Si queremos desempaquetar dicho objeto basta con escribir en el mismo orden de almacenamiento de los datos de la tupla los nombres de las variables que almacenarán dichos valores, separado por comas y a continuación el operador de asignación y el nombre de la tupla. Veamos el siguiente ejemplo:

miTupla = 'Cesar', 'Gamboa', 1.7, 13, 9,1973

print(f'Tupla empaquetada: {miTupla}')

nombre, apellido, estatura, dia_nac, mes_nac, ano_nac = miTupla

print(f'''

Datos desempaquetados:

Nombre: {nombre}

Apellido: {apellido}

Estatura: {estatura}

Fecha de nacimiento: {dia_nac}/{mes_nac}/{ano_nac}''')

Resultado:

Tupla empaquetada: ('Cesar', 'Gamboa', 1.7, 13, 9, 1973)

Datos desempaquetados:

Nombre: Cesar

Apellido: Gamboa

Estatura: 1.7

Fecha de nacimiento: 13/9/1973

Como podemos comprobar Python ha "desempaquetado" los valores almacenados en la tupla y los ha almacenado en una serie de variables en el mismo orden en que fue empaquetado.

Método INDEX()

Al igual que en las listas, en versiones mas recientes Python admite el uso del método INDEX() en los objetos tipo tuplas a fin de averiguar el índice de un elemento determinado. Veamos el siguiente ejemplo: