// o problemaDuas respostas raramente bastam

Até agora, uma decisão no seu código tinha só dois destinos. Você fazia uma pergunta que só admite “sim” ou “não”, e o programa seguia por um de dois caminhos:

if chovendo:
    print("Leve o guarda-chuva")
else:
    print("Pode ir tranquilo")

Isso funciona bem quando existem exatamente duas saídas. O problema aparece quando a resposta certa depende de faixas ou de várias situações diferentes. Qual camiseta vestir não é “sim ou não” — depende de quão quente está. Quanto custa um ingresso não é “sim ou não” — depende da idade da pessoa.

Para esses casos, o Python tem uma palavra no meio do caminho: elif.

// a ideia centralPense numa cascata de peneiras

Esqueça por um segundo a sintaxe. A melhor imagem mental para if / elif / else é uma cascata: imagine peneiras empilhadas, uma embaixo da outra.

Um valor é jogado no topo e começa a cair. Cada peneira faz uma pergunta. A primeira peneira que responde “sim” segura o valor ali — e ele para de cair. As peneiras de baixo nem chegam a ser usadas. Se o valor passar por todas sem ser segurado, ele cai no chão: esse chão é o else.

// a sintaxeAs três peças e o que cada uma faz

Uma estrutura completa tem três tipos de bloco. Repare que só o if é obrigatório:

if primeira_condição:      # obrigatório — abre a cascata
    # roda se ESTA for a 1ª verdadeira
elif segunda_condição:    # opcional — pode ter quantos quiser
    # só é testada se a de cima falhou
elif terceira_condição:   # mais um degrau, se precisar
    ...
else:                     # opcional — o "chão", sem condição
    # roda quando nenhuma acima deu certo

Três detalhes que vale gravar:

// mão na massaUm exemplo: preço do ingresso por idade

Vamos sair do exemplo de notas e usar uma bilheteria. As regras são:

• 60 anos ou mais → meia-entrada (idoso)
• 18 anos ou mais → inteira
• 6 anos ou mais → meia-entrada (criança)
• abaixo disso → entrada gratuita

idade = 25

if idade >= 60:
    print("Meia-entrada (idoso)")
elif idade >= 18:
    print("Inteira")
elif idade >= 6:
    print("Meia-entrada (criança)")
else:
    print("Entrada gratuita")

Experimente você mesmo

Arraste para mudar a idade e veja qual peneira segura o valor. Repare no que acontece com as peneiras de baixo quando uma de cima já pegou.

// seguindo o rastroComo o Python lê, valor por valor

A tabela abaixo mostra o caminho que o programa percorre para três idades. “Testa” significa que ele chegou a avaliar aquela linha; onde tem “—”, ele nem passou por lá.

Olhe a linha da idade 70: o programa nem pergunta “é maior que 18?”. Ele já achou a primeira resposta verdadeira e foi embora. Isso não é preguiça — é o comportamento que economiza trabalho e evita confusão.

// o pulo do gatoPor que a ordem muda tudo

Aqui está a parte que mais gera bug em quem está começando. Repare que no código eu escrevi elif idade >= 18, e não algo como 18 <= idade < 60. Por quê?

Porque quando o Python chega naquele elif, ele já sabe que a linha de cima falhou. Se a idade fosse 60 ou mais, o valor teria sido segurado lá em cima e nem chegaria aqui. Então, ao pisar no segundo degrau, o programa já tem certeza de que a idade é menor que 60 — basta perguntar se é maior ou igual a 18.

Veja o que acontece se você inverter e colocar a peneira mais “larga” em cima:

# ⚠️ ordem trocada de propósito
idade = 70

if idade >= 6:                 # quase todo mundo cai aqui!
    print("Meia-entrada (criança)")
elif idade >= 18:
    print("Inteira")
elif idade >= 60:
    print("Meia-entrada (idoso)")

Uma pessoa de 70 anos vira “criança” — não porque a conta está errada, mas porque idade >= 6 é a primeira verdadeira, e a cascata para no primeiro “sim”. As duas peneiras de baixo nunca serão alcançadas por ninguém.

