Estruturas de Seleção em Python: if, elif e else do zero à prática real

Por que estruturas de seleção são o divisor de águas no aprendizado de programação?

Há um momento preciso em que o aluno deixa de ser um digitador de comandos e começa a pensar como programador: quando o programa passa a tomar decisões. Até ali, a sequência linear de instruções é suficiente — variável recebe valor, print exibe resultado. Simples, porém inerte. Sem condicionais, um programa é apenas uma receita de bolo sem nenhuma variação possível.

As estruturas de seleção — if, elif e else — são o mecanismo que transforma código em comportamento adaptativo. É a partir delas que surgem sistemas de consulta, jogos, validadores de entrada, classificadores de dados e toda a lógica de negócio que sustenta aplicações reais. Ensiná-las bem, na escola pública, com contexto significativo, é um dos investimentos pedagógicos de maior retorno no curso técnico em Desenvolvimento de Sistemas.

O custo real de não dominar condicionais no início do curso

O aluno que não consolida a lógica condicional nas primeiras semanas acumula passivo técnico ao longo de todo o curso. Estruturas de repetição, funções, manipulação de listas, tratamento de erros — todas dependem da capacidade de formular condições booleanas corretamente. O while é um if que se repete. O try/except é uma seleção baseada em tipo de erro. O polimorfismo, mais adiante, é uma forma de despacho condicional abstraído.

Na prática de laboratório, os sintomas são reconhecíveis: o aluno que escreve quatro if independentes onde deveria usar elif, gerando conflitos lógicos silenciosos; o que não aplica .lower() antes de comparar strings e não entende por que a letra “A” não é reconhecida como “a”; o que abandona o exercício do jogo de adivinhação porque não sabe importar o módulo random. Cada um desses bloqueios tem origem na mesma lacuna conceitual.

Como esta sequência de aulas opera dentro da realidade da escola pública

A série [SIS]ANO1C1B2S9 é composta por quatro aulas de 50 minutos cada, estruturadas em progressão de complexidade. As três primeiras constroem o repertório técnico — sintaxe, métodos de string, variáveis compostas — por meio de problemas contextualizados. A quarta aula recapitula e aplica tudo em dois projetos interativos de maior complexidade, introduzindo também o módulo random.

A infraestrutura necessária é mínima: computador com Python instalado ou acesso ao Replit via navegador, caderno para rascunhos e conexão à internet para referências. O modelo pedagógico é direto — exposição do conceito, demonstração de código comentado, atividade prática com entrega no AVA — o que viabiliza execução mesmo em laboratórios com recursos limitados. A resolução dos exercícios está estimada entre 15 e 30 minutos por desafio, respeitando o tempo real disponível após a instrução.

if, elif e else: fundamento conceitual e diferenciação precisa

Os três comandos formam uma cadeia lógica exclusiva: apenas um bloco é executado por vez, o primeiro cuja condição se mostrar verdadeira. Compreender essa exclusividade é o ponto mais crítico — e mais frequentemente mal compreendido — do aprendizado inicial.

A distinção entre múltiplos if independentes e uma cadeia if/elif/else é semântica e funcional. Com if independentes, todas as condições são avaliadas, gerando risco de múltiplos blocos serem executados ou de efeitos colaterais indesejados. Com elif, a avaliação cessa na primeira condição satisfeita — mais eficiente e semanticamente correto para condições mutuamente exclusivas.

Como estruturar o aprendizado: método em quatro etapas

Templates de código comentados — extraídos das aulas

Os quatro blocos a seguir correspondem aos exemplos trabalhados nas aulas A1 a A4. Cada um representa um nível de complexidade crescente: do mapeamento direto de letras, passando por variáveis estruturadas, até lógica de jogo com módulo externo.

Template A1 — Mapeamento de letras com lower()

# Recebe e normaliza a entrada do usuário
letra = input("Digite uma letra do alfabeto: ")
letra = letra.lower()   # normaliza para minúscula antes de comparar

# Cadeia de seleção: cada elif verifica uma letra
if letra == 'a':
    print("Avião")
elif letra == 'b':
    print("Bola")
elif letra == 'c':
    print("Carro")
elif letra == 'd':
    print("Dado")
elif letra == 'e':
    print("Elefante")
# ... restante do alfabeto seguindo o mesmo padrão ...
else:
    print("Não conheço uma palavra que comece com essa letra.")

Template A2 — Guia de candidatos com variáveis e input()

# Dados dos candidatos armazenados em variáveis
candidato1_numero  = 1
candidato1_nome    = "João"
candidato1_partido = "Partido A"
candidato1_vice    = "Maria"

candidato2_numero  = 2
candidato2_nome    = "Pedro"
candidato2_partido = "Partido B"
candidato2_vice    = "Ana"

