12. Iteração com loops for e range()

No Capítulo 11, aprendemos sobre loops while, que repetem ações enquanto uma condição permanecer verdadeira. Embora loops while sejam poderosos e flexíveis, eles exigem que a gente gerencie manualmente contadores do loop e atualize condições. O Python fornece outro tipo de loop—o loop for—que se destaca em uma tarefa diferente, mas extremamente comum: processar cada item em uma coleção de dados, um de cada vez.

O loop for é um dos recursos mais usados do Python. Seja processando linhas em um arquivo, calculando estatísticas a partir de uma sequência de números, ou verificando cada caractere em uma string, o loop for oferece uma forma limpa e legível de trabalhar com sequências de dados. Neste capítulo, vamos explorar como loops for funcionam, como usar a função range() do Python para operações de contagem e como controlar a execução do loop com break, continue e a cláusula else, menos conhecida.

12.1) O loop for e conceitos de iteração

12.1.1) O que é um loop for?

Um loop for em Python repete um bloco de código uma vez para cada item em uma sequência. A sequência pode ser uma string, uma lista (que vamos aprender em detalhes no Capítulo 14) ou qualquer outra coleção de itens. A principal diferença em relação a um loop while é que um loop for lida automaticamente com a iteração—você não precisa atualizar manualmente um contador ou verificar uma condição.

Aqui está a estrutura básica de um loop for:

for variable in sequence:
    # Bloco de código a executar para cada item
    # A variável contém o item atual

O loop for funciona assim:

1. O Python pega o primeiro item da sequência e o atribui à variável
2. O bloco de código (indentado sob o comando for) é executado
3. O Python pega o próximo item, o atribui à variável e executa o bloco novamente
4. Isso continua até que todos os itens da sequência tenham sido processados

Vamos ver um exemplo simples com uma string:

# Imprima cada caractere em um nome
name = "Alice"
for character in name:
    print(character)

Output:

A
l
i
c
e

Neste exemplo, a string "Alice" é a sequência. O loop processa cada caractere, um de cada vez. Durante a primeira iteração, character contém 'A', durante a segunda iteração contém 'l', e assim por diante. O nome da variável character é uma escolha nossa—poderíamos chamá-la de letter, char ou até só c. Escolha nomes que deixem claro o propósito do seu código.

Convenções de nomes para variáveis de loop: Ao escrever loops for, escolha nomes de variáveis que descrevam o que cada item representa. Use nomes descritivos como character, student ou score quando o valor for importante para entender seu código. Use i para contadores numéricos simples quando você estiver apenas contando iterações. Use _ (underscore) quando você não precisa do valor—essa é uma convenção do Python que significa “não me importo com este valor”.

Aqui vai um exemplo prático que conta vogais em uma palavra:

# Conte vogais em uma palavra
word = "Python"
vowel_count = 0
 
for letter in word:
    if letter in "aeiouAEIOU":
        vowel_count += 1
        print(f"Found vowel: {letter}")
 
print(f"Total vowels: {vowel_count}")

Output:

Found vowel: o
Total vowels: 1

O loop examina cada letra em "Python". Quando ele encontra uma vogal (usando o operador in que aprendemos no Capítulo 7), ele incrementa o contador e imprime uma mensagem. Esse padrão—inicializar um contador antes do loop e então atualizá-lo dentro—é extremamente comum em programação.

Aqui está outro exemplo que demonstra acumulação ao construir um resultado:

# Conte letras maiúsculas em uma string
text = "Python Programming"
uppercase_count = 0
 
for char in text:
    if char.isupper():
        uppercase_count += 1
 
print(f"Found {uppercase_count} uppercase letters in '{text}'")

Output:

Found 2 uppercase letters in 'Python Programming'

Este exemplo mostra o padrão de acumulação: inicializamos um contador em zero antes do loop, depois examinamos cada caractere e incrementamos o contador quando encontramos uma letra maiúscula. Depois que o loop termina, usamos o resultado acumulado. Esse padrão aparece o tempo todo em programação—contar itens que atendem a certos critérios, somar valores ou ir construindo resultados pouco a pouco.

