Considere o seguinte código feito em sala. co Pedido de pix.ipynb Note que, neste exemplo, o algoritmo pede ao usuário para digitar o número 1 para fazer o pix, e qualquer outro para não fazer.
Copie e modifique esse código, de modo que o usuário não mais tenha que digitar 1 ou outro número, mas “sim” ou “não” (exatamente desta forma); isto é, quando o algoritmo perguntar se a pessoa pode fazer o pix, ao invés de dizer para digitar 1 ou outro número, deve pedir para o usuário digitar sim ou não. Então, com base na resposta, o algoritmo exibe as mensagens correspondentes.
a) Existem muitas formas do usuário digitar as palavras “sim” e “não”. Por exemplo: “sim”, “Sim”, “SIM”, “não”, “Não” etc. Em outras palavras, pode haver diferentes variações com maiúsculas e minúsculas. Uma solução óbvia seria verificar todas essas possibilidades, o que seria muito trabalhoso.
Existe um comando para evitar, em que é possível obter uma “versão” da palavra digitada pelo usuário apenas com letras minúsculas (ou maiúsculas).
Pesquise que comando é esse, descreva como ele funciona, e modifique o algoritmo que você fez para utilizar esse comando, de modo que o usuário possa digitar qualquer variação de sim e não. Indique de onde você tirou a informação sobre o comando.
b) Explique porque, caso não utilizássemos o comando do item anterior, seria necessário verificar todas as possibilidades. Ou seja, porque não bastaria comparar diretamente o que o usuário digitou com a palavra “sim” em minúsculas.

Passo 1

O que o enunciado pede e quais informações temos:
  • Pedir para alterar um código que atualmente solicita que o usuário digite o número 1 para fazer o pix, e outro número para não fazer.
  • Agora o pedido é para que o usuário digite exatamente as palavras “sim” ou “não” (exatamente dessa forma, com acento em “não”), em vez de números.
  • Além disso, deve-se permitir que o usuário digite qualquer variação de maiúsculas/minúsculas (por exemplo: “sim”, “Sim”, “SIM”, “não”, “Não”, “NÃO” etc.) sem que isso quebre o programa.
  • A tarefa tem duas partes:
    a) Pesquisar e usar um comando que transforme a palavra digitada para uma “versão” só com letras minúsculas (ou maiúsculas), descrever como funciona e modificar o algoritmo para usar esse comando. Indicar a fonte da informação.
    b) Explicar por que, se não usarmos esse comando, seria necessário verificar todas as possíveis variações (ou seja, por que não basta comparar diretamente com “sim” em minúsculas).

Passo 2

Escolha do método (o que vamos fazer, sem calcular ainda):
  • Vamos ler a resposta do usuário com a função de entrada padrão.
  • Vamos “normalizar” a resposta convertendo-a para minúsculas usando um método de string, para que variações de maiúsculas/minúsculas deixem de importar.
  • Depois comparamos a versão normalizada com a string “sim” e com “não” para decidir qual mensagem exibir.
  • Observação prática: usaremos também .strip() para eliminar espaços extras antes/depois da resposta (por exemplo, se o usuário digitar " sim " com espaços).

Passo 3

Explicando o comando que normaliza maiúsculas/minúsculas (a parte didática):
  • Em Python, strings (texto) têm métodos que transformam o próprio texto. Um método muito usado para normalizar caixa de texto é o método lower().
  • O que lower() faz: toma uma string e devolve outra string onde todas as letras maiúsculas foram convertidas para suas equivalentes minúsculas. Exemplos práticos:
    • "Sim".lower() produz "sim".
    • "SIM".lower() produz "sim".
    • "NÃO".lower() produz "não". (O método lida com caracteres acentuados Unicode, convertendo maiúsculas acentuadas em minúsculas correspondentes.)
  • Por que isso ajuda: após aplicar lower() podemos comparar sempre com a forma minúscula fixa "sim" ou "não", e todas as variações de caixa darão certo.
  • Fonte da informação: documentação oficial do Python sobre tipos de texto (str) — consulte a seção sobre métodos de string (métodos como lower, upper e strip) na documentação oficial do Python.

Passo 4

Código modificado (explicado passo a passo)
  • Primeiro, o código em si (cópia pronta que você pode colar num arquivo .py ou num Jupyter Notebook):
