Capítulo 3 — Estruturas condicionais

Até agora, todos os nossos programas seguem uma linha reta: executam um comando, depois outro, depois outro, sempre na mesma ordem, sempre fazendo a mesma coisa. Mas pense na sua própria rotina: se está chovendo, você pega o guarda-chuva; se não está, sai sem ele. Se a nota foi maior que 7, passou; se não, ficou de recuperação. A vida é cheia de decisões, e os programas também precisam tomar decisões.

Neste capítulo, vamos aprender a fazer o Python escolher caminhos diferentes dependendo da situação. Para isso, usaremos as estruturas condicionais: if, elif e else. Mas antes de sair codificando, vamos aprender uma ferramenta visual muito útil para planejar decisões: os fluxogramas.

1. Fluxogramas: representando decisões visualmente

Antes de escrever código, é muito útil desenhar o que o programa precisa fazer. Um fluxograma é um diagrama que mostra o passo a passo de um algoritmo, usando formas geométricas padronizadas. Pense nele como um mapa do seu programa: ele mostra por onde o programa pode passar e quais caminhos ele pode tomar.

Símbolos básicos

Cada forma tem um significado. Vale a pena decorar essas quatro — são as que vamos usar sempre:

Forma Significado Exemplo
Oval (retângulo arredondado) Início ou fim do programa "Início", "Fim"
Retângulo Processo (uma ação, um cálculo) resultado = a + b
Losango Decisão (pergunta sim/não) "Idade >= 18?"
Paralelogramo Entrada ou saída de dados "Digite sua idade", "Exiba o resultado"

O símbolo mais importante aqui é o losango. Ele sempre contém uma pergunta cuja resposta é "sim" ou "não", e a partir dele o fluxo se divide em dois caminhos. É exatamente isso que vamos fazer no código com o if.

Exemplo: é maior de idade?

Imagine um programa que pergunta a idade e diz se a pessoa é maior ou menor de idade. Antes de escrever o código, podemos planejar assim:

flowchart TD
    A([Início]) --> B[/Digite sua idade/]
    B --> C{idade >= 18?}
    C -->|Sim| D[/Exiba: Maior de idade/]
    C -->|Não| E[/Exiba: Menor de idade/]
    D --> F([Fim])
    E --> F

Vamos ler esse fluxograma passo a passo:

  1. O programa começa (oval "Início")
  2. Pede a idade ao usuário (paralelogramo — entrada de dados)
  3. Faz uma pergunta: "idade >= 18?" (losango — decisão)
  4. Se a resposta for sim, exibe "Maior de idade"
  5. Se a resposta for não, exibe "Menor de idade"
  6. Nos dois casos, o programa termina (oval "Fim")

Repare que os dois caminhos se encontram no final. Isso é comum: depois de tomar a decisão e executar a ação correspondente, o programa continua normalmente.

Do fluxograma ao código

O fluxograma acima vira código Python assim:

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

if idade >= 18:
    print("Maior de idade")
else:
    print("Menor de idade")

A tradução é quase direta: o paralelogramo de entrada vira input(), o losango vira if, o caminho do "sim" fica dentro do if, e o caminho do "não" fica dentro do else. Desenhar o fluxograma primeiro ajuda a pensar com clareza antes de escrever qualquer linha de código.

Dica para o professor: peça aos alunos que desenhem o fluxograma antes de escrever o código. Isso ajuda muito a organizar o pensamento, especialmente quando o problema tem várias condições.

2. Operadores de comparação

Para tomar decisões, o Python precisa comparar valores. Os operadores de comparação fazem exatamente isso: pegam dois valores, comparam, e retornam True (verdadeiro) ou False (falso). Esses dois valores — True e False — são do tipo bool, que vimos brevemente no capítulo anterior.

Aqui estão todos os operadores de comparação:

Operador Significado Exemplo Resultado
== Igual a 5 == 5 True
!= Diferente de 5 != 3 True
> Maior que 7 > 3 True
< Menor que 2 < 1 False
>= Maior ou igual a 5 >= 5 True
<= Menor ou igual a 3 <= 2 False

Você pode testar todos eles direto no modo interativo do Python. Abra o IDLE e experimente:

>>> 10 > 5
True
>>> 3 == 7
False
>>> 10 >= 10
True
>>> 10 > 10
False