12.1.2) Entendendo iteração

Iteração (iteration) é o processo de repetir uma ação para cada elemento em uma coleção. Quando dizemos que um objeto é iterável (iterable), queremos dizer que o Python pode processar seus elementos um de cada vez em um loop for. Strings são iteráveis—podemos fazer loop pelos seus caracteres. Como veremos em breve, muitos outros tipos do Python também são iteráveis.

A variável em um loop for (como character ou letter nos nossos exemplos) é chamada de variável do loop (loop variable). Essa variável é criada automaticamente pelo loop for e existe apenas dentro do escopo do loop. A cada passagem pelo loop, o Python atribui o próximo item da sequência a essa variável.

Aqui vai um exemplo que demonstra como a variável do loop muda:

# Mostre como a variável do loop é atualizada
colors = "RGB"  # Vermelho, Verde, Azul
for color_code in colors:
    print(f"Processing color code: {color_code}")
    print(f"  This is iteration for '{color_code}'")

Output:

Processing color code: R
  This is iteration for 'R'
Processing color code: G
  This is iteration for 'G'
Processing color code: B
  This is iteration for 'B'

A cada passagem pelo loop, color_code contém um caractere diferente da string. O loop passa automaticamente para o próximo caractere—não precisamos escrever nenhum código para avançar pela sequência.

12.1.3) Loop for vs loop while para iteração

Poderíamos realizar o mesmo processamento caractere a caractere com um loop while, mas isso exige mais código e gerenciamento manual:

# Usando loop while para iterar sobre uma string (mais complexo)
name = "Alice"
index = 0
while index < len(name):
    character = name[index]
    print(character)
    index += 1  # É preciso atualizar o índice manualmente

Isso produz o mesmo output do nosso exemplo anterior com loop for, mas repare no que tivemos que fazer:

• Criar e inicializar uma variável de índice
• Verificar a condição index < len(name) em cada iteração
• Extrair manualmente o caractere usando name[index]
• Lembrar de incrementar o índice (esquecer isso cria um loop infinito!)

O loop for faz tudo isso automaticamente:

# Usando loop for para iterar sobre uma string (mais simples)
name = "Alice"
for character in name:
    print(character)

Isso é bem mais limpo e menos sujeito a erros. O loop for é a escolha natural quando você quer processar cada item em uma coleção. Use um loop while quando você precisa de mais controle sobre a lógica de iteração ou quando você não sabe de antemão quantas vezes repetir.

12.2) Usando range() para loops de contagem

12.2.1) Apresentando a função range()

Enquanto loops for são ótimos para processar sequências existentes, muitas vezes precisamos repetir uma ação um número específico de vezes—como imprimir uma mensagem cinco vezes ou calcular os dez primeiros números quadrados. A função range() do Python gera uma sequência de números que a gente pode percorrer com um loop for.

A forma mais simples de range() recebe um argumento—o número de inteiros a gerar, começando do 0:

# Imprima números de 0 a 4
for number in range(5):
    print(number)

Output:

0
1
2
3
4

⚠️ Erro comum: Iniciantes frequentemente esperam que range(5) produza 1, 2, 3, 4, 5, mas na verdade ele produz 0, 1, 2, 3, 4. Lembre-se: range(n) começa em 0 e para antes de n. Esse comportamento de “parar antes” é consistente com o slicing do Python, que aprendemos no Capítulo 5. O range começa em 0 (por padrão) e vai até, mas sem incluir, o valor de parada.

Esse padrão é perfeito para repetir uma ação um número específico de vezes:

# Imprima uma saudação cinco vezes
for i in range(5):
    print(f"Welcome! (iteration {i})")

Output:

Welcome! (iteration 0)
Welcome! (iteration 1)
Welcome! (iteration 2)
Welcome! (iteration 3)
Welcome! (iteration 4)

A variável i é um nome comum para um contador de loop (abreviação de “index” ou “iteration”), embora você possa usar qualquer nome de variável válido. Quando o valor da variável do loop não importa para sua lógica, i é uma escolha convencional.

