Decidindo o destino do seu código: a lógica das condições em Python (if/elif/else)#

O que você saberá se você ler todo este capítulo?#

  1. Como funcionam as estruturas de seleção (se/senão-se/senão) (em Python, if/elif/else).

  2. Que é possível montar estas estruturas de forma que façam sentido no nosso código: assim, podemos usar só if, ou if com vários elif e sem else ou if com else.

  3. Que não podemos ter if com dois else, ou elif e else sem if.

  4. Que podemos colocar uma estrutura de seleção dentro da outra, ainda que não seja muito legal e nem muito recomendado.

  5. Que podemos usar várias estruturas de seleção de forma separada ao longo do código onde fizer sentido.

  6. Que testes de mesa e debuggers ajudam a identificar problemas no código sem quebrar (tanto) a cabeça.

  7. Que é legal usar debuggers! 🐛

Primeiro bug identificado na história. A imagem mostra um inseto grudado com uma fita adesiva em uma folha de caderno de 1947.
Primeiro bug da história, de 1947. Você vai começar a encontrar outros bugs no seu código conforme ele aumenta em complexidade. Créditos: Transfer from United States Department of Defense, Naval Surface Warfare Center. National Museum of American History.

Respirando um pouco antes de continuar#

Oi de novo! Parabéns por ter aprendido a programar em Python! É incrível como você já conseguiu dominar as coisas básicas da linguagem em tão pouco tempo. Saber como desenvolver algoritmos (isso é diferente de seguir tutoriais e seguir um passo-a-passo, tá?) é uma habilidade muito importante na sua carreira e pode ser útil em diversas áreas.

Não desanime se encontrar desafios ao longo do caminho. A programação é uma habilidade que exige persistência e dedicação, mas os resultados podem ser extremamente gratificantes. Continue aprendendo, desenvolvendo seus próprios projetos e participando da comunidade Python. Você verá que em pouco tempo será capaz de criar programas ainda mais complexos e úteis.

Veja só: até agora você aprendeu vários operadores e funções em Python. Imagine trabalhar com algoritmos como sendo brincar com vários blocos de Lego. Você tem diferentes tipos de blocos (funções, operadores e variáveis) que podem ser combinados de várias maneiras para construir coisas novas. Cada bloco tem sua própria função e você pode usá-los em diferentes combinações para alcançar o resultado desejado.

Assim como no Lego, você precisa de criatividade e raciocínio para construir algo novo. Você pode começar com um conjunto básico de blocos (as funções e operadores básicos do Python que você viu no capítulo anterior) e, à medida que se familiariza com eles, pode experimentar combinações mais avançadas e construir coisas mais complexas.

Por exemplo, imagine que você queira construir um robô com o jogo de Lego. Você pode começar com blocos simples, como aquelas peças retangulares que todo mundo conhece, para construir o corpo do robô. Em seguida, você pode adicionar blocos mais específicos, como engrenagens e motores para torná-lo mais funcional.

Da mesma forma, no Python, você pode começar com funções simples, como input() e print() para criar um programa básico que pede ao usuário para inserir um número e o imprime na tela. À medida que você aprende mais, pode adicionar funções mais específicas e criar as suas próprias funções, ou usar loops e condicionais para tornar seu programa mais complexo e interativo.

Por isso, agora vamos aprender sobre as estruturas de seleção (ou controle) para que você tenha um repertório um pouco mais avançado. Com as estruturas de seleção em Python, como o if, o else e o elif, você pode criar programas que tomam decisões baseadas em condições específicas. Lembra das analogias da receita de bolo? Então: imagine agora uma receita de bolo em que você decide seguir um conjunto de instruções com base nos ingredientes disponíveis na sua cozinha. Se você tem açúcar e cenoura, você pode fazer um bolo de cenoura. Se você tem cacau e açúcar, você pode fazer um bolo de chocolate. As possibilidades são muitas e dependem das condições que você tem em mãos.

Até porque nem sempre é um caminho direto que sempre vai chegar a uma única decisão. Nem sempre quando você vai no supermercado comprar alguma coisa você sai com exatamente os mesmos itens que você planejou no começo que iria comprar, não é? Vamos ver como trabalhar com essas seleções em Python?

Imagem de um homem olhando para geladeiras cheias de bebidas em um supermercado.
Créditos: Victoriano Izquierdo no Unsplash.

Se, senão-se, senão#

O que você viu e construiu até agora são algoritmos sequenciais. Um algoritmo sequencial é uma sequência de instruções executadas na ordem em que aparecem. Ele é utilizado quando uma tarefa precisa ser executada de forma linear, passo a passo, sem a necessidade de tomar decisões ou realizar desvios de fluxo. É como uma receita simples de bolo, onde as instruções precisam ser seguidas em ordem para obter o resultado esperado: você tem que seguir exatamente as instruções seguindo uma ordem pré-definida. Não há como escapar ou como pular ou trocar passo nenhum.

Por outro lado, nem tudo na vida é tão rígido assim. Imagine um algoritmo que poderia ser construído para controlar um semáforo de trânsito. O algoritmo leva em consideração o tempo em que cada sinal deve permanecer aberto para permitir a passagem de veículos e, em seguida, muda para a próxima cor. Afinal de contas, não seria muito legal que ele ficasse aberto e fechado pelo mesmo período de tempo em ruas bem movimentadas em cidades grandes, não é? Ou, imagine um algoritmo de uma loja online oferece diferentes opções de frete para seus clientes. O tempo de entrega e até as opções de transportadora vão depender do lugar em que o cliente mora e o tamanho da encomenda.

É para casos como estes que existem as estruturas de seleções. Por isso, saiba que usamos estruturas de seleção quando precisamos tomar decisões ou realizar desvios durante o fluxo do algoritmo. Ele permite que o algoritmo execute diferentes conjuntos de instruções, dependendo de uma condição. É como um jogo de escolhas, onde as decisões que tomamos alteram o desenrolar da história.

A diferença fundamental entre esses dois tipos de algoritmos (o que começaremos a ver agora e o que você trabalhou até o capítulo anterior) é que o algoritmo sequencial segue um fluxo linear de instruções, enquanto o algoritmo que emprega estruturas de seleção pode tomar diferentes caminhos dependendo da condição sendo testada para um caso específico.

Resumo: os algoritmos que você viu até agora seguia uma sequência pré-determinada de ações. A partir de agora você também poderá criar algoritmos capazes de tomar decisões de acordo com as condições que são apresentadas.

Agora, como funcionam essas estruturas de seleção? Vamos pensar em alguns exemplos da vida real.

Bloqueando um usuário#