Repare a diferença entre os dois últimos: 10 >= 10 é True porque 10 é igual a 10, e o >= aceita "maior ou igual". Já 10 > 10 é False porque 10 não é maior que 10 — é apenas igual.

Comparando strings

Dá para comparar strings (textos) também! Quando comparamos com ==, o Python verifica se os textos são idênticos:

>>> "banana" == "banana"
True
>>> "Banana" == "banana"
False
>>> "abacaxi" != "manga"
True

Atenção: "Banana" com B maiúsculo não é igual a "banana" com b minúsculo. Para o Python, letras maiúsculas e minúsculas são diferentes. Mais adiante veremos como lidar com isso usando .lower().

Cuidado: = não é ==

Esse é um dos erros mais comuns para quem está começando, e é fácil entender por quê — os dois parecem iguais. Mas fazem coisas completamente diferentes:

Se você escrever if idade = 15:, o Python vai reclamar com um erro de sintaxe. O correto é if idade == 15: (com dois sinais de igual).

# ERRADO — isso dá erro de sintaxe!
# O Python não entende: você quer guardar 15 ou perguntar se é 15?
if idade = 15:
    print("Quinze anos")

# CERTO — comparação com ==
# Aqui sim: estamos perguntando "idade é igual a 15?"
if idade == 15:
    print("Quinze anos")

Uma dica para lembrar: quando você lê o código em voz alta, = se lê como "recebe" e == se lê como "é igual a". Então idade = 15 é "idade recebe 15" e idade == 15 é "idade é igual a 15?".

3. A estrutura if

O if (que em inglês significa "se") é o comando mais básico de decisão. Ele executa um bloco de código somente se a condição for verdadeira. Se a condição for falsa, o Python simplesmente pula aquele bloco e continua o programa.

Sintaxe

if condição:
    # código que será executado se a condição for True

Três coisas são essenciais para o if funcionar:

  1. A condição vem depois da palavra if — geralmente é uma comparação como idade >= 18 ou nome == "Ana"
  2. A linha do if termina com dois-pontos (:) — se esquecer os dois-pontos, o Python dá erro
  3. O código que "pertence" ao if precisa estar indentado — ou seja, com 4 espaços à frente

A importância da indentação

Em muitas linguagens de programação, usam-se chaves { } para marcar blocos de código. Em Python, isso é feito com indentação — os espaços no início da linha. Isso não é opcional nem é só para ficar bonito: a indentação define o que está dentro ou fora do if.

Veja este exemplo com cuidado:

nota = 8

if nota >= 7:
    print("Parabéns!")           # ← dentro do if (tem 4 espaços)
    print("Você foi aprovado!")  # ← também dentro do if (tem 4 espaços)

print("Fim do programa")        # ← fora do if (sem espaços extras)

O que acontece quando nota é 8? As três mensagens aparecem:

Parabéns!
Você foi aprovado!
Fim do programa

E quando nota é 5? O Python vê que 5 >= 7 é False, pula as duas linhas indentadas e vai direto para a última:

Fim do programa

A linha print("Fim do programa") sempre executa porque não está indentada — ela está fora do if. Entender essa diferença é fundamental.

Exemplo: verificar se um número é positivo

numero = int(input("Digite um número: "))

if numero > 0:
    print(f"O número {numero} é positivo!")

print("Obrigado por usar o programa!")

Se o usuário digitar 7, a saída é:

O número 7 é positivo!
Obrigado por usar o programa!

Se digitar -3, a saída é apenas:

Obrigado por usar o programa!

O programa não "trava" nem dá erro quando a condição é falsa — ele simplesmente pula o bloco do if e segue em frente. Mas e se quisermos que o programa faça algo diferente quando o número não é positivo? Para isso, temos o else.

4. if...else

O else (que em inglês significa "senão") cria dois caminhos possíveis: um para quando a condição é verdadeira e outro para quando é falsa. É como uma bifurcação na estrada: o programa sempre vai por um dos dois caminhos, nunca pelos dois ao mesmo tempo e nunca por nenhum.

Sintaxe

if condição:
    # código para quando a condição é True
else:
    # código para quando a condição é False