12.2.2) Especificando valores de início e fim

Você pode fornecer dois argumentos para range() para especificar tanto onde começar quanto onde parar:

# Imprima números de 1 a 5
for number in range(1, 6):
    print(number)

Output:

1
2
3
4
5

Aqui, range(1, 6) começa em 1 e para antes de 6, nos dando os números de 1 a 5. Isso é útil quando você precisa contar a partir de um valor diferente de zero.

Vamos usar isso para calcular uma tabela de multiplicação simples:

# Imprima a tabuada do 7 de 1 a 10
multiplier = 7
for number in range(1, 11):
    result = multiplier * number
    print(f"{multiplier} × {number} = {result}")

Output:

7 × 1 = 7
7 × 2 = 14
7 × 3 = 21
7 × 4 = 28
7 × 5 = 35
7 × 6 = 42
7 × 7 = 49
7 × 8 = 56
7 × 9 = 63
7 × 10 = 70

O loop vai de 1 a 10, multiplicando cada número por 7. Isso demonstra como range() facilita fazer cálculos em cima de uma sequência numérica específica.

12.2.3) Usando um valor de passo

A função range() aceita um terceiro argumento opcional: o valor de passo (step), que determina quanto aumentar (ou diminuir) entre números:

# Imprima números pares de 0 a 10
for number in range(0, 11, 2):
    print(number)

Output:

0
2
4
6
8
10

Com range(0, 11, 2), começamos em 0, paramos antes de 11 e aumentamos de 2 em 2. Isso nos dá todos os números pares de 0 a 10.

Você também pode usar um passo negativo para contar de trás para frente:

# Contagem regressiva de 10 a 1
for number in range(10, 0, -1):
    print(number)
print("Liftoff!")

Output:

10
9
8
7
6
5
4
3
2
1
Liftoff!

Aqui, range(10, 0, -1) começa em 10, para antes de 0 e diminui de 1 em 1. O passo negativo faz o range contar ao contrário.

Vamos ver um exemplo prático que calcula a soma de todos os números ímpares de 1 a 100:

# Some todos os números ímpares de 1 a 100
total = 0
for number in range(1, 101, 2):  # Começa em 1, passo de 2
    total += number
 
print(f"Sum of odd numbers from 1 to 100: {total}")

Output:

Sum of odd numbers from 1 to 100: 2500

Ao usar range(1, 101, 2), geramos apenas os números ímpares (1, 3, 5, ..., 99), evitando a necessidade de checar a paridade de cada número dentro do loop. Isso deixa o código mais eficiente e com intenção mais clara.

12.2.4) O que range() realmente retorna

A função range() não cria uma lista de números na memória—ela cria um objeto range (range object) que gera números sob demanda. Isso é eficiente em termos de memória, especialmente para ranges grandes:

# range() retorna um objeto range, não uma lista
numbers = range(1000000)
print(type(numbers))  # Output: <class 'range'>
print(numbers)        # Output: range(0, 1000000)

Output:

<class 'range'>
range(0, 1000000)

Mesmo que esse range represente um milhão de números, ele usa pouquíssima memória porque o Python não cria de fato todos os milhões de números até você iterar sobre eles. Cada número é gerado apenas quando necessário pelo loop.

Se você precisar de uma lista de números de verdade, pode converter o range:

# Converta range em uma lista
small_numbers = list(range(5))
print(small_numbers)  # Output: [0, 1, 2, 3, 4]

Output:

[0, 1, 2, 3, 4]

Vamos aprender mais sobre listas e a função list() no Capítulo 14. Por enquanto, basta saber que range() funciona perfeitamente com loops for sem precisar de conversão.

12.3) Iterando sobre strings e outras sequências

12.3.1) Iterando sobre strings caractere por caractere

Já vimos vários exemplos de iteração sobre strings. Esse é um dos usos mais comuns de loops for porque strings são sequências de caracteres, e frequentemente precisamos examinar ou processar cada caractere individualmente.

