¿Cómo crear tuplas en Python y por qué utilizarlas?

La tupla es un tipo de datos incorporado en Python que se utiliza para almacenar una colección de datos. Es similar a una lista pero es ligeramente más rápida.

Sin embargo, sus limitaciones hacen que las listas sean más deseables en algunas situaciones. En este artículo, le explicaré todo lo que necesita saber para empezar a utilizar tuplas.

¿Qué es una tupla?

Como se mencionó anteriormente, una tupla es uno de los tipos de datos incorporados en Python que se utilizan para almacenar colecciones de datos. Es similar a una lista de Python en que almacena los datos en un formato iterable, similar a un array. Sin embargo, a diferencia de una lista, una tupla es inmutable. Es decir, una vez creada, sus valores no pueden modificarse.

No se pueden añadir elementos adicionales, y los elementos existentes no se pueden eliminar. Una tupla, por tanto, es ideal para almacenar datos que no cambian. Incluso puede ser una colección de datos de distintos tipos. En la siguiente sección, analizaremos las distintas formas de crear tuplas en Python.

¿Cómo crear una tupla en Python?

Existen al menos tres formas de crear tuplas en Python. En esta sección, cubriremos tres de los métodos más comunes que probablemente utilizará y verá al leer el código de otros.

Para ejecutar los siguientes ejemplos de código, necesitará tener instalado Python. Si aún no tiene Python instalado, aquí tiene una guía útil para instalarlo. Alternativamente, puede ejecutar su código en un tiempo de ejecución de Python en línea como Google Colab.

#1. Uso del literal de tupla (paréntesis)

La forma más común de ver definidas las tuplas en Python es colocando una colección de valores entre paréntesis. Estos valores están separados por comas. El siguiente ejemplo ilustra este método:

# Crea una tupla colocando valores entre paréntesis
values = (1, 2, 3)

# Imprimiendo la tupla en la pantalla
print(values)

# Imprimiendo el tipo de la variable values
print(type(values))

La ejecución de este código producirá lo siguiente:

Como puede ver en la salida, la tupla contiene los valores con los que la hemos inicializado. También es de tipo <clase 'tupla'>.

Cuando se crean tuplas en Python, los paréntesis no son necesarios. Por lo tanto este valores = 1, 2, 3 es igual de válido que este valores = (1, 2, 3). Sin embargo, es recomendable que utilice paréntesis para que su código sea más comprensible.

Crear tuplas con un solo elemento en Python es un poco complicado. En lugar de limitarse a colocar un elemento entre paréntesis, también debe añadir una coma final. He aquí un ejemplo para ilustrarlo:

# Sin coma al final, esto no creará una tupla
not_a_tuple = (1)

# Con coma al final, esto creará una tupla
a_tuple = (1,)

# Impresión de not_a_tuple
print(not_a_tuple)

# Impresión del tipo de datos de not_a_tuple
print(type(not_a_tuple))

# Impresión de a_tuple
print(a_tuple)

# Impresión del tipo de datos de a_tuple
print(type(a_tuple))

Ejecutando el código anterior, verá que no_una_tupla se convierte en un int de valor 1. Es importante tener esto en cuenta al crear tuplas.

#2. Uso de la función constructora

El segundo método para crear tuplas en Python utiliza la función constructora de tuplas. En este método, usted llama a la función, pasando un objeto iterable como una lista como argumento. Éste se convertirá en una tupla. He aquí un ejemplo:

# Creación de una tupla a partir de una lista de valores
values = tuple([1, 2, 3])

# Impresión de los valores
print(values)

# Impresión del tipo de datos del identificador de valores
print(type(values))

Como puede ver, utilizando la función se consigue el mismo resultado que utilizando el literal. Sin embargo, la función le permite crear una tupla basada en un valor dinámico, como una lista cuyos valores sólo se conocen en tiempo de ejecución. Con el primer método, tendría que conocer los valores o identificadores que componen su tupla mientras escribe el código.

#3. Creación de una tupla vacía

