1.5 – ¿Qué es una tupla?

Autor:

ciberkaos

– Tema:

Python

– Publicado:

febrero 26, 2026

– Actualizado:

febrero 26, 2026

Contenido

Slicing (rebanado)
Ejercicios

Las tuplas son criaturas curiosas del ecosistema Python. Parecen listas… pero no lo son. Son inmutables, compactas y muy seguras. Cuando algo en tu programa no debe cambiar jamás, una tupla es la cápsula criogénica perfecta.

Una tupla (tuple) es una colección ordenada e inmutable de elementos.

Ordenada → mantiene el orden de inserción
Inmutable → no se puede modificar tras crearla
Permite duplicados
Puede contener distintos tipos

La inmutabilidad las hace más rápidas, más seguras y más ligeras que las listas.

Crear una tupla

mi_tupla = (1, 2, 3, 4, 5)

También se puede crear sin paréntesis:

mi_tupla = 1, 2, 3, 4, 5

Tupla vacía:

vacia = ()

Tuplas de un solo elemento

Detalle clásico que rompe cerebros:

tupla = (42,)   # Correcto
no_tupla = (42) # Es un entero, NO una tupla

La coma es obligatoria.

Acceso a elementos

Por índice

t = (10, 20, 30, 40)
print(t[0])    # 10
print(t[-1])   # 40

Slicing (rebanado)

t = (10, 20, 30, 40, 50)
print(t[1:4])   # (20, 30, 40)
print(t[:3])    # (10, 20, 30)
print(t[::2])   # (10, 30, 50)

El slicing devuelve otra tupla.

Métodos de las tuplas

Las tuplas tienen pocos métodos porque no se pueden modificar.

count(x)

Cuenta cuántas veces aparece un valor.

t = (1,2,3,2,2)
print(t.count(2))   # 3

index(x)

Devuelve la posición del primer valor encontrado.

t = (10,20,30,40)
print(t.index(30))   # 2

Si no existe → error.

Funciones útiles con tuplas

t = (10,20,30,40)
len(t)   # tamaño
min(t)   # mínimo
max(t)   # máximo
sum(t)   # suma (si numéricos)

Concatenar y repetir tuplas

Concatenar

t1 = (1,2,3)
t2 = (4,5,6)t3 = t1 + t2
print(t3)

Repetir

t = (1,2,3)
print(t * 2)

Convertir entre lista y tupla

Las tuplas no se pueden modificar, pero puedes convertirlas:

t = (10,20,30)lista = list(t)
lista.append(40)t = tuple(lista)
print(t)

Este es el truco clásico para “modificar” tuplas.

Desempaquetado de tuplas

Una de sus habilidades más elegantes.

t = (10, 20, 30)a, b, c = t
print(a, b, c)

Desempaquetado extendido

t = (1,2,3,4,5)a, *medio, b = t
print(a)      # 1
print(medio)  # [2,3,4]
print(b)      # 5

Python convierte automáticamente el resto en lista.

Verificar pertenencia

t = (10,20,30)print(20 in t)   # True
print(99 in t)   # False

Recorrer tuplas

for valor in (1,2,3):
    print(valor)

Con índice:

t = (10,20,30)for i, v in enumerate(t):
    print(i, v)

Por qué usar tuplas

Usa tuplas cuando:

Los datos no deben cambiar
Quieres seguridad frente a modificaciones accidentales
Necesitas mejor rendimiento
Quieres usar datos como claves en diccionarios (las listas no pueden)

Ejemplo real:

coordenada = (40.4168, -3.7038)

Diferencia clave: lista vs tupla

Característica	Lista	Tupla
Mutable	Sí	No
Velocidad	Más lenta	Más rápida
Memoria	Más	Menos
Métodos	Muchos	Pocos
Seguridad	Baja	Alta

Errores comunes

Intentar modificar una tupla:

t = (1,2,3)
t[0] = 9   # TypeError

Olvidar la coma en tupla de un elemento.

Ejemplo práctico

mi_tupla = (10, 20, 30, 40, 50)print(mi_tupla[1])
print(mi_tupla.index(30))
print(mi_tupla.count(20))lista = list(mi_tupla)
lista.append(60)mi_tupla = tuple(lista)
print(mi_tupla)

Salida:

(10, 20, 30, 40, 50, 60)

Métodos principales de las tuplas en Python

Método	Qué hace	Ejemplo	Resultado
`count(x)`	Cuenta cuántas veces aparece un valor	`(1,2,2,3).count(2)`	`2`
`index(x)`	Devuelve el índice del primer valor encontrado	`(10,20,30).index(20)`	`1`

Funciones útiles con tuplas

(No son métodos propios de la tupla, pero se usan constantemente)

Función	Qué hace	Ejemplo	Resultado
`len(t)`	Número de elementos	`len((1,2,3))`	`3`
`min(t)`	Valor mínimo	`min((5,2,9))`	`2`
`max(t)`	Valor máximo	`max((5,2,9))`	`9`
`sum(t)`	Suma de elementos numéricos	`sum((1,2,3))`	`6`
`sorted(t)`	Devuelve lista ordenada	`sorted((3,1,2))`	`[1,2,3]`
`tuple(iterable)`	Convierte iterable a tupla	`tuple([1,2,3])`	`(1,2,3)`
`list(t)`	Convierte tupla a lista	`list((1,2,3))`	`[1,2,3]`

Operaciones comunes con tuplas

Operación	Qué hace	Ejemplo	Resultado
`t1 + t2`	Concatenar tuplas	`(1,2) + (3,4)`	`(1,2,3,4)`
`t * n`	Repetir tupla	`(1,2) * 2`	`(1,2,1,2)`
`x in t`	Verificar pertenencia	`2 in (1,2,3)`	`True`
`x not in t`	Verificar ausencia	`9 in (1,2,3)`	`False`