Aqui vai um exemplo que valida uma senha verificando se ela contém pelo menos um dígito:

# Verifique se uma senha contém pelo menos um dígito
password = "secure123"
has_digit = False
 
for character in password:
    if character.isdigit():
        has_digit = True
        print(f"Found digit: {character}")
 
if has_digit:
    print("Password contains at least one digit ✓")
else:
    print("Password must contain at least one digit ✗")

Output:

Found digit: 1
Found digit: 2
Found digit: 3
Password contains at least one digit ✓

O loop examina cada caractere usando o método de string .isdigit() (que aprendemos no Capítulo 5). Quando ele encontra um dígito, define has_digit como True. Depois que o loop termina, verificamos a flag para determinar se algum dígito foi encontrado.

Aqui vai outro exemplo prático que conta diferentes tipos de caracteres:

# Analise tipos de caracteres em uma string
text = "Hello, World! 123"
letters = 0
digits = 0
spaces = 0
other = 0
 
for char in text:
    if char.isalpha():
        letters += 1
    elif char.isdigit():
        digits += 1
    elif char.isspace():
        spaces += 1
    else:
        other += 1
 
print(f"Letters: {letters}")
print(f"Digits: {digits}")
print(f"Spaces: {spaces}")
print(f"Other: {other}")

Output:

Letters: 10
Digits: 3
Spaces: 2
Other: 2

Esse loop categoriza cada caractere usando métodos de string que aprendemos no Capítulo 5. A cadeia if-elif-else (do Capítulo 8) garante que cada caractere seja contado em exatamente uma categoria.

12.3.2) Processando strings com índices

Às vezes você precisa tanto do caractere quanto da sua posição na string. Você pode usar range(len(string)) para iterar sobre os índices:

# Encontre posições de um caractere específico
text = "Mississippi"
search_char = "s"
 
print(f"Looking for '{search_char}' in '{text}':")
for index in range(len(text)):
    if text[index] == search_char:
        print(f"  Found at index {index}")

Output:

Looking for 's' in 'Mississippi':
  Found at index 2
  Found at index 3
  Found at index 5
  Found at index 6

O loop itera pelos índices de 0 até len(text) - 1. Para cada índice, verificamos se o caractere naquela posição corresponde ao caractere que estamos procurando. Essa abordagem é útil quando você precisa saber onde algo aparece, não apenas que aparece.

12.3.3) Iterando sobre outros tipos de sequência

O loop for funciona com qualquer sequência iterável em Python. Embora tenhamos focado em strings neste capítulo, você vai aprender sobre outros tipos de sequência em capítulos posteriores. Por exemplo, o Capítulo 14 vai ensinar sobre listas (list), que são coleções ordenadas capazes de armazenar múltiplos valores de qualquer tipo. A sintaxe do loop for continua a mesma independentemente do tipo de sequência que você está iterando—o loop lida automaticamente com a obtenção de cada item da sequência.

12.4) Usando break e continue em loops for

12.4.1) O comando break em loops for

Assim como nos loops while (Capítulo 11), o comando break sai imediatamente de um loop for, pulando quaisquer iterações restantes. Isso é útil quando você encontrou o que estava procurando e não precisa continuar buscando.

Aqui vai um exemplo que procura por um caractere específico:

# Procure a primeira vogal em uma string
text = "Python"
found_vowel = False
 
for char in text:
    if char.lower() in "aeiou":
        print(f"First vowel found: {char}")
        found_vowel = True
        break  # Pare de procurar assim que encontrar a primeira vogal
 
if not found_vowel:
    print("No vowels found")

Output:

First vowel found: o

Sem break, o loop continuaria examinando todos os caracteres restantes mesmo depois de encontrar a primeira vogal. O comando break torna o código mais eficiente ao parar assim que a tarefa é concluída.

Aqui vai um exemplo prático que valida a entrada do usuário verificando caracteres inválidos:

# Verifique se um nome de usuário contém apenas caracteres permitidos
username = "alice_123"
allowed = "abcdefghijklmnopqrstuvwxyz0123456789_"
is_valid = True
 
