Ahora vamos a explorar las tuplas, otra estructura de datos secuencial en Python que comparte similitudes con las listas, pero con una diferencia fundamental: la inmutabilidad.

Creación de Tuplas:

Las tuplas se pueden crear de varias maneras:

1. Usando paréntesis (): Se encierran los elementos separados por comas dentro de paréntesis. Aunque los paréntesis son opcionales en muchos casos, se recomienda usarlos para mayor claridad.

   Python

    

   tupla_vacia = ()
   tupla_un_elemento = (5,)  # ¡Ojo con la coma al final para tuplas de un solo elemento!
   tupla_numeros = (1, 2, 3, 4, 5)
   tupla_cadenas = ("manzana", "banana", "cereza")
   tupla_mixta = (1, "hola", 3.14, True)
   tupla_sin_parentesis = 10, 20, 30  # Esto también crea una tupla
   

2. Usando la función tuple(): Se puede convertir un iterable (como una lista, cadena o rango) en una tupla.

   Python

   lista = [1, 2, 3]
   tupla_desde_lista = tuple(lista)  # (1, 2, 3)
   
   cadena = "python"
   tupla_desde_cadena = tuple(cadena)  # ('p', 'y', 't', 'h', 'o', 'n')
   
   rango = range(5)
   tupla_desde_rango = tuple(rango)  # (0, 1, 2, 3, 4)
   

Inmutabilidad de las Tuplas:

La característica principal que distingue a las tuplas de las listas es su inmutabilidad. Una vez que se crea una tupla, no se pueden modificar los elementos que contiene:

• No se pueden añadir nuevos elementos.
• No se pueden eliminar elementos existentes.
• No se pueden modificar los elementos existentes (reasignar un nuevo valor a un índice).

Intentar realizar estas operaciones en una tupla generará un error (TypeError).

mi_tupla = (1, 2, 3)

# Intentar modificar un elemento generará un error:
# mi_tupla[0] = 10  # TypeError: 'tuple' object does not support item assignment

# Intentar añadir un elemento generará un error:
# mi_tupla.append(4) # AttributeError: 'tuple' object has no attribute 'append'

# Intentar eliminar un elemento generará un error:
# del mi_tupla[1]   # TypeError: 'tuple' object doesn't support item deletion

Usos de las Tuplas:

A pesar de su inmutabilidad, las tuplas son muy útiles en diversas situaciones:

1. Representación de datos fijos: Cuando necesitas almacenar una secuencia de elementos que no deberían cambiar durante la ejecución del programa. Esto puede ser útil para representar coordenadas (x, y), registros (nombre, edad, ciudad), o cualquier conjunto de valores relacionados que permanecen constantes.

   Python

    

   coordenadas = (10, 20)
   persona = ("Ana", 30, "Madrid")
   colores_rgb = (255, 0, 0)  # Rojo
   

2. Devolver múltiples valores desde una función: Las funciones en Python pueden devolver múltiples valores en forma de tupla. Esto es una forma concisa y legible de agrupar valores relacionados que son el resultado de una operación.

   Python

    

   def obtener_estadisticas(numeros):
       minimo = min(numeros)
       maximo = max(numeros)
       suma = sum(numeros)
       return minimo, maximo, suma  # Devuelve una tupla
   
   datos = [1, 5, 2, 8, 3]
   min_val, max_val, total = obtener_estadisticas(datos)
   print(f"Mínimo: {min_val}, Máximo: {max_val}, Suma: {total}")
   

3. Uso como claves en diccionarios: Debido a su inmutabilidad, las tuplas pueden utilizarse como claves en diccionarios (a diferencia de las listas, que son mutables y por lo tanto no hashables). Esto permite crear estructuras de datos más complejas donde una combinación de valores actúa como un identificador único.

   Python

    

   puntos = {
       (0, 0): "Origen",
       (1, 2): "Punto A",
       (-1, 3): "Punto B"
   }
   print(puntos[(1, 2)])  # Salida: Punto A
   

4. Desempaquetado de secuencias: Las tuplas (y las listas) se pueden desempaquetar fácilmente en variables individuales.

   Python

    

   coordenadas = (10, 20)
   x, y = coordenadas
   print(f"x = {x}, y = {y}")  # Salida: x = 10, y = 20
   
   persona = ("Ana", 30, "Madrid")
   nombre, edad, ciudad = persona
   print(f"Nombre: {nombre}, Edad: {edad}, Ciudad: {ciudad}")
   

5. Rendimiento (en ciertos casos): En algunas situaciones, las operaciones en tuplas pueden ser ligeramente más rápidas que en listas debido a su naturaleza estática. Sin embargo, la diferencia suele ser pequeña y no es el principal factor para elegir entre ellas.

Similitudes con las Listas:

A pesar de su inmutabilidad, las tuplas comparten algunas operaciones con las listas:

• Acceso a elementos por índice: Se utilizan los mismos corchetes [] para acceder a los elementos.
• Slicing: Se pueden obtener subconjuntos de una tupla utilizando la notación de slicing (por ejemplo, mi_tupla[1:3]).
• Iteración: Se pueden recorrer los elementos de una tupla con bucles for.
• Operadores de pertenencia (in, not in).
• Funciones como len(), min(), max(), sum() pueden utilizarse con tuplas.

En resumen:

Las tuplas son secuencias inmutables de elementos. Son útiles para representar datos fijos, devolver múltiples valores de funciones, usarse como claves de diccionario y para el desempaquetado de secuencias. Su inmutabilidad garantiza que los datos permanezcan constantes a lo largo del programa.