// além dos númeroselif não é só para faixas

As condições de um elif podem ser qualquer pergunta de verdadeiro/falso — inclusive comparar textos com ==. Um semáforo, por exemplo:

cor = "amarelo"

if cor == "verde":
    print("Pode seguir")
elif cor == "amarelo":
    print("Atenção, reduza")
elif cor == "vermelho":
    print("Pare")
else:
    print("Cor inválida")

Aqui o else tem um papel muito útil: ele captura qualquer coisa que você não previu — um texto digitado errado, um valor inesperado. É a sua rede de segurança.

// mais um exemploFaixas no sentido crescente

No ingresso, as faixas iam do maior para o menor. Mas às vezes é mais natural ir do menor para o maior — e a cascata funciona igualzinho. Uma saudação que depende da hora do dia:

hora = 14

if hora < 12:
    print("Bom dia")
elif hora < 18:
    print("Boa tarde")
else:
    print("Boa noite")

Repare a beleza da cascata aqui: o segundo teste é só hora < 18, e não 12 <= hora < 18. Como o programa só chega nesse elif quando o hora < 12 já falhou, ele já sabe que são 12h ou mais. Você escreve menos e o código fica mais claro — de novo, a ordem trabalhando a seu favor.

// erros comunsTrês armadilhas para evitar

// pratiqueCinco exercícios (com solução)

numero = -4

if numero > 0:
    print("positivo")
elif numero < 0:
    print("negativo")
else:
    print("zero")   # sobrou só o caso == 0

velocidade = 95

if velocidade > 100:
    print("multa grave")
elif velocidade > 80:
    print("multa leve")
else:
    print("dentro do limite")

nota = 78

if nota >= 90:
    print("A")
elif nota >= 75:
    print("B")
elif nota >= 60:
    print("C")
else:
    print("D")

quantidade = 60

if quantidade >= 100:
    print("20% de desconto")
elif quantidade >= 50:
    print("10% de desconto")
elif quantidade >= 10:
    print("5% de desconto")
else:
    print("sem desconto")

# pontos = 950 deveria dar "ouro"...
pontos = 950

if pontos >= 100:
    print("bronze")
elif pontos >= 500:
    print("prata")
elif pontos >= 900:
    print("ouro")

pontos = 950

if pontos >= 900:
    print("ouro")
elif pontos >= 500:
    print("prata")
elif pontos >= 100:
    print("bronze")

// teste rápidoConsegue prever a saída?

Leia cada trecho e escolha o que ele imprime. Clique numa opção para conferir na hora.

// o problemaUma pergunta só nem sempre basta

Imagine a tela de login de um site. Para deixar a pessoa entrar, não basta o usuário estar certo — a senha também precisa estar. São duas condições que têm que valer juntas.

Com o que você já sabe, dava para resolver com um if dentro do outro. Funciona, mas fica pesado. Existe um jeito mais direto de dizer “isto e aquilo” ou “isto ou aquilo” numa linha só.

// a ideia centralPortões em série e em paralelo

Pense na sua condição como um caminho com portões:

and são portões em série, um atrás do outro. Para passar, você precisa abrir todos. Se um só estiver trancado, você não passa.

or são portões em paralelo, lado a lado. Basta um estar aberto para você passar.

not é o inverte-tudo: pega um valor verdadeiro e devolve falso, e vice-versa.

// o operador andAs duas coisas precisam ser verdade

O login com and:

usuario = "joao"
senha = "1234"

if usuario == "joao" and senha == "1234":
    print("Acesso liberado")
else:
    print("Dados incorretos")

O and só resulta em verdadeiro quando os dois lados são verdadeiros. Basta um errar e o resultado inteiro vira falso — cai no else.

// o operador orBasta uma delas ser verdade

Agora um caso de or: um cliente ganha frete grátis se for a primeira compra ou se for cliente VIP. Qualquer um dos dois já basta.

primeira_compra = False
cliente_vip = True

if primeira_compra or cliente_vip:
    print("Frete grátis")