Repare que o else não tem condição — ele simplesmente pega todos os casos que o if não pegou. Também termina com dois-pontos (:) e o código dentro dele precisa estar indentado.

Exemplo: par ou ímpar

numero = int(input("Digite um número: "))

if numero % 2 == 0:
    print(f"{numero} é par")
else:
    print(f"{numero} é ímpar")

Lembra do operador % (módulo) do capítulo 1? Ele dá o resto da divisão. Quando dividimos um número por 2, se o resto for zero, o número é par. Se o resto for diferente de zero, o número é ímpar. Veja no modo interativo:

>>> 10 % 2
0        # resto zero → par
>>> 7 % 2
1        # resto 1 → ímpar
>>> 4 % 2
0        # resto zero → par

Então numero % 2 == 0 está perguntando: "o resto da divisão por 2 é zero?" Se sim, é par. Se não, é ímpar.

Outro exemplo: pode dirigir?

idade = int(input("Qual a sua idade? "))

if idade >= 18:
    print("Você pode tirar carteira de motorista!")
else:
    faltam = 18 - idade
    print(f"Você ainda não pode dirigir. Faltam {faltam} ano(s).")

Repare que dentro do else temos duas linhas de código: uma que calcula quantos anos faltam e outra que exibe a mensagem. Isso é perfeitamente normal — dentro de cada bloco (if ou else) você pode ter quantas linhas precisar, desde que todas estejam indentadas no mesmo nível.

Vamos simular o programa com diferentes idades:

Visualizando com fluxograma

O if...else pode ser representado assim:

flowchart TD
    A{condição} -->|True| B[bloco do if]
    A -->|False| C[bloco do else]
    B --> D[continua o programa]
    C --> D

Sempre dois caminhos, e os dois se encontram depois.

5. if...elif...else

E quando temos mais de duas possibilidades? Por exemplo, classificar uma nota em A, B, C, D ou F. São cinco opções — não dá para resolver com um simples "sim ou não". Para isso, usamos o elif, que é uma abreviação de "else if" (em português: "senão, se").

O elif permite testar várias condições em sequência, como uma série de perguntas: "É isso? Não? Então é aquilo? Também não? Então é aquilo outro?"

Sintaxe

if condição1:
    # executa se condição1 for True
elif condição2:
    # executa se condição1 for False E condição2 for True
elif condição3:
    # executa se as anteriores forem False E condição3 for True
else:
    # executa se NENHUMA condição anterior for True

Você pode ter quantos elif precisar — dois, cinco, dez, quantos quiser. O else no final é opcional, mas é uma boa prática incluí-lo para cobrir "todos os outros casos" que você não previu.

Uma coisa importante: o Python testa as condições de cima para baixo. Assim que encontrar uma que seja True, executa aquele bloco e pula todo o resto. Ele não continua testando as outras condições.

Exemplo: classificação de nota

nota = float(input("Digite sua nota (0 a 10): "))

if nota >= 9:
    conceito = "A"
elif nota >= 7:
    conceito = "B"
elif nota >= 5:
    conceito = "C"
elif nota >= 3:
    conceito = "D"
else:
    conceito = "F"

print(f"Sua nota {nota} corresponde ao conceito {conceito}")

Vamos simular com nota = 8.5:

  1. 8.5 >= 9? Não → pula
  2. 8.5 >= 7? Sim → conceito recebe "B", e o Python pula todo o resto

Mesmo que 8.5 >= 5 e 8.5 >= 3 também sejam verdadeiros, o Python nem chega a testá-los. Ele para no primeiro True que encontrar.

Agora com nota = 2.0:

  1. 2.0 >= 9? Não → pula
  2. 2.0 >= 7? Não → pula
  3. 2.0 >= 5? Não → pula
  4. 2.0 >= 3? Não → pula
  5. Caiu no else → conceito recebe "F"

A ordem das condições importa!

Como o Python para no primeiro True, a ordem em que você escreve as condições faz toda a diferença. Veja o que aconteceria se invertêssemos a ordem:

# ERRADO — ordem invertida!
nota = 9.5

if nota >= 3:
    conceito = "D"    # 9.5 >= 3 é True, então cai aqui!
elif nota >= 5:
    conceito = "C"    # nunca chega aqui para nota 9.5
elif nota >= 7:
    conceito = "B"    # nunca chega aqui
