break, continue e o else dos laços em Python

O break encerra o laço na hora, o continue abandona o resto da volta atual e passa para a próxima, e o else do laço é um bloco que roda só quando o laço termina sem ter sido interrompido por um break. Os três funcionam do mesmo jeito no for e no while, e juntos resolvem as buscas, os filtros e as tentativas limitadas, que são a maior parte do que se faz com laços.

Este artigo fecha o módulo de repetição. O break já apareceu no artigo sobre o faça-enquanto, e o continue num exemplo curto do for e range. Aqui eles são vistos de frente: o que cada comando faz com o fluxo, o else que quase ninguém conhece, a armadilha do continue dentro do while, como sair de dois laços e como esses comandos entram nos programas de ESP32.

Três comandos, três destinos

A figura mostra um laço de cinco voltas em três situações. Sem nenhum desvio, as cinco voltas rodam e o laço termina de forma normal. Com um continue na volta 3, o resto daquela volta é pulado e o laço segue para a 4, e o final continua normal. Com um break na volta 3, o laço acaba ali: as voltas 4 e 5 não rodam, e o programa salta para depois do laço.

O que diferencia as duas saídas à direita é o else. Ele roda no fim normal, nas duas primeiras fileiras, e não roda quando o laço foi interrompido, na terceira. As seções a seguir detalham cada comando.

break: parar quando já achou

O break serve para parar de procurar quando a resposta já apareceu. Continuar o laço depois disso seria trabalho jogado fora:

for n in range(51, 100):
    if n % 7 == 0:
        print("primeiro multiplo de 7 acima de 50:", n)
        break
print("fim")

A saída é primeiro multiplo de 7 acima de 50: 56 e fim. O laço testa 51, 52, 53, 54, 55 e 56, e o break interrompe na sexta volta, sem olhar os números de 57 a 99. O programa continua na primeira linha sem recuo depois do for. A mesma ideia vale para o while, como no artigo sobre o faça-enquanto, em que o break é a saída do while True.

continue: pular a volta de hoje

O continue interrompe só a volta atual. O Python salta para a próxima volta, que no for é o próximo valor e no while é o teste da condição.

for n in range(1, 8):
    if n % 3 == 0:
        continue
    print(n)
print("fim")

A saída é 1, 2, 4, 5, 7 e fim. Quando n é múltiplo de 3, o continue pula o print e o laço vai direto para o valor seguinte. O 3 e o 6 não aparecem. O desafio Múltiplos de 5 e o Pares de 1 a 10 pedem filtros assim, e podem ser resolvidos com continue ou com um if em volta do print.

Aliás, o continue quase sempre pode ser trocado por um if. A escolha é de legibilidade. Quando o filtro é uma recusa no começo do corpo ("se o valor não serve, passe para o próximo"), o continue evita que o resto do corpo fique aninhado dentro de um if, e cada nível de recuo a menos é um ganho de leitura.

O que vier depois do continue ou do break no mesmo bloco nunca roda, e o Python não avisa:

for i in range(3):
    print(i)
    if i == 1:
        continue
        print("nunca aparece")

A saída é 0, 1 e 2, sem a mensagem. A linha depois do continue é código morto. Se algo que devia acontecer sumiu, olhe se ele ficou depois de um desses comandos.

A armadilha do continue no while

No for, o próximo valor vem do range, e o continue não consegue atrapalhá-lo. No while, quem muda a variável do teste é o código do próprio programa, e o continue pode pular exatamente essa linha:

i = 0
voltas = 0
while i < 5 and voltas < 8:
    voltas += 1
    if i == 2:
        continue
    print(i)
    i += 1
print("voltas", voltas, "i", i)
print("---")
i = 0
while i < 5:
    i += 1
    if i == 3:
        continue
    print(i)

A saída tem 0, 1, a linha voltas 8 i 2, a separação e 1, 2, 4, 5. Na primeira versão, quando i chega a 2, o continue volta ao teste sem passar pelo i += 1, e o i fica preso em 2 para sempre. O voltas < 8 é uma trava que corta o laço para o exemplo terminar: sem ela, o programa não acabaria. Na segunda versão, o i += 1 vem antes do if, e o continue só pula o print. A regra prática é atualizar a variável do teste antes de qualquer continue.

O else do laço

O Python permite um else: depois de um for ou de um while. O nome engana quem pensa no else do if: o do laço significa "se o laço terminou sem break". Ele é a resposta de "não achei":

for n in (3, 8, 12, 7):
    if n % 2 == 0:
        print("primeiro par", n)
        break
else:
    print("nenhum par")
for n in (3, 5, 7):
    if n % 2 == 0:
        print("primeiro par", n)
        break
else:
    print("nenhum par")

A saída é primeiro par 8 e nenhum par. No primeiro laço, o 8 é par, o break roda e o else é ignorado. No segundo, nenhum valor é par, o break nunca roda, o laço acaba sozinho e o else executa. A figura abaixo destaca a coluna do else.