else:
    print("Frete normal")

O or só dá falso quando os dois lados são falsos. Se pelo menos um for verdadeiro, o resultado é verdadeiro.

// o operador notInverter uma resposta

O not vira a resposta do avesso. É útil para dizer “se não for tal coisa”:

chovendo = False

if not chovendo:
    print("Pode lavar o carro")

Como chovendo é False, o not transforma em True e o bloco roda.

// experimenteA tabela verdade, ao vivo

Ligue e desligue as duas condições abaixo e veja como cada operador responde na hora. Repare que and só fica verde com as duas ligadas, enquanto or já fica verde com uma só.

// tabelaTodas as combinações de uma vez

Se preferir enxergar tudo junto, esta é a “tabela verdade” de and e or. V = verdadeiro, F = falso:

Um jeito de memorizar: and é exigente (só a primeira linha passa); or é generoso (só a última reprova).

// conexão com a aula anteriorTestar se um valor está entre dois limites

Lembra do sistema de notas, onde “recuperação” era de 5 a 7? Com and dá para dizer isso diretamente: a nota precisa ser maior ou igual a 5 e menor que 7.

nota = 6

if nota >= 5 and nota < 7:
    print("Em recuperação")

// erros comunsTrês armadilhas para evitar

// pratiqueQuatro exercícios (com solução)

idade = 20
tem_carteira = True

if idade >= 18 and tem_carteira:
    print("pode dirigir")
else:
    print("não pode")

dia = "sábado"

if dia == "sábado" or dia == "domingo":
    print("descanso")
else:
    print("trabalho")

temp = 22

if temp >= 18 and temp <= 26:
    print("agradável")
else:
    print("desconfortável")

idade = 25
tem_convite = False
na_lista_vip = True

if idade >= 18 and (tem_convite or na_lista_vip):
    print("pode entrar")
else:
    print("barrado")

// teste rápidoConsegue prever a saída?

Leia cada trecho e escolha o que ele imprime. Clique numa opção para conferir na hora.

// o problemaCopiar e colar não escala

Suponha que você queira imprimir os números de 1 a 5. Dá para fazer na força bruta:

print(1)
print(2)
print(3)
print(4)
print(5)

Funciona para 5. Mas e para 1000? Ou quando você não sabe de antemão quantas vezes vai precisar — como “peça a senha até a pessoa acertar”? É aí que entra a repetição.

// a ideia centralUm if que não desiste

A melhor forma de entender o while é pensar nele como um if teimoso. Um if comum pergunta uma vez e, se for verdade, roda o bloco uma vez. O while pergunta, roda o bloco, e então volta e pergunta de novo — repetindo enquanto a resposta continuar sendo verdadeira.

Ele só para quando a pergunta finalmente responde “não” (falso). A tradução literal ajuda: while quer dizer “enquanto”.

// a sintaxeOs três ingredientes de todo while

Quase todo while bem-feito tem três partes. Veja o contador de 1 a 5:

i = 1                 # 1. começo: prepara a variável

while i <= 5:          # 2. condição: repita enquanto isto for verdade
    print(i)
    i = i + 1         # 3. avanço: muda a variável rumo ao fim

// passo a passoRode o laço com as suas mãos

Aqui está o mesmo contador, mas você controla cada volta. Clique em “Executar uma volta” e acompanhe: o Python testa a condição, e só roda o print se ela for verdadeira.

Repare no momento em que i chega a 6: a condição i <= 5 vira falsa, o bloco não roda mais e o laço termina. É exatamente assim que o Python decide parar.

// seguindo o rastroO que acontece em cada volta

// o perigoO laço infinito

Se você esquecer o avanço, a condição nunca muda e o programa fica preso para sempre — travando a tela (foi mais ou menos isso que aconteceu quando “tudo travou”, lembra?).

# ⚠️ NÃO rode isto: laço infinito
i = 1
while i <= 5:
    print(i)
    # faltou o i += 1 → i é sempre 1 → nunca para

// uso realRepetir sem saber quantas vezes

