if, elif e else em Python: várias faixas e condições aninhadas

O elif permite que o programa escolha entre três ou mais caminhos numa só estrutura. Ele funciona como um "senão, se": o Python testa a primeira condição, depois a segunda, depois a terceira, e executa o bloco da primeira que for verdadeira, ignorando todas as outras. O else no final cobre o que sobrou. Quando uma decisão só faz sentido depois de outra, o bloco pode conter um if dentro dele, e isso se chama condição aninhada.

O artigo anterior apresentou o if e o else, que escolhem entre dois caminhos e levantam a primeira questão de quem programa: o recuo. Este mostra como crescer para mais caminhos sem escrever uma pilha de ifs que se atropelam, por que a ordem das condições muda o resultado, como aninhar com segurança e quais problemas aparecem mais nas aulas.

O problema: duas opções não bastam

Uma escola converte a nota de zero a dez em conceito: de 9 para cima, A; de 7 a menos de 9, B; de 6 a menos de 7, C; abaixo disso, D. São quatro caminhos, e o if com else só distingue dois. A tentação é empilhar ifs, um por conceito, e a seção sobre ordem mostra o que acontece quando se faz isso. Por ora, vale lembrar do que a decisão precisa: uma lista de perguntas, em ordem, em que a primeira resposta "sim" decide e as demais deixam de importar.

É exatamente o que o elif faz. A estrutura completa tem um if no começo, quantos elif forem necessários e, se quiser, um else no final.

O elif: a escada de testes

for nota in (10, 9, 8.5, 7, 6, 5.99, 0):
    if nota >= 9:
        conceito = "A"
    elif nota >= 7:
        conceito = "B"
    elif nota >= 6:
        conceito = "C"
    else:
        conceito = "D"
    print(nota, conceito)

A saída é 10 A, 9 A, 8.5 B, 7 B, 6 C, 5.99 D e 0 D. O for percorre as notas, uma por vez, e o bloco if e elif roda para cada uma. Repare nos limites: a nota 9 é A, e a nota 7 é B, porque o teste é >=. A nota 5.99 fica em D, mesmo estando a um centésimo do C. Cada condição só precisa dizer o limite de baixo, porque o limite de cima já foi tratado pelos testes anteriores: quando o programa chega ao nota >= 7, ele já sabe que a nota é menor que 9, senão o primeiro teste teria decidido.

Cada elif tem a mesma anatomia do if: a palavra, a condição, os dois-pontos e o bloco recuado. O else continua sem condição e continua opcional. Dá para ter if com elif e sem else, e nesse caso, se nenhum teste for verdadeiro, nenhum bloco roda e o programa segue adiante.

Três if soltos não são um if com elif

A confusão mais comum de quem aprende é achar que escrever três ifs em sequência é o mesmo que escrever if, elif e elif. Não é. Cada if novo é uma pergunta independente, e todas são feitas.

nota = 9.5
if nota >= 9:
    print("A")
if nota >= 7:
    print("B")
if nota >= 6:
    print("C")
print("---")
if nota >= 9:
    print("A")
elif nota >= 7:
    print("B")
elif nota >= 6:
    print("C")
print("---")
if nota >= 6:
    print("C")
elif nota >= 7:
    print("B")
elif nota >= 9:
    print("A")

A saída é A, B, C, uma linha de separação, A, outra separação e C. No primeiro trecho, a nota 9.5 satisfaz as três condições, e cada if solto roda o seu bloco: o programa responde três vezes. No segundo, o elif faz o que se espera, e só o primeiro True vence. No terceiro, a ordem está invertida: a condição nota >= 6 é verdadeira para quase tudo, então ela captura a nota 9.5 antes que o nota >= 9 tenha chance, e o conceito A fica inalcançável. Nenhum dos três trechos dá erro. Só um dá a resposta certa.

A regra de bolso que resolve quase tudo: escreva as condições do caso mais restritivo para o menos restritivo. Na escada de notas, de 9 para baixo. Numa escada de temperaturas crescentes, a lógica se inverte, e a primeira condição é a do menor valor:

for t in (12, 18, 25, 26, 31, 40):
    if t < 18:
        print(t, "frio")
    elif t < 26:
        print(t, "agradavel")
    elif t < 32:
        print(t, "quente")
    else:
        print(t, "muito quente")

A saída vai de 12 frio a 40 muito quente, e os limites ficam nos lugares certos: 18 é agradável e 26 é quente, porque os testes são < e o valor igual ao limite cai na faixa de cima. O que importa nos dois exemplos é a mesma ideia: as faixas se tocam sem buracos e sem sobreposição, e cada valor cai em exatamente uma delas.

Um if novo recomeça a conversa

Uma cadeia if, elif, else termina onde a indentação volta para a margem com uma linha que não é elif nem else. O if que aparece depois é outra cadeia, sem relação com a anterior.

x = 7
if x > 3:
    print("maior que 3")
elif x > 5:
    print("maior que 5")
if x > 5:
    print("maior que 5 (if novo)")