# Pergunta ao usuário usando 'sim' ou 'não'
resposta = input("Você pode fazer o pix? Digite 'sim' ou 'não': ")
# Remove espaços nas extremidades e converte tudo para minúsculas
resposta_normalizada = resposta.strip().lower()

if resposta_normalizada == 'sim':
    print("Ok, pix autorizado. Vamos prosseguir com a transferência.")
elif resposta_normalizada == 'não':
    print("Tudo bem, pix não autorizado. Nenhuma transferência será feita.")
else:
    print("Resposta inválida. Por favor digite exatamente 'sim' ou 'não'.")
  • Explicação linha a linha:
    1. input(...): exibe a mensagem e lê a resposta do usuário como uma string.
    2. resposta.strip(): remove espaços no começo e no fim para evitar problemas se o usuário apertar espaço sem querer.
    3. .lower(): converte todo o texto para minúsculas, garantindo que "Sim", "SIM", " sIm " etc. vire "sim" (após o strip).
    4. if resposta_normalizada == 'sim': compara de forma simples com a forma minúscula fixa.
    5. elif resposta_normalizada == 'não': trata o caso negativo com acento.
    6. else: cuida de entradas inválidas (por exemplo, se a pessoa digitou “talvez” ou “nao” sem acento).

Passo 5

Observações úteis e casos especiais (para você não se surpreender na prova)
  • O método lower() resolve o problema de variações de maiúsculas/minúsculas automaticamente. Exemplos de entradas que funcionarão:
    • "SIM" -> 'sim' -> reconhecido
    • " Sim " -> 'sim' -> reconhecido (por causa do strip)
    • "Não" -> 'não' -> reconhecido
    • "NÃO" -> 'não' -> reconhecido
  • Atenção com a ausência do til ~ em “não”: se alguém digitar "nao" (sem acento), após .lower() fica "nao", que é diferente de "não". Ou seja, o código que compare somente com "não" NÃO aceitará "nao". Se quiser aceitar também "nao" (usuários que não usam acento), você tem duas opções simples:
    1. Comparar com ambas as formas:
      if resposta_normalizada in ('não', 'nao'):
          ...
      
    2. Fazer uma normalização de acentos usando o módulo unicodedata e remover diacríticos antes da comparação (mais avançado).
  • Para a maior parte das provas e exercícios simples, comparar com 'sim' e 'não' usando .lower() e .strip() já é o esperado.

Passo 6

Resposta ao item (a): descrição do comando e onde pesquisei
  • Comando: o método de string lower() em Python (usado como s.lower() onde s é uma string) converte todas as letras de s para minúsculas.
  • Como funciona (resumo didático): pega a string original e devolve uma nova string com todas as letras em minúsculas; isso permite comparar de maneira consistente com uma string em minúsculas fixa como "sim" ou "não".
  • Onde encontrei a informação: na documentação oficial do Python, na seção sobre o tipo texto (str) e seus métodos (procure por str.lower() na documentação do Python).

Passo 7

Resposta ao item (b): por que seria necessário verificar todas as possibilidades sem usar lower()
  • Em Python (e na maioria das linguagens), a comparação de strings é sensível a maiúsculas e minúsculas; isto é, duas strings são consideradas diferentes se qualquer letra tiver caixa diferente.
  • Exemplos que mostram o problema:
    • "Sim" == "sim" é False.
    • "SIM" == "sim" é False.
  • Portanto, se você não normalizar a caixa, teria que testar manualmente todas as variações que quer aceitar, por exemplo:
    if resposta == 'sim' or resposta == 'Sim' or resposta == 'SIM' or resposta == 'sIm':
        ...
    
    — isso é impraticável e propenso a erro. Usando .lower() você reduz todas essas variações a uma única forma ('sim') e faz apenas uma comparação simples.

Resposta

(a) Use o método de string lower() em Python: após ler a entrada, aplique resposta_normalizada = resposta.strip().lower() e compare com 'sim' e 'não'. Informação retirada da documentação oficial do Python sobre o tipo str e seus métodos (procure por str.lower() na documentação).
(b) Porque a comparação de strings é sensível a maiúsculas/minúsculas; sem normalizar, "Sim" e "sim" são diferentes, logo seria preciso verificar manualmente todas as variações possíveis de caixa (o que é trabalhoso e pouco robusto).

Exercícios relacionados