Imagine um usuário que está tentando entrar em um sistema. Se a senha digitada for a correta, o acesso será liberado. Caso contrário, nada irá acontecer: o usuário permanecerá na tela de entrada. Simples, não é? Um exemplo de pseudocódigo seria:

 1. Início
 2.   Texto: nome_usuario, senha_usuario
 3.   
 4.   Escreva("Digite o nome do usuário:")
 5.   Leia(nome_usuario)
 6.   Escreva("Digite a senha:")
 7.   Leia(senha_usuario)
 8.   
 9.   Se a senha_usuario é válida para o nome_usuario, então
10.     Liberar acesso ao sistema
11.   Fim Se
12. Fim

Veja que nas linhas 9 até a 11 temos uma estrutura de seleção. Essa estrutura é composta por três partes:

  1. A condição (o se, que está no começo da linha 9);

  2. A ação (o que acontece logo após a palavra então no final da linha 9).

  3. A indicação do final da ação (o fim se, na linha 11).

Perceba que a indentação na linha 10 ajuda a perceber que esta ação fica dentro da condição estabelecida pela linha 9. Ou seja:

  1. Se a senha_usuario estiver correta para o nome_usuario, o algoritmo irá rodar todos os passos, incluindo a linha 10.

  2. Se a senha_usuario não estiver correta, o algoritmo pulará o passo 10. Ou seja: o acesso não será concedido.

Dirigindo#

Agora, vamos pensar em um caso em que o “se” possui duas condições sendo testadas. A mesma lógica funcionaria com três ou mais condições, também. Assim, vamos supor que queiramos fazer um algoritmo para dirigir um carro até a Universidade. Por outro lado, não dá para dirigir com o tanque vazio, não é? Para evitar isso, vamos abastecer o carro quando o tanque estiver abaixo de 25% da capacidade (ou seja, 1/4 de tanque). E, se formos abastecer, precisaremos pagar. Por isso, antes de parar para abastecer é importante verificar se temos dinheiro para tal. Um exemplo de pseudocódigo seria:

 1. Início
 2.   Pegue as chaves do carro.
 3.   Ande até o carro.
 4.   Desbloqueie o carro.
 5.   Entre no carro, se sentando no banco do motorista.
 6.   Verifique o trânsito antes de sair de casa.
 7.   Escolha o melhor caminho.
 8.   Verifique se há combustível suficiente no tanque do carro para ir até a Universidade.
 9.   Ligue o carro.
10.   Respeite as leis de trânsito e limite de velocidade durante todo o trajeto.
11.   Se o tanque estiver abaixo de 1/4 e se tiver dinheiro o suficiente para pagar pelo combustível então
12.     Dirija até o posto de combustível.
13.     Pare em um posto de combustível no meio do caminho e abasteça.
14.     Pague pelo combustível.
15.     Saia do posto.
16.   Fim Se
17.   Dirija até a Universidade.
18.   Estacione o carro em um local apropriado e seguro.
19.   Desligue o motor e retire a chave.
20.   Saia do carro.
21. Fim

Perceba que a indentação nos passos 12 a 15 nos ajuda a perceber que estes passos ficam dentro da condição estabelecida pela linha 11. Para ficar mais fácil, vamos pensar nos seguintes exemplos:

  1. Temos mais do que 1/4 de tanque: vamos pular as linhas 12, 13, 14 e 15. Afinal, não precisamos entrar agora no posto. Ou seja: leia o código das linhas 1 até 11, e depois das linhas 17 até 21.

  2. Temos menos do que 1/4 de tanque, mas não temos dinheiro: vamos pular as linhas 12, 13, 14 e 15. Afinal, não temos dinheiro para pagar pelo combustível. Ou seja: leia o código das linhas 1 até 11, e depois das linhas 17 até 21.

  3. Temos menos do que 1/4 de tanque e temos dinheiro: vamos ler o código das linhas 1 até 21, sem parar. Isto porque precisamos ir ao posto (porque temos pouco combustível) e poderemos pagar por ele.

Ainda, perceba que nas linhas 11 até a 16 temos uma estrutura de seleção. Essa estrutura é composta por três partes:

  1. A condição (o se, que está no começo da linha 11);

  2. A ação (o que acontece logo após a palavra então no final da linha 11).

  3. A indicação do final da ação (o fim se, na linha 16).

O algoritmo verifica se a condição (isto é, tudo o que está dentro da linha 11) é verdadeira e, se for, executa a ação que vem logo em seguida (que está nas linhas 12 a 15). Caso contrário, o programa segue para o próximo comando (ou seja: ele pulará as linhas 12, 13, 14, 15 e 16 e irá direto para a 17). O fim se é utilizado para indicar o final da estrutura de controle.

“Se” com duas condições#

Veja também que temos uma condição na linha 11 de comparação: percebeu a palavra e entre as duas frases naquela linha? Pois bem. Vamos pensar melhor no que isto significa na prática e o que aconteceria se mudássemos esta estrutura:

  1. Tanque estiver abaixo de 1/4 e se tiver dinheiro o suficiente para pagar pelo combustível:

    • O operador e indica que as duas condições (tanque abaixo de 1/4, dinheiro suficiente para pagar) precisam ser verdadeiras ao mesmo tempo para que possamos ir para as linhas 12, 13, 14 e 15.

    • Isto significa que precisamos ter o tanque abaixo da quantidade esperada e também o dinheiro para pagar para que possamos ir ao posto de combustível. Afinal, não faria sentido ir ao posto sem dinheiro ou se não precisássemos por ainda ter combustível o suficiente.

    • Se ainda tivermos combustível (ou seja, tanque abaixo de 1/4 não for verdade) nem testaríamos se teríamos dinheiro ou não, já que seria desnecessário testar isso.

  2. Tanque estiver abaixo de 1/4 ou se tiver dinheiro o suficiente para pagar pelo combustível:

    • O operador ou indica que somente uma das duas condições (tanque abaixo de 1/4, dinheiro suficiente para pagar) precisam ser verdadeiras para que possamos ir para as linhas 12, 13, 14 e 15.

    • Isto significa que poderíamos entrar no posto de gasolina sem dinheiro (o que não deixaria o frentista feliz com você) ou com o tanque cheio (o que seria desnecessário).

  3. Tanque não estiver abaixo de 1/4 e se tiver dinheiro o suficiente para pagar pelo combustível:

    • Temos agora um operador de negação (não) na primeira condição. Logo, esta condição pode ser relida como tanque igual ou acima de 1/4.

    • O operador e indica que as duas condições (tanque igual ou acima de 1/4, dinheiro suficiente para pagar) precisam ser verdadeiras ao mesmo tempo para que possamos ir para as linhas 12, 13, 14 e 15.

    • Isto significa que só entraríamos no posto se tivermos muito combustível. Ou seja: teve alguma emergência em algum dia e por algum motivo ele está abaixo de 1/4? Boa sorte: seu algoritmo irá garantir que você nunca entrará no posto de gasolina.

  4. Tanque estiver abaixo de 1/4 e se não tiver dinheiro o suficiente para pagar pelo combustível:

    • Agora, o operador não está na segunda condição. Em outras palavras, você só iria ao posto de gasolina se não tivesse dinheiro para pagar. Provavelmente em pouco tempo você será banido de todos os postos de combustível da região.