A força do while aparece quando você não sabe o número de repetições. Pedir a senha até acertar:

senha = ""

while senha != "1234":
    senha = input("Digite a senha: ")

print("Acesso liberado")

Enquanto a senha estiver errada, o laço repete e pede de novo. No instante em que a pessoa digita “1234”, a condição vira falsa e o programa segue. Você não precisou saber quantas tentativas ela levaria.

// saindo no meioO comando break

Às vezes você quer repetir “para sempre” e só sair quando algo acontecer. O break interrompe o laço na hora, de dentro dele:

while True:                       # repete indefinidamente
    opcao = input("Continuar? (s/n) ")
    if opcao == "n":
        break                    # sai do laço imediatamente

print("Programa encerrado")

while True: sozinho seria um laço infinito de propósito — o break é a saída de emergência que você mesmo controla.

// teste rápidoConsegue prever a saída?

Leia cada trecho e escolha o resultado. Cuidado com os laços infinitos!

// pratiqueQuatro exercícios (com solução)

i = 1
while i <= 10:
    print(i)
    i += 1

soma = 0
i = 1
while i <= 100:
    soma = soma + i
    i += 1
print(soma)     # 5050

i = 10
while i >= 1:
    print(i)
    i -= 1     # agora diminui!
print("Fim!")

numero = int(input("Digite um positivo: "))

while numero <= 0:
    numero = int(input("Inválido. Tente de novo: "))

print("Obrigado!")

// o problemaQuando o while fica repetitivo

Para contar de 1 a 5 com while, você precisa lembrar de três coisas: criar a variável, testar a condição e não esquecer o avanço — senão, laço infinito. É trabalho manual, e trabalho manual dá erro.

Quando o número de repetições é conhecido, existe uma ferramenta feita sob medida: o for. Ele cuida do avanço sozinho.

// a ideia centralUm garçom que serve item por item

Imagine o for como um garçom com uma bandeja de itens. Ele pega o primeiro, entrega para o seu bloco de código, espera você terminar, pega o próximo, e assim por diante — até a bandeja acabar. Você não controla o “próximo”: o garçom faz isso.

Por isso a frase que descreve o for é: “para cada item da coleção, faça isto”. Você só diz o que fazer com um item; o laço se encarrega de passar por todos.

// a sintaxefor item in coleção

Percorrendo as letras de uma palavra, uma por vez:

for letra in "Python":
    print(letra)

A cada volta, a variável letra recebe automaticamente o próximo caractere. Você escolhe o nome dessa variável — poderia ser for x in "Python":.

// a função rangeGerando uma sequência de números

E se você quer números, não letras? A função range cria a sequência para o for percorrer. Ela tem três formas:

range(5)          # 0, 1, 2, 3, 4   (começa no 0)
range(1, 6)       # 1, 2, 3, 4, 5   (de 1 até 6, sem o 6)
range(0, 10, 2)   # 0, 2, 4, 6, 8   (de 2 em 2)

Contar de 1 a 5 com for fica assim:

for i in range(1, 6):
    print(i)

// experimenteVeja o for puxar cada item

Escolha uma sequência e clique em “Próximo item”. O item da vez fica destacado e vai para a saída — é literalmente o que o for faz por dentro.

// lado a ladoO mesmo contador, while vs for

Os dois imprimem 1 a 5. Repare como o for some com as três linhas de controle manual:

i = 1
while i <= 5:
    print(i)
    i += 1

for i in range(1,6):
    print(i)

// erros comunsTrês tropeços frequentes

// teste rápidoConsegue prever a saída?

Atenção ao começo em 0 e ao fim que não entra.

// pratiqueQuatro exercícios (com solução)

for i in range(1, 11):
    print(i)

soma = 0
for i in range(1, 101):
    soma += i
print(soma)   # 5050

n = int(input("Número: "))

for i in range(1, 11):
    print(n, "x", i, "=", n * i)

palavra = "programacao"
vogais = 0

for letra in palavra:
    if letra in "aeiou":
        vogais += 1

print(vogais)   # 5

// o problemaUma variável para cada coisa não escala

