Loops sobre elementos de tuplas

14.1 Loop for

Em Python, percorrer os elementos de uma tupla geralmente é feito usando o loop for. Esse é o jeito mais comum, que permite acessar cada elemento da tupla e executar um bloco de código para ele.

Loop for

O loop for percorre cada elemento da tupla, atribuindo temporariamente o valor do elemento atual a uma variável, especificada após a palavra-chave for. Exemplo:

my_tuple = (1, 2, 3, 4, 5)
for number in my_tuple:
    print(number)

Você já tem experiência com listas e o loop for, então vamos dar uma olhada em alguns exemplos práticos:

Exemplo 1: Somando elementos da tupla

Vamos ver um exemplo onde somamos todos os elementos de uma tupla.

my_tuple = (10, 20, 30, 40, 50)
total = 0

for number in my_tuple:
    total += number

print(f"Soma dos elementos da tupla: {total}")

Neste exemplo, criamos uma tupla my_tuple e uma variável total para armazenar a soma dos elementos. Usando o loop for, iteramos por cada elemento da tupla e o adicionamos ao total. No final, temos a soma de todos os elementos da tupla.

Exemplo 2: Encontrando o elemento máximo

Agora vamos ver um exemplo de como encontrar o elemento máximo em uma tupla.

my_tuple = (5, 17, 23, 11, 2)
max_value = my_tuple[0]

for number in my_tuple:
    if number > max_value:
        max_value = number

print(f"Valor máximo na tupla: {max_value}")

Nesse exemplo, inicializamos a variável max_value com o primeiro elemento da tupla. Em seguida, iteramos por todos os elementos da tupla, comparando cada elemento com o valor máximo atual e atualizando max_value, se encontrarmos um valor maior.

14.2 Tuplas Aninhadas

Tuplas podem conter outras tuplas, e o loop for pode ser usado para iterar por essas estruturas de dados aninhadas.

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

for inner_tuple in nested_tuple:
    for number in inner_tuple:
        print(number, end=' ')
    print()

Neste exemplo, nested_tuple contém tuplas. Usamos loops for aninhados para iterar por cada elemento das tuplas internas. Resultado da execução:

1 2 3 
4 5 6 
7 8 9 

14.3 Loop for com Índices

Assim como em listas, os elementos de uma tupla têm índices, então você pode percorrer os elementos usando o loop for (combinado com a função range()). Isso permite trabalhar não só com os próprios elementos, mas também com suas posições, o que pode ser necessário para manipulações mais complexas com dados.

Noções Básicas de Iteração com Índices

Para iterar sobre uma tupla com acesso ao índice de cada elemento, você pode usar um código como:

my_tuple = ('a', 'b', 'c', 'd')
for i in range(len(my_tuple)):
    print(f'index: {i}, Element: {my_tuple[i]}')

Vantagens de Usar Índices

Com índices, é fácil implementar algoritmos que exigem acesso simultâneo a vários elementos da tupla, como comparar o elemento atual com o anterior ou o próximo.

Exemplo:

my_tuple = (15, 20, 23, 18, 22, 19, 21)
for i in range(1, len(my_tuple)):
    if my_tuple[i] > my_tuple[i - 1]:  # Comparamos o elemento com o anterior
        print(f'{my_tuple[i]} é maior que {my_tuple[i - 1]}')

Usando o loop for com índices para processar dados

Suponha que temos uma tupla com dados de temperatura de uma semana e queremos calcular a temperatura média, excluindo valores extremos (a temperatura mais baixa e a mais alta).

temperatures = (15, 20, 23, 18, 22, 19, 21)
sorted_temps = sorted(temperatures)

# Excluímos a primeira e a última temperatura
filtered_temps = sorted_temps[1:-1]

average_temp = sum(filtered_temps) / len(filtered_temps)
print(f"Temperatura média da semana (sem valores extremos): {average_temp}")

14.4 Usando a Função enumerate()

Em Python, a função enumerate() oferece uma maneira conveniente de iterar sobre os elementos de uma tupla com acesso simultâneo aos seus índices. Isso é especialmente útil quando é necessário processar tanto o índice quanto o valor do elemento da lista dentro do loop.

Noções Básicas da Função enumerate()

A função enumerate() envolve a tupla em um objeto especial e retorna um iterador que gera pares de tuplas de valores, consistindo no índice e no valor do elemento da tupla:

my_tuple = ('apple', 'banana', 'cherry')
for index, element in enumerate(my_tuple):
    print(f'index: {index}, Element: {element}')

Agora você tem não só o elemento, mas também seu índice.

Vantagens do enumerate()

Usar enumerate() torna o código mais legível e evita a necessidade de gerenciar manualmente os índices usando range(len(…)). Isso simplifica a manipulação dos elementos da lista, como alteração, acesso aos elementos e realização de verificações condicionais.

Exemplos de Uso

Às vezes, é preciso encontrar todos os índices onde um determinado valor aparece na tupla.

my_tuple = (1, 2, 3, 2, 4, 2, 5)
search_value = 2
indices = []

for index, value in enumerate(my_tuple):
    if value == search_value:
        indices.append(index)

print(f"Valor {search_value} aparece nos índices: {indices}")

Este código encontrará todos os índices onde o valor 2 aparece na tupla:

Valor 2 aparece nos índices: [1, 3, 5]

Filtragem de Dados Baseada em Índices

Vamos considerar um exemplo onde filtramos dados com base nos índices, deixando apenas os elementos com índices pares.

my_tuple = ('a', 'b', 'c', 'd', 'e', 'f')

filtered_tuple = tuple(value for index, value in enumerate(my_tuple) if index % 2 == 0)
print(f"Tupla com elementos em índices pares: {filtered_tuple}")

Este código cria uma nova tupla contendo apenas os elementos com índices pares:

Tupla com elementos em índices pares: ('a', 'c', 'e')