Aprovação de crédito#

Vamos pensar em um caso diferente: agora, você solicitará um financiamento para um banco para comprar alguma coisa: seja uma casa, um carro, ou uma moto. A lógica é simples: o banco lhe dará o dinheiro que precisa se você tiver um salário compatível para pagar o valor que você está pedindo. Simples, certo? Um exemplo de pseudocódigo para isso poderia ser:

 1. Início
 2.   Real: credito_desejado, renda_mensal
 3.   
 4.   Escreva("Digite o valor do crédito desejado: ")
 5.   Leia(credito_desejado)
 6.   
 7.   Escreva("Digite a renda mensal do cliente: ")
 8.   Leia(renda_mensal)
 9.   
10.   Se credito_desejado < renda_mensal então
11.       Escreva("Crédito aprovado!")
12.   Senão
13.       Escreva("Crédito negado.")    
14.   Fim Se
15. Fim

Observe que temos uma coisa nova na linha 12: o senão. Ele é usado em algoritmos para fazer uma ação caso a condição do “se” não seja atendida. Em outras palavras, ele é usado para estabelecer um caminho alternativo quando a condição do “se” não é verdadeira.

Pensemos aqui o que aconteceria com o nosso código:

  1. 👍 Estamos pedindo menos do que estaria dentro da nossa renda (podemos pagar o empréstimo): a linha 10 é verdadeira. O algoritmo vai rodar a linha 11 e pulará as linhas 12 e 13.

  2. 👎 Estamos pedindo mais do que podemos pagar (está acima da nossa renda): a linha 10 é falsa. O algoritmo pulará a linha 11 e irá rodar as linhas 12 e 13.

Senão-se#

Também é possível combinar testes adicionais dentro de um único teste. Imaginemos agora que queremos mostrar uma mensagem chamada “Crédito aprovado, mas com ressalvas” se o valor que você está pedindo é exatamente igual à sua renda mensal.

É para isso que serve o “senão-se”, bem útil para indicar uma condição alternativa caso a primeira condição não seja satisfeita. Ele funciona da seguinte forma: se a condição do “se” for verdadeira, o algoritmo executa a sequência de instruções dentro daquele bloco. Caso contrário, ele verifica a próxima condição do “senão-se” e executa as instruções dentro do bloco correspondente, caso a condição seja verdadeira. Se nenhuma das condições for verdadeira, o algoritmo executa as instruções dentro do bloco do “senão”, caso ele exista.

Essa estrutura é útil em situações onde existem múltiplas possibilidades de resultados, permitindo que o algoritmo execute diferentes sequências de instruções dependendo da condição satisfeita. Vamos modificar o pseudocódigo acima para incluir isto:

 1. Início
 2.   Real: credito_desejado, renda_mensal
 3.   
 4.   Escreva("Digite o valor do crédito desejado: ")
 5.   Leia(credito_desejado)
 6.   
 7.   Escreva("Digite a renda mensal do cliente: ")
 8.   Leia(renda_mensal)
 9.   
10.   Se credito_desejado < renda_mensal então
11.       Escreva("Crédito aprovado!")
12.   Senão-se credito_desejado == renda_mensal então
13.       Escreva("Crédito aprovado, mas com ressalvas.") 
14.   Senão
15.       Escreva("Crédito negado.")    
16.   Fim Se
17. Fim

Vejamos alguns pontos importantes no código acima:

  1. Adicionamos as linhas 12 e 13.

  2. As linhas 10 até a 16 fazem parte de um único bloco de se/senão-se/senão. Sabemos disso porque o primeiro “Se” começa na linha 10 e o próximo “Fim Se” acontece na linha 16. Além disso, todos eles seguem a mesma indentação.

  3. 👍 Estamos pedindo menos do que estaria dentro da nossa renda (podemos pagar o empréstimo): a linha 10 é verdadeira. O algoritmo vai rodar a linha 11 e pulará as linhas 12 a 15 já que não faria sentido testar as demais condições.

  4. ✋ Estamos pedindo o mesmo valor da nossa renda (podemos pagar o empréstimo): a linha 10 é falsa (ou seja: falhou a primeira condição). Como falhou a primeira condição, o algoritmo vai testar a próxima condição (linha 12). Como a condição da linha 12 está correta, o algoritmo vai rodar a linha 13 e ignorar os testes seguintes. Assim, ele pularia as linhas 11 e 15.

  5. 👎 Estamos pedindo mais do que podemos pagar (está acima da nossa renda): a linha 10 é falsa e a linha 12 é falsa. Como tudo o que veio antes falhou, resta somente o “senão” que serve justamente para os cenários em que todos os testes anteriores falharam. Por isso, o algoritmo pulará a linha 11 e 13, mas rodará a linha 15.

Um resumo até aqui#

Calma! Sei que as coisas podem ficar bem confusas. Vamos para um resumo:

  1. O “se”, “senão-se” e “senão” são estruturas de seleção utilizadas em algoritmos para realizar testes lógicos e tomar decisões com base em diferentes condições.

    • Podemos pensar no uso das estruturas condicionais “se”, “senão-se” e “senão” em um processo de decisão. Imagine que você está em uma loja de doces e tem R$ 100,00 para gastar em balas. Se o preço de um pacote de bala for R$ 20,00, você pode comprar até 5 pacotes. Nesse caso, o “se” seria a condição de que o preço da bala seja igual ou menor que R$ 20,00, e a ação seria comprar o pacote. Já o “senão” seria a condição de que o preço da bala é maior que R$ 20,00, e a ação seria não comprar o pacote.

    • Agora, imagine que você tem uma preferência por chicletes, mas poderia escolher outro doce se não puder pagar pelos 5 pacotes de chicletes.

      • Aqui, o “se” seria a condição de que o preço do chiclete seja menor ou igual a R$ 20,00, e a ação seria comprar o chiclete.

      • O “senão-se” seria a condição de que o preço do pirulito seja menor ou igual a R$ 20,00, e a ação seria comprar o pirulito.

      • Poderíamos ter um segundo “senão-se” para os casos em que tanto o preço do pacote de chiclete e de bala estiverem acima de R$ 20,00. Este segundo “senão-se” seria a condição de que o preço do pacote de paçocas seja menor ou igual a R$ 20,00, e a ação seria comprar a paçoca.

      • E o “senão” seria para os casos em que tudo o que veio antes não deu certo (ou seja: tá tudo caro). Aqui, a ação seria não comprar nada e ir embora da loja.

  2. O “se” é uma estrutura de seleção em algoritmos que permite verificar se uma condição é verdadeira ou falsa e executar uma ação correspondente.

    • Por exemplo, “se” o dia de hoje for sábado, então vá ao cinema.

  3. Já o “senão-se” permite adicionar mais uma condição caso a primeira seja falsa.

    • Por exemplo, “se” o dia for sábado, vá ao cinema, “senão-se” o dia for domingo, vá ao parque.

  4. E por fim, o “senão” é usado caso nenhuma das condições anteriores seja verdadeira, executando uma ação padrão.

    • Por exemplo, “se” o dia for sábado, vá ao cinema, “senão-se” o dia for domingo, vá ao parque, “senão” fique em casa (o que pode ser segunda, quarta, ou qualquer outro dia que não seja sábado ou domingo).

  5. Nem todo “se” precisa ter “senão-se” e “senão”.

    • Por exemplo, quando temos apenas uma condição para verificar, não precisamos utilizar o “senão-se” ou o “senão”.

  6. Podemos ter “se” e “senão-se” sem necessariamente ter um “senão” para finalizar.

  7. Podemos ter um “se” e vários “senão-se” dentro de um mesmo bloco de seleção. Nesse caso, cada “senão-se” é verificado na ordem em que aparecem, e caso a condição seja verdadeira, o conjunto de instruções correspondente será executado.

  8. Essas estruturas são importantes para programar um comportamento específico para um algoritmo, permitindo que o mesmo possa lidar com diferentes situações corretamente.

