Recorrer Tuplas en Python

Recorrer una tupla te permite visitar cada elemento de uno en uno y operar sobre él. Dado que las tuplas son secuencias inmutables — su contenido no puede cambiar — iterar sobre ellas es seguro y sencillo. Esta página cubre todas las técnicas comunes: bucles for, bucles while, enumerate(), range(len()), zip(), recorrido de tuplas anidadas y control de bucles con break/continue.

Si eres nuevo en las tuplas, lee primero Python Tuples. Para conocer la sintaxis general de los bucles, consulta Python For Loops y Python While Loops.

Uso de un Bucle for

La forma más sencilla y pythónica de iterar sobre una tupla es un bucle for. Python recorre cada elemento en orden y lo asigna a la variable del bucle.

Recorrer una tupla con un bucle for

Salida:

1
2
3
4
5

El bucle termina automáticamente al llegar al último elemento — no se requieren operaciones aritméticas con índices.

Uso de un Bucle while

Un bucle while te da control manual sobre el índice. Es útil cuando necesitas avanzar o retroceder más de un paso, o cuando la condición de parada depende de algo distinto a la longitud de la tupla.

Recorrer una tupla con un bucle while

my_tuple = ('apple', 'banana', 'cherry')
i = 0

while i < len(my_tuple):
    print(my_tuple[i])
    i += 1

Salida:

apple
banana
cherry

Siempre incrementa i dentro del cuerpo del bucle; de lo contrario, el bucle se ejecutará indefinidamente.

Acceder al Índice con enumerate()

Cuando necesitas tanto la posición como el valor, usa enumerate(). Envuelve cada elemento con su índice de base cero y devuelve ambos juntos.

Recorrer una tupla usando enumerate

colors = ('red', 'green', 'blue')

for index, color in enumerate(colors):
    print(index, color)

Salida:

0 red
1 green
2 blue

Puedes comenzar a contar desde cualquier número pasando un segundo argumento:

Iniciar enumerate desde 1

colors = ('red', 'green', 'blue')

for index, color in enumerate(colors, start=1):
    print(index, color)

Salida:

1 red
2 green
3 blue

enumerate() es preferible a range(len()) cuando necesitas tanto el índice como el valor, porque es más legible y evita el paso adicional de indexación.

Acceder al Índice con range(len())

Un patrón más antiguo pero igualmente válido utiliza range(len()) para generar los índices válidos y luego accede a cada elemento por posición.

Recorrer una tupla usando range y len

fruits = ('apple', 'banana', 'cherry')

for i in range(len(fruits)):
    print(i, fruits[i])

Salida:

0 apple
1 banana
2 cherry

Este enfoque es útil cuando necesitas comparar elementos adyacentes o modificar una lista derivada según la posición, ya que tanto el índice como el valor están disponibles al mismo tiempo.

Iteración Sobre Tuplas Anidadas

Una tupla puede contener otras tuplas. Usa un bucle for anidado para acceder a los valores internos.

Iterar sobre una tupla anidada (matriz)

matrix = ((1, 2, 3), (4, 5, 6), (7, 8, 9))

for row in matrix:
    for value in row:
        print(value, end=' ')
    print()

Salida:

1 2 3 
4 5 6 
7 8 9 

Cada iteración del bucle externo te entrega una tupla interna (row). El bucle interno recorre esa tupla interna elemento por elemento.

También puedes desempaquetar la tupla interna directamente en el encabezado del bucle si la forma es fija:

Desempaquetar tuplas internas al recorrer

points = ((0, 0), (1, 2), (3, 4))

for x, y in points:
    print(f'x={x}, y={y}')

Salida:

x=0, y=0
x=1, y=2
x=3, y=4

Esto hace que el código sea casi tan legible como el inglés natural y evita los subíndices row[0] / row[1]. Para más información sobre el desempaquetado, consulta Unpack Tuples.

Recorrer Dos Tuplas en Paralelo con zip()

zip() empareja elementos de dos (o más) tuplas por posición y te permite desempaquetarlos en un solo bucle.

Recorrer dos tuplas en paralelo

names = ('Alice', 'Bob', 'Carol')
scores = (95, 87, 92)

for name, score in zip(names, scores):
    print(name, score)

Salida:

Alice 95
Bob 87
Carol 92

zip() se detiene en cuanto se agota la tupla más corta, por lo que las longitudes desiguales no generan un error — se truncan silenciosamente. Si necesitas todos los pares y quieres rellenar los huecos, usa itertools.zip_longest() de la biblioteca estándar en su lugar.

Control de Bucles: break y continue

Detención Anticipada con break

break sale del bucle inmediatamente cuando se cumple una condición.

Detener un bucle sobre una tupla con break

numbers = (1, 2, 3, 4, 5, 6)

for n in numbers:
    if n == 4:
        break
    print(n)

Salida:

1
2
3

El bucle imprime 1, 2, 3 y luego se detiene al encontrar el 4.

Omitir Elementos con continue

continue salta a la siguiente iteración sin ejecutar el código restante del cuerpo del bucle.

Omitir números pares usando continue

numbers = (1, 2, 3, 4, 5, 6)

for n in numbers:
    if n % 2 == 0:
        continue
    print(n)

Salida:

1
3
5

Solo se imprimen los números impares; los números pares se omiten silenciosamente.

Construir una Lista a Partir de un Bucle sobre una Tupla

Dado que las tuplas son inmutables, no puedes modificarlas directamente. Un patrón común es iterar sobre una tupla y recopilar los resultados en una nueva lista.

Crear una lista de cuadrados a partir de una tupla

numbers = (1, 2, 3, 4, 5)
squares = [n ** 2 for n in numbers]
print(squares)

Salida:

[1, 4, 9, 16, 25]

La comprensión de lista itera sobre la tupla igual que un bucle for y es más concisa para transformaciones simples. Consulta Python Tuples y Tuple Methods para más información sobre cómo trabajar con datos de tuplas.

Cuándo Usar Cada Técnica

Práctica