A medida que trabaje con tuplas en su código, es posible que necesite crear tuplas vacías. Las tuplas vacías se crean como cabría esperar. Puede utilizar el constructor de tuplas o el literal to al crearlas. He aquí un ejemplo que demuestra cómo utilizar cualquiera de los dos métodos:

# Utilizando el literal de tupla
tupla_vacia_1 = ()

# Utilizando el constructor
tupla_vacia_2 = tupla()

Las tuplas vacías son útiles cuando se representa un conjunto vacío de resultados. Considere la siguiente función:

def crear_rango(inicio, fin):
 return tupla(rango(inicio, fin))

Esta función crea una tupla con valores desde el inicio hasta el valor final que usted le pase. Si quisiera iterar sobre los resultados de la función utilizaría algo como esto

mis_valores = crear_rango(0, 5)

para valor en mis_valores:
 pasar

Si proporcionara 5 y 5 a la función crear_rango, el resultado sería una tupla vacía. Y si intentara iterar sobre ella, sólo tendría cero iteraciones, y su código procedería con normalidad.

Por otro lado, si no hubiera ninguna tupla vacía, y en su lugar obtuviera el valor Ninguno, entonces intentar iterar sobre ella arrojaría un error. Para evitar que el programa se bloquee, tendría que implementar una prueba para el caso límite de que la función create_range devolviera None o cualquier otro valor que representara una tupla vacía.

Esto daría lugar a un código desordenado. Lo ideal sería evitar los casos especiales en la medida de lo posible. Esto significa que el valor de retorno de todas las funciones debería tener una interfaz idéntica para que su código funcione en el caso general tanto como sea posible. En este caso, esto significa devolver una tupla todo el tiempo, aunque, a veces, estará vacía.

Cómo acceder a los elementos

Hay dos formas de acceder a los elementos de una tupla en Python. El primer método es por índice, y el segundo es desestructurando los elementos. En primer lugar, examinaremos cómo acceder a los elementos por índice.

Acceder a los elementos por el índice

Acceder a los elementos por el índice es similar a cómo accedería a los elementos de una lista por el índice. Para ello se utiliza la notación de corchetes. Las tuplas utilizan un sistema de indexación basado en cero, lo que significa que el primer elemento es el índice 0, y el que le sigue es el índice 1 hasta el último elemento.

El siguiente ejemplo muestra cómo acceder a los elementos por índice:

# Creación de una tupla
valores = (1, 2, 3, 4)

# Acceso al primer elemento
primer_elemento = valores[0]

# Acceso al cuarto elemento(índice 3)
cuarto_elemento = valores<x>[3]</x>

También puede utilizar la indexación negativa. El elemento con índice -1 es el último elemento, y el elemento con índice -2 es el segundo desde el último elemento.

# Creación de la tupla
values = (1, 2, 3, 4)

# Acceso al último elemento
last_element = values[-1]

# Acceso al penúltimo elemento
second_from_last_element = values[-2] 

Además, también puede acceder a subcolecciones de elementos de una tupla troceándola. Esto es similar a cómo se trocearía una lista. La notación es la siguiente <tupla>[<inicio>: <fin>: <salto>]. El siguiente ejemplo demuestra el corte en rodajas:

# Creación de la tupla
values = (1, 2, 3, 4, 5, 6, 7)

# Obtención de los tres primeros elementos
values[1: 3]

# Obtención de todos los demás elementos
values[::2]

Iterar sobre los elementos

Una tupla es un objeto iterable en Python. Por lo tanto, puede iterar sobre sus elementos utilizando un bucle for, como se muestra en el siguiente ejemplo:

valores = (1, 2, 3, 4)

para valor en valores:
 print(valor)

Este método de acceso a los elementos es ideal cuando se desea acceder a todos los elementos de la tupla.

Acceso a elementos mediante desestructuración

Para explicar la desestructuración, considere el siguiente escenario en el que intentamos obtener los distintos elementos de una tupla.

# Crear la tupla para registrar la información de un usuario
person_record = (1, 'John Doe', 'john@example.com')