if, elif, else#

Começando com uma explicação direta:

  • O “se” em Python se chama if.

  • O “senão-se” em Python se chama elif (vem de else-if, que é exatamente “senão-se” em inglês).

  • O “senão” em Python se chama else.

Apenas if#

Dito isso, vamos a alguns exemplos? Vou deixar de falar em “se”/”senão-se”/”senão” para falar if/elif/else. Afinal, estamos estudando Python. Vamos usar um arquivo .py para desenvolver e testar o código. Caso não se lembre como fazer isso, recomendo que relembre dos exemplos que fizemos do input() e print() no capítulo anterior, aqui.

Isto posto, você já deve saber como o if funciona, não é? Teste este código, então:

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

if idade >= 16:
    print("Você pode votar nas eleições!")

Este código verifica a idade de uma pessoa. Se ela tiver 16 anos de idade ou mais, a mensagem “Você pode votar nas eleições!” aparecerá na tela. Se você for testar algum valor abaixo disso (como 14 anos), nada aparecerá na tela.

Veja que o if idade >= 16 é responsável para verificar se o valor armazenado na variável idade é igual ou maior a 16. Se for, esta condição é verdadeira. E, quando a condição é verdadeira, a próxima linha pode ser executada. Veja que na última linha existem quatro espaços (ou um Tab) à esquerda: ela é a indentação que já comentamos antes, agora em Python.

Agora, testemos outro código:

num1 = int(input("Digite o primeiro número: "))
num2 = int(input("Digite o segundo número: "))

if num1 > num2:
    print(f"{num1} é maior que {num2}.")
    print(f"A diferença entre {num1} e {num2} é {num1 - num2}.")
    print(f"A soma de {num1} e {num2} é {num1 + num2}.")
    
print("Obrigado!")

Consegue entender o que este código faz só de olhar? Veja: pedimos dois números inteiros ao usuário, e guardamos os resultados em num1 e num2. Somente quando num1 for maior do que num2 é que aqueles três print seguidos aparecerão. Caso contrário (isto é, quando num1 for igual ou menor do que num2) pularemos aquelas três linhas e iremos diretamente à mensagem escrita “Obrigado!”.

O que acha de testar você mesmo? Teste os seguintes cenários:

  1. Primeiro número: 0, segundo número: 5.

  2. Primeiro número: 9, segundo número: 5.

  3. Primeiro número: 5, segundo número: 5.

Consegue entender o comportamento do código nesses 3 casos diferentes?

if e else#

Agora, vamos testar um if com else. Vamos lá:

nota1 = float(input("Digite a nota da primeira prova: "))
nota2 = float(input("Digite a nota da segunda prova: "))
media = (nota1 + nota2) / 2.0

if media >= 7:
    print("Parabéns, você foi aprovado com média", media)
    print("Continue estudando e se preparando para os próximos desafios.")
else:
    print("Infelizmente, você foi reprovado com média", media)
    print("Você precisa estudar mais para a próxima oportunidade.")

Neste exemplo, o programa solicita duas notas de prova e calcula a média. Se a média for maior ou igual a 7, o programa exibe uma mensagem de parabéns e informa a média do aluno. Caso contrário, o programa exibe uma mensagem de reprovação, informa a média do aluno e exibe uma mensagem indicando que o aluno precisa estudar mais para a próxima prova.

Teste o funcionamento com os seguintes valores:

  1. Primeira nota: 7.0, segunda nota: 7.0.

  2. Primeira nota: 9.0, segunda nota: 7.0.

  3. Primeira nota: 6.0, segunda nota: 1.0.

Consegue ver as semelhanças e diferenças no funcionamento? Consegue explicar por que sempre apareceram duas mensagens na tela para o usuário após digitar as duas notas?

if, elif e else#

Agora, vamos modificar o código acima para incluir o elif. Basicamente, queremos que o algoritmo funcione assim:

  • Notas iguais ou maiores de 7.0: o estudante estaria aprovado.

  • Notas iguais ou maiores de 4.0, mas abaixo de 7.0: o estudante estaria em recuperação.

  • Notas abaixo de 4.0: o estudante estaria reprovado.

nota1 = float(input("Digite a nota da primeira prova: "))
nota2 = float(input("Digite a nota da segunda prova: "))
media = (nota1 + nota2) / 2.0

if media >= 7:
    print("Parabéns, você foi aprovado com média", media)
    print("Continue estudando e se preparando para os próximos desafios.")
elif media >= 5:
    print("Você está em recuperação com média", media)
    print("Você precisa estudar mais para a próxima prova.")
else:
    print("Infelizmente, você foi reprovado com média", media)
    print("Você precisa estudar mais para a próxima oportunidade.")

Teste o funcionamento com os seguintes valores:

  1. Primeira nota: 7.0, segunda nota: 7.0.

  2. Primeira nota: 10.0, segunda nota: 2.0.

  3. Primeira nota: 5.0, segunda nota: 1.0.

Além disso, note o seguinte:

  1. Veja que coloquei elif media >= 5 ao invés de elif media >= 5 and media < 7. Por quê? O motivo é simples: como o primeiro teste falhou, já sabemos com 100% de certeza de que media < 7. Por isso, seria bem redundante fazermos

  2. Consegue entender (e testar) em quais casos ele cai no else?