elif nota >= 9:
    conceito = "A"    # nunca chega aqui

# Resultado: nota 9.5 com conceito "D"! Completamente errado.

Com a ordem invertida, uma nota 9.5 receberia conceito "D", porque 9.5 >= 3 é True e é a primeira condição testada. O Python para ali e não testa mais nada.

Regra prática: quando usar >=, comece pelo maior valor e vá descendo. Quando usar <=, comece pelo menor valor e vá subindo. Assim as condições mais "exigentes" são testadas primeiro.

Mais um exemplo: faixa etária

idade = int(input("Qual a sua idade? "))

if idade < 0:
    print("Idade inválida!")
elif idade <= 12:
    print("Criança")
elif idade <= 17:
    print("Adolescente")
elif idade <= 64:
    print("Adulto")
else:
    print("Idoso")

Aqui começamos com uma verificação de segurança (idade < 0). Isso é uma boa prática: antes de classificar, verifique se o dado faz sentido. Ninguém tem idade negativa!

Repare que não precisamos escrever idade >= 0 and idade <= 12 na segunda condição. Se o programa chegou até o segundo elif, já sabemos que idade < 0 era False, ou seja, a idade é 0 ou mais. Então basta testar idade <= 12. Esse é um dos benefícios do elif: cada condição já "herda" a informação de que as anteriores foram falsas.

6. Operadores lógicos: and, or, not

Às vezes, uma condição só não basta. Imagine que você quer verificar se alguém é adolescente — a idade precisa ser maior ou igual a 13 e também menor ou igual a 17. São duas condições que precisam ser verdadeiras ao mesmo tempo. Para combinar condições assim, usamos os operadores lógicos.

Operador Significado Como funciona
and E True só se as duas condições forem verdadeiras
or OU True se pelo menos uma condição for verdadeira
not NÃO Inverte: True vira False, False vira True

Combinando condições com and

O and exige que ambas as condições sejam verdadeiras. Se qualquer uma delas for falsa, o resultado é False.

idade = int(input("Qual sua idade? "))

if idade >= 13 and idade <= 17:
    print("Você é adolescente!")
else:
    print("Você não é adolescente.")

Vamos testar com diferentes idades para entender exatamente como o and funciona:

# idade = 15
# idade >= 13 → True
# idade <= 17 → True
# True and True → True ✓ É adolescente!

# idade = 20
# idade >= 13 → True
# idade <= 17 → False
# True and False → False ✗ Não é adolescente.

# idade = 10
# idade >= 13 → False
# idade <= 17 → True
# False and True → False ✗ Não é adolescente.

# idade = 5
# idade >= 13 → False
# idade <= 17 → True
# False and True → False ✗ Não é adolescente.

Repare: com and, basta uma das duas ser False para o resultado ser False. As duas precisam ser True para dar True.

Combinando condições com or

O or é mais "generoso": basta uma das condições ser verdadeira para o resultado ser True. Só dá False se todas forem falsas.

dia = input("Que dia da semana é hoje? ").lower()

if dia == "sábado" or dia == "sabado" or dia == "domingo":
    print("É fim de semana! Hora de descansar.")
else:
    print("Dia de aula!")

Usamos .lower() para converter a resposta para minúsculas, assim não importa se o usuário digitar "Sábado", "SÁBADO" ou "sábado" — tudo vira "sábado". Incluímos também "sabado" (sem acento) para o caso de alguém esquecer o acento.

Vamos rastrear o que acontece quando o usuário digita "domingo":

# dia = "domingo"
# dia == "sábado" → False
# dia == "sabado" → False
# dia == "domingo" → True
# False or False or True → True ✓ É fim de semana!

E quando digita "segunda":

# dia = "segunda"
# dia == "sábado" → False
# dia == "sabado" → False
# dia == "domingo" → False
# False or False or False → False ✗ Dia de aula!

Um erro muito comum com or

Muita gente tenta escrever assim:

# ERRADO — não funciona como esperado!
if dia == "sábado" or "domingo":
    print("Fim de semana!")

Isso não faz o que parece! O Python não entende como "dia é igual a sábado ou a domingo". Ele entende como duas coisas separadas: dia == "sábado" (uma comparação) or "domingo" (uma string sozinha). E uma string sozinha sempre vale True em Python! Então essa condição seria sempre verdadeira, não importa o dia.