Repare no alinhamento. O else do laço fica na mesma coluna do for, e não na do if de dentro. Quem alinha o else ao if troca a pergunta: em vez de "não achei", o programa passa a perguntar, a cada volta, "este valor não é par?". O resultado muda:

for n in (3, 8, 12, 7):
    if n % 2 == 0:
        print("par", n)
        break
    else:
        print("impar", n)

A saída é impar 3 e par 8. O else aqui é o do if, e roda em cada volta cujo n é ímpar. Os dois programas parecem iguais a olho nu, e a única diferença é o recuo de uma linha.

Números primos com for e else

O exemplo clássico do else do laço é o teste de número primo. Um número é primo se nenhum divisor entre 2 e n - 1 o divide. O laço procura um divisor, e o else diz que não achou:

for n in (1, 2, 9, 13, 15, 17):
    if n < 2:
        print(n, "nao e primo")
        continue
    for d in range(2, n):
        if n % d == 0:
            print(n, "divisivel por", d)
            break
    else:
        print(n, "primo")

A saída é 1 nao e primo, 2 primo, 9 divisivel por 3, 13 primo, 15 divisivel por 3 e 17 primo. O exemplo junta os três comandos. O continue descarta o 1 sem entrar no laço de dentro. O break interrompe a busca no primeiro divisor, e o else do laço de dentro responde "primo" quando a busca termina sem achar. Para o 2, o range(2, 2) é vazio e o laço de dentro não roda nenhuma vez, mas o else roda, e o 2 sai como primo, que é o resultado certo.

O else do while

O while tem o mesmo else, com a mesma regra:

tentativas = 0
while tentativas < 3:
    tentativas += 1
    print("tentativa", tentativas)
else:
    print("else: acabaram as tentativas")
print("---")
n = 0
while n > 0:
    print("nao roda")
else:
    print("else roda mesmo com zero voltas")
print("---")
tentativas = 0
while tentativas < 3:
    tentativas += 1
    if tentativas == 2:
        print("achou na", tentativas)
        break
else:
    print("else nao aparece")

A saída tem as três tentativas e else: acabaram as tentativas, depois else roda mesmo com zero voltas e, na última parte, só achou na 2. O else roda quando a condição do while dá False, inclusive na primeira vez, e não roda quando o break interrompe. Num while True, o único jeito de sair é o break, então o else nunca roda e não faz sentido escrevê-lo.

O for sobre um grupo vazio também executa o else, e o comando pass, que não faz nada, serve de marcador onde a sintaxe exige um bloco:

for n in (1, 2, 3):
    pass
else:
    print("else sem break")
for n in ():
    print("nao roda")
else:
    print("else com grupo vazio")
x = 5
if x > 3:
    pass
print("pass nao faz nada")

A saída é else sem break, else com grupo vazio e pass nao faz nada.

Sair de dois laços de uma vez

O break sai só do laço onde está. Com laços aninhados, o de fora continua, como no artigo anterior. Para sair dos dois, o jeito mais direto é uma variável de controle:

achou = False
for i in range(3):
    for j in range(3):
        if i * j == 4:
            achou = True
            break
    if achou:
        break
print(i, j, achou)

A saída é 2 2 True. O break de dentro interrompe o for j e marca achou. O if achou do laço de fora interrompe o for i logo em seguida. Quando as funções chegarem na série, outra saída será colocar os dois laços numa função e usar return, que sai de tudo.

O que muda na ESP32

Os três comandos são os mesmos do Python do computador. Em hardware, o par continue e break com o else do laço descreve bem as tentativas de leitura. O exemplo tenta ler um sensor até três vezes, e o else trata o caso de todas falharem:

leituras = (None, None, 23.5)
for tentativa in range(3):
    valor = leituras[tentativa]
    if valor is None:
        print("tentativa", tentativa + 1, "sem leitura")
        continue
    print("leitura", valor)
    break
else:
    print("sem leitura apos 3 tentativas")
print("---")
leituras = (None, None, None)
for tentativa in range(3):
    valor = leituras[tentativa]
    if valor is None:
        print("tentativa", tentativa + 1, "sem leitura")
        continue
    print("leitura", valor)
    break
else:
    print("sem leitura apos 3 tentativas")

Na primeira parte, a saída é tentativa 1 sem leitura, tentativa 2 sem leitura e leitura 23.5. Na segunda, as três tentativas falham e o else imprime sem leitura apos 3 tentativas. A tupla leituras faz o papel do sensor, que na placa viria de um dht ou de um ADC, e None quer dizer "sem resposta". O continue descarta a tentativa ruim, o break aceita a boa, e o else só roda quando nenhuma serviu. O artigo sobre sensores DHT22, HC-SR04 e PIR mostra leituras reais, que falham de vez em quando.

O mesmo continue serve para descartar leituras fora da faixa antes de calcular a média:

leituras = (512, -1, 530, 4096, 498)
soma = 0
validas = 0
for v in leituras:
    if v < 0 or v > 4095:
        print("descartada", v)
        continue
    soma = soma + v
    validas = validas + 1