🖐 Ah, sugestão: troque aquele elif media >= 5: por if media >= 5:. Teste de novo. O que aconteceu de diferente? Por quê?

Três elif#

E se tivéssemos três elif, pode? Pode! Olha só:

nota1 = float(input("Digite a nota da primeira prova: "))
nota2 = float(input("Digite a nota da segunda prova: "))
media = (nota1 + nota2) / 2.0

if media >= 9.5:
    print("Parabéns, a sua nota foi excelente! Você foi aprovado com média", media)
elif media >= 8:
    print("Parabéns, a sua nota foi muito boa! Você foi aprovado com média", media)
elif media >= 7:
    print("Parabéns, você foi aprovado com média", media)
    print("Continue estudando e se preparando para os próximos desafios.")
elif media >= 5:
    print("Você está em recuperação com média", media)
    print("Você precisa estudar mais para a próxima prova.")
else:
    print("Infelizmente, você foi reprovado com média", media)
    print("Você precisa estudar mais para a próxima oportunidade.")

Observe que agora temos três elif. O primeiro será verdadeiro para as notas que são iguais ou acima de 8, mas abaixo de 9.5. Já o segundo será verdadeiro para as notas que são iguais ou acima de 7, mas abaixo de 8. Já o terceiro será verdadeiro para as notas iguais ou acima de 5, mas abaixo de 7.

  1. O que acha de testar com algumas notas diferentes para ver este funcionamento na prática?

  2. O que acha de modificar o código para remover completamente aquele else? Teste com uma nota baixa (como dois 0). Deveria mesmo aparecer alguma mensagem falando que o estudante foi reprovado?

if dentro de if#

Outro uso interessante é o encapsulamento de if. É uma técnica utilizada para colocar um if dentro de outro if, e consiste em colocar as condições mais restritivas em primeiro lugar, criando uma hierarquia lógica na execução do código. Dessa forma, as condições mais simples e de execução mais rápida são verificadas primeiro, evitando a execução desnecessária de outras condições. Veja e teste o código abaixo:

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

if idade >= 18:
    print("Você é maior de idade.")
    if idade >= 21:
        print("Você pode beber nos Estados Unidos.")
else:
    print("Você é menor de idade.")

Neste exemplo, o primeiro if verifica se a pessoa possui 18 anos ou mais. Se sim, mostrará uma mensagem dizendo “Você é maior de idade.”. Dentro deste primeiro if perceba que há um segundo if que verifica se a pessoa tem 21 anos ou mais para saber se pode beber nos Estados Unidos. Veja que, de um ponto de vista lógico, quem tem 21 anos automaticamente possui 18 anos: por isso que colocamos dentro daquele primeiro if.

Agora, se a pessoa possui menos de 18 anos, o else será executado, mostrando na tela uma mensagem correspondente. Veja como o algoritmo funciona se você informa idades como 15, 19 e 23 anos para ver isto na prática.

🛑 Usar um if dentro de outro if pode tornar o código mais difícil de ler e entender, além de aumentar a complexidade e a possibilidade de erros. Isso ocorre porque a lógica do código pode ficar confusa, com vários níveis de aninhamento e condições que precisam ser avaliadas em diferentes níveis. Além disso, usar muitos if dentro de outros if pode indicar que a estrutura do código pode ser melhorada com, por exemplo, o uso de operadores lógicos como and e or em uma única linha em vez de colocar vários if aninhados. Apesar disso, em alguns casos o uso de if dentro de if pode ser inevitável ou até mesmo a melhor solução para um problema específico.

if dentro de if dentro de if#

E dá para usar um if dentro de if dentro de outro if? Dá sim, mas o aviso anterior permanece: isso não necessariamente é uma boa prática do ponto de vista de legibilidade, complexidade e risco de introduzir erros de lógica no código. Veja o exemplo abaixo:

nota1 = float(input("Digite a primeira nota: "))
nota2 = float(input("Digite a segunda nota: "))
nota3 = float(input("Digite a terceira nota: "))

if nota1 >= 7:
    if nota2 >= 7:
        if nota3 >= 7:
            print("Parabéns, você foi aprovado(a)!")
        else:
            print("Sua nota na terceira avaliação foi abaixo da média.")
    else:
        print("Sua nota na segunda avaliação foi abaixo da média.")
else:
    print("Sua nota na primeira avaliação foi abaixo da média.")

Percebe que isso ficou um pouco mais feio de se ler? Apesar disso, a lógica funciona: neste exemplo, o programa verifica a nota do aluno em três avaliações. Se o aluno tiver uma nota abaixo da média na primeira avaliação, o programa imprime a mensagem “Sua nota na primeira avaliação foi abaixo da média.” (veja o último else).

Se o aluno tiver uma nota acima ou igual a 7 na primeira avaliação, o programa verifica a nota na segunda avaliação. Se o aluno tiver uma nota abaixo da média na segunda avaliação, o programa imprime a mensagem “Sua nota na segunda avaliação foi abaixo da média.”.

Se a nota na segunda avaliação também for maior ou igual a 7, o programa verifica a nota na terceira avaliação. Se todas as notas forem maiores ou iguais a 7, o programa imprime a mensagem “Parabéns, você foi aprovado(a)!”. Caso contrário, mostrará a mensagem “Sua nota na terceira avaliação foi abaixo da média.”.

Teste as seguintes combinações de notas para entender melhor o funcionamento na prática. Veja qual das mensagens de print() são mostradas e o porquê.

  1. Primeira nota: 5, segunda nota: 8, terceira nota: 10.

  2. Primeira nota: 5, segunda nota: 8, terceira nota: 5.

  3. Primeira nota: 5, segunda nota: 5, terceira nota: 10.

  4. Primeira nota: 10, segunda nota: 5, terceira nota: 5.

  5. Primeira nota: 10, segunda nota: 10, terceira nota: 5.

  6. Primeira nota: 10, segunda nota: 4, terceira nota: 10.

  7. Primeira nota: 10, segunda nota: 10, terceira nota: 10.

Vários blocos de if#

Você pode usar essas estruturas de if/elif/else como quiser no seu código desde que isto faça sentido. Como você viu, você pode fazer if sem else, ou if e else sem elif, if e elif sem else ou até encapsular várias dessas estruturas.

Você também pode usar diferentes blocos independentes entre si. Na prática, significa que um bloco estaria totalmente separado do outro em sua lógica. Para ficar mais claro, teste o exemplo abaixo:

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

# Primeiro bloco de if/else
if idade < 18:
    print("Você é menor de idade!")
else:
    print("Você é maior de idade!")

# Segundo bloco de if/elif/else
media = float(input("Qual é a sua média na disciplina? "))