Imagine guardar o nome de três alunos:

aluno1 = "Ana"
aluno2 = "Bruno"
aluno3 = "Carla"

Com três, tudo bem. Com trinta, vira um pesadelo — e você não consegue percorrer todos com um laço, porque são variáveis separadas. Precisamos de uma “caixa” que segure vários valores juntos.

// a ideia centralUma estante de prateleiras numeradas

Pense numa lista como uma estante com prateleiras numeradas. Cada prateleira guarda um valor, e todas ficam sob um nome só. Para pegar um item, você diz o nome da estante e o número da prateleira.

Detalhe crucial que já apareceu no range: a numeração começa no 0. A primeira prateleira é a de número 0, a segunda é a 1, e assim por diante.

// a sintaxeCriar e acessar

Uma lista se escreve entre colchetes [ ], com os itens separados por vírgula:

frutas = ["maçã", "banana", "uva"]

print(frutas[0])    # maçã   (primeira prateleira)
print(frutas[2])    # uva    (terceira prateleira)
print(frutas[-1])   # uva    (atalho: a última)

O número entre colchetes é o índice. O índice -1 é um atalho muito usado: significa “a última prateleira”, sem você precisar saber o tamanho.

// operaçõesTamanho, trocar e adicionar

frutas = ["maçã", "banana", "uva"]

len(frutas)              # 3  → quantos itens tem

frutas[1] = "laranja"     # troca a banana por laranja

frutas.append("kiwi")   # adiciona no fim da lista

// experimenteMexa na lista e veja os índices

Adicione e remova itens. Repare como o len muda e como cada prateleira tem seu número, sempre começando no 0.

// o encontro perfeitoPercorrer a lista com for

Aqui os dois últimos assuntos se juntam. O for percorre uma lista item por item, sem você mexer em índice nenhum:

frutas = ["maçã", "banana", "uva"]

for fruta in frutas:
    print(fruta)

A cada volta, fruta recebe o próximo item da lista. É a forma mais natural de trabalhar com todos os valores de uma vez.

// erros comunsDuas ciladas com índices

// teste rápidoConsegue prever a saída?

Lembre: a contagem começa no 0.

// pratiqueQuatro exercícios (com solução)

cores = ["azul", "verde", "vermelho"]

print(cores[0])    # azul
print(cores[-1])   # vermelho

numeros = [10, 20, 30, 40]
soma = 0

for n in numeros:
    soma += n

print(soma)   # 100

notas = [4, 8, 6, 9, 3]
aprovados = 0

for nota in notas:
    if nota >= 7:
        aprovados += 1

print(aprovados)   # 2

valores = [3, 9, 2, 7, 5]
maior = valores[0]   # começa supondo o 1º

for v in valores:
    if v > maior:
        maior = v

print(maior)   # 9

// o problemaNem tudo se acha por posição

Imagine guardar o preço de alguns produtos numa lista:

precos = [5, 2, 4]   # café? pão? leite? qual é qual?

O número está lá, mas você teria que decorar que “o preço do café está na posição 0”. Se a ordem mudar, tudo quebra. O que você quer mesmo é perguntar direto: “quanto custa o café?” — buscar pelo nome, não pela posição.

// a ideia centralGavetas etiquetadas, não numeradas

Se a lista é uma estante de prateleiras numeradas, o dicionário é um armário de gavetas etiquetadas. Você não abre a “gaveta 0”: você abre a gaveta “café” e encontra o valor guardado nela.

Cada item do dicionário é um par: uma chave (a etiqueta) e um valor (o conteúdo). É a mesma ideia de um dicionário de verdade — você procura a palavra (chave) e lê o significado (valor).

// a sintaxeCriar e acessar por chave

Um dicionário usa chaves { } e pares no formato chave: valor:

precos = {"café": 5, "pão": 2, "leite": 4}

print(precos["café"])    # 5
print(precos["leite"])   # 4

Entre colchetes vai a chave, não um número. precos["café"] abre a gaveta “café” e devolve 5.

// operaçõesAdicionar, alterar e checar