for char in username:
    if char.lower() not in allowed:
        print(f"Invalid character found: '{char}'")
        is_valid = False
        break  # Não há necessidade de verificar mais
 
if is_valid:
    print(f"Username '{username}' is valid ✓")
else:
    print(f"Username '{username}' is invalid ✗")

Output:

Username 'alice_123' is valid ✓

O loop verifica cada caractere em relação ao conjunto permitido. Se ele encontra um caractere inválido, relata o problema e sai do loop imediatamente—não faz sentido verificar o resto do nome de usuário quando já sabemos que ele é inválido.

12.4.2) O comando continue em loops for

O comando continue pula o restante da iteração atual e passa para o próximo item da sequência. Isso é útil quando você quer pular certos itens sem sair do loop completamente.

Aqui vai um exemplo que processa apenas certos caracteres:

# Imprima apenas consoantes de uma string
word = "Programming"
 
for letter in word:
    if letter.lower() in "aeiou":
        continue  # Pule vogais
    print(letter, end="")
print()  # Nova linha no final

Output:

Prgrmmng

Quando o loop encontra uma vogal, continue pula o comando print() e vai para o próximo caractere. Apenas consoantes chegam ao print.

Aqui vai um exemplo mais prático que calcula estatísticas enquanto pula dados inválidos. Note que o método .split() (do Capítulo 6) retorna uma lista de strings, que vamos aprender no Capítulo 14. Por enquanto, apenas saiba que loops for podem iterar sobre o resultado:

# Calcule a média de notas de teste válidas (0-100)
# O método .split() retorna uma lista de strings (Capítulo 14)
scores_input = "85 92 -5 78 105 90 88"
valid_scores = 0
total = 0
 
for score_str in scores_input.split():
    score = int(score_str)
    
    if score < 0 or score > 100:
        print(f"Skipping invalid score: {score}")
        continue  # Pule esta nota
    
    valid_scores += 1
    total += score
 
if valid_scores > 0:
    average = total / valid_scores
    print(f"Average of {valid_scores} valid scores: {average:.1f}")
else:
    print("No valid scores to average")

Output:

Skipping invalid score: -5
Skipping invalid score: 105
Average of 5 valid scores: 86.6

O loop processa cada string de nota. Quando ele encontra uma nota inválida (negativa ou acima de 100), ele imprime um aviso e usa continue para pular a adição dessa nota ao total. Isso permite que o loop processe todas as notas válidas enquanto ignora as inválidas.

12.4.3) Quando usar break e continue

Use break quando:

• Você está procurando por algo e quer parar assim que encontrar
• Você encontrou uma condição de erro que torna inútil continuar
• Você completou sua tarefa e não precisa processar os itens restantes

Use continue quando:

• Você quer pular certos itens com base em uma condição
• Você está filtrando dados e quer processar apenas itens que atendem a critérios
• Você quer evitar if muito aninhados ao lidar com casos especiais cedo

Tanto break quanto continue podem deixar seu código mais claro ao mostrar explicitamente quando e por que você está mudando o fluxo normal da iteração. Porém, usar demais pode tornar o código mais difícil de acompanhar—use quando realmente melhorar a clareza.

12.5) Usando else com loops for

12.5.1) O padrão for-else

Os loops for do Python suportam uma cláusula opcional else que executa depois que o loop termina normalmente—isto é, quando o loop termina de iterar por todos os itens sem encontrar um comando break. Isso pode parecer estranho no começo (por que “else” se não há “if”?), mas é útil para distinguir entre “encontrei o que estava procurando” e “procurei em tudo e não encontrei”.

Aqui está a estrutura básica:

for item in sequence:
    # Corpo do loop
    if some_condition:
        break
else:
    # Isso executa apenas se o loop terminou sem dar break
    print("Loop completed normally")

O bloco else roda se, e somente se, o loop sair naturalmente por esgotar a sequência. Se um comando break sair do loop mais cedo, o bloco else é ignorado.