if media >= 7:
    print("Parabéns, você foi aprovado com média", media)
    print("Continue estudando e se preparando para os próximos desafios.")
elif media >= 5:
    print("Você está em recuperação com média", media)
    print("Você precisa estudar mais para a próxima prova.")
else:
    print("Infelizmente, você foi reprovado com média", media)
    print("Você precisa estudar mais para a próxima oportunidade.")

# Terceiro bloco de if/else
saldo = float(input("Qual é o seu saldo na conta-corrente? "))

if saldo < 0:
    print("O seu saldo está negativo!")
elif saldo == 0:
    print("O seu saldo está zerado!")
else:
    print("O seu saldo está positivo!")

Neste exemplo, cada bloco de if/else trata de uma condição independente: o primeiro bloco verifica se o número é positivo ou negativo, o segundo verifica se a sua média lhe garantiria uma aprovação ou não, e o terceiro verifica se o seu saldo é positivo, negativo, ou zero. Cada bloco é executado independentemente dos outros e apresenta uma mensagem correspondente à condição verificada. Veja que é a indentação (que já vimos anteriormente) que nos ajuda a entender onde começa e onde termina cada um desses blocos.

Uma alternativa: o switch/match#

Importante: o match começou a existir somente a partir do Python 3.10, em 2021. Logo, versões anteriores não terão suporte a isto.

Outras linguagens de programação possuíam uma outra alternativa ao if/elif/else: o switch. O Python introduziu uma estrutura parecida com o nome de match nas suas versões mais recentes. Se você já entende o if/elif/else, o match pode ser visualizado como um super-if.

Esse tipo de estrutura só pode ser usado em alguns casos. Para ficar mais fácil, vamos pensar em trens. Você está em uma estação de trem e quer pegar um trem específico. Você precisa ver qual é a plataforma para encontrar o trem certo. Como estamos falando de trens, eles somente param nas plataformas: você não espera que passe um ônibus nos trilhos, e nem um trem pelas ruas junto dos outros carros. Vamos testar um exemplo? Veja só:

destino = "Plataforma 3"

match destino:
    case "Plataforma 1":
        print("Expresso para Hogwarts")
    case "Plataforma 3":
        print("Trem regional para a Terra Média")
    case "Plataforma 2":
        print("Trem diário para Nárnia")
    case _:
        print("Nenhum trem.")

Trem regional para a Terra Média

Aqui, a estrutura match verifica qual é a plataforma a partir do valor que está dentro da variável destino. Por exemplo: se você estiver na Plataforma 3, pegará o “Trem regional para a Terra Média”. O símbolo _ é usado como um coringa, o que significa “qualquer valor” - parecido com o else, sabe?

Agora, como seria este mesmo código com if/elif/else? Vejamos:

destino = "Plataforma 3"

if destino == "Plataforma 1":
    print("Expresso para Hogwarts")
elif destino == "Plataforma 3":
    print("Trem regional para a Terra Média")
elif destino == "Plataforma 2":
    print("Trem diário para Nárnia")
else:
    print("Nenhum trem.")

Trem regional para a Terra Média

O código com o match fica mais limpo, né? Por outro lado, nem sempre usamos match: existem situações em que precisamos ter um controle maior no código que só um if/elif/else fornece. Além disso, existem casos mais simples em que um único if resolveria. Portanto, este match é uma alternativa para alguns casos específicos, beleza?

Comentários#

Você percebeu no código acima algumas linhas em cinza e que iniciavam com #? Aquelas linhas se referem aos comentários de código. Comentários de códigos são trechos de texto escritos em linguagem humana (português, inglês, italiano, francês, etc.) que servem para explicar o que está sendo feito em determinado trecho do código para que outros humanos entendam.

Estas linhas serão ignoradas pelo computador como parte do código, mas são muito importantes para outros programadores que possam estar lendo o código, pois ajudam a entender o que está acontecendo e por que determinadas decisões foram tomadas na escrita do programa. Até ajudam também a explicar o que o desenvolvedor queria fazer no código, e que não necessariamente refletiria a realidade. Isto pode ser útil para ajudar a investigar o código e entender se o seu comportamento seria de fato esperado (ou não).

Comentários em códigos podem ser utilizados para explicar o propósito de variáveis, funções, condicionais, laços de repetição, entre outros elementos do código. Eles também podem ser usados para documentar mudanças realizadas no código ao longo do tempo, facilitando a manutenção do programa.

Em Python, existem duas formas principais de se fazer comentários em códigos:

# este é um exemplo de comentário em uma linha. Tudo o que vem aqui é ignorado pelo Python.

'''
Já essas três aspas simples entre uma linha e outra servem para comentários multi-linha.
Quer dizer, são para casos em que o meu comentário usa mais de uma linha.
Pode ser melhor do que ter que criar várias linhas começando com um símbolo de "#".
'''

 1. Início
 2.   Inteiro: num1, num2, soma
 3. 
 4.   Escreva("Digite o primeiro número: ")
 5.   Leia(num1)
 6.   
 7.   Escreva("Digite o segundo número: ")
 8.   Leia(num2)
 9.   
10.   soma = num1 + num2
11.   Escreva("O resultado da soma é: ", soma)
12. Fim

Ora, como transcreveríamos este exemplo? O mesmíssimo algoritmo acima, mas escrito em Python, seria assim:

print("Digite o primeiro número: ")
num1 = int(input())

print("Digite o segundo número: ")
num2 = int(input())

soma = num1 + num2
print("A soma dos números é: ", soma)

Agora, quais são as semelhanças e diferenças entre os dois algoritmos? Comecemos pelas diferenças: as palavras Início e Fim saíram de cena. Além disso, a linha 2 do pseudocódigo que declarava as três variáveis deixou de existir: em Python, isto não é mais necessário. Finalmente, a função Escreva deu lugar à print, e a Leia deu lugar à int(input()).

Quanto às semelhanças, temos várias delas. Primeiro, a ordem do algoritmo é mantida. A organização também: veja como as linhas estão organizadas. O mesmo se aplica às mensagens e à operação de soma. Por isso que começar a escrever algoritmos em Python é mais simples do que parece a princípio: se você sabe como os algoritmos funcionam de forma geral e sabe interpretar pseudocódigo, então rapidamente você também conseguirá escrever algoritmos utilizando Python.

Mas, e aí? Como testamos isso usando o PyCharm? Vamos testar aqui por partes, beleza?

Teste de mesa e debugging#

Conforme os nossos códigos vão aumentando em complexidade é comum que tenhamos erros e que precisemos investigá-los. É para isso que existem duas técnicas diferentes, mas importantes: o teste de mesa e o debug (ou debugging).

Teste de mesa#