# Acceder a los diferentes elementos de la tupla para utilizarlos en nuestro código
id = person_record[1]
name = person_record[2]
email = person_record<x>[3]</x>

Python nos permite utilizar un método más cómodo para acceder a los valores, como se ilustra a continuación:

# Creación de la tupla para registrar la información de un usuario
person_record = (1, 'John Doe', 'john@example.com')

id, name, email = person_record

Esto se denomina desestructuración. Es decir, a la primera variable, id en este caso, se le asignará el primer valor de la tupla y a la segunda variable el segundo elemento. Y así hasta el final de la tupla. El ejemplo anterior equivale a esto

id, name, email = (1, 'John Doe', 'john@example.com')

En este caso, en lugar de almacenar la tupla en una variable, la estamos desestructurando inmediatamente. Si combinamos esto con el conocimiento de que no es necesario utilizar paréntesis al crear tuplas, podemos escribir el código de la siguiente manera.

id, name, email = 1, 'John Doe', 'john@example.com'

Al final de todo esto, tendrá las variables id, name y email con los valores 1, 'John Doe' y 'john@example.com'. Esta es una forma cómoda y sucinta de crear variables en Python que verá en el código de producción. Es útil saber que en el corazón de esta elegante sintaxis se encuentra el concepto de tuplas.

Diferencias entre tupla y lista

Aunque ambas son similares, algunas diferencias clave hacen que cada una sea más adecuada para un caso de uso concreto. Comprender estas diferencias le ayudará a decidir cuál es el mejor tipo de datos que puede utilizar y a escribir un código mejor y más eficiente.

Ventajas de una tupla

#1. Es más rápido

Debido a que los valores de una tupla se almacenan en memoria contigua, el acceso a los valores es más rápido en comparación con una lista. Sin embargo, como una vez creadas no pueden modificarse, las tuplas no siempre son la mejor estructura de datos para almacenar colecciones de valores.

Su caso de uso ideal es almacenar muchos datos en memoria que no cambian pero a los que se accederá varias veces durante la ejecución del programa. En este caso, su programa se beneficiará enormemente del aumento de rendimiento de las tuplas.

#2. Devolver múltiples valores

Puede utilizar tuplas para devolver múltiples valores desde una función y desestructurar el resultado. Por ejemplo

from random import randint

def crear_dos_numeros():
 primer_num = randint(0, 9)
 segundo_num = randint(0, 9)

 return primer_num, segundo_num

primer_num, segundo_num = crear_dos_numeros()

En este ejemplo, tenemos una función que crea dos números aleatorios y los devuelve ambos en una tupla. La sentencia return primer_num , segundo_num es equivalente a escribir return (primer_num, segundo_num). Esto se debe a que los paréntesis son opcionales cuando se crean tuplas. Para acceder al resultado, lo estamos desestructurando.

#3. Los valores están protegidos contra escritura

Las tuplas son inmutables una vez creadas. Son, por tanto, ideales para almacenar en memoria datos que no cambien durante la ejecución del programa. Garantizan que no sobrescriba accidentalmente los datos en otra parte de su código.

#4. Almacenar múltiples tipos de datos

Las tuplas le permiten almacenar valores de múltiples tipos de datos. Esto le permite crear registros de datos, como almacenar los detalles de un usuario en una tupla. También puede almacenar elementos más complicados como funciones, diccionarios, otras tuplas e incluso listas.

Métodos comunes de tuplas

#1. contar()

El objeto tupla contiene el método count, que cuenta el número de veces que aparece un elemento. Por ejemplo:

# Creación de una tupla con varios números
values = (1, 2, 3, 4, 5, 4, 4, 6)

# Recuento del número de cuatros
n_fours = values.count(4)

# Prining out the number of fours
print(n_fours)

En este ejemplo, podemos ver que el número 4 aparece exactamente tres veces en nuestra tupla.

#2. índice()

El método index se puede utilizar para encontrar el índice de la primera aparición de un valor en una tupla. Si el valor no existe, se lanzará una excepción ValueError. A continuación se muestra un código para ilustrar cómo funciona el método index:

