2 Estruturas de Controle Condicionais
Nesta seção, aprenderemos como fazer nossos programas tomarem decisões.
2.1 Tomando Decisões com if/else
A estrutura if/else permite que o programa execute blocos de código diferentes com base em uma condição ser Verdadeira ou Falsa.
Sintaxe:
if condicao:
# Código a ser executado se a condição for Verdadeira
else:
# Código a ser executado se a condição for FalsaAtenção: A indentação (o espaço no início da linha) é como o Python sabe qual código pertence ao if e qual pertence ao else.
Exemplos Práticos:
(portao.py): Um portão eletrônico que só abre com a senha correta.
# -#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-
#
# Crie um programa que funcione como um portão com senha.
#
# O programa deve pedir ao usuário para digitar uma senha.
# A senha correta é "python".
#
# - Se o usuário digitar a senha correta, o programa deve exibir "Acesso Permitido.".
# - Se o usuário digitar qualquer outra coisa, o programa deve exibir "Acesso Negado.".
#
# -#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-
# Pede a senha ao usuário e armazena o texto digitado na variável `senha`.
senha = input("Digite a senha: ")
# A estrutura `if/else` toma uma decisão com base em uma condição.
# A condição `senha == "python"` compara o texto na variável `senha` com o
# texto "python". O operador `==` verifica se os dois são exatamente iguais.
if senha == "python":
# Este bloco de código só é executado se a condição for Verdadeira.
print("Acesso Permitido.")
else:
# Se a condição for Falsa (a senha não é "python"),
# o programa pula o bloco `if` e executa este bloco `else`.
print("Acesso Negado.")
Explicação: O programa compara (==) a senha digitada com "python". Se forem iguais, o primeiro bloco é executado. Caso contrário, o bloco do else é executado.
(positivo.py): Verifica se um número é positivo ou negativo.
# -#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-
#
# Crie um programa que verifique se um número é positivo ou negativo.
#
# O programa deve pedir ao usuário para digitar um número inteiro.
#
# - Se o número for maior ou igual a zero, o programa deve exibir "Número positivo.".
# - Se o número for menor que zero, o programa deve exibir "Número negativo.".
#
# -#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-
# A função `input()` lê o que o usuário digita e retorna como texto (string).
# A função `int()` converte esse texto para um número inteiro.
num = int(input("Digite um número: "))
# A estrutura `if/else` avalia a condição `num >= 0`.
# O operador `>=` significa "maior ou igual a".
if num >= 0:
# Se a condição for Verdadeira (o número é 0, 1, 2, ...),
# este bloco de código é executado.
print("Número positivo.")
else:
# Se a condição for Falsa (o número é -1, -2, ...),
# o programa ignora o bloco `if` e executa este bloco `else`.
print("Número negativo.")
2.2 Múltiplas Condições com if/elif/else
Quando temos mais de duas possibilidades, usamos o elif (uma contração de “else if”) para testar várias condições em sequência.
Exemplos Práticos:
(corretor.py): Atribui um conceito (A, B, C, F) com base na nota de um aluno.
# -#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-
#
# Crie um programa que converta uma nota numérica em um conceito alfabético.
#
# O programa deve primeiro pedir ao usuário para digitar uma nota de 0 a 100.
# Depois, ele deve atribuir e exibir um conceito com base na seguinte tabela:
#
# - Nota >= 90: Conceito A
# - Nota >= 75: Conceito B
# - Nota >= 50: Conceito C
# - Nota < 50: Conceito F
#
# O programa deve exibir o conceito correspondente à nota fornecida.
#
# -#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-
# Lê a nota do usuário
nota = int(input("Digite a nota (0-100): "))
# Pense na estrutura `if/elif/else` como uma cascata de verificações.
# O Python testa a primeira condição (`nota >= 90`). Se for verdadeira,
# ele executa o código daquele bloco e ignora todo o resto do `if`.
#
# Se a primeira condição for falsa, ele desce para a próxima (`nota >= 75`).
# Ao chegar aqui, já sabemos que a nota é menor que 90 porque a condição `nota >= 90` falhou,
# por isso, não é preciso verificar `nota < 90`. A própria estrutura `elif` garante isso.
# O mesmo vale para os `elif`s seguintes.
if nota >= 90:
print("Conceito: A")
elif nota >= 75:
print("Conceito: B")
elif nota >= 50:
print("Conceito: C")
else:
print("Conceito: F")
Explicação: O Python testa as condições em ordem. Assim que uma delas for Verdadeira, ele executa o bloco correspondente e ignora o resto.
(semaforo.py): Simula o comportamento de um semáforo.
# -#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-
#
# Crie um programa que simule o funcionamento de um semáforo.
#
# O programa deve primeiro pedir ao usuário para digitar uma cor de semáforo
# (as opções são "vermelho", "amarelo", "verde").
#
# Com base na cor digitada, o programa deve exibir a ação correspondente:
# - "vermelho": "Pare."
# - "amarelo": "Atenção."
# - "verde": "Siga."
#
# Se o usuário digitar qualquer outra cor, o programa deve exibir "Cor inválida.".
#
# -#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-
# Pede a cor ao usuário
cor = input("Digite a cor (vermelho/amarelo/verde): ")
# Este exemplo usa `if/elif/else` para tomar uma decisão com base no texto (string) digitado
# pelo usuário. O Python primeiro verifica se a cor é "vermelho". Se for, ele imprime "Pare." e
# ignora o resto da estrutura. Se não for, ele passa para o `elif` e faz a próxima verificação.
# O bloco `else` no final funciona como uma rota de escape, capturando qualquer entrada que
# não corresponda a nenhuma das condições anteriores.
if cor == "vermelho":
print("Pare.")
elif cor == "amarelo":
print("Atenção.")
elif cor == "verde":
print("Siga.")
else:
print("Cor inválida.")
(menu.py): Cria um menu de opções simples para o usuário.
# -#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-
#
# Crie um programa que simule um menu de jogo simples.
#
# O programa deve primeiro exibir as seguintes opções para o usuário:
# 1. Iniciar Jogo
# 2. Carregar Jogo
# 3. Sair
#
# Em seguida, o programa deve pedir ao usuário para digitar sua escolha (1, 2 ou 3).
#
# Com base na escolha numérica do usuário, o programa deve exibir uma das seguintes mensagens:
# - Se a escolha for 1: "Iniciando..."
# - Se a escolha for 2: "Carregando..."
# - Se a escolha for 3: "Saindo..."
# - Para qualquer outro número: "Seleção desconhecida."
#
# -#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-
# Exibe as opções e pede a escolha ao usuário
print("1. Iniciar Jogo")
print("2. Carregar Jogo")
print("3. Sair")
escolha = int(input("Digite a escolha (1/2/3): "))
# Este exemplo usa uma estrutura `if/elif/else` para responder à
# entrada do usuário. Cada `if` ou `elif` verifica se a `escolha`
# corresponde a um dos valores esperados (1, 2 ou 3).
# Se uma correspondência for encontrada, o bloco de código associado
# é executado e o resto da estrutura é ignorado.
# O `else` final lida com qualquer entrada que não seja uma das opções válidas.
if escolha == 1:
print("Iniciando...")
elif escolha == 2:
print("Carregando...")
elif escolha == 3:
print("Saindo...")
else:
print("Seleção desconhecida.")
2.3 Combinando Condições: Operadores Booleanos
Podemos criar condições mais complexas usando os operadores and, or e not.
and: Ambas as condições precisam ser Verdadeiras.or: Pelo menos uma das condições precisa ser Verdadeira.not: Inverte o resultado da condição (Verdadeiro vira Falso e vice-versa).
Exemplos Práticos:
and (montanha_russa.py): Para entrar no brinquedo, você precisa ter altura E idade mínimas.
# -#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-
#
# Crie um programa que verifique se uma pessoa pode andar em uma montanha-russa.
#
# O programa deve primeiro pedir ao usuário sua altura em centímetros e sua idade.
#
# Para que uma pessoa possa andar na montanha-russa, AMBAS as condições a seguir devem ser verdadeiras:
# 1. A altura deve ser superior a 120 cm.
# 2. A idade deve ser de 12 anos ou mais.
#
# O programa deve exibir "Você pode andar no brinquedo." se ambas as condições forem atendidas,
# ou "Você não pode andar." caso contrário.
#
# -#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-
# Pede a altura e a idade ao usuário
altura = int(input("Digite altura em cm: "))
idade = int(input("Digite idade: "))
# A estrutura `if/else` com o operador `and` é usada para checar múltiplas condições.
# O operador `and` exige que AMBAS as condições (`altura > 120` e `idade >= 12`)
# sejam verdadeiras para que o bloco de código do `if` seja executado.
# Se uma das condições (ou ambas) for falsa, o programa pula para o bloco `else`.
if altura > 120 and idade >= 12:
print("Você pode andar no brinquedo.")
else:
print("Você não pode andar.")
or (desconto.py): Para ter desconto, você precisa ser estudante OU ter mais de 60 anos.
# -#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-
#
# Crie um programa que determine se um cliente tem direito a um desconto.
#
# O programa deve primeiro perguntar ao usuário duas coisas:
# 1. Se ele é estudante (a resposta deve ser "sim" ou "nao").
# 2. Qual é a sua idade.
#
# Um cliente tem direito ao desconto se pelo menos uma das seguintes condições for verdadeira:
# - O cliente é um estudante.
# - O cliente tem mais de 60 anos.
#
# O programa deve então exibir "Desconto aplicado!" ou "Preço normal." com base nas respostas.
#
# -#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-
# Pergunta o status e a idade do usuário
status = input("Você é estudante (sim/nao)? ")
idade = int(input("Digite sua idade: "))
# A estrutura `if/else` com o operador `or` testa múltiplas condições.
# O operador `or` exige que APENAS UMA das condições (`status == "sim"` ou `idade > 60`)
# seja verdadeira para que o bloco do `if` seja executado.
# O programa só executará o bloco `else` se AMBAS as condições forem falsas.
if status == "sim" or idade > 60:
print("Desconto aplicado!")
else:
print("Preço normal.")
not (game_over.py): O jogo continua se a condição game_over NÃO for Verdadeira.
# -#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-
#
# Crie um programa que demonstre o uso do operador lógico `not`.
#
# O programa deve usar uma única variável booleana chamada `game_over`.
#
# A lógica do programa deve ser a seguinte:
# - Se `game_over` for `False`, o programa deve exibir "Continue jogando!".
# - Se `game_over` for `True`, o programa deve exibir "Fim de Jogo.".
#
# Use o operador `not` para inverter a condição no seu `if`.
#
# -#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-
# Define uma variável booleana
game_over = False
# O operador `not` inverte o valor de uma condição booleana.
# Se `game_over` é `False`, `not game_over` se torna `True`.
# Se `game_over` fosse `True`, `not game_over` se tornaria `False`.
# Isso é útil para verificar o oposto de uma condição.
if not game_over:
print("Continue jogando!")
else:
print("Fim de Jogo.")
2.4 Decisões Aninhadas
Podemos colocar uma estrutura if/else dentro de outra. Isso é útil para fazer verificações sequenciais.
Exemplos Práticos:
(login.py): Um sistema de login que primeiro verifica o usuário e, se o usuário estiver correto, verifica a senha.
# -#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-
#
# Crie um programa que simule um sistema de login simples.
#
# O programa deve primeiro pedir ao usuário para digitar um nome de usuário.
#
# A lógica de verificação deve ser aninhada:
# 1. Verificação Externa (Usuário):
# - Se o nome de usuário for "admin", o programa deve então pedir a senha.
# - Se o nome de usuário for qualquer outra coisa, o programa deve exibir "Usuário desconhecido."
#
# 2. Verificação Interna (Senha) - Só acontece se o usuário for "admin":
# - Se a senha digitada for "1234", o programa deve exibir "Bem-vindo, Administrador.".
# - Se a senha for incorreta, deve exibir "Senha errada.".
#
# -#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-
# Pede o nome de usuário
usuario = input("Usuário: ")
# A primeira estrutura `if/else` (externa) verifica o nome de usuário.
# Se o usuário for "admin", o programa entra no bloco `if` para fazer uma
# segunda verificação (a da senha).
# Se o usuário não for "admin", o programa executa o `else` e termina.
if usuario == "admin":
# Se o usuário estiver correto, o programa pede a senha.
senha = input("Senha: ")
# A segunda estrutura `if/else` (interna ou aninhada) verifica a senha.
# Esta verificação só acontece se a primeira (usuário) for bem-sucedida.
if senha == "1234":
print("Bem-vindo, Administrador.")
else:
print("Senha errada.")
else:
# Caso o usuário nem seja "admin"
print("Usuário desconhecido.")
Explicação: A verificação da senha só acontece se a verificação do usuário for bem-sucedida.
(loja.py): Verifica o estoque antes de perguntar sobre o tamanho do produto.
# -#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-
#
# Crie um programa que simule a verificação de estoque de uma loja.
#
# O programa deve primeiro perguntar a quantidade de itens no estoque.
#
# A lógica de verificação deve ser aninhada:
# 1. Verificação de Estoque:
# - Se o estoque for maior que 0, o programa deve então perguntar o tamanho desejado (P/M).
# - Se o estoque for 0 ou menos, o programa deve exibir "Fora de estoque." e terminar.
#
# 2. Verificação de Tamanho - Só acontece se houver estoque:
# - Se o tamanho for "P", exiba "Aqui está o tamanho Pequeno.".
# - Se o tamanho for "M", exiba "Aqui está o tamanho Médio.".
#
# -#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-
# Verifica a quantidade total
estoque = int(input("Quantos itens no estoque? "))
# A primeira estrutura `if/else` (externa) verifica se há itens no estoque.
# Se `estoque > 0` for verdadeiro, o programa entra no bloco `if` para
# perguntar sobre o tamanho.
# Se for falso, o programa pula para o `else` e informa que não há estoque.
if estoque > 0:
tamanho = input("Tamanho (P/M)? ")
# A segunda estrutura `if/else` (interna) só é executada se houver estoque.
# Ela verifica qual tamanho o cliente escolheu e exibe a mensagem apropriada.
if tamanho == "P":
print("Aqui está o tamanho Pequeno.")
else:
print("Aqui está o tamanho Médio.")
else:
# Se estoque for 0 ou negativo, nem pergunta o tamanho
print("Fora de estoque.")
(qualificacao.py): Combina operadores lógicos com aninhamento para um sistema de qualificação mais complexo.
# -#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-
#
# Crie um programa que simule um processo de qualificação para uma vaga de emprego.
#
# O programa deve usar verificações aninhadas para decidir se um candidato é contratado.
#
# A lógica é a seguinte:
# 1. Verificação de Diploma:
# - O programa primeiro pergunta se o candidato tem diploma ("sim" ou "nao").
# - Se a resposta for "nao", o programa deve exibir "Diploma é obrigatório." e terminar.
# - Se a resposta for "sim", o programa deve prosseguir para a próxima verificação.
#
# 2. Verificação de Experiência - Só acontece se o candidato tiver diploma:
# - O programa pergunta os anos de experiência.
# - Se a experiência for maior que 3 anos, exiba "Você foi contratado!".
# - Caso contrário, exiba "Experiência insuficiente.".
#
# -#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-
# Pergunta se tem diploma
diploma = input("Você tem diploma (sim/nao)? ")
# A primeira estrutura `if/else` (externa) verifica se o candidato tem diploma.
# Se a resposta for "sim", o programa avança para a verificação de experiência.
# Se for "nao", o programa executa o `else` e encerra, pois o diploma é um pré-requisito.
if diploma == "sim":
experiencia = int(input("Anos de experiência: "))
# A segunda estrutura `if/else` (interna) avalia os anos de experiência.
# Ela só é alcançada se o candidato tiver um diploma.
if experiencia > 3:
print("Você foi contratado!")
else:
print("Experiência insuficiente.")
else:
# Se não tiver diploma, é rejeitado imediatamente
print("Diploma é obrigatório.")
2.5 Mais Exemplos com Aninhamento
Vamos combinar o que aprendemos para resolver problemas com múltiplos níveis de decisão.
Exemplos Práticos:
(classificacao_produto.py): Um sistema que usa if/elif/else para a categoria principal e, dentro de cada uma, aninha outras condições para preço e avaliação.
# -#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-
#
# Crie um programa que classifica um produto com base em sua categoria, preço e avaliação.
#
# O programa deve pedir ao usuário três informações:
# 1. Categoria do produto (as opções são: "eletrônicos", "roupas", "alimentos").
# 2. Preço do produto (um número com casas decimais).
# 3. Avaliação do produto (um número de 0 a 5).
#
# A lógica de classificação é complexa e aninhada:
#
# - Se a categoria for "eletrônicos":
# - Se o preço for > 5000, é um "Produto de alto valor".
# - Se a avaliação for >= 4.5, a recomendação é "Compra premium, excelente avaliação.".
# - Senão, a recomendação é "Considere outras opções devido à avaliação.".
# - Se o preço estiver entre 1000 e 5000, é um "Produto de médio valor".
# - Se a avaliação for >= 4.0, a recomendação é "Bom custo-benefício.".
# - Senão, a recomendação é "Pesquise por promoções.".
# - Se o preço for < 1000, é um "Produto de baixo valor e acessível.".
#
# - Se a categoria for "roupas":
# - Se a avaliação for >= 4.5, é uma "Peça de alta qualidade e bem avaliada.".
# - Se o preço for > 200, a recomendação é "Item de grife/especial.".
# - Senão, a recomendação é "Ótima compra!".
# - Se a avaliação for < 4.5, é uma "Peça comum.".
# - Se o preço for < 50, a recomendação é "Bom para o dia a dia.".
# - Senão, a recomendação é "Verifique a qualidade do tecido.".
#
# - Se a categoria for "alimentos":
# - A categoria é impressa.
# - Se o preço for > 50, é um "Produto gourmet.".
# - Senão, é um "Produto de consumo regular.".
# - Adicionalmente, se a avaliação for < 3.0, uma atenção é emitida.
#
# - Se a categoria não for nenhuma das anteriores, exiba "Categoria não reconhecida.".
#
# -#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-
categoria = input("Digite a categoria do produto (eletrônicos, roupas, alimentos): ")
preco = float(input("Digite o preço do produto: R$ "))
avaliacao = float(input("Digite a avaliação do produto (0 a 5): "))
print()
print("--- Classificação do Produto ---")
# A estrutura `if/elif/else` principal separa o fluxo do programa pela categoria.
# Cada bloco de categoria tem suas próprias regras e lógicas aninhadas.
if categoria == "eletrônicos":
# Dentro da categoria "eletrônicos", a primeira verificação aninhada é o preço.
if preco > 5000:
print("Produto de alto valor.")
# Dentro dos produtos de alto valor, há outra verificação aninhada para a avaliação.
if avaliacao >= 4.5:
print("Recomendação: Compra premium, excelente avaliação.")
else:
print("Recomendação: Considere outras opções devido à avaliação.")
elif 1000 <= preco <= 5000:
print("Produto de médio valor.")
if avaliacao >= 4.0:
print("Recomendação: Bom custo-benefício.")
else:
print("Recomendação: Pesquise por promoções.")
else:
print("Produto de baixo valor e acessível.")
elif categoria == "roupas":
# Para "roupas", a lógica aninhada começa pela avaliação.
if avaliacao >= 4.5:
print("Peça de alta qualidade e bem avaliada.")
# A verificação de preço vem depois da avaliação.
if preco > 200:
print("Recomendação: Item de grife/especial.")
else:
print("Recomendação: Ótima compra!")
else:
print("Peça comum.")
if preco < 50:
print("Recomendação: Bom para o dia a dia.")
else:
print("Recomendação: Verifique a qualidade do tecido.")
elif categoria == "alimentos":
print("Categoria: Alimentos.")
# Para "alimentos", as verificações são mais simples e não tão aninhadas.
if preco > 50:
print("Produto gourmet.")
else:
print("Produto de consumo regular.")
# Esta é uma verificação independente que ocorre para qualquer alimento.
if avaliacao < 3.0:
print("Atenção: Produto com baixa avaliação de consumidores.")
else:
# O `else` final captura qualquer categoria que não seja uma das esperadas.
print("Categoria não reconhecida. Não é possível fazer uma recomendação.")
(diagnostico.py): Um exemplo com múltiplos níveis de ifs aninhados para simular uma triagem de diagnóstico simples.
# -#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-
#
# Crie um programa que simule um sistema de triagem médica simples.
#
# O programa deve fazer uma série de perguntas de "sim" ou "não" para chegar a um diagnóstico preliminar.
# A lógica de decisão deve ser aninhada, seguindo a árvore abaixo:
#
# 1. O paciente tem febre?
# - Se SIM:
# 2. O paciente tem tosse?
# - Se SIM:
# 3. O paciente tem dificuldade para respirar?
# - Se SIM: Diagnóstico de "Alerta! Risco de condição respiratória grave."
# - Se NÃO: Diagnóstico de "Pode ser uma gripe ou resfriado forte."
# - Se NÃO:
# 3. O paciente tem dor de cabeça forte?
# - Se SIM: Diagnóstico de "Pode ser uma virose ou dengue."
# - Se NÃO: Diagnóstico de "Febre sem outros sintomas claros."
# - Se NÃO:
# 2. O paciente tem dor no corpo?
# - Se SIM: Diagnóstico de "Pode ser fadiga muscular ou estresse."
# - Se NÃO: Diagnóstico de "Sintomas não indicam uma condição clara."
#
# O programa deve exibir o diagnóstico final com base nas respostas.
#
# -#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-
print("--- Sistema de Triagem Médica Simples ---")
print("Responda às perguntas com 'sim' ou 'não'.")
# O primeiro `if` cria a primeira grande bifurcação na lógica: com febre ou sem febre.
sintoma_febre = input("O paciente tem febre? ")
if sintoma_febre == "sim":
# Este bloco inteiro só é executado se o paciente tiver febre.
# A segunda pergunta (tosse) está aninhada aqui.
sintoma_tosse = input("O paciente tem tosse? ")
if sintoma_tosse == "sim":
# Este bloco só é executado se o paciente tiver febre E tosse.
# A terceira pergunta (dificuldade de respirar) está aninhada aqui.
sintoma_dificuldade_respirar = input("O paciente tem dificuldade para respirar? ")
if sintoma_dificuldade_respirar == "sim":
print("Diagnóstico: Alerta! Risco de condição respiratória grave.")
print("Procurar um médico imediatamente.")
else:
print("Diagnóstico: Pode ser uma gripe ou resfriado forte.")
print("Recomenda-se observação e consulta médica se os sintomas piorarem.")
else: # Não tem tosse, mas tem febre
# Este bloco é executado se o paciente tiver febre, mas NÃO tiver tosse.
sintoma_dor_cabeca = input("O paciente tem dor de cabeça forte? ")
if sintoma_dor_cabeca == "sim":
print("Diagnóstico: Pode ser uma virose ou dengue.")
print("Monitorar e procurar um médico.")
else:
print("Diagnóstico: Febre sem outros sintomas claros.")
print("Manter observação e hidratação.")
else: # Não tem febre
# Este bloco `else` corresponde ao primeiro `if`. Ele só é executado se o paciente NÃO tiver febre.
sintoma_dor_corpo = input("O paciente tem dor no corpo? ")
if sintoma_dor_corpo == "sim":
print("Diagnóstico: Pode ser fadiga muscular ou estresse.")
print("Repouso é recomendado.")
else:
print("Diagnóstico: Sintomas não indicam uma condição clara.")
print("Se o mal-estar persistir, consulte um médico.")
2.6 Alguns exemplos práticos
Aqui estão mais alguns exemplos que combinam as ideias anteriores para resolver problemas do mundo real e um desafio de engenharia.
Exemplos Práticos:
(aventura_texto.py): Um mini jogo de aventura onde cada escolha do jogador leva a um resultado diferente, usando if/elif/else aninhados.
# -#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-
#
# Crie um mini jogo de aventura em texto onde as escolhas do jogador determinam o resultado.
#
# O jogo começa com uma descrição e uma escolha inicial. Cada escolha leva a um novo cenário
# com uma nova escolha, criando uma estrutura de "árvore de decisões".
#
# A estrutura da aventura é a seguinte:
#
# 1. Início: Você está em uma bifurcação. Caminhos: "esquerda" ou "direita".
# - Se escolher "esquerda":
# - Cenário: Você encontra uma cabana abandonada.
# - Escolha: "entrar" ou "continuar".
# - Se "entrar": Fim de jogo (fantasma).
# - Se "continuar": Fim de jogo (rio).
# - Outra escolha: Fim de jogo (lobos).
# - Se escolher "direita":
# - Cenário: Você encontra uma fonte mágica.
# - Escolha: "beber" ou "ignorar".
# - Se "beber": Vitória!
# - Se "ignorar": Fim de jogo (escuridão).
# - Outra escolha: Fim de jogo (fonte seca).
# - Se a primeira escolha for inválida: Fim de jogo (indecisão).
#
# O programa deve guiar o jogador por essa narrativa, usando `if/elif/else` aninhados.
#
# -#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-
print("--- Aventura na Floresta Sombria ---")
print("Você está em uma bifurcação na floresta. O caminho da esquerda parece mais escuro,")
print("enquanto o da direita tem um brilho fraco.")
# A primeira estrutura `if/elif/else` lida com a primeira e mais importante escolha do jogador.
escolha1 = input("Qual caminho você escolhe? (esquerda/direita): ")
if escolha1 == "esquerda":
# Este bloco de código representa todo o ramo da história do "caminho da esquerda".
print("Você segue pelo caminho escuro. Após alguns minutos, encontra uma cabana abandonada.")
# Uma nova escolha é apresentada, e uma nova estrutura `if/elif/else` aninhada é usada.
escolha2 = input("Você decide entrar na cabana ou continuar pelo caminho? (entrar/continuar): ")
if escolha2 == "entrar":
print()
print("Dentro da cabana, você encontra um baú. Ao abri-lo, um fantasma aparece!")
print("FIM DE JOGO: Você foi assombrado.")
elif escolha2 == "continuar":
print()
print("Você ignora a cabana e continua.")
print("Mais à frente, o caminho termina em um rio largo e de correnteza forte.")
print("FIM DE JOGO: Você não consegue atravessar.")
else:
# O `else` aninhado captura uma decisão inválida para a segunda escolha.
print()
print("Decisão inválida. A hesitação atraiu os lobos.")
print("FIM DE JOGO: Você foi cercado.")
elif escolha1 == "direita":
# Este bloco de código representa todo o ramo da história do "caminho da direita".
print()
print("Você segue em direção ao brilho. Você encontra uma fonte mágica que emana a luz.")
# Novamente, uma nova escolha com uma nova estrutura aninhada.
escolha3 = input("Você bebe da fonte ou a ignora? (beber/ignorar): ")
if escolha3 == "beber":
print()
print("Ao beber a água, você se sente revigorado e ganha a habilidade de ver no escuro.")
print("VITÓRIA: Você agora pode explorar a floresta com segurança!")
elif escolha3 == "ignorar":
print()
print("Você decide não arriscar.")
print("A fonte para de brilhar e a floresta fica completamente escura.")
print("FIM DE JOGO: Você está perdido na escuridão.")
else:
print()
print("Decisão inválida. A fonte interpreta sua indecisão como uma ofensa e seca.")
print("FIM DE JOGO: Você perdeu sua chance.")
else:
# Este `else` final pertence à primeira estrutura e captura uma decisão inválida na primeira escolha.
print()
print("Você não conseguiu decidir. Ficou parado no mesmo lugar até a noite cair.")
print("FIM DE JOGO: A floresta não perdoa a indecisão.")
(custo_frete.py): Um sistema mais realista para calcular o custo de um frete, combinando peso, distância e método de envio em uma série de decisões.
# -#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-
#
# Crie um programa que calcule o custo do frete de um pacote com base em várias condições.
#
# O cálculo do custo é dividido em três partes:
#
# 1. Custo Base por Peso:
# - Pacotes com até 1 kg: Custo fixo de R$ 10,00.
# - Pacotes de 1 a 5 kg: R$ 10,00 + R$ 2,50 por kg acima de 1 kg.
# - Pacotes com mais de 5 kg: R$ 20,00 + R$ 3,75 (2.50 * 1.5) por kg acima de 5 kg.
#
# 2. Adicional por Distância:
# - Distância de até 100 km: Adicional de R$ 5,00.
# - Distância entre 101 km e 500 km: Adicional de R$ 20,00.
# - Distância acima de 500 km: Adicional de R$ 50,00.
#
# 3. Multiplicador por Método de Envio:
# - "normal": Sem custo adicional (multiplicador 1.0).
# - "expresso": Custo total é multiplicado por 1.5 (aumento de 50%).
# - "prioritario": Custo total é multiplicado por 2.0 (aumento de 100%).
#
# O programa deve pedir ao usuário o peso, a distância e o método de envio,
# e então calcular e exibir o custo final do frete.
#
# -#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-
# Lê as informações do pacote do usuário.
peso_kg = float(input("Digite o peso do pacote (kg): "))
distancia_km = int(input("Digite a distância da entrega (km): "))
metodo_envio = input("Digite o método de envio (normal, expresso, prioritario): ")
# Define a taxa de aumento para pacotes mais pesados.
taxa_base_por_kg = 2.50
custo_frete = 0.0
# 1. Cálculo baseado no peso
# Esta primeira estrutura `if/elif/else` define um custo inicial com base no peso.
# - Pacotes com até 1 kg têm um custo fixo.
# - Pacotes entre 1 kg e 5 kg têm um custo base mais uma taxa por kg adicional.
# - Pacotes com mais de 5 kg têm um custo base maior e uma taxa por kg mais alta.
if peso_kg <= 1:
custo_frete = 10.0
elif 1 < peso_kg <= 5:
custo_frete = 10.0 + (peso_kg - 1) * taxa_base_por_kg
else: # peso_kg > 5
custo_frete = 20.0 + (peso_kg - 5) * (taxa_base_por_kg * 1.5) # Taxa maior para pacotes pesados
# 2. Adicional baseado na distância
# A segunda estrutura `if/elif/else` adiciona um valor ao custo do frete
# com base na distância da entrega. Note que o `custo_frete` é atualizado
# de forma incremental (custo_frete = custo_frete + ...).
if distancia_km > 500:
custo_frete = custo_frete + 50.0 # Taxa de longa distância
elif 100 < distancia_km <= 500:
custo_frete = custo_frete + 20.0 # Taxa de média distância
else: # distancia_km <= 100
custo_frete = custo_frete + 5.0 # Taxa local
# 3. Multiplicador por método de envio
# A terceira estrutura `if/elif/else` aplica um multiplicador ao custo
# com base no método de envio escolhido pelo usuário.
if metodo_envio.lower() == "expresso":
custo_frete = custo_frete * 1.5 # Aumento de 50%
elif metodo_envio.lower() == "prioritario":
custo_frete = custo_frete * 2.0 # Aumento de 100%
# Se for "normal", mantém o mesmo valor (multiplicador 1.0)
# Exibe o custo final do frete.
print(f"Custo total do frete: R$ {custo_frete}")
# 3. Multiplicador baseado no método de envio
# A terceira estrutura `if/elif/else` aplica um multiplicador de custo
# com base no método de envio escolhido. O custo é modificado
# (custo_frete = custo_frete * ...) para envios "expresso" ou "prioritario".
if metodo_envio == "expresso":
custo_frete = custo_frete * 1.5
print("Método de Envio: Expresso (taxa de 50%)")
elif metodo_envio == "prioritario":
custo_frete = custo_frete * 2.0
print("Método de Envio: Prioritário (taxa de 100%)")
else:
print("Método de Envio: Normal (sem taxa adicional)")
print()
print(f"Resumo do Custo:")
print(f"Peso: {peso_kg} kg")
print(f"Distância: {distancia_km} km")
print(f"Custo final do frete: R$ {custo_frete}")