Um teste de mesa é uma técnica utilizada para verificar a lógica e o funcionamento de um algoritmo manualmente, ou seja, sem a necessidade de executá-lo em um computador. É uma ferramenta muito importante para os programadores, pois permite identificar possíveis erros e corrigi-los antes mesmo de executar o algoritmo.

Como ele é um processo manual, ele pode funcionar também em pseudocódigos. Você pode fazê-lo com um papel e caneta na sua mesa (daí o nome). Você irá seguir passo a passo as instruções, acompanhando as alterações de valores das variáveis em cada etapa. Esse processo permite que você identifique possíveis erros no algoritmo e verifique se a lógica está funcionando corretamente.

Uma analogia para explicar o teste de mesa seria a construção de uma casa. Antes de iniciar a construção, é preciso fazer um planejamento, onde é definido como a casa será dividida, quantos cômodos terá, onde ficarão as janelas, portas, entre outras coisas. Nesse processo, é possível identificar possíveis problemas, como um cômodo muito pequeno ou uma porta que impede o acesso a algum ambiente. O teste de mesa funciona de forma semelhante, onde o programador define a lógica do algoritmo e faz a simulação de sua execução, identificando possíveis erros e ajustando-os antes mesmo de executá-lo no computador.

Veja no exemplo abaixo um funcionamento do 101computing.net. Imagine que você imprimiu aquele algoritmo em uma folha de papel e está percorrendo cada uma daquelas linhas com uma caneta. Ao chegar na linha 1, você anotou o valor que estava na variável number naquela tabela ao lado (Trace Table). Ao chegar na linha 2, como o valor da variável não mudou, você não mudou nada no resultado. Ao chegar na linha 3, mudou o valor da variável i e, com isso, você alterou também na tabela. E assim foi sucessivamente até chegar ao final do algoritmo. Um pequeno spoiler: este exemplo usa uma estrutura de repetição nas linhas 3 a 5, e veremos este tipo de extrutura em maior profundidade no próximo capítulo.

Imagem de um homem olhando para geladeiras cheias de bebidas em um supermercado.
Créditos: Using Trace Tables @ 101computing.net.

Debugging#

Já o debugging é o processo de identificação e correção de erros em um código já implementado em Python ou em outra linguagem de programação. Ele utiliza ferramentas específicas (debuggers) que permitem ao desenvolvedor acompanhar o fluxo de execução do código e identificar onde o erro ocorreu.

Imagine como se fosse um teste de mesa automatizado. E, para ajudar, o PyCharm possui isso também. O que acha de testarmos? Primeiro, vamos colar este código em um arquivo dentro de um projeto no PyCharm:

nota1 = float(input("Digite a primeira nota: "))
nota2 = float(input("Digite a segunda nota: "))
nota3 = float(input("Digite a terceira nota: "))

if nota1 >= 7:
    if nota2 >= 7:
        if nota3 >= 7:
            print("Parabéns, você foi aprovado(a)!")
        else:
            print("Sua nota na terceira avaliação foi abaixo da média.")
    else:
        print("Sua nota na segunda avaliação foi abaixo da média.")
else:
    print("Sua nota na primeira avaliação foi abaixo da média.")

Veja na imagem abaixo como o seu código deve ficar. Também perceba o botão de debug à direita do botão de run. Ele é representado por um inseto na cor verde.

Código de verificação de notas colado dentro de um arquivo chamado main.py dentro do PyCharm. Realçado, o botão com um desenho de um inseto na cor verde aparece realçado.
O seu código deverá aparecer nesta área aqui. Veja também no canto superior esquerdo (realçado em roxo) o botão de debug, representado por um inseto verde.

Agora, ao invés de clicarmos no botão de Run, clicaremos no botão de Debug. Você também pode ativar o debugger ao clicar em Run > Debug '$ARQUIVO' ou apertando Shift + F9 em seu teclado. Você verá que não mudará muita coisa em relação ao comportamento padrão do código: você digitará as notas, e ele lhe apresentará um resultado final.

Dito isso, vamos começar a usar o debugger de fato. Observe a imagem abaixo. Veja que antes (parte de cima da imagem) há um espaço em branco na linha 5 entre o número “5” e o código. Ao clicar neste espaço em branco aparecerá um círculo vermelho (parte de baixo da imagem). Este círculo é um breakpoint: é ele que denota que o debugger deve parar nesta linha para que possamos investigar o que está acontecendo. Clique na linha 5 para que apareça um breakpoint lá (conforme a parte de baixo da imagem abaixo) e rode o debugger novamente.

A linha 5 possui um espaço vazio à sua direita, entre o número 5 e o código. Ao clicar neste espaço vazio um círculo vermelho aparece.
Veja o antes e o depois de adicionar um breakpoint.

Assim que você digitou as três notas o código parou na linha 5. O que você estará vendo na sua tela deverá ser parecido com a visão da tela abaixo.

O debugger está visível na parte inferior da tela. Aparecem os valores das variáveis digitadas e um conjunto adicional de botões na parte inferior da tela.
Observe as novas funcionalidades do debugger realçadas em roxo, laranja e amarelo.

  1. Parte roxa: são os valores das variáveis neste momento do código. No caso, eu digitei as três notas com os valores 3, 6 e 8. Estes três valores apareceram na parte à direita do debugger.

  2. Parte laranja: são botões para que você possa avançar (ou voltar) no código para investigar o seu funcionamento. Passe o mouse me cada um deles dentro do seu PyCharm em aberto para ver o que querem dizer. Para testar, clique no Step Over (primeiro botão; símbolo da flecha indo para cima e depois para baixo). O código deve passar para a próxima linha que ele deverá executar. Com o tempo, teste outros destes botões.

  3. Parte amarela: permite controlar o debugger. Isto inclui interrompê-lo ou, ainda, continuar o algoritmo até que ele chegue ao próximo breakpoint.

Experimente colocar um segundo breakpoint na linha 8, mas informe as notas 3, 5 e 4 para testar. Você verá que o seu debugger nunca irá chegar na linha 8. Isto acontece porque, com estas notas, o seu código nunca alcançaria as condições impostas pelos if nas linhas 5, 6 e 7 para chegar à linha 8. Hmmm, quer saber? O que acha de você mesmo chegar a estas conclusões no debugger? Lembra que na parte roxa existe um texto escrito “Evaluate expression (Enter) or add a watch […]”? O que acha de você digitar naquele campo o comando nota1 >= 7 e apertar Enter? Você verá que aparecerá uma nova variável chamada result. Esta variável possui o resultado desta comparação (que é a mesma da linha 5). Em outras palavras: você pode usar o debugger para também testar se a lógica do seu if está funcionando como esperado ou não. Legal, né?

Exercícios#