O correto é repetir a comparação completa em cada lado do or:

# CERTO — cada condição é uma comparação completa
if dia == "sábado" or dia == "domingo":
    print("Fim de semana!")

Invertendo com not

O not simplesmente inverte o valor: o que era True vira False e vice-versa. É como dizer "o contrário de".

chovendo = False

if not chovendo:
    print("Pode sair sem guarda-chuva!")

Como chovendo é False, not chovendo é True, e a mensagem aparece.

Outro exemplo prático:

tem_lição = input("Você já fez a lição de casa? (s/n): ").lower()

if not tem_lição == "s":
    print("Vá fazer a lição antes de jogar!")
else:
    print("Pode jogar!")

Aqui, not tem_lição == "s" significa "a pessoa não respondeu 's'". Se respondeu qualquer outra coisa (como "n", "não", ou até algo sem querer), o programa manda fazer a lição.

Combinando vários operadores

Você pode combinar and, or e not na mesma expressão. Mas quando faz isso, precisa tomar cuidado com a ordem de avaliação. O Python avalia na seguinte prioridade: primeiro not, depois and, e por último or.

Isso pode causar confusão. Veja este exemplo:

idade = 16
tem_autorizacao = True

Queremos dizer: "pode entrar se tiver 18 anos ou mais, OU se tiver 16 ou 17 com autorização dos pais". Vamos ver três formas de escrever isso:

Versão 1 — sem parênteses (pode dar problema):

if idade >= 18 or idade >= 16 and tem_autorizacao:
    print("Pode entrar!")

Essa funciona neste caso, mas é difícil de ler. Quem olha para isso pode se perguntar: o and se aplica a quê? O Python primeiro avalia idade >= 16 and tem_autorizacao (porque and tem prioridade sobre or), e depois faz o or com idade >= 18. Funciona, mas só por sorte — a ordem natural do Python coincidiu com o que queríamos.

Versão 2 — parênteses no lugar errado (BUG!):

if (idade >= 18 or idade >= 16) and tem_autorizacao:
    print("Pode entrar!")

Isso está errado! Parece fazer sentido quando se lê rápido, mas veja o que acontece: (idade >= 18 or idade >= 16) é avaliado primeiro. Para um adulto de 25 anos sem autorização (tem_autorizacao = False), o resultado seria: (True or True) and False → True and False → False. Ou seja, um adulto de 25 anos sem autorização não poderia entrar! Isso não faz sentido — adultos não precisam de autorização.

O problema é que os parênteses agruparam as duas condições de idade juntas, e agora ambas dependem da autorização.

Versão 3 — parênteses no lugar certo (CORRETO):

if idade >= 18 or (idade >= 16 and tem_autorizacao):
    print("Pode entrar!")

Agora sim! Os parênteses deixam claro que a autorização só é exigida para quem tem 16 ou 17 anos. Quem tem 18 ou mais entra independentemente da autorização. Vamos simular:

# Adulto de 25 sem autorização:
# idade >= 18 → True
# Como é 'or' e o lado esquerdo já é True, nem precisa avaliar o resto
# Resultado: True ✓ Pode entrar!

# Jovem de 16 com autorização:
# idade >= 18 → False
# (idade >= 16 and tem_autorizacao) → (True and True) → True
# False or True → True ✓ Pode entrar!

# Jovem de 16 sem autorização:
# idade >= 18 → False
# (idade >= 16 and tem_autorizacao) → (True and False) → False
# False or False → False ✗ Não pode entrar!

# Criança de 12:
# idade >= 18 → False
# (idade >= 16 and tem_autorizacao) → (False and ...) → False
# False or False → False ✗ Não pode entrar!

Moral da história: quando misturar and com or, sempre use parênteses para deixar claro o que deve ser avaliado junto. Mesmo que a ordem natural do Python dê o resultado certo, os parênteses tornam o código muito mais fácil de ler e de entender.

Tabela-verdade

Para consulta rápida, aqui está o comportamento completo de and, or e not:

A B A and B A or B not A
True True True True False
True False False True False
False True False True True
False False False False True

Não precisa decorar — com o tempo você internaliza. Mas a tabela é útil para consultar quando estiver em dúvida.

