Loop em Tuplas em Python

Percorrer uma tupla permite visitar cada elemento um de cada vez e agir sobre ele. Como as tuplas são sequências imutáveis — seu conteúdo não pode ser alterado — iterá-las é seguro e direto. Esta página aborda todas as técnicas comuns: loops for, loops while, enumerate(), range(len()), zip(), travessia de tuplas aninhadas e controle de loop com break/continue.

Se você é novo em tuplas, leia Python Tuples primeiro. Para a sintaxe geral de loops, veja Python For Loops e Python While Loops.

Usando um Loop for

A forma mais simples e Pythônica de iterar sobre uma tupla é o loop for. Python percorre cada elemento em ordem e o atribui à variável do loop.

Percorrer uma tupla com um loop for

Saída:

1
2
3
4
5

O loop termina automaticamente quando chega ao último elemento — nenhuma aritmética de índice é necessária.

Usando um Loop while

Um loop while oferece controle manual sobre o índice. É útil quando você precisa avançar ou retroceder mais de um passo, ou quando a condição de parada depende de algo diferente do comprimento da tupla.

Percorrer uma tupla com um loop while

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

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

Saída:

apple
banana
cherry

Sempre incremente i dentro do corpo do loop; caso contrário, o loop será executado para sempre.

Acessando o Índice com enumerate()

Quando você precisa tanto da posição quanto do valor, use enumerate(). Ele envolve cada elemento com seu índice de base zero e retorna ambos juntos.

Percorrer uma tupla usando enumerate

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

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

Saída:

0 red
1 green
2 blue

Você pode começar a contar a partir de qualquer número passando um segundo argumento:

Iniciar o enumerate a partir de 1

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

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

Saída:

1 red
2 green
3 blue

enumerate() é preferível a range(len()) sempre que você precisa do índice e do valor, pois é mais legível e evita o passo extra de indexação.

Acessando o Índice com range(len())

Um padrão mais antigo, mas ainda válido, usa range(len()) para gerar os índices válidos e depois acessa cada elemento por posição.

Percorrer uma tupla usando range e len

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

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

Saída:

0 apple
1 banana
2 cherry

Essa abordagem é útil quando você precisa comparar elementos adjacentes ou modificar uma lista derivada com base na posição, pois tanto o índice quanto o valor estão disponíveis ao mesmo tempo.

Iterando Sobre Tuplas Aninhadas

Uma tupla pode conter outras tuplas. Use um loop for aninhado para acessar os valores internos.

Iterar sobre uma tupla aninhada (matriz)

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

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

Saída:

1 2 3 
4 5 6 
7 8 9 

Cada iteração do loop externo fornece uma tupla interna (row). O loop interno então percorre essa tupla interna elemento por elemento.

Você também pode desempacotar a tupla interna diretamente no cabeçalho do loop se o formato for fixo:

Desempacotar tuplas internas durante o loop

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

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

Saída:

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

Isso torna o código quase legível como inglês simples e evita subscritos row[0] / row[1]. Para mais sobre desempacotamento, veja Unpack Tuples.

Iterando Sobre Duas Tuplas em Paralelo com zip()

zip() emparelha elementos de duas (ou mais) tuplas por posição e permite desempacotá-los em um único loop.

Iterar sobre duas tuplas em paralelo

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

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

Saída:

Alice 95
Bob 87
Carol 92

zip() para assim que a tupla mais curta é esgotada, portanto comprimentos diferentes não geram um erro — eles são silenciosamente truncados. Se você precisar de todos os pares e quiser preencher as lacunas, use itertools.zip_longest() da biblioteca padrão.

Controle de Loop: break e continue

Parando Cedo com break

break sai do loop imediatamente quando uma condição é atendida.

Parar um loop de tupla cedo com break

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

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

Saída:

1
2
3

O loop imprime 1, 2, 3 e então para ao encontrar 4.

Pulando Elementos com continue

continue salta para a próxima iteração sem executar o código restante no corpo do loop.

Pular números pares usando continue

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

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

Saída:

1
3
5

Apenas os números ímpares são impressos; os números pares são silenciosamente pulados.

Construindo uma Lista a Partir de um Loop de Tupla

Como as tuplas são imutáveis, você não pode alterá-las no lugar. Um padrão comum é iterar sobre uma tupla e coletar resultados em uma nova lista.

Criar uma lista de quadrados a partir de uma tupla

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

Saída:

[1, 4, 9, 16, 25]

A compreensão de lista itera sobre a tupla assim como um loop for e é mais concisa para transformações simples. Veja Python Tuples e Tuple Methods para mais informações sobre como trabalhar com dados de tupla.

Quando Usar Cada Técnica

Prática