precos = {"café": 5, "pão": 2}

precos["suco"] = 6       # chave nova → adiciona
precos["café"] = 5.5     # chave existente → altera

len(precos)              # 3 → quantos pares
"café" in precos         # True → a chave existe?

// experimenteAbra a gaveta pela etiqueta

Clique numa chave para buscar o valor. Repare no que acontece quando você procura uma chave que não existe — e depois adicione ela.

// percorrerPassar por todos os pares com for

O for num dicionário entrega as chaves. Com .items(), ele entrega chave e valor de uma vez:

precos = {"café": 5, "pão": 2, "leite": 4}

for produto, preco in precos.items():
    print(produto, "custa", preco)

Também existem .keys() (só as chaves) e .values() (só os valores) — úteis, por exemplo, para somar todos os preços com .values().

// erros comunsDuas ciladas com chaves

// teste rápidoConsegue prever a saída?

Pense em chaves e valores — e no que acontece com uma chave que falta.

// pratiqueQuatro exercícios (com solução)

agenda = {"Ana": "9999-1111", "Bruno": "9888-2222"}

print(agenda["Ana"])   # 9999-1111

precos = {"café": 5, "pão": 2, "leite": 4}
total = 0

for preco in precos.values():
    total += preco

print(total)   # 11

estoque = {"maçã": 10, "uva": 4}
produto = "pera"

if produto in estoque:
    print(estoque[produto])
else:
    print("não temos")

precos = {"café": 5, "pão": 2, "leite": 4, "bolo": 8}
mais_caro = ""
maior_preco = 0

for produto, preco in precos.items():
    if preco > maior_preco:
        maior_preco = preco
        mais_caro = produto

print(mais_caro)   # bolo

// o problemaCopiar e colar espalha o mesmo código

Imagine que, em vários pontos do programa, você precise mostrar uma saudação em três linhas. Copiar e colar esse trecho funciona — até você querer mudar o texto e ter que caçar todas as cópias. Um erro em uma delas, e o comportamento fica inconsistente.

A solução é escrever esse bloco uma única vez, dar um nome a ele, e depois só chamá-lo pelo nome. Isso é uma função.

// a ideia centralUma máquina que você constrói

Pense numa função como uma máquina que você mesmo monta. Há dois momentos bem diferentes:

Construir a máquina (def): você descreve o que ela faz e dá um nome. Nesse momento, nada acontece ainda — a máquina fica ali, pronta, desligada.

Ligar a máquina (a chamada): você escreve o nome dela seguido de ( ). É só aí que o bloco roda. E você pode ligar quantas vezes quiser.

// a sintaxeDefinir e chamar

def saudacao():        # constrói a máquina (não roda ainda)
    print("Olá!")
    print("Bem-vindo")

saudacao()             # liga a máquina → agora roda
saudacao()             # liga de novo

Repare: as linhas de dentro do def ficam recuadas (indentadas), como no if e no for. E a chamada saudacao(), com os parênteses, é o que faz tudo acontecer.

// entradaParâmetros: dar informação para a máquina

Uma máquina fica mais útil quando aceita ingredientes. Em funções, esses ingredientes são os parâmetros — valores que você passa entre os parênteses:

def saudacao(nome):
    print("Olá,", nome)

saudacao("Ana")      # Olá, Ana
saudacao("Bruno")    # Olá, Bruno

Ao chamar, o valor que você passa ("Ana") entra na função como nome. A mesma máquina, resultados diferentes conforme a entrada.

// saídareturn: pegar o resultado de volta

Até aqui as funções só imprimiam. Mas muitas vezes você quer que a máquina devolva um resultado para você usar depois. Isso é o return:

def dobro(x):
    return x * 2

resultado = dobro(5)    # resultado recebe 10
print(resultado)         # 10
print(dobro(7) + 1)      # 15 (dá para usar direto numa conta)

// experimenteRegule a entrada, veja a saída

Escolha a regra da função e mova a entrada. A máquina aplica a regra e devolve o resultado — é o que o return faz.

// juntandoVários parâmetros