7. Condicionais aninhados

Um condicional aninhado é um if dentro de outro if. Imagine que você está num prédio e precisa passar por duas portas: primeiro verifica se tem a chave da porta de fora, e só se passar por ela verifica se tem a chave da porta de dentro. A segunda verificação só acontece se a primeira der certo.

Quando faz sentido

tem_ingresso = input("Você tem ingresso? (s/n): ").lower()

if tem_ingresso == "s":
    idade = int(input("Qual sua idade? "))
    if idade >= 18:
        print("Entrada liberada!")
    else:
        print("Entrada liberada na área para menores.")
else:
    print("Você precisa comprar um ingresso primeiro.")

Aqui faz sentido aninhar, porque a pergunta sobre idade só existe se a pessoa tiver ingresso. Se ela não tem ingresso, não adianta perguntar a idade — ela nem vai entrar. O if de dentro só é alcançado quando o if de fora é True.

Vamos simular três cenários:

Cenário 1: tem_ingresso = "n"
→ Cai no else de fora
→ Exibe "Você precisa comprar um ingresso primeiro."
→ A pergunta sobre idade nem aparece.

Cenário 2: tem_ingresso = "s", idade = 20
→ Entra no if de fora
→ Pergunta a idade
→ 20 >= 18 é True → "Entrada liberada!"

Cenário 3: tem_ingresso = "s", idade = 14
→ Entra no if de fora
→ Pergunta a idade
→ 14 >= 18 é False → "Entrada liberada na área para menores."

Quando é melhor evitar

Muitas vezes, condicionais aninhados podem ser substituídos por elif ou por operadores lógicos, deixando o código mais limpo e mais fácil de ler. Compare as duas versões:

# Versão com aninhamento — funciona, mas fica "escadinha"
if idade >= 18:
    if tem_carteira:
        print("Pode dirigir")
    else:
        print("Não pode dirigir, tire sua carteira")
else:
    print("Não pode dirigir, é menor de idade")
# Versão com operadores lógicos — mais limpa e direta
if idade >= 18 and tem_carteira:
    print("Pode dirigir")
elif idade >= 18 and not tem_carteira:
    print("Não pode dirigir, tire sua carteira")
else:
    print("Não pode dirigir, é menor de idade")

As duas versões fazem exatamente a mesma coisa, mas a segunda é mais fácil de ler porque todos os caminhos estão no mesmo nível de indentação.

Regra prática: se o seu código tem mais de dois níveis de indentação dentro de ifs aninhados (um if dentro de outro if dentro de outro if), é hora de repensar. Geralmente dá para simplificar com elif ou and/or.

8. Prática com Turtle e condicionais

Agora vamos juntar condicionais com o Turtle para criar programas interativos! O professor vai demonstrar os exemplos a seguir — acompanhe no seu computador.

8.1. Escolhendo a forma

Este programa pergunta ao usuário qual forma ele quer e desenha com o Turtle:

import turtle

t = turtle.Turtle()
t.speed(3)

forma = input("O que você quer desenhar? (triangulo / quadrado / circulo): ").lower()

if forma == "triangulo":
    # Um triângulo equilátero tem 3 lados e ângulo externo de 120°
    t.forward(100)
    t.left(120)
    t.forward(100)
    t.left(120)
    t.forward(100)
    t.left(120)
elif forma == "quadrado":
    # Um quadrado tem 4 lados e ângulo externo de 90°
    t.forward(100)
    t.left(90)
    t.forward(100)
    t.left(90)
    t.forward(100)
    t.left(90)
    t.forward(100)
    t.left(90)
elif forma == "circulo":
    t.circle(50)
else:
    print("Forma não reconhecida! Tente 'triangulo', 'quadrado' ou 'circulo'.")

turtle.done()

Repare que usamos .lower() no input() para aceitar "Triangulo", "TRIANGULO" ou "triangulo" — tudo é convertido para minúsculas antes de comparar.

O código do triângulo e do quadrado é repetitivo — são os mesmos dois comandos várias vezes. No capítulo 4 (Estruturas de repetição), vamos aprender a usar for para simplificar esse tipo de código.

8.2. Escolhendo cores