Vamos ver um exemplo prático que procura um valor específico. O método .split() (do Capítulo 6) retorna uma lista de strings, que vamos aprender no Capítulo 14:

# Procure um número alvo
numbers = "2 4 6 8 10"
target = 7
 
for num_str in numbers.split():
    num = int(num_str)
    if num == target:
        print(f"Found {target}!")
        break
else:
    print(f"{target} not found in the sequence")

Output:

7 not found in the sequence

O loop busca em todos os números. Como ele nunca encontra 7, ele termina normalmente e o bloco else é executado. Agora vamos procurar um número que existe:

# Procure um número alvo que existe
numbers = "2 4 6 8 10"
target = 6
 
for num_str in numbers.split():
    num = int(num_str)
    if num == target:
        print(f"Found {target}!")
        break
else:
    print(f"{target} not found in the sequence")

Output:

Found 6!

Desta vez, quando o loop encontra 6, ele executa break, que pula o bloco else completamente. Esse padrão lida elegantemente com os casos “encontrou” e “não encontrou” sem precisar de uma variável flag separada.

12.5.2) Usos práticos de for-else

O padrão for-else é particularmente útil para operações de busca. Aqui vai um exemplo que valida se uma string contém apenas dígitos:

# Verifique se uma string é um inteiro válido
user_input = "12345"
 
for char in user_input:
    if not char.isdigit():
        print(f"Invalid: '{char}' is not a digit")
        break
else:
    print(f"'{user_input}' is a valid integer")

Output:

'12345' is a valid integer

Se a entrada contiver qualquer caractere que não seja dígito, o loop dá break e o bloco else não roda. Se todos os caracteres forem dígitos, o loop termina normalmente e o bloco else confirma a validade.

Vamos testar com uma entrada inválida:

# Verifique se uma string é um inteiro válido (caso inválido)
user_input = "123a5"
 
for char in user_input:
    if not char.isdigit():
        print(f"Invalid: '{char}' is not a digit")
        break
else:
    print(f"'{user_input}' is a valid integer")

Output:

Invalid: 'a' is not a digit

12.5.3) Comparando for-else com variáveis flag

Antes de aprender sobre for-else, você pode ter usado uma variável flag para rastrear se algo foi encontrado:

# Usando uma variável flag (abordagem tradicional)
text = "Python"
found_vowel = False
 
for char in text:
    if char.lower() in "aeiou":
        print(f"Found vowel: {char}")
        found_vowel = True
        break
 
if not found_vowel:
    print("No vowels found")

Output:

Found vowel: o

O padrão for-else elimina a necessidade da variável flag:

# Usando for-else (mais Pythonic)
text = "Python"
 
for char in text:
    if char.lower() in "aeiou":
        print(f"Found vowel: {char}")
        break
else:
    print("No vowels found")

Output:

Found vowel: o

Ambas as abordagens funcionam corretamente, mas a versão for-else é mais concisa e expressa com clareza a intenção: “procure por algo e, se não encontrar, faça isto”. A cláusula else representa diretamente o caso “não encontrado”.

12.6) Escolhendo entre loops for e while

12.6.1) Quando usar um loop for

Use um loop for quando:

1. Você estiver processando cada item em uma coleção:

# Processando cada caractere em uma string
message = "Hello"
for char in message:
    print(char.upper())

Output:

H
E
L
L
O

2. Você precisa repetir uma ação um número específico de vezes:

# Imprima uma linha de borda
for i in range(40):
    print("-", end="")
print()

Output:

----------------------------------------

3. Você estiver iterando sobre um intervalo numérico:

# Calcule o fatorial de 5
factorial = 1
for n in range(1, 6):
    factorial *= n
print(f"5! = {factorial}")

Output:

5! = 120

4. Você sabe com antecedência o que está iterando:

# Processe uma sequência conhecida de valores
grades = "A B C D F"
for grade in grades.split():
    print(f"Grade: {grade}")

Output:

Grade: A
Grade: B
Grade: C
Grade: D
Grade: F