print("media", soma / validas, "de", validas)

A saída é descartada -1, descartada 4096 e media 513.3333 de 3. A faixa de 0 a 4095 é a do conversor analógico da ESP32 (assunto do artigo sobre ADC e atenuação), e valores fora dela são leituras defeituosas. O simulador mostra 513.3333, com o float de 32 bits, e o Python do computador mostraria 513.3333333333334. Se todas as leituras fossem descartadas, validas ficaria em 0 e a divisão daria erro, o mesmo cuidado do if contador > 0 do artigo sobre o while.

Erros comuns e como reconhecê-los

O continue fora de um laço é erro de sintaxe, e a mensagem varia:

continue

Traceback (most recent call last):
  File "main.py", line 1
SyntaxError: 'break'/'continue' outside loop

O Python do computador diz SyntaxError: 'continue' not properly in loop para o continue e 'break' outside loop para o break. O sintoma costuma ser o mesmo: o comando perdeu o recuo e foi parar na margem, fora do laço. Os outros erros do artigo são de lógica, e o Python não acusa nenhum.

Em sala de aula: onde estes comandos costumam tropeçar

Os casos abaixo se repetem nas turmas, e em todos o programa roda.

O else na coluna errada

É o caso do impar 3 e do par 8: o else alinhado ao if em vez de ao for. O programa imprime "não achei" a cada volta, e o aluno acha que o laço está repetindo errado. A conferência é visual: o else do laço começa na mesma coluna do for ou do while.

O continue que trava o while

A versão do i preso em 2. O sintoma é o programa que "para de repente", sem erro e sem saída. A pergunta é: o continue passa por cima da linha que atualiza a variável?

Confundir continue e break

O break sai do laço, o continue só da volta. Quem troca um pelo outro descobre pelo resultado: um programa que para cedo demais, ou que não para. A figura das três fileiras é um bom resumo para rever.

Código depois do break ou do continue

A mensagem que nunca aparece, a soma que não acontece. O Python executa as linhas em ordem, e o que está depois de um desses comandos, no mesmo bloco, é ignorado.

O else onde não precisava

Nem toda busca precisa de else. Uma variável achou, como no exemplo dos dois laços, deixa o código mais fácil de ler para quem não conhece o else do laço, e vale usar quando o grupo de leitores do programa for misto. O else do laço é uma ferramenta limpa, mas é uma das partes menos conhecidas do Python.

Esquecer o caso do zero

A média sem leituras válidas, a busca em grupo vazio. O else do for roda no grupo vazio, e a divisão por validas quebra se ele for 0. Em todo laço com filtro, vale perguntar o que acontece quando o filtro recusa tudo.

Exercício: quantos primos até 30

Reaproveitando o teste de primo, o programa percorre os números de 2 a 30, mostra os primos e conta quantos são. O for de dentro procura um divisor, o break interrompe a busca e o else do laço de dentro registra o primo.

total = 0
for n in range(2, 31):
    for d in range(2, n):
        if n % d == 0:
            break
    else:
        print(n, end=" ")
        total = total + 1
print()
print("primos ate 30:", total)

A saída é a lista 2 3 5 7 11 13 17 19 23 29 numa linha, e depois primos ate 30: 10. Para melhorar, troque o range(2, n) do laço de dentro por range(2, n // 2 + 1), que testa só até a metade de n, e confirme que a lista é a mesma. O ganho de tempo aparece em números grandes, e vale a pena medir.

Perguntas frequentes

O else do laço é igual ao else do if?

Não. O do if roda quando a condição é falsa. O do laço roda quando o laço termina sem break. A escrita é a mesma, e o significado é outro.

O continue funciona dentro de um if?

Funciona: ele age sobre o laço que envolve o if. Quase sempre aparece dentro de um if, que é quem decide quando pular.

Posso usar break dentro de um if dentro de um for dentro de outro for?

Pode, e ele sai só do for mais próximo. Os laços de fora seguem rodando, a menos que você os interrompa também.

Para que serve o pass?

Para ocupar um bloco que a sintaxe exige e que ainda não tem nada. Um if sem corpo é erro, e um if com pass é aceito e não faz nada. É útil como marcador enquanto se escreve o programa.

Quando usar o else do laço em vez de uma variável?

Quando o laço procura algo e o programa precisa reagir ao caso de não achar. Se o leitor do código não conhece o else do laço, uma variável como achou costuma ser mais clara.

Para continuar

A trilha Lógica com Python tem desafios que usam laços com filtro. O Contador de positivos e o Maior número pedem decisões dentro de um laço, os Pares de 1 a 10 e os Múltiplos de 5 são bons para praticar o continue. Para a base, releia o artigo sobre o while.

Com isto o módulo de repetição está completo: o programa já decide e repete. O próximo assunto abre o módulo de funções, com def, a chamada de uma função e a divisão de um programa em partes pequenas.