Las tuplas en Python son una estructura de datos que se utiliza para almacenar colecciones de elementos, pero a diferencia de las listas, las tuplas son inmutables, lo que significa que una vez que se crean, no pueden modificarse. A continuación mostraremos la funcionalidad básica que nos proporcionan las tuplas en Python, con explicaciones y ejemplos prácticos.
Creación de tuplas
Podemos crear una tupla en Python encerrando elementos entre paréntesis ():
# Tupla vacía
tupla_vacia = ()
# Tupla de números enteros
numeros_enteros = (1, 2, 3, 4, 5)
# Tupla de números flotantes
numeros_flotantes = (1.5, 2.25, 3.75)
# Tupla de cadenas de texto
nombres = ("Ana", "Carlos", "María")
# Tupla con elementos de diferentes tipos
mixta = (10, "Python", True, 3.14)
También podemos crear una tupla sin usar paréntesis, simplemente separando los elementos por comas. Esto se conoce como «tupla implícita»:
tupla = 1, 2, 3
Acceso a elementos
Podemos acceder a los elementos de una tupla utilizando índices, al igual que con las listas. El primer elemento tiene un índice de 0 y el último de -1:
numeros = (10, 20, 30, 40, 50) primer_elemento = numeros[0] # 10 segundo_elemento = numeros[1] # 20 ultimo_elemento = numeros[-1] # 50 (índice negativo para acceder al último elemento)
Inmutabilidad de las tuplas
La principal diferencia entre las listas y las tuplas es que las tuplas son inmutables. Si necesitamos una estructura de datos que no cambie, podemos usar tuplas en lugar de listas para evitar modificaciones accidentales. Una vez que se crea una tupla, no podemos modificar sus elementos ni agregar nuevo contenido:
tupla = (1, 2, 3) tupla[0] = 10 # Esto dará un error, ya que no se pueden modificar los elementos de una tupla tupla.append(4) # Esto también dará un error, ya que no se pueden agregar elementos a una tupla
Operaciones con tuplas
Longitud de la tupla
Podemos obtener la longitud de una tupla utilizando la función len():
numeros = (1, 2, 3, 4, 5) longitud = len(numeros) # 5
Concatenación de tuplas
Podemos concatenar dos o más tuplas utilizando el operador +:
tupla1 = (1, 2, 3) tupla2 = (4, 5, 6) concatenada = tupla1 + tupla2 # (1, 2, 3, 4, 5, 6)
Repetición de tuplas
Podemos repetir una tupla utilizando el operador *:
tupla = (1, 2, 3) repetida = tupla * 3 # (1, 2, 3, 1, 2, 3, 1, 2, 3)
Búsqueda en tuplas
Podemos buscar elementos en una tupla utilizando el operador in:
numeros = (1, 2, 3, 4, 5) existe_3 = 3 in numeros # True existe_6 = 6 in numeros # False
Troceado de tuplas (slicing)
Al igual que con las listas, podemos obtener subtuplas (slices) de una tupla utilizando la sintaxis [inicio:fin]:
numeros = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) sub_tupla = numeros[2:6] # (3, 4, 5, 6) tupla_inversa = numeros[::-1] # (10, 9, 8, 7, 6, 5, 4, 3, 2, 1)
Métodos disponibles para las tuplas
Dado que las tuplas son inmutables, no tienen muchos métodos incorporados como las listas. Sin embargo, tienen dos métodos principales:
count()
La función count() nos permite contar cuántas veces aparece un elemento en una tupla:
tupla = (1, 2, 2, 3, 4, 2) contador = tupla.count(2) # 3 (el número 2 aparece 3 veces en la tupla)
index()
La función index() nos permite encontrar el índice de la primera aparición de un elemento en una tupla:
tupla = (10, 20, 30, 40, 50) indice = tupla.index(30) # 2 (el número 30 está en el índice 2 de la tupla)
Convertir tuplas en listas y viceversa
Si necesitamos modificar una tupla, podemos convertirla en una lista, realizar las modificaciones y luego convertirla de nuevo en una tupla:
tupla = (1, 2, 3) lista = list(tupla) # [1, 2, 3] # Realizar modificaciones en la lista (agregar o eliminar elementos) lista.append(4) # [1, 2, 3, 4] # Convertir la lista de vuelta en una tupla tupla_modificada = tuple(lista) # (1, 2, 3, 4)
Por otro lado, si tenemos una lista y queremos evitar modificaciones, podemos convertirla en una tupla:
lista = [1, 2, 3] tupla = tuple(lista) # (1, 2, 3)
Desempaquetado de tuplas
Podemos desempaquetar los elementos de una tupla en variables individuales:
tupla = (10, 20, 30) a, b, c = tupla print(a) # 10 print(b) # 20 print(c) # 30
El desempaquetado de tuplas también se puede usar para intercambiar valores de variables de manera sencilla:
a = 10 b = 20 # Intercambiar los valores de a y b utilizando una tupla a, b = b, a print(a) # 20 print(b) # 10
Iterar sobre tuplas
Podemos utilizar un bucle for para iterar sobre los elementos de una tupla de manera similar a las listas:
numeros = (1, 2, 3, 4, 5)
for numero in numeros:
print(numero)
Comprobación de existencia en tuplas
Al igual que con las listas, podemos utilizar el operador in para comprobar si un elemento está presente en una tupla:
numeros = (1, 2, 3, 4, 5)
if 3 in numeros:
print("El número 3 está en la tupla.")
Tuplas y funciones
A continuación enumeramos algunas ventajas adicionales asociadas al uso de funciones y otros tipos de estructuras de datos que veremos de forma detallada en otras unidades. Hemos creído conveniente exponerlas ahora para ser conscientes del gran potencial que presentan las tuplas de Python.
Retorno de valores
Las tuplas son útiles cuando queremos devolver múltiples valores desde una función:
def dividir_y_restar(a, b):
division = a / b
resta = a - b
return division, resta
resultado = dividir_y_restar(10, 3)
print(resultado) # (3.3333333333333335, 7)
# Desempaquetar los valores de la tupla en variables separadas
division_resultado, resta_resultado = dividir_y_restar(10, 3)
print(division_resultado) # 3.3333333333333335
print(resta_resultado) # 7
Tuplas y funciones con argumentos variables
Las tuplas también son útiles cuando trabajamos con funciones que aceptan argumentos variables:
def suma_todos(*numeros):
total = sum(numeros)
return total
resultado = suma_todos(1, 2, 3, 4, 5)
print(resultado) # 15
# También podemos pasar una tupla como argumento
tupla_numeros = (1, 2, 3, 4, 5)
resultado = suma_todos(*tupla_numeros)
print(resultado) # 15
En este ejemplo, el operador * se utiliza para desempaquetar la tupla y pasar sus elementos como argumentos separados a la función.
Cuándo utilizar tuplas en vez de listas
Las tuplas tienen varias ventajas:
- Inmutabilidad: Al ser inmutables, son más seguras para almacenar datos que no deben cambiar, como fechas, coordenadas o claves de diccionarios.
- Claves de diccionarios: Las tuplas son «hashables», lo que significa que pueden usarse como claves en diccionarios. Las listas, al ser mutables, no son «hashables» y no se pueden utilizar como claves.
- Rendimiento: Las tuplas son ligeramente más rápidas que las listas debido a su inmutabilidad. Si tienes un conjunto de datos que no cambiará, usar tuplas puede ser más eficiente.
- Empaquetado y desempaquetado: Las tuplas permiten un empaquetado y desempaquetado sencillo de elementos.
- Comparación: Las tuplas se pueden comparar directamente, lo que facilita su uso para ordenar o realizar comparaciones.
Tuplas como claves de diccionarios
Hablaremos de los diccionarios en otra unidad, pero queremos anticipar ahora la justificación del uso de tuplas para acceder a nuestros datos. Como hemos mencionado, a diferencia de las listas, las tuplas se pueden utilizar como claves en diccionarios debido a su inmutabilidad. Por ello, cuando necesitamos una clave compuesta por múltiples elementos, las tuplas son la opción más adecuada:
diccionario = {("Juan", 25): "Estudiante", ("María", 30): "Profesora"}
# Acceder al valor utilizando una tupla como clave
valor = diccionario[("Juan", 25)] # "Estudiante"