O que acha de colocar a mão na massa com mais exercícios? Vamos lá?

  1. Crie um algoritmo que solicita ao usuário que insira um número inteiro e exibe na tela se ele é par ou ímpar.

    • Exemplo: um usuário digita o número 7. O algoritmo deve retornar a mensagem “Ímpar”.

  2. Crie um algoritmo que solicita ao usuário que insira um número e exibe na tela se ele é positivo, negativo ou zero.

    • Exemplo: um usuário digita o número -51.05. O algoritmo deve retornar a mensagem “Negativo”.

  3. Crie um algoritmo que peça ao usuário três números e informe qual deles é o maior.

    • Exemplo: um usuário digita os números 5, 7 e 1. O algoritmo deve retornar a mensagem “O segundo número é o maior.”

  4. Escreva um código que solicite o preço de um produto e, caso o valor seja maior que R$ 100,00, aplique um desconto de 10%. Caso contrário, não aplique nenhum desconto e informe o preço final ao usuário.

    • Exemplo: um usuário digita o valor 200. O algoritmo deve retornar a mensagem “O preço com desconto é: R$ 180.00”.

  5. Escreva um código que solicite a idade e o gênero de uma pessoa e informe se ela pode se aposentar, levando em consideração as seguintes regras: mulheres podem se aposentar com 63 anos ou mais, enquanto homens podem se aposentar com 68 anos ou mais.

    • Exemplo: um usuário digita a idade 65 e gênero masculino. O algoritmo deve retornar a mensagem “Você ainda não pode se aposentar.”.

Respostas#

1. Crie um algoritmo que solicita ao usuário que insira um número inteiro e exibe na tela se ele é par ou ímpar.

num = int(input("Insira um número inteiro: "))

if num % 2 == 0:
    print(num, "é um número par")
else:
    print(num, "é um número ímpar")

O algoritmo começa solicitando ao usuário que insira um número inteiro através da função input(), que lê a entrada do usuário como uma string. Em seguida, o número é convertido para um inteiro usando a função int(), e armazenado na variável num.

A partir daí, usamos um condicional if para verificar se o número é par ou ímpar. Se o resto da divisão por 2 (num % 2) for igual a 0, significa que o número é par, e a mensagem correspondente é exibida na tela usando a função print(). Caso contrário, o número é ímpar, e a mensagem correspondente é exibida.

2. Crie um algoritmo que solicita ao usuário que insira um número e exibe na tela se ele é positivo, negativo ou zero.

num = float(input("Digite um número: "))

if num > 0:
    print("O número é positivo.")
elif num < 0:
    print("O número é negativo.")
else:
    print("O número é zero.")

O programa começa pedindo para que o usuário digite um número, que é armazenado na variável num. Em seguida, um bloco condicional if-elif-else é utilizado para verificar se o número é positivo, negativo ou zero.

Se o número for maior que zero, o programa exibe a mensagem O número é positivo. Se o número for menor que zero, o programa exibe a mensagem O número é negativo. Se o número for igual a zero, o programa exibe a mensagem O número é zero.

3. Crie um algoritmo que peça ao usuário três números e informe qual deles é o maior.

num1 = int(input("Digite o primeiro número: "))
num2 = int(input("Digite o segundo número: "))
num3 = int(input("Digite o terceiro número: "))

if num1 >= num2 and num1 >= num3:
    print("O primeiro número é o maior.")
elif num2 >= num1 and num2 >= num3:
    print("O segundo número é o maior.")
else:
    print("O terceiro número é o maior.")

O código solicita ao usuário que insira três números inteiros e armazena cada um deles nas variáveis num1, num2 e num3. Em seguida, o programa utiliza uma estrutura de seleção if/elif/else para verificar qual é o maior número entre os três.

No primeiro bloco de condição, a instrução if testa se num1 é maior ou igual a num2 e num3. Se essa condição for verdadeira, o programa imprime a mensagem “O primeiro número é o maior.” na tela.

Caso a condição do if não seja satisfeita, a próxima instrução elif é executada, testando se num2 é maior ou igual a num1 e num3. Se essa condição for verdadeira, o programa imprime a mensagem “O segundo número é o maior.” na tela.

Por fim, se nenhuma das condições anteriores for satisfeita, o bloco else é executado, indicando que num3 é o maior número entre os três e imprimindo a mensagem “O terceiro número é o maior.” na tela.

4. Escreva um código que solicite o preço de um produto e, caso o valor seja maior que R$ 100,00, aplique um desconto de 10%. Caso contrário, não aplique nenhum desconto e informe o preço final ao usuário.

preco = float(input("Digite o preço do produto: "))

if preco > 100:
    preco_com_desconto = preco * 0.9
    print("O preço com desconto é: R$", preco_com_desconto)
else:
    print("O preço sem desconto é: R$", preco)

Este código inicia solicitando ao usuário que digite o preço de um produto, que é armazenado na variável preco. Em seguida, é criada uma estrutura de seleção utilizando o comando if, que verifica se o valor da variável preco é maior do que 100.

Caso seja, o código calcula o valor do produto com desconto de 10%, multiplicando o valor de preco por 0.9 e armazenando o resultado na variável preco_com_desconto. O código então exibe o valor com desconto para o usuário utilizando a função print(). Caso o valor da variável preco seja menor ou igual a 100, a estrutura de seleção utiliza o comando else para exibir o valor do produto sem desconto utilizando novamente o print() para isto.

5. Escreva um código que solicite a idade e o gênero de uma pessoa e informe se ela pode se aposentar, levando em consideração as seguintes regras: mulheres podem se aposentar com 63 anos ou mais, enquanto homens podem se aposentar com 68 anos ou mais.

idade = int(input("Digite a idade: "))
genero = input("Digite o gênero (M ou F): ")

if genero == "F" and idade >= 63:
    print("Você pode se aposentar!")
elif genero == "M" and idade >= 68:
    print("Você pode se aposentar!")
else:
    print("Você ainda não pode se aposentar.")

Este código solicita que o usuário informe a idade e o gênero (representado pela letra M maiúscula para masculino e F maiúscula para feminino). Em seguida, ele verifica se o gênero é feminino e se a idade é maior ou igual a 63 anos, ou se o gênero é masculino e a idade é maior ou igual a 68 anos. Se alguma dessas condições for atendida, o programa exibe a mensagem “Você pode se aposentar!”. Caso contrário, exibe a mensagem “Você ainda não pode se aposentar.”

O uso de if/elif/else permite que o programa execute diferentes ações com base nas condições estabelecidas. No caso deste exemplo, se o gênero for feminino e a idade for maior ou igual a 63 anos, ou se o gênero for masculino e a idade for maior ou igual a 68 anos, a ação será a mesma: exibir a mensagem “Você pode se aposentar!”. No entanto, se nenhuma dessas condições for atendida, a ação será diferente, e o programa exibirá a mensagem “Você ainda não pode se aposentar.”.

Referências bibliográficas#