# Crear una tupla con varios números
values = (1, 2, 3, 4, 5, 4, 4, 6)

# Buscar el índice de 4
index_of_four = values.index(4)
print("Índice de cuatro:", index_of_four)

# Buscar el índice de 9
index_of_nine = values.index(9)
print("Índice de nueve:", index_of_nine)

Y cuando ejecutamos el código anterior, ésta es la salida:

En este caso, el índice de 4 es 3, y el código se ejecutó sin problemas. Pero a la hora de encontrar el índice de 9, el programa lanzó una excepción. Es importante manejar este tipo de excepciones cuando se escriben programas Python que utilizan el método del índice.

#3. len()

Como todos los objetos iterables en Python, las tuplas tienen una propiedad de longitud a la que se puede acceder cuando pasa la tupla como argumento a la función len ().

# Crear una tupla
valores = (1, 2, 3, 4)

# Obtener la longitud
longitud = len(valores)

# Imprimir la salida
print(longitud)

Este es el resultado de ejecutar el código anterior.

#4. mín() y máx()

Los métodos min y max funcionan recorriendo en bucle cada elemento de un iterable y comparando si es mayor o menor que el anterior. Al final, max devolverá el elemento mayor del iterable mientras que min devuelve el menor.

Con números, la operación es obvia. Con cadenas, Python utilizará el orden alfabético. La palabra más pequeña, devuelta por min, es la primera palabra si las cadenas se escribieron en orden alfabético. Mientras que la palabra más grande es la última palabra. Si el iterable contiene una mezcla de diferentes tipos de datos, entonces ambas operaciones fallarán porque Python no sabe cómo comparar diferentes tipos de datos.

He aquí un ejemplo de código:

# Crear tupla con valores
valores = (1, 2, 3, 4, 5)

# Obtener el valor mayor
mayor = max(valores)

# Obtener el valor menor
menor = min(valores)

# Imprimir los resultados
print(mayor)
print(menor)

#5. ordenado()

La función sorted en Python toma un objeto iterable y devuelve una lista de los elementos ordenados. Puede llamar a la función sorted, pasarle una tupla como argumento y obtener los elementos de la tupla ordenados en una lista. Para convertir la lista ordenada en una tupla, puede utilizar la función constructora. He aquí un ejemplo:

# Creando una tupla con valores en orden aleatorio
values = (1, 5, 3, 3, 2, 4)

# Usando sorted para ordenar los valores en una lista
sorted_list = sorted(values)

# Convirtiendo la lista en una tupla
sorted_tuple = tuple(sorted_list)

# Imprimiendo la salida
print(sorted_tuple)

#6. Suma y multiplicación de tuplas

La operación de suma sobre dos tuplas simplemente las concatena. La operación de multiplicación repite los elementos de una tupla tantas veces como el valor con el que se multiplicó. He aquí un ejemplo para ilustrar los dos ejemplos.

# Crear una tupla con algunos valores
valores = (1, 2, 3, 4, 5)

# Crear una nueva tupla utilizando la suma
sumado = valores valores

# Crear una nueva tupla utilizando la multiplicación
multiplicado = valores * 2

print("valores valores =", sumado)
print("valores * 2 =", multiplicado)

Palabras finales

En este artículo ha aprendido que

• Las tuplas son objetos similares a las listas que se utilizan para almacenar colecciones de valores.
• A diferencia de las listas, son inmutables.
• Son más rápidas y eficientes que las listas.
• Pueden construirse utilizando paréntesis y separando los valores con comas.
• También pueden construirse utilizando la función constructora de tuplas.
• Puede acceder a valores individuales utilizando un sistema de índice basado en cero.
• También puede desestructurar valores de la tupla.
• También puede iterar sobre los valores utilizando un bucle for.
• Los diferentes métodos que puede utilizar con una tupla.

A continuación, puede consultar más contenidos de Python, como Métodos de lista de Python y Métodos de diccionario de Python.