A principal característica de loops for é que eles trabalham com iteração definida (definite iteration)—você sabe qual sequência está iterando, mesmo que não saiba de antemão quantos itens ela contém.

12.6.2) Quando usar um loop while

Use um loop while quando:

1. Você estiver repetindo até uma condição mudar:

# Continue perguntando até receber uma entrada válida
while True:
    age_input = input("Enter your age: ")
    if age_input.isdigit():
        age = int(age_input)
        if age > 0:
            print(f"Age recorded: {age}")
            break
    print("Please enter a valid positive number")

2. Você não sabe quantas iterações vai precisar:

# Conte quantas vezes você consegue dobrar um número antes de passar de 1000
number = 1
count = 0
while number <= 1000:
    number *= 2
    count += 1
print(f"Doubled {count} times to reach {number}")

Output:

Doubled 10 times to reach 1024

3. A iteração depende de condições complexas:

# Simule um jogo simples em que a vida do jogador diminui
health = 100
turn = 0
 
while health > 0 and turn < 10:
    damage = 15
    health -= damage
    turn += 1
    print(f"Turn {turn}: Health = {health}")
 
if health <= 0:
    print("Game over!")
else:
    print("Survived 10 turns!")

Output:

Turn 1: Health = 85
Turn 2: Health = 70
Turn 3: Health = 55
Turn 4: Health = 40
Turn 5: Health = 25
Turn 6: Health = 10
Turn 7: Health = -5
Game over!

4. Você precisa de mais controle sobre a lógica de iteração:

# Processe uma string, mas pule duplicatas consecutivas
text = "bookkeeper"
index = 0
 
while index < len(text):
    char = text[index]
    print(char, end="")
    
    # Pule caracteres idênticos consecutivos
    while index < len(text) and text[index] == char:
        index += 1
 
print()

Output:

bokeper

A principal característica de loops while é a iteração indefinida (indefinite iteration)—você continua até que uma condição se torne falsa, mas pode não saber de antemão quando isso vai acontecer.

12.6.3) Convertendo entre for e while

Muitos problemas podem ser resolvidos com qualquer um dos tipos de loop. Aqui está a mesma tarefa implementada das duas formas:

# Usando loop for: some números de 1 a 10
total = 0
for number in range(1, 11):
    total += number
print(f"Sum (for loop): {total}")
 
# Usando loop while: some números de 1 a 10
total = 0
number = 1
while number <= 10:
    total += number
    number += 1
print(f"Sum (while loop): {total}")

Output:

Sum (for loop): 55
Sum (while loop): 55

Ambos produzem o mesmo resultado, mas o loop for é mais conciso e menos propenso a erros—não há risco de esquecer de incrementar o contador. Quando você puder usar qualquer um, prefira o loop for.

No entanto, alguns problemas são mais naturalmente expressos com while:

# Encontre a primeira potência de 2 maior que 1000
power = 1
exponent = 0
 
while power <= 1000:
    exponent += 1
    power = 2 ** exponent
 
print(f"2^{exponent} = {power} (first power of 2 > 1000)")

Output:

2^10 = 1024 (first power of 2 > 1000)

Esse problema não se encaixa naturalmente em um loop for porque não sabemos de antemão quantas iterações precisamos—estamos procurando um valor que atenda a uma condição.

Neste capítulo, exploramos o loop for do Python, que oferece uma forma limpa e poderosa de iterar sobre sequências. Aprendemos como range() gera sequências numéricas para operações de contagem, como controlar o fluxo do loop com break e continue e como o padrão for-else lida elegantemente com operações de busca. Também analisamos quando escolher loops for versus loops while com base na natureza da sua tarefa de iteração.

O loop for é um dos recursos mais usados do Python. À medida que você continuar aprendendo Python, você vai usar loops for constantemente—processando dados de arquivos, trabalhando com listas e dicionários e transformando coleções de informação. No próximo capítulo, vamos explorar o comando match do Python, que oferece outra forma de tomar decisões com base em valores, fornecendo uma alternativa mais estruturada a longas cadeias de if-elif para certos tipos de problemas.