Aqui o usuário escolhe a cor do desenho. Repare que há um tratamento para quando o usuário digita algo que não está na lista — em vez de dar erro, usamos uma cor padrão:

import turtle

t = turtle.Turtle()
t.speed(3)
t.pensize(3)

cor = input("Escolha uma cor (vermelho / azul / verde): ").lower()

if cor == "vermelho":
    t.color("red")
elif cor == "azul":
    t.color("blue")
elif cor == "verde":
    t.color("green")
else:
    print(f"Cor '{cor}' não reconhecida. Usando preto.")
    t.color("black")

# Desenha um quadrado com a cor escolhida
t.forward(100)
t.left(90)
t.forward(100)
t.left(90)
t.forward(100)
t.left(90)
t.forward(100)
t.left(90)

turtle.done()

Uma observação: os nomes de cores no Turtle são em inglês (red, blue, green, black, yellow, orange, purple...). Por isso pedimos a cor em português e traduzimos para inglês no código.

8.3. Semáforo interativo

Esse é o mais elaborado. O programa desenha um semáforo e acende a luz que o usuário escolher. As outras ficam cinza.

Usamos aqui uma técnica nova: uma variável para guardar a tradução da cor. Isso simplifica o código em vez de repetir .replace() várias vezes:

import turtle

t = turtle.Turtle()
t.speed(5)
t.pensize(2)

sinal = input("Qual sinal está aceso? (vermelho / amarelo / verde): ").lower()

# Traduz a cor escolhida para inglês
if sinal == "vermelho":
    cor_acesa = "red"
elif sinal == "amarelo":
    cor_acesa = "yellow"
elif sinal == "verde":
    cor_acesa = "green"
else:
    print("Cor não reconhecida! Usando vermelho.")
    cor_acesa = "red"

# Desenha o corpo do semáforo (retângulo preto)
t.penup()
t.goto(-30, -100)
t.pendown()
t.color("black")
t.begin_fill()
t.forward(60)
t.left(90)
t.forward(180)
t.left(90)
t.forward(60)
t.left(90)
t.forward(180)
t.left(90)
t.end_fill()

# Desenha a luz vermelha (em cima)
t.penup()
t.goto(0, 40)
t.pendown()
if cor_acesa == "red":
    t.color("red")
else:
    t.color("gray")
t.begin_fill()
t.circle(20)
t.end_fill()

# Desenha a luz amarela (no meio)
t.penup()
t.goto(0, -10)
t.pendown()
if cor_acesa == "yellow":
    t.color("yellow")
else:
    t.color("gray")
t.begin_fill()
t.circle(20)
t.end_fill()

# Desenha a luz verde (embaixo)
t.penup()
t.goto(0, -60)
t.pendown()
if cor_acesa == "green":
    t.color("green")
else:
    t.color("gray")
t.begin_fill()
t.circle(20)
t.end_fill()

t.hideturtle()
turtle.done()

Repare que o código para desenhar cada luz é muito parecido — só muda a posição e a cor que comparamos. Há código repetido aqui, e isso é proposital: no Capítulo 5 (Funções), vamos aprender a criar uma função desenha_luz() para evitar essa repetição.

9. Exercícios

Agora é a sua vez! Tente resolver cada exercício sozinho antes de pedir ajuda. Lembre-se: errar faz parte do aprendizado — leia as mensagens de erro com calma, elas geralmente dizem exatamente o que está errado.

Se travar em algum exercício, tente estas estratégias:

  1. Desenhe o fluxograma primeiro (no caderno mesmo, não precisa ser bonito)
  2. Pense em quais são os caminhos possíveis do programa
  3. Teste seu programa com diferentes entradas, inclusive entradas "estranhas"

a) Crie um programa que peça a idade do usuário e informe se ele pode votar (>= 16 anos), se o voto é obrigatório (entre 18 e 69) ou facultativo (16-17 ou >= 70). Se a idade for menor que 16, exiba que a pessoa ainda não pode votar.

b) Escreva um programa que funcione como uma calculadora simples: peça dois números e uma operação (+, -, *, /) e exiba o resultado. Se a operação for divisão e o segundo número for zero, exiba uma mensagem de erro em vez de tentar dividir (dividir por zero causa erro no Python!).

c) Crie um programa que peça três números ao usuário e exiba o maior e o menor deles. Dica: você vai precisar comparar os números dois a dois.