Uma função pode receber quantos ingredientes precisar, separados por vírgula:

def soma(a, b):
    return a + b

print(soma(3, 4))     # 7
print(soma(10, 20))   # 30

A ordem importa: o primeiro valor vira a, o segundo vira b.

// erros comunsTrês tropeços com funções

// teste rápidoConsegue prever a saída?

Preste atenção em quando a função é chamada e no que ela devolve.

// pratiqueQuatro exercícios (com solução)

def cumprimentar(nome):
    print("Bom dia,", nome, "!")

cumprimentar("Ana")
cumprimentar("Bruno")

def area(base, altura):
    return base * altura

print(area(4, 3))   # 12

def eh_par(n):
    return n % 2 == 0

print(eh_par(4))   # True
print(eh_par(7))   # False

def maior(a, b):
    if a > b:
        return a
    else:
        return b

print(maior(3, 8))   # 8

// o problemaUm erro derruba tudo

Peça um número ao usuário e some 1. Parece inofensivo:

idade = int(input("Sua idade: "))
print("Ano que vem:", idade + 1)

Se a pessoa digitar “abc” em vez de um número, o int() não consegue converter, o Python levanta um erro e o programa para na hora — despejando uma mensagem técnica assustadora. Precisamos de um plano B.

// a ideia centralA rede de segurança

Pense no try/except como a rede embaixo do trapezista. Você tenta a manobra arriscada (try); se cair, a rede te segura (except) em vez de você se espatifar no chão.

Em código: “tente rodar este bloco; se der qualquer erro no meio dele, abandone o resto e execute o plano B, sem travar o programa.”

// a sintaxetry e except

try:
    idade = int(input("Sua idade: "))
    print("Ano que vem:", idade + 1)
except:
    print("Isso não parece um número. Tente de novo.")

Agora, em vez de quebrar, o programa mostra uma mensagem amigável e segue vivo. Repare que o bloco try pode ter várias linhas — se qualquer uma falhar, o pulo para o except acontece na hora.

// experimenteVeja o programa "cair" na rede

Escolha o valor do divisor e clique em Executar. Com um número normal, o try vai até o fim. Com zero, a divisão dá erro e o programa cai no except.

// mais precisoCapturar o erro certo

Um except sozinho captura qualquer erro. Melhor do que isso é dizer qual erro você espera — assim você não esconde bugs de outro tipo por acidente. Cada situação tem seu nome de erro:

try:
    numero = int(texto)
    resultado = 10 / numero
except ValueError:
    print("O texto não era um número")
except ZeroDivisionError:
    print("Não posso dividir por zero")

Você pode ter vários except, cada um para um tipo de erro. Os nomes mais comuns no começo: ValueError (conversão inválida), ZeroDivisionError (divisão por zero), KeyError (chave que não existe num dicionário) e IndexError (posição fora da lista).

// erros comunsTrês armadilhas ao tratar erros

// teste rápidoConsegue prever a saída?

Acompanhe o fluxo: o erro faz o programa pular para o except.

// pratiqueQuatro exercícios (com solução)

try:
    idade = int(input("Idade: "))
    print(idade * 2)
except ValueError:
    print("Digite apenas números")

def dividir(a, b):
    try:
        return a / b
    except ZeroDivisionError:
        return "erro"

print(dividir(10, 2))   # 5.0
print(dividir(10, 0))   # erro

precos = {"café": 5}
chave = "chá"

try:
    print(precos[chave])
except KeyError:
    print("produto não encontrado")

while True:
    try:
        n = int(input("Digite um número: "))
        break                 # deu certo → sai do laço
    except ValueError:
        print("Inválido, tente de novo.")

print("Você digitou:", n)

// o objetivoO que vamos construir

O programa sorteia um número secreto de 1 a 100. Você tenta adivinhar; a cada palpite, ele responde “muito alto” ou “muito baixo”, até você acertar — e então conta em quantas tentativas você conseguiu.

Simples de descrever, mas repare em quantas ferramentas do curso ele exige:

• Sortear e guardar o número — variáveis e o módulo random (fundamentos)
• Repetir os palpites — laço while e break (aula 3)
• Comparar o palpite — if / elif / else (aula 1)
• Guardar os palpites e contar — listas e acumulador (aula 5)
• Organizar em blocos — funções com return (aula 7)
• Aguentar entrada inválida — try / except (aula 8)

// jogue agoraÉ isto que você vai construir

Antes de escrever uma linha, jogue a versão pronta aqui do lado. Tente também digitar algo que não é número — veja como ele não trava (isso é o try/except em ação).

// passo 1Sortear o número secreto

O Python tem um módulo chamado random para gerar números aleatórios. Nós o importamos e pedimos um número inteiro entre 1 e 100:

import random

secreto = random.randint(1, 100)   # sorteia de 1 a 100

importvariável import traz ferramentas prontas; randint(1, 100) devolve um número aleatório (aqui o 100 entra, diferente do range).

// passo 2Repetir os palpites com while

Não sabemos quantas tentativas o jogador vai levar — caso clássico de while. Repetimos “para sempre” e sairemos com break quando ele acertar:

while True:
    palpite = int(input("Seu palpite: "))
    # ... comparar aqui ...

whileinput

// passo 3Comparar com if / elif / else

Três caminhos: acertou, chutou baixo ou chutou alto. Quando acerta, o break encerra o laço:

    if palpite == secreto:
        print("Acertou!")
        break
    elif palpite < secreto:
        print("Muito baixo.")
    else:
        print("Muito alto.")

if / elif / elsebreak

// passo 4Não deixar um "abc" derrubar o jogo

Se o jogador digitar algo que não é número, o int() quebra. Envolvemos a leitura num try/except e usamos continue para recomeçar o laço sem contar aquela tentativa:

    try:
        palpite = int(input("Seu palpite: "))
    except ValueError:
        print("Digite um número!")
        continue   # volta ao topo do while

try / exceptcontinue

// passo 5Contar e guardar os palpites numa lista

Guardamos cada palpite numa lista e usamos len para saber quantas tentativas foram:

palpites = []
# ... dentro do laço, a cada palpite válido:
palpites.append(palpite)
# ... ao acertar:
print("Você acertou em", len(palpites), "tentativas!")

listaappendlen

// passo 6Organizar em funções

Por fim, separamos responsabilidades em funções: uma para sortear, outra para ler um palpite válido (com o tratamento de erro embutido). Fica mais limpo e reutilizável:

def pedir_palpite():
    while True:
        try:
            return int(input("Seu palpite: "))
        except ValueError:
            print("Digite um número!")

funçãoreturn Repare como o return dentro do try só acontece quando a conversão dá certo — senão, o laço pede de novo.

// o código completoTudo junto e funcionando

Reunindo os seis passos, este é o programa inteiro. Copie no seu computador e rode com Python:

import random


def pedir_palpite():
    while True:
        try:
            return int(input("Seu palpite (1 a 100): "))
        except ValueError:
            print("Isso não é um número. Tente de novo.")


def jogar():
    secreto = random.randint(1, 100)
    palpites = []
    print("Pensei num número de 1 a 100. Adivinhe!")

    while True:
        palpite = pedir_palpite()
        palpites.append(palpite)

        if palpite == secreto:
            print("Acertou! Foram", len(palpites), "tentativas.")
            print("Seus palpites:", palpites)
            break
        elif palpite < secreto:
            print("Muito baixo. Tente um maior.")
        else:
            print("Muito alto. Tente um menor.")


jogar()

// como evoluirTrês desafios para deixá-lo seu

Um projeto bom nunca está “terminado”. Tente estas melhorias — as soluções estão escondidas, mas tente antes de espiar.

distancia = abs(palpite - secreto)
if distancia < 5:
    print("🔥 Quente!")
else:
    print("🧊 Frio.")

placar = {}
nome = input("Seu nome: ")
placar[nome] = len(palpites)   # tentativas até vencer

for jogador, tentativas in placar.items():
    print(jogador, "→", tentativas, "tentativas")