# Leitura e conversão de tipo: string → inteiro
numero_candidato = int(input("Digite o número do candidato (1 ou 2): "))

# Seleção por número digitado
if numero_candidato == candidato1_numero:
    print("Candidato:", candidato1_nome)
    print("Partido:",   candidato1_partido)
    print("Vice:",      candidato1_vice)
elif numero_candidato == candidato2_numero:
    print("Candidato:", candidato2_nome)
    print("Partido:",   candidato2_partido)
    print("Vice:",      candidato2_vice)
else:
    print("Candidato não encontrado.")

Template A3 — Tabela periódica com if/elif/else

# Consulta de elementos químicos por sigla
sigla = input("Digite a sigla do elemento químico: ")

if sigla == "H":
    print("Número atômico: 1 | Nome: Hidrogênio | Massa: 1,008")
elif sigla == "He":
    print("Número atômico: 2 | Nome: Hélio | Massa: 4,003")
elif sigla == "Li":
    print("Número atômico: 3 | Nome: Lítio | Massa: 6,941")
elif sigla == "C":
    print("Número atômico: 6 | Nome: Carbono | Massa: 12,011")
elif sigla == "O":
    print("Número atômico: 8 | Nome: Oxigênio | Massa: 15,999")
elif sigla == "Fe":
    print("Número atômico: 26 | Nome: Ferro | Massa: 55,845")
# Desafio: completar com todos os 118 elementos
else:
    print("Elemento não encontrado na base de dados.")

Template A4 — Jogo de adivinhação com módulo random

import random

# Gera número secreto entre 1 e 100
numero_secreto = random.randint(1, 100)
tentativas      = 0
acertou         = False

while not acertou:
    palpite = int(input("Adivinhe o número (1–100): "))
    tentativas += 1

    if palpite < numero_secreto:
        print("O número secreto é maior.")
    elif palpite > numero_secreto:
        print("O número secreto é menor.")
    else:
        print(f"Correto! Tentativas: {tentativas}")
        acertou = True

Template A4 — Classificador de faixas etárias

idade = int(input("Digite sua idade: "))

if idade <= 12:
    print("Categoria: Criança")
elif idade <= 17:
    print("Categoria: Adolescente")
elif idade <= 64:
    print("Categoria: Adulto")
else:
    print("Categoria: Idoso")

Casos reais: do problema de sala ao projeto significativo

Métodos lower() e upper(): padronização de entrada como boa prática de engenharia

A Aula 1 introduz um conceito que vai muito além da sintaxe de string: a ideia de que a entrada do usuário deve ser normalizada antes de ser processada. Em sistemas reais, entradas inconsistentes são uma das principais fontes de bugs silenciosos. Um sistema de login que aceita “admin” mas rejeita “Admin” é um sistema mal construído.

O padrão correto — demonstrado no código da Aula 1 — é aplicar .lower() imediatamente após o input(), armazenando o resultado na mesma variável. Isso concentra a normalização em um único ponto, tornando o restante do código mais legível e o comportamento do sistema mais previsível.

Módulo random: primeira extensão do ambiente Python

A Aula 4 marca uma transição importante no curso: o aluno sai do Python “puro” e importa pela primeira vez um módulo da biblioteca padrão. O módulo random é pedagogicamente ideal para essa estreia porque seu uso é imediato — import random seguido de random.randint(1, 100) — e o resultado é visível e lúdico.

O jogo de adivinhação combina três conceitos simultâneos: estrutura de repetição (while), estrutura de seleção (if/elif/else) e importação de módulo. A variável tentativas como contador e a flag booleana acertou introduzem padrões de design que reaparecerão em contextos mais complexos ao longo do curso.

Expansão estratégica: além da aula — como transformar este conteúdo em ativo

Perguntas frequentes sobre estruturas de seleção em Python

Conclusão: o condicional como mudança de mentalidade pedagógica

Ensinar estruturas de seleção é, em última instância, ensinar o aluno a decompor decisões em condições verificáveis. Esse é um dos transferes mais valiosos que a programação oferece ao pensamento geral — a capacidade de tornar explícito aquilo que normalmente fica implícito no raciocínio cotidiano.

A progressão das quatro aulas desta série — do simples mapeamento de letras ao jogo com estado e módulo externo — demonstra que é possível construir complexidade crescente sem perder o contexto significativo. O aluno do ensino médio técnico em escola pública não precisa de exercícios artificiais para aprender lógica condicional. Precisa de problemas reais, bem dimensionados para o tempo disponível, com instruções claras de entrega e com desafios opcionais para quem vai além.

O professor que estrutura essas quatro aulas como um arco narrativo — não como quatro atividades isoladas — não apenas ensina Python. Ensina a pensar por condições. E esse aprendizado não fica na linguagem.