d) Com o Turtle, peça ao usuário para escolher uma forma ("triangulo", "quadrado", "pentagono" ou "hexagono") e desenhe a forma escolhida com o tamanho de lado 100. Se digitar algo inválido, exiba uma mensagem de erro. Dica: para o pentágono, o ângulo externo é 72°; para o hexágono, é 60°.

e) Escreva um programa que peça um ano ao usuário e informe se é bissexto. A regra é: um ano é bissexto se for divisível por 4, exceto os divisíveis por 100, que só são bissextos se também forem divisíveis por 400. Teste com: 2024 (bissexto), 1900 (não é), 2000 (é). Dica: use and, or e o operador %.

f) Crie um programa que simule um caixa eletrônico simplificado: o usuário digita o valor do saque (que deve ser múltiplo de 2) e o programa informa quantas notas de 100, 50, 20, 10, 5 e 2 serão usadas, sempre priorizando as notas maiores. Dica: use divisão inteira (//) e módulo (%).

g) Com o Turtle, crie um programa que peça uma cor ao usuário ("vermelho", "amarelo" ou "verde") e desenhe um sinal de trânsito (três círculos empilhados), destacando o círculo da cor escolhida. Os outros devem ficar cinza. É parecido com o exemplo da prática, mas tente fazer sozinho!

h) Escreva um programa que peça o peso (em kg) e a altura (em metros) do usuário, calcule o IMC (fórmula: peso / altura²) e classifique: abaixo do peso (< 18.5), peso normal (18.5-24.9), sobrepeso (25-29.9) ou obesidade (>= 30). Exiba o valor do IMC formatado com uma casa decimal.

i) Crie um jogo de pedra, papel e tesoura contra o computador. O computador escolhe aleatoriamente (use import random e random.choice(["pedra", "papel", "tesoura"])), o usuário digita sua escolha, e o programa diz quem ganhou. Lembre-se de tratar empates! Dica: são 9 combinações possíveis (3 escolhas × 3 escolhas).

j) Escreva um programa que peça o salário de um funcionário e calcule o aumento conforme a faixa: até R$1.500 ganha 15%, de R$1.500 a R$3.000 ganha 10%, acima de R$3.000 ganha 5%. Exiba o salário antigo, o percentual de aumento, o valor do aumento em reais e o novo salário, todos formatados com duas casas decimais.

10. Desafio de capítulo: Quiz interativo

Crie um quiz interativo com pelo menos 5 perguntas sobre um tema que você goste (esportes, games, ciência, música, história — o que quiser!). O programa deve:

Dica: use uma variável pontos que começa em 0 e aumenta 1 a cada acerto. Use .lower() nas respostas para não errar por causa de maiúsculas/minúsculas.

Exemplo de como pode começar:

pontos = 0

print("=" * 40)
print("     Quiz de Ciências")
print("=" * 40)
print()

# Pergunta 1
resposta = input("1. Qual é o planeta mais próximo do Sol? ").lower()
if resposta == "mercúrio" or resposta == "mercurio":
    print("✓ Correto!")
    pontos = pontos + 1
else:
    print(f"✗ Errado! Você respondeu '{resposta}'. A resposta certa era Mercúrio.")

print()

# Pergunta 2
resposta = input("2. Qual é a fórmula química da água? ").lower()
if resposta == "h2o":
    print("✓ Correto!")
    pontos = pontos + 1
else:
    print(f"✗ Errado! Você respondeu '{resposta}'. A resposta certa era H2O.")

print()

# Continue com mais 3 perguntas...

# No final, exiba a pontuação:
print("=" * 40)
print(f"Você acertou {pontos} de 5 perguntas!")
print()

if pontos == 5:
    print("Perfeito! Você é um expert!")
elif pontos == 4:
    print("Muito bem! Quase perfeito!")
elif pontos == 3:
    print("Bom, mas pode melhorar!")
else:
    print("Estude mais e tente de novo!")

Extra para quem quiser ir além: em vez de perguntas abertas, faça perguntas de múltipla escolha — exiba as opções (A, B, C, D) e peça ao usuário para digitar a letra. Isso também é mais fácil de corrigir no código, porque você compara apenas uma letra!

Python