Dominando Tuplas en Python: Creación, Acceso y Operaciones Avanzadas

Tuplas en Python

Descubre el poder de las tuplas en Python: secuencias inmutables que ofrecen velocidad, seguridad y versatilidad para datos heterogéneos. Esta guía cubre desde la sintaxis básica hasta operaciones avanzadas.

Video: Listas y Tuplas en Python

Una tupla se comporta como una lista pero es inmutable una vez creada. A diferencia de las listas, no puedes alterar sus elementos, lo que hace a las tuplas ideales para conjuntos de datos fijos.

---

Crear una Tupla

Las tuplas se definen colocando valores separados por comas dentro de paréntesis (). Aunque los paréntesis son opcionales, mejoran la legibilidad.

Las tuplas pueden contener cualquier número de elementos y mezclar tipos de datos: enteros, floats, cadenas, listas, otras tuplas, etc.

# Diferentes tipos de tuplas
# Tupla vacía
my_tuple = ()
print(my_tuple)
# Tupla con enteros
my_tuple = (1, 2, 3)
print(my_tuple)
# Tipos de datos mixtos
my_tuple = (1, "Hola", 3.4)
print(my_tuple)
# Tupla anidada
my_tuple = ("ratón", [8, 4, 6], (1, 2, 3))
print(my_tuple)

Salida

() (1, 2, 3) (1, 'Hola', 3.4) ('ratón', [8, 4, 6], (1, 2, 3))

Las tuplas también pueden crearse sin paréntesis, una técnica llamada tuple packing.

my_tuple = 3, 4.6, "perro"
print(my_tuple)
# Desempaquetado de tupla
a, b, c = my_tuple
print(a)
print(b)
print(c)

Salida

(3, 4.6, 'perro') 3 4.6 perro

Cuando una tupla contiene un solo elemento, se requiere una coma final para distinguirla de un valor simple.

my_tuple = ("hola")
print(type(my_tuple))  # <class 'str'>
# Tupla de un elemento
my_tuple = ("hola",)
print(type(my_tuple))  # <class 'tuple'>
# Paréntesis opcionales
my_tuple = "hola",
print(type(my_tuple))  # <class 'tuple'>

Salida

<class 'str'> <class 'tuple'> <class 'tuple'>

---

Acceder a Elementos de la Tupla

Las tuplas soportan varios métodos para acceso a elementos:

1. Indexación

Usa el operador de índice [] con índices base cero. Acceso fuera de rango lanza IndexError; índices no enteros lanzan TypeError.

# Ejemplo de indexación
my_tuple = ('p','e','r','m','i','t')
print(my_tuple[0])  # 'p'
print(my_tuple[5])  # 't'
# Indexación anidada
n_tuple = ("ratón", [8, 4, 6], (1, 2, 3))
print(n_tuple[0][3])  # 's'
print(n_tuple[1][1])  # 4

Salida

p t s 4

2. Indexación Negativa

Los índices negativos cuentan desde el final: -1 es el último elemento.

# Indexación negativa
my_tuple = ('p', 'e', 'r', 'm', 'i', 't')
print(my_tuple[-1])  # 't'
print(my_tuple[-6])  # 'p'

Salida

t p

3. Slicing

Usa sintaxis inicio:fin para extraer sub-tuplas.

# Ejemplo de slicing
my_tuple = ('p','r','o','g','r','a','m','i','z')
print(my_tuple[1:4])   # ('r', 'o', 'g')
print(my_tuple[:-7])   # ('p', 'r')
print(my_tuple[7:])    # ('i', 'z')
print(my_tuple[:])     # tupla completa

Salida

('r', 'o', 'g') ('p', 'r') ('i', 'z') ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')

---

Modificar una Tupla

Las tuplas son inmutables. La asignación directa a un elemento lanza TypeError:

# Intentando modificación
my_tuple = (4, 2, 3, [6, 5])
# my_tuple[1] = 9  # TypeError

Sin embargo, si un elemento es mutable (ej. una lista), su estado interno puede cambiar:

my_tuple[3][0] = 9
print(my_tuple)  # (4, 2, 3, [9, 5])

Las tuplas pueden reasignarse a un nuevo valor completamente:

my_tuple = ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
print(my_tuple)

Usa + para concatenación y * para repetición; ambas devuelven una nueva tupla.

print((1, 2, 3) + (4, 5, 6))  # (1, 2, 3, 4, 5, 6)
print(("Repetir",) * 3)       # ('Repetir', 'Repetir', 'Repetir')

Salida

(1, 2, 3, 4, 5, 6) ('Repetir', 'Repetir', 'Repetir')

---

Eliminar una Tupla

No se pueden eliminar elementos individuales. La tupla completa se puede borrar con del:

my_tuple = ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
# del my_tuple[3]  # TypeError
del my_tuple
# print(my_tuple)  # NameError

Salida

Traceback (most recent call last): File "<string>", line 12, in <module> NameError: name 'my_tuple' is not defined

---

Métodos de Tupla

Las tuplas solo exponen dos métodos integrados: count() y index().

my_tuple = ('a', 'p', 'p', 'l', 'e')
print(my_tuple.count('p'))  # 2
print(my_tuple.index('l'))  # 3

Salida

2 3

---

Operaciones Adicionales con Tuplas

1. Prueba de Pertenencia

Verifica existencia con la palabra clave in.

my_tuple = ('a', 'p', 'p', 'l', 'e')
print('a' in my_tuple)
print('b' in my_tuple)
print('g' not in my_tuple)

Salida

True False True

2. Iteración

Recorre tuplas con for:

for nombre in ('Juan', 'María'):
    print("Hola", nombre)

Salida

Hola Juan Hola María

3. Ventajas sobre Listas

• Ideales para datos heterogéneos; las listas suelen ser homogéneas.
• La inmutabilidad da ventaja de rendimiento en iteración.
• Tuplas con solo elementos inmutables pueden servir como claves de diccionario.
• Datos protegidos contra escritura, evitando modificaciones accidentales.