elif x > 100:
    print("enorme")
else:
    print("nenhum dos dois")

A saída é maior que 3 e maior que 5 (if novo). Na primeira cadeia, o x > 3 já decidiu e o elif x > 5 nem foi olhado. A segunda cadeia começa do zero com o if x > 5, e por isso o 7 recebe as duas mensagens. Se a intenção era uma cadeia só, o segundo if deveria ser elif.

Condições aninhadas

Às vezes a segunda pergunta só faz sentido depois da primeira. Para saber se alguém pode dirigir, só se pergunta pela carteira se a pessoa já for maior de idade. Isso se escreve com um if dentro de outro, um nível de recuo para dentro.

idade = 20
tem_carteira = False
if idade >= 18:
    if tem_carteira:
        print("pode dirigir")
    else:
        print("precisa tirar a carteira")
else:
    print("menor de idade")
if idade >= 18 and tem_carteira:
    print("pode dirigir")
elif idade >= 18:
    print("precisa tirar a carteira")
else:
    print("menor de idade")

As duas versões dão a mesma saída, precisa tirar a carteira duas vezes. A primeira aninha: a pergunta da carteira só acontece dentro do bloco dos maiores de idade, e cada else fica no recuo do if a que pertence. A segunda é plana: usa and e elif. Qual é melhor depende do problema. Aninhar deixa mais clara a dependência ("só pergunto isto se aquilo for verdade"), e a versão plana costuma ficar mais curta quando as condições são do mesmo nível. Mais de três níveis de recuo, em geral, é sinal de que vale reorganizar.

A qual if pertence o else?

Com ifs aninhados, a pergunta que mais confunde é essa, e a resposta é sempre a mesma: ao if que tem o mesmo recuo.

a = 5
b = 0
if a > 3:
    if b > 3:
        print("x")
else:
    print("else do externo")
print("---")
if a > 3:
    if b > 3:
        print("x")
    else:
        print("else do interno")
print("fim")

Na primeira parte, o else está na margem, alinhado ao if a > 3. Como a > 3 é verdadeiro, o else do externo não roda, e nada é impresso, nem x, porque b > 3 é falso. Na segunda, o else foi recuado um nível e passou a pertencer ao if b > 3: a saída é else do interno e fim. É o mesmo texto com uma diferença de quatro espaços, e o programa passa a responder uma pergunta diferente.

O que muda na ESP32

A estrutura e as regras do elif são as mesmas no MicroPython. Dois pontos pedem cuidado na placa. O primeiro é a precisão do float, que de 32 bits não separa números muito próximos:

print(5.9999999 >= 6, 5.9999999, 5.99999 >= 6, 5.99999)
nota = 5.9999999
if nota >= 6:
    print("aprovado")
else:
    print("reprovado")

No simulador, a saída é True 6.0 False 5.99999 e aprovado: o valor 5.9999999 é arredondado para 6.0 na hora em que o programa o lê, e a comparação com 6 passa. No Python do computador, com o float de 64 bits, 5.9999999 >= 6 é False e o programa responderia reprovado. Com notas digitadas isso quase não importa, mas uma média calculada ou uma leitura de sensor que fica a uma fração do limite pode cair numa faixa ou na outra conforme o tipo de float. Quando uma decisão importa de verdade, deixe uma folga entre as faixas ou trabalhe com inteiros.

O segundo ponto é o uso mais comum do elif em hardware: converter uma leitura em níveis. O conversor analógico da ESP32 devolve valores de 0 a 4095, e um sensor de luz pode virar três estados:

for valor in (0, 500, 1500, 3000, 4095):
    if valor < 1000:
        nivel = "escuro"
    elif valor < 2500:
        nivel = "penumbra"
    else:
        nivel = "claro"
    print(valor, nivel)

A saída é 0 escuro, 500 escuro, 1500 penumbra, 3000 claro e 4095 claro. As leituras reais flutuam, e quando uma delas fica rente a um limite o estado pisca entre dois níveis. A solução, com uma margem para cada lado, é um dos assuntos do artigo sobre ADC e atenuação.

As mensagens para os erros típicos do elif também diferem:

No simulador, todos viram o mesmo invalid syntax, e o número da linha é o que ajuda. O exemplo clássico de quem vem de C ou JavaScript:

x = 5
if x > 9:
    print("a")
else if x > 3:
    print("b")

Traceback (most recent call last):
  File "main.py", line 4
SyntaxError: invalid syntax

O Python não tem else if. A palavra é uma só, elif, e vai junto com a condição e os dois-pontos.

Em sala de aula: onde o elif costuma tropeçar

Os problemas abaixo se repetem em quase toda turma que chega a este assunto. Cada um dá um programa que roda, o que torna a causa difícil de achar.

Vários if no lugar de um elif

O programa pede o conceito e responde três vezes para a mesma nota, ou imprime um "aprovado" e um "reprovado" juntos. A causa é a que a figura das três versões mostra: cada if solto é uma pergunta nova. A pergunta a se fazer é se as respostas são mutuamente exclusivas. Se sim, é um elif.

A ordem das faixas trocada

O conceito A nunca aparece, porque o teste nota >= 6 vem antes do nota >= 9. É um erro que passa em todos os testes com notas baixas e só aparece quando alguém com nota alta usa o programa. Escrever a lista de faixas no papel, da mais restritiva para a menos, antes de digitar, evita o problema.

O limite com o sinal errado

Com nota > 6 no lugar de nota >= 6, quem tirou exatamente 6 cai em D. É o tipo de defeito que só aparece no valor-limite, e a defesa é testar sempre os limites: o próprio valor, um acima e um abaixo.

Comparar com vários valores usando or

if conceito == "A" or "B" não compara com A e com B. Lembra do x == 1 or 2 do artigo sobre operadores lógicos? O texto "B" sozinho é sempre verdadeiro, e a condição passa para todo conceito. A forma certa é repetir a variável, conceito == "A" or conceito == "B", ou usar in: conceito in ("A", "B").

A pirâmide de ifs

Cinco ou seis níveis de if aninhado, cada vez mais para a direita, com o else lá no fim da página e ninguém mais lembrando a qual pergunta ele responde. Quase sempre dá para achatar: um and junta duas perguntas do mesmo nível, e um elif troca um aninhamento que só serve para escolher entre alternativas.

O else perdido

O else recuado a mais ou a menos, e o programa passa a responder à pergunta errada, como na figura das duas versões. A conferência é visual: o else e o if a que ele pertence começam na mesma coluna.

Faltou o else final

O programa funciona para tudo o que se previu, e para o que ninguém previu simplesmente não faz nada: nenhuma mensagem, nenhum erro. Num cadastro, o usuário digita uma opção que não existe e o programa fica mudo. Um else com uma mensagem como "opção inválida" transforma o silêncio numa pista.

Exercício: que tipo de triângulo é esse?

Dados os três lados de um triângulo, o programa deve dizer se ele é equilátero (três lados iguais), isósceles (dois iguais) ou escaleno (todos diferentes). Mas antes é preciso saber se os lados formam um triângulo: cada lado tem de ser menor que a soma dos outros dois. É uma decisão com duas camadas, e é aí que o aninhamento ajuda.

for lados in ((3, 3, 3), (3, 3, 5), (3, 4, 5), (1, 2, 10), (2, 2, 4)):
    a, b, c = lados
    if a < b + c and b < a + c and c < a + b:
        if a == b == c:
            print(lados, "equilatero")
        elif a == b or b == c or a == c:
            print(lados, "isosceles")
        else:
            print(lados, "escaleno")
    else:
        print(lados, "nao forma triangulo")

A saída tem cinco linhas: (3, 3, 3) equilatero, (3, 3, 5) isosceles, (3, 4, 5) escaleno, (1, 2, 10) nao forma triangulo e (2, 2, 4) nao forma triangulo. O último caso merece atenção: os lados 2, 2 e 4 têm dois iguais, mas 4 não é menor que 2 mais 2, e um if que só olhasse a igualdade o chamaria de isósceles. A pergunta externa filtra, e a escada de dentro classifica. Repare na ordem da escada interna: o caso equilátero, o mais restritivo, vem primeiro, porque um equilátero também tem dois lados iguais e seria capturado pelo isósceles se este viesse antes. Para ler os lados do teclado, troque a primeira linha por três int(input()), como no artigo sobre conversão de tipos.

Perguntas frequentes

Quantos elif posso usar?

Quantos precisar. Mas uma escada com mais de cinco ou seis degraus costuma pedir outra estrutura, e o próximo artigo da série mostra uma alternativa com dicionários para o caso em que cada degrau é só uma comparação de igualdade.

O else é obrigatório no final?

Não, mas ele é uma boa rede de proteção. Sem ele, um valor que não se encaixa em nenhuma faixa passa sem fazer nada, e o defeito demora a aparecer.

Qual a diferença entre elif e um novo if?

O elif pertence à cadeia que o if abriu e só é avaliado se todas as condições anteriores forem falsas. Um if novo abre outra cadeia, e é avaliado sempre.

Posso colocar um elif dentro de um bloco aninhado?

Pode. Cada if aninhado pode ter os seus próprios elif e else, e eles ficam no mesmo recuo do if a que pertencem. O recuo é o que diz quem é quem.

O Python tem switch?

Não do jeito de C ou de Java. Para escolher entre muitos valores exatos, a saída é a escada de elif ou um dicionário, que o próximo artigo explica.

Para continuar

A trilha Lógica com Python tem desafios com várias faixas. O Positivo ou negativo pede mais de duas respostas, o Dia da semana e a Estação do ano cobram escadas com limites, e a Calculadora com menu escolhe a operação a partir de uma opção digitada. Se o recuo ainda atrapalha, releia o artigo sobre if e else, que reúne os erros de indentação mais comuns.

O próximo assunto é a escolha entre muitas opções: quando a escada de elif fica longa demais, o que um dicionário resolve melhor e por que o MicroPython não tem match e case.