O que é iteração?

Um programa que envia um e-mail de lembrete para 10.000 usuários não contém 10.000 cópias do código de envio. Ele contém o código uma vez, dentro de um loop, e o loop o executa uma vez por usuário. Cada execução é uma iteração, e o loop como um todo é a forma como o programa itera sobre os seus usuários.

Como a iteração funciona, passo a passo

Todo loop segue o mesmo ciclo:

1. Verificar. Testar a condição do loop, que é um booleano: existe outro item, ou o contador ainda está abaixo do limite?
2. Executar. Se a resposta for verdadeira, executar o corpo do loop uma vez.
3. Atualizar. Passar para o próximo item ou mudar o contador.
4. Repetir. Voltar ao passo 1. Quando a verificação der falso, o programa continua com o código que vem depois do loop.

Aqui o corpo executa cinco vezes, e cada iteração soma o próximo número a um total acumulado:

total = 0

for n in range(1, 6):
    total = total + n
    print("iteration", n, "total is now", total)

print("Done:", total)

iteration 1 total is now 1
iteration 2 total is now 3
iteration 3 total is now 6
iteration 4 total is now 10
iteration 5 total is now 15
Done: 15

A variável total fica fora do loop, então ela mantém o seu valor de uma iteração para a outra. Esse padrão, uma variável definida antes do loop e atualizada dentro dele, se chama acumulador, e aparece em quase todo loop que calcula alguma coisa.

Loops de contagem e loops de condição

Existem dois tipos de iteração. A iteração definida executa um número conhecido de vezes: uma vez por item de uma lista, ou uma vez para cada número de 1 a 5. O loop for do Python foi feito para isso, muitas vezes junto com range().

A iteração indefinida repete até que algo aconteça, e o número de passagens não é conhecido de antemão. Um loop while serve para esse caso:

balance = 100
years = 0

while balance < 200:
    balance = balance * 1.10
    years = years + 1

print(years, "years, balance", round(balance, 2))

8 years, balance 214.36

Um dinheiro que rende 10% ao ano leva 8 anos para dobrar. O programa descobriu isso iterando, não resolvendo uma equação. Os guias de loops for e loops while cobrem os dois em Python.

Iterando sobre uma coleção

A maioria dos loops percorre uma coleção: os elementos de um array, os caracteres de uma string, as linhas de um arquivo. O loop for do Python entrega cada elemento diretamente, e enumerate() acrescenta a sua posição:

fruits = ["apple", "banana", "cherry"]

for index, fruit in enumerate(fruits):
    print(index, fruit)

0 apple
1 banana
2 cherry

Por baixo dos panos, o for pede à coleção um iterador com iter() e depois chama next() nele uma vez por iteração. Você mesmo pode fazer essas chamadas:

colors = ["red", "green", "blue"]

it = iter(colors)
print(next(it))
print(next(it))
print(next(it))
print(next(it, "no more items"))

red
green
blue
no more items

Sem o valor padrão, o quarto next() lança StopIteration. Essa exceção é o sinal que o loop for usa para saber que a coleção terminou.

Outras linguagens escrevem a mesma ideia de outro jeito. C conta com um índice, enquanto Java e JavaScript também têm um loop que entrega cada elemento:

for (int i = 0; i < 3; i++) {
    printf("%s\n", colors[i]);
}

for (String color : colors) {
    System.out.println(color);
}

for (const color of colors) {
    console.log(color);
}

Iteração vs recursão

A recursão é a outra forma de repetir um trabalho: uma função chama a si mesma com uma versão menor do problema até chegar a um caso que ela consegue responder diretamente. Tudo o que se escreve com uma pode ser escrito com a outra, mas elas se comportam de forma diferente:

A linha da memória faz diferença na prática. O Python permite cerca de 1.000 chamadas aninhadas por padrão, então uma soma recursiva de 5.000 números falha onde um loop não tem problema nenhum:

def sum_loop(n):
    total = 0
    for k in range(1, n + 1):
        total = total + k
    return total

def sum_recursive(n):
    if n == 0:
        return 0
    return n + sum_recursive(n - 1)

print(sum_loop(100), sum_recursive(100))
print(sum_loop(5000))

try:
    print(sum_recursive(5000))
except RecursionError:
    print("sum_recursive(5000) failed: RecursionError")

5050 5050
12502500
sum_recursive(5000) failed: RecursionError

A visualização de recursão mostra a pilha de chamadas crescendo e diminuindo passo a passo.

Erros comuns

O loop infinito. Um loop while cuja condição nunca fica falsa executa até você parar o programa. A causa comum é esquecer o passo de atualização, como deixar de fora count = count - 1.

Erro de um a mais (off by one). range(1, 5) dá 1, 2, 3 e 4, não 5, porque o valor final fica de fora. Um loop que executa uma vez a mais ou a menos ainda roda sem erro e dá uma resposta errada, o que é um erro de lógica.

Alterar uma lista enquanto a percorre. Remover itens da lista sobre a qual você está iterando faz o loop pular elementos:

numbers = [1, 2, 2, 3]

for n in numbers:
    if n == 2:
        numbers.remove(n)

print(numbers)

[1, 2, 3]

Um 2 sobrou, porque remover o primeiro 2 empurrou o segundo para uma posição pela qual o loop já tinha passado. Monte uma lista nova: numbers = [n for n in numbers if n != 2].

Para onde ir agora

Os loops percorrem coleções, então o que é um array é a página que acompanha esta naturalmente, e o que é um booleano explica as verificações de verdadeiro ou falso que decidem quando um loop para. Quando um loop dá o resultado errado sem nenhuma mensagem de erro, leia o que é um erro de lógica. Para praticar loops, comece o curso de Python ou experimente os exemplos acima no playground de Python.