Exercícios de Python com respostas

Resposta: B. Porque a sintaxe é limpa e legível, deixando o iniciante focar na lógica.

O ponto forte do Python para iniciantes é a legibilidade: o código parece inglês simples, então a energia vai para aprender lógica, não para decorar símbolos. Ele não é o mais rápido, não é a única linguagem gratuita e, como qualquer linguagem, tem erros.

Estudar a aula: O que é Python e por que aprender essa linguagem

Resposta: B. O ecossistema de bibliotecas: código pronto e compartilhado para cada tipo de tarefa.

A versatilidade vem das bibliotecas: pacotes de código prontos para cada área, criados pela comunidade. A linguagem base é a mesma que você vai aprender; o que muda entre as áreas são as bibliotecas importadas.

Estudar a aula: Onde Python é usado: sites, automações, dados, IA e segurança

Resposta: B. Porque revisitar um problema com ferramentas novas fixa melhor o aprendizado.

A espiral é proposital: retomar um projeto conhecido aplicando conceitos novos (como o tratamento de erros) consolida os dois aprendizados. Você compara o antes e o depois no seu próprio código.

Estudar a aula: O que você vai construir até o final do curso

Resposta: C. Estudar 30 a 40 minutos por dia, rodando os exemplos e respondendo os checkpoints.

Prática espaçada com recuperação ativa é o método com mais evidência: sessões curtas e frequentes, com código rodado de verdade e autoteste. Maratona cansa e não fixa; ler sem praticar forma leitor de código, não programador.

Estudar a aula: Como estudar programação sem travar no começo

Resposta: A. O texto Bom dia aparece na área de saída.

O print mostra na saída o que estiver entre parênteses e aspas. O Playground roda Python de verdade no navegador, então não precisa de instalação, e o print funciona em qualquer sistema.

Estudar a aula: Seu primeiro código, agora, no navegador

Resposta: B. Acompanhar o curso inteiro pelo Playground, incluindo práticas e projeto final.

O Playground roda o interpretador Python real no navegador e cobre todas as aulas, práticas e o projeto final. Instalar no computador melhora o conforto e prepara para as próximas etapas da trilha, mas não é requisito deste curso.

Estudar a aula: Programar sem instalar nada: o Playground é um ambiente completo

Resposta: B. O Python é instalado, mas o comando python não é reconhecido no terminal.

A caixinha adiciona a pasta do Python ao PATH, a lista de pastas onde o Windows procura comandos. Sem ela, o Python existe no computador, mas o terminal não o encontra e responde que o comando não é reconhecido. O conserto é rodar o instalador de novo em modo Modify ou reinstalar marcando a opção.

Estudar a aula: Como instalar o Python no Windows, passo a passo

Resposta: B. A pasta do Python não está no PATH, porque a caixinha ficou desmarcada na instalação.

O aviso de comando não reconhecido significa que o Windows não encontrou o Python nas pastas do PATH, quase sempre porque a opção Add python.exe to PATH não foi marcada. Teste py --version, feche e reabra o terminal, e conserte pelo instalador em modo Modify.

Estudar a aula: Conferindo a instalação: python --version e o modo interativo

Resposta: C. Porque a extensão ensina o editor a entender Python e a chamar o interpretador já instalado.

São peças diferentes: o interpretador (instalado na aula 2) executa o código; o VS Code é o editor onde você escreve; e a extensão Python é a ponte que dá ao editor as cores, a detecção de erros e o botão de play que chama o interpretador. A extensão não contém nem remove o Python.

Estudar a aula: Instalando e conhecendo o VS Code

Resposta: C. Abrir o modo interativo com python, digitar 15 * 12, ver a resposta e sair com exit().

Teste rápido e descartável é a especialidade do modo interativo: entrar, digitar a conta, ler a resposta e sair. Criar arquivo para isso funciona, mas é burocracia desnecessária; e o prompt do Windows não entende expressões Python, só comandos do sistema.

Estudar a aula: Terminal, editor e arquivo .py: quem faz o quê

Resposta: B. O terminal está posicionado em outra pasta, então não encontra o arquivo.

O comando python ola.py procura o arquivo no diretório de trabalho atual do terminal. Se o prompt mostra outra pasta, o arquivo não é encontrado, mesmo existindo no disco. Navegue com cd C:\meus-projetos-python e execute de novo. Conferir o prompt antes de rodar evita esse tropeço.

Estudar a aula: Prática: sua pasta de projetos e o primeiro .py executado

Resposta: B. Total: 15

A conta 10 + 5 está sem aspas, então o Python calcula e obtém 15. O print mostra os dois argumentos na mesma linha com um espaço automático entre eles: Total: 15. Misturar texto e número com vírgula é permitido e muito comum.

Estudar a aula: O famoso print: a primeira ferramenta do programador

Resposta: C. Lê e executa as linhas de cima para baixo, na ordem em que foram escritas.

O interpretador é sequencial e literal: começa na primeira linha, executa, e desce uma a uma até o fim. Ele não reordena, não otimiza a sequência e não adivinha intenção. Por isso a ordem das linhas define a ordem da saída.

Estudar a aula: Executando um programa: o que acontece quando você aperta rodar

Resposta: B. NameError, porque o nome Print não existe; o Python até sugere o print correto.

A escrita é válida, então não é SyntaxError. O interpretador executa, procura o nome Print, não encontra (Python diferencia maiúsculas de minúsculas) e responde NameError: name 'Print' is not defined, com a sugestão Did you mean: 'print'?.

Estudar a aula: Erros de sintaxe sem pânico: lendo o que o Python diz

Resposta: C. # Moldura com 30 asteriscos para alinhar com a maior linha do cartão

Comentário bom registra o porquê: a alternativa correta explica uma decisão de tamanho que o código sozinho não conta. As outras três são eco: repetem o que qualquer pessoa vê na própria linha, ocupando espaço sem informar nada.

Estudar a aula: Comentários no código: o que o Python ignora e você não deveria

Resposta: B. Ele executa normalmente, mas fica mais difícil de ler e manter.

O PEP 8 é convenção, não obrigação técnica: o interpretador ignora estilo e executa do mesmo jeito, na mesma velocidade e sem avisos. O preço de ignorar o guia é pago por pessoas, na hora de ler, revisar e corrigir o código.

Estudar a aula: Código limpo desde o início: os hábitos do PEP 8

Resposta: B. Com print(), sem nada dentro dos parênteses.

O print() com parênteses vazios imprime uma linha em branco na saída. Linha vazia no código é ignorada pelo interpretador e não gera saída; print(" ") imprime um espaço quase invisível, mas não é a forma limpa; e print("branco") mostra a palavra branco.

Estudar a aula: Prática: seu cartão de visitas em código

Resposta: B. Pega o valor atual de pontos, soma 10 e guarda o resultado de volta em pontos.

O igual em Python não compara: ele atribui, da direita para a esquerda. Primeiro o Python calcula pontos + 10 com o valor atual; depois guarda o resultado sob o nome pontos, substituindo o valor antigo. É o padrão dos contadores que você verá no módulo 8.

Estudar a aula: O que são variáveis: dando nome aos valores

Resposta: B. 7, porque o espaço é um caractere e entra na conta.

len() conta todos os caracteres da string, e o espaço é um caractere como qualquer outro. As letras b, o, m, d, i, a somam 6, mais o espaço, 7. len() funciona com strings (e, mais adiante no curso, com listas), devolvendo sempre um número inteiro.

Estudar a aula: Textos com str: o tipo que guarda palavras

Resposta: C. Ignora os underlines na conta: o valor é o inteiro 212000000.

O underline dentro de um número é um separador visual para leitura humana: o Python o descarta ao interpretar o valor. 212_000_000 e 212000000 são o mesmo int, e o print mostra o número sem os underlines. Sem aspas, não há texto envolvido.

Estudar a aula: Números inteiros com int: contas sem vírgula

Resposta: C. Sem nenhum erro, o Python cria uma tupla (19, 90), um dado errado e silencioso.

A vírgula em Python separa valores, então 19,90 vira o par (19, 90), uma tupla de dois inteiros, sem nenhuma mensagem de erro. O programa segue rodando com o dado errado. Decimal em Python se escreve com ponto: preco = 19.90.

Estudar a aula: Números decimais com float: o ponto no lugar da vírgula

Resposta: B. O primeiro guarda 18 na variável; o segundo pergunta se o valor é 18 e devolve True ou False.

Um sinal de igual atribui: cola a etiqueta idade no valor 18. Dois sinais comparam: perguntam se o valor guardado é 18 e devolvem um booleano, True ou False. Confundir os dois é o erro de digitação mais clássico da programação, então vale reler a linha sempre que uma comparação se comportar estranho.

Estudar a aula: Verdadeiro ou falso com bool: o tipo das decisões

Resposta: B. print("Nota: " + str(8))

O + com uma string à esquerda exige string à direita. str(8) converte o número no texto "8", e a concatenação funciona: Nota: 8. Converter para int não ajuda (o problema é justamente o int na soma com texto), e o == compararia em vez de juntar.

Estudar a aula: Descobrindo o tipo com type() e convertendo valores

Resposta: B. Porque altura é medida com fração (float, com ponto) e idade é contagem em anos completos (int).

A escolha do tipo segue o dado: altura é uma medida que carrega fração, então float com ponto decimal; idade se conta em anos completos, então int. Escrever idade = 31.0 não geraria erro, mas mentiria sobre a natureza do dado e traria os arredondamentos de float sem necessidade.

Estudar a aula: Prática: um cadastro simples com os tipos certos

Resposta: B. O programa para, espera o usuário digitar e apertar Enter, e devolve o que foi digitado.

O input() pausa a execução: o programa fica esperando até o usuário digitar algo e apertar Enter. O valor digitado é devolvido pela função e, se nenhuma variável o guardar, ele se perde.

Estudar a aula: Pedindo informações ao usuário com input()

Resposta: B. Executa o input(): mostra a pergunta e espera a resposta; só depois guarda o resultado em cidade.

O lado direito do sinal de igual resolve primeiro: o input() roda, pausa o programa e espera o Enter. O valor digitado é o resultado dessa espera, e só então a atribuição o guarda na variável cidade.

Estudar a aula: Guardando as respostas em variáveis

Resposta: B. Porque o input() devolveu o texto "25", e o + entre textos concatena em vez de somar.

O input() devolve sempre str: a variável guardou o texto "25", não o número 25. Entre textos, o sinal + emenda um no outro, então "25" + "5" produz "255". Convertendo com int(input()), a soma dá 30.

Estudar a aula: Convertendo texto para número: int() e float()

Resposta: C. O programa quebra com ValueError, porque o texto não tem como virar número inteiro.

A int() exige texto com cara de número, como "20". Recebendo "vinte", ela levanta ValueError e o programa para, mostrando o traceback. Perguntar de novo automaticamente exige try/except e repetição, assuntos dos módulos 14 e 8.

Estudar a aula: Erros comuns com input() e como evitá-los

Resposta: A. 2086, o ano em que a pessoa completa 100 anos.

A conta é 2026 - 40 + 100 = 2086: do ano atual, recua até o nascimento aproximado (1986) e avança 100 anos. E não quebra porque a idade foi convertida com int(input()); sem a conversão, aí sim o programa pararia com TypeError ao misturar número e texto na conta.

Estudar a aula: Prática: uma conversa completa no terminal

Resposta: B. 5.0, porque a divisão com / sempre devolve float.

Em Python 3, o operador / devolve float em todos os casos, mesmo quando a divisão é exata. Por isso 10 / 2 resulta em 5.0. Para obter um resultado inteiro existe o operador //, tema da próxima aula.

Estudar a aula: Soma, subtração, multiplicação e divisão

Resposta: C. 3, o que sobra depois que o 5 cabe 4 vezes em 23.

O operador % devolve o resto da divisão inteira: 5 cabe 4 vezes em 23 (totalizando 20) e sobram 3. A divisão comum 23 / 5 daria 4.6, o quociente inteiro 23 // 5 daria 4, e o % não tem relação com porcentagem.

Estudar a aula: Divisão inteira e resto: os operadores // e %

Resposta: B. 50, porque primeiro 4 ** 2 dá 16, depois 3 * 16 dá 48, depois 2 + 48.

A ordem é: potência primeiro (4 ** 2 = 16), multiplicação depois (3 * 16 = 48) e soma por último (2 + 48 = 50). Calcular da esquerda para a direita, ignorando a precedência, é o erro que leva ao 400.

Estudar a aula: Potência e a ordem das operações

Resposta: B. A primeira guarda o valor 18 na variável; a segunda pergunta se idade vale 18 e responde True ou False.

Um sinal de igual é atribuição (ordem de guardar valor); dois sinais são comparação (pergunta de igualdade, com resposta bool). Confundir os dois é o erro clássico, e o Python acusa SyntaxError quando encontra atribuição onde esperava comparação.

Estudar a aula: Operadores de comparação: perguntas de sim ou não

Resposta: B. Porque o Python lê (idade == 17) or (18), e o 18 sozinho vale como verdadeiro, tornando a expressão sempre verdadeira.

Cada lado do or é avaliado separadamente: o lado direito é só o número 18, que conta como verdadeiro na avaliação lógica. Por isso a expressão dá um valor verdadeiro com qualquer idade, sem erro nenhum. O correto é idade == 17 or idade == 18, com uma comparação completa de cada lado.

Estudar a aula: Operadores lógicos: and, or e not

Resposta: B. Porque a divisão tem precedência sobre a soma: b / 2 resolve primeiro e o resultado é 20.0, não 15.0.

Pela ordem das operações, b / 2 calcula primeiro (10.0) e depois soma com a (20.0). A média verdadeira exige parênteses: (a + b) / 2, que soma primeiro (30.0) e divide depois (15.0). É o erro silencioso mais comum desta prática.

Estudar a aula: Prática: sua calculadora simples no terminal

Resposta: B. Uma expressão que o Python avalia até virar True ou False.

Condição é uma expressão, geralmente uma comparação como idade >= 18, que o Python avalia e transforma em True ou False. É sobre essa resposta que o if decide qual caminho o programa segue.

Estudar a aula: O que é uma condição: o programa que escolhe caminho

Resposta: C. O Python pula o bloco inteiro e segue o programa na próxima linha sem indentação.

Condição False não é erro: o Python simplesmente pula o bloco indentado, sem executar nenhuma linha dele, e retoma o programa na primeira linha alinhada à margem esquerda. O silêncio do bloco pulado é a decisão funcionando.

Estudar a aula: Usando o if: a anatomia da primeira decisão

Resposta: B. Porque o else nunca leva condição: ele já significa todos os casos em que o if deu False.

O else é o caminho do senão: por definição, ele cobre exatamente os casos em que a condição do if virou False. Colocar condição nele é SyntaxError. Quando existe uma segunda condição de verdade a testar, a ferramenta certa é o elif.

Estudar a aula: Usando o else: o caminho alternativo

Resposta: B. Porque 9.5 >= 5 é True, o primeiro degrau vence e os degraus das faixas altas nunca são testados.

A escada para no primeiro True. Como 9.5 também satisfaz nota >= 5, a condição mais aberta engole a nota antes de as faixas altas serem testadas. Em faixas com >=, ordene do valor mais alto para o mais baixo.

Estudar a aula: Usando o elif: várias faixas de decisão

Resposta: B. O programa quebra com TypeError, porque o input devolve texto e texto não se compara com número usando >=.

O input sempre devolve string. Comparar string com int usando >= gera TypeError, porque o Python não adivinha a conversão. A correção é converter na leitura: idade = int(input("Idade: ")).

Estudar a aula: Condições com números e textos, sem armadilhas

Resposta: B. Levanta IndentationError: expected an indented block, porque o if exige pelo menos uma linha recuada.

Os dois pontos anunciam um bloco, e bloco exige recuo. Sem nenhuma linha indentada depois do if, o Python para com IndentationError: expected an indented block, apontando a linha. A correção é recuar o conteúdo do if com 4 espaços.

Estudar a aula: Indentação sem erro: a regra dos 4 espaços

Resposta: B. Porque a escada só chega nesse degrau se os anteriores deram False: quem passou do idade < 16 tem 16 ou mais.

A escada é lida de cima para baixo e para no primeiro True. Se a execução chegou ao elif idade < 18, é porque idade < 16 já deu False, ou seja, a idade é 16 ou mais. O degrau herda essa informação e só precisa testar o teto da faixa.

Estudar a aula: Prática: pode votar? Pode tirar CNH?

Resposta: B. A condição do while: quando o teste responde falso, o loop termina.

O while testa a condição antes de cada volta. Enquanto a resposta for verdadeira, o bloco executa de novo; quando a condição vira falsa, o programa segue para a linha depois do loop. Não existe limite automático de voltas, e o print não tem relação com o encerramento.

Estudar a aula: O que é um loop: o superpoder de repetir sem cansar

Resposta: B. Antes de cada volta, inclusive antes da primeira; se já for falsa, o bloco não roda nenhuma vez.

O while é um loop com teste na entrada: avalia a condição antes de cada iteração, inclusive antes da primeira. Por isso, um while cuja condição já nasce falsa pula o bloco por completo, sem executar nem uma volta e sem gerar erro.

Estudar a aula: Como funciona o while: anatomia e passo a passo

Resposta: C. A variável de controle não é atualizada dentro do bloco, então a condição nunca vira falsa.

Se nada dentro do bloco muda a variável testada na condição, o teste dá verdadeiro para sempre e o loop nunca termina. A correção é garantir a linha de atualização (ou um break). Para parar o programa travado, use Ctrl+C no terminal ou o botão de parar no Playground.

Estudar a aula: Loop infinito: como evitar, como reconhecer e como parar

Resposta: B. Acumular o total: somar o número da volta atual ao que já foi somado antes.

Essa linha é o acumulador em ação: pega o total somado até aqui, adiciona o número da volta atual e guarda o resultado de volta em soma. Quem conta as voltas é quantidade = quantidade + 1, quem encerra o loop é a condição numero != 0 e quem converte a entrada é o int.

Estudar a aula: Contadores e acumuladores: contando e somando dentro do loop

Resposta: B. O programa se despede, mas o menu volta a aparecer: sem break, o while True nunca termina.

A condição do while True é sempre verdadeira, então a única saída é o break. Sem ele, a opção sair executa a despedida e o loop recomeça, prendendo o usuário no menu. Não é erro de sintaxe: o Python roda o código exatamente como foi escrito.

Estudar a aula: Menus com while: o padrão que aparece em todo programa de terminal

Resposta: B. Para a contagem recomeçar do 1 toda vez que a opção 3 for escolhida.

Se o contador nascesse antes do loop principal, ele valeria 1 apenas na primeira contagem; nas seguintes, continuaria do valor em que parou e a condição contador <= n poderia já nascer falsa. Dentro do elif, cada escolha da opção 3 zera o estado e a contagem sempre sai completa.

Estudar a aula: Prática: seu menu interativo de 4 opções

Resposta: B. for, porque a quantidade de repetições é conhecida e a sequência controla o fim sozinha.

Quando a quantidade de voltas é conhecida de antemão, o for é a escolha natural: a sequência (como range(50)) decide quantas voltas acontecem, sem contador manual e sem risco de loop infinito. O while continua sendo o certo quando o fim depende de uma condição imprevisível, como a resposta do usuário.

Estudar a aula: for ou while: a diferença de mentalidade

Resposta: B. 3, 4, 5, 6 e 7.

O range(3, 8) começa no 3 (início incluído) e para antes do 8 (fim exclusivo), gerando 3, 4, 5, 6 e 7. O 8 é o muro: marca onde a sequência para, mas nunca entra nela.

Estudar a aula: Usando o range(): início, fim e passo

Resposta: A. 6, porque o loop soma 1 + 2 + 3 no acumulador.

O range(1, 4) gera 1, 2 e 3 (fim exclusivo). O acumulador soma começa em 0 e recebe 1, depois 2, depois 3, chegando a 6. O print fora do loop mostra o total uma única vez, que é o comportamento desejado.

Estudar a aula: Repetindo ações: N vezes, com ou sem contador

Resposta: B. 7, porque a string tem 7 caracteres e o espaço é um deles.

O for percorre a string caractere por caractere, e "bom dia" tem 7: b, o, m, espaço, d, i, a. O espaço é um caractere como qualquer outro, então ganha uma volta própria. Percorrer palavras em vez de letras é possível, mas exige outra ferramenta (o split(), que aparece no módulo 12).

Estudar a aula: Percorrendo textos letra por letra

Resposta: C. 100 vezes, porque o loop de dentro roda completo a cada volta do de fora.

Para CADA volta do loop de fora, o de dentro roda do início ao fim: 10 voltas de fora vezes 10 de dentro dá 100 execuções do miolo. É a mecânica do relógio: o ponteiro dos minutos completa a volta inteira para o das horas avançar uma posição.

Estudar a aula: Tabuada com for: do 7 sozinho ao 1 ao 10 completo

Resposta: B. Porque o fim do range é exclusivo, e sem o + 1 a última tabuada pedida ficaria de fora.

O usuário que pede do 3 ao 6 espera ver a tabuada do 6, mas range(3, 6) para no 5, por causa do fim exclusivo. O fim + 1 traduz a contagem humana (que inclui as pontas) para a do range. Sem ele, o programa roda sem erro e entrega menos do que prometeu.

Estudar a aula: Prática: tabuada automática do jeito que o usuário pedir

Resposta: B. A lista guarda todos os valores numa variável só, em ordem, pronta para crescer e ser percorrida.

A lista agrupa valores relacionados numa única variável ordenada: dá para medir com len(), percorrer com for e crescer sem editar o código. Velocidade não é o ponto, ela não corrige nada sozinha e aceita qualquer tipo, inclusive misturados.

Estudar a aula: O que é uma lista: muitos valores numa variável só

Resposta: B. verde, porque a contagem começa em 0 e o índice 1 é o segundo item.

A contagem começa em zero: cores[0] é "azul", cores[1] é "verde" e cores[2] é "vermelho". O índice 1 existe (a lista tem 3 itens, índices de 0 a 2) e quem conta do fim são os índices negativos, como cores[-1].

Estudar a aula: Criando e acessando itens: o índice começa em zero

Resposta: B. Constrói uma lista aos poucos: cada volta do loop acrescenta um item novo no fim.

A lista nasce vazia e cada volta do loop dá um append, acrescentando o item novo no fim sem tocar nos anteriores. Ao final, a lista tem um item por volta executada. É o padrão de construção de listas mais comum do Python.

Estudar a aula: Adicionando itens: append no fim, insert na posição

Resposta: B. remove() apaga pelo VALOR e não devolve nada; pop() apaga pela POSIÇÃO e devolve o item removido.

remove("banana") procura o valor e apaga a primeira ocorrência, sem devolver nada (e gera ValueError se não achar). pop(0) tira o item da posição e o entrega para você guardar numa variável; sem argumento, tira o último. Os dois funcionam com qualquer tipo de item.

Estudar a aula: Removendo itens: remove, pop e del, cada um no seu papel

Resposta: B. 16, porque total acumula a soma de 3, 8 e 5.

É o padrão acumulador: total começa em 0 e recebe cada valor da lista, uma volta por vez (0+3=3, 3+8=11, 11+5=16). O total = 0 fica FORA do loop, então não zera a cada volta. O mesmo resultado sairia de sum(valores).

Estudar a aula: Percorrendo listas com for: visitar, somar e comparar

Resposta: B. if nome not in convidados: convidados.append(nome)

Para evitar duplicata, o append só deve acontecer quando o nome está AUSENTE, e quem expressa ausência é o not in. As alternativas com in e count > 0 fazem o contrário (só adicionam quem JÁ está lá), e o index gera ValueError quando o nome não existe.

Estudar a aula: Verificando se um item existe: in, count e index

Resposta: B. Porque remove() com item inexistente geraria ValueError e derrubaria o programa; o if troca o erro por um aviso.

remove() levanta ValueError quando o valor não está na lista, e um erro não tratado encerra o programa na hora. Conferir com in antes permite responder com uma mensagem educada e voltar ao menu. É o caso de borda mais importante do projeto; velocidade e quantidade não têm relação com o if.

Estudar a aula: Prática: lista de compras interativa com menu

Resposta: C. O programa para com um TypeError, porque tupla não aceita alteração de item.

Tupla é imutável: depois de criada, nenhum item pode ser trocado, adicionado ou removido. A tentativa gera TypeError na hora, o que é proposital: melhor um erro visível agora do que um dado corrompido em silêncio.

Estudar a aula: O que é uma tupla: a lista que não muda

Resposta: B. Tupla, porque é um registro fixo que não deve mudar durante o programa.

Coordenadas de um lugar fixo são o exemplo clássico de registro fixo: nascem prontas e qualquer alteração seria erro. A tupla protege contra mudança acidental e ainda avisa quem lê o código de que aquele dado é fechado. Tamanho e tipo não são o critério; o comportamento no tempo é.

Estudar a aula: Lista ou tupla: como escolher a certa

Resposta: C. Os colchetes geram KeyError e param o programa; o get devolve 0 e a execução continua.

Com colchetes, chave inexistente gera KeyError na hora. O get faz a mesma busca com plano B: devolve o valor padrão informado (aqui, 0) e o programa segue. Use colchetes quando a chave deve existir e o get quando a ausência é uma possibilidade normal.

Estudar a aula: Dicionários: cada valor com o seu nome

Resposta: C. Um par completo: a chave em campo e o valor correspondente em valor.

O método items entrega os pares chave e valor juntos, desempacotados nas duas variáveis do for. É diferente do for direto no dicionário, que percorre apenas as chaves, e do values, que percorre apenas os valores.

Estudar a aula: Cadastro com dicionário: a ficha completa

Resposta: B. Um conjunto com {1, 2, 3}: as repetições são descartadas em silêncio.

O conjunto não aceita repetição, mas isso não gera erro: as cópias extras são simplesmente descartadas, sobrando uma ocorrência de cada valor. O resultado é um set com {1, 2, 3}, sem garantia de ordem, e não uma lista.

Estudar a aula: Conjuntos com set: sem ordem e sem repetição

Resposta: B. Recuperação, porque a média 5.5 é maior ou igual a 5 e menor que 7.

A média é (6.0 + 5.0) / 2 = 5.5. O teste media >= 7 falha, o teste media >= 5 passa, então a situação é Recuperação. As regras olham a MÉDIA, não cada nota isolada: é assim que o if, elif e else do programa foi montado.

Estudar a aula: Prática: a ficha de aluno completa

Resposta: B. ana, porque .upper() devolve uma string nova e o resultado não foi guardado.

Strings são imutáveis: .upper() fabrica uma string nova e a devolve. Como o resultado não foi guardado em nenhuma variável, ele se perdeu, e nome continua valendo ana. Para mudar, seria nome = nome.upper().

Estudar a aula: Maiúsculas e minúsculas: upper, lower, title e capitalize

Resposta: B. Porque o .strip() remove espaços acidentais das pontas, evitando que "sim " seja tratado como resposta diferente de "sim".

O usuário pode digitar espaços sem perceber, e "sim " é diferente de "sim" numa comparação. O .strip() limpa só as pontas (o miolo fica intacto) e não mexe na caixa das letras; para isso existe o .lower(). Sem .strip() não há erro, há bug silencioso.

Estudar a aula: Removendo espaços: strip, lstrip e rstrip

Resposta: B. bom dia, porque .replace() devolve uma string nova e o resultado não foi guardado.

Mesma regra de todos os métodos de string: .replace() fabrica uma string nova com a troca feita e a devolve. Sem guardar o resultado (texto = texto.replace("dia", "noite")), o original segue intacto. O terceiro argumento do replace existe, mas é opcional.

Estudar a aula: Procurando e substituindo: in, find, count e replace

Resposta: B. R$ 9.50

O :.2f força exatamente duas casas decimais: quando o número tem menos, o Python completa com zero (9.5 vira 9.50); quando tem mais, ele arredonda. É o formato padrão para exibir dinheiro, com o detalhe de usar ponto, não vírgula.

Estudar a aula: f-strings: mensagens formatadas do jeito moderno

Resposta: C. len(frase.split())

O .split() quebra a frase numa lista de palavras (["bom", "dia,", "Brasil"]) e o len() conta os itens da lista: 3. O len(frase) contaria caracteres (15), e contar espaços falharia com espaços duplicados ou nas pontas, caso em que o split sem argumento continua certo.

Estudar a aula: Contando caracteres e palavras: len, split e join

Resposta: B. Porque limpar as pontas e zerar a caixa antes de separar garante palavras limpas e minúsculas, prontas para o teste de conectivo em minúsculas.

O pipeline prepara o dado para o passo seguinte: o strip tira a sujeira das pontas, o lower zera a caixa (essencial para SILVA casar com o teste in CONECTIVOS, que compara em minúsculas) e o split separa as palavras. Outras ordens até rodam sem erro de sintaxe, mas a lógica de conectivos falharia se a caixa não estivesse normalizada antes do teste.

Estudar a aula: Prática: formatador de nomes

Resposta: C. Qualquer correção precisa ser feita nas cinco cópias; esquecer uma cria um erro silencioso.

Código repetido funciona, e é isso que o torna traiçoeiro: quando algo muda, todas as cópias precisam mudar juntas. Uma cópia esquecida deixa o programa inconsistente sem nenhuma mensagem de erro. A função resolve isso concentrando o bloco num lugar só.

Estudar a aula: O que é uma função: o bloco de código com nome

Resposta: B. Nada aparece na tela: o def só guarda a função; sem chamada, o corpo não executa.

Definir não é executar. O def apenas registra a função na memória e o programa segue. O corpo só roda quando existe uma chamada: o nome da função seguido de parênteses. Definição sem chamada não é erro; é só uma receita que ninguém cozinhou ainda.

Estudar a aula: Criando funções com def: anatomia completa

Resposta: B. Olá, Pedro!, porque o parâmetro saudacao usa o valor padrão.

O parâmetro saudacao tem valor padrão, então ele é opcional: sem o segundo argumento, vale Olá e a função imprime Olá, Pedro!. O parâmetro nome, sem padrão, continua obrigatório; esquecê-lo aí sim geraria erro de argumento faltando.

Estudar a aula: Parâmetros: as entradas da função

Resposta: C. None, porque função sem return devolve None.

Sem return, a chamada devolve None, e é isso que fica em x. O texto do print apareceu na tela, mas tela e retorno são canais diferentes: mostrar não é devolver. Nenhum erro acontece na hora, o que torna esse comportamento fácil de não perceber.

Estudar a aula: Retorno com return: a função que devolve resultado

Resposta: B. Imprime 10 e depois quebra com TypeError, porque x guardou None.

O print interno mostra 10 na tela, mas mostrar não é devolver: sem return, a chamada vale None, e é isso que x guarda. Na linha seguinte, None + 1 gera TypeError citando NoneType. A correção é trocar o print da função por return e deixar o print para o programa principal.

Estudar a aula: Mostrar ou retornar: print não é return

Resposta: B. Chamar as funções na ordem certa, conectando o retorno de uma à entrada da outra.

O programa principal é o coordenador: chama as funções na sequência, passa os retornos adiante e cuida da exibição final. Os cálculos e decisões moram nas funções, cada uma com sua tarefa. Repetir código por segurança é exatamente o problema que as funções eliminam.

Estudar a aula: Organizando programas com funções

Resposta: B. Porque sum e len trabalham com a lista inteira, seja qual for o tamanho dela.

O parâmetro notas recebe a lista inteira como um único valor, e sum e len operam sobre ela sem se importar com o tamanho: somam tudo e contam tudo. É a combinação de listas (módulo 10) com funções que torna o código genérico de graça.

Estudar a aula: Prática: funções de notas, média e aprovação

Resposta: C. Erro de lógica: o programa roda até o fim, mas o raciocínio da conta estava errado.

Média de notas de 0 a 10 não pode dar 17.3. Como o programa rodou sem mensagem, não é erro de escrita nem de execução: é erro de lógica, a família silenciosa. O Python fez a conta escrita, que não era a conta pretendida.

Estudar a aula: Por que erros acontecem: as três famílias

Resposta: B. Ler a última linha, que traz o tipo do erro e a mensagem, e depois subir para achar o arquivo e a linha.

A regra de ouro é ler de baixo para cima: a última linha resume o tipo e a mensagem do erro, e as linhas File e line acima dela dão o endereço. O tamanho do traceback só reflete quantas funções estavam envolvidas, não a gravidade.

Estudar a aula: Lendo mensagens de erro: a anatomia do traceback

Resposta: B. ValueError, porque int() aceita texto, mas o valor dez não contém um número.

A função int() aceita texto como entrada, então o tipo está certo; o problema é o VALOR, que não contém dígitos para converter. Isso é ValueError. Seria TypeError se a operação recusasse o tipo em si, como somar texto com número.

Estudar a aula: TypeError, ValueError e a turma dos erros mais comuns

Resposta: B. Porque o except específico captura só o erro esperado; os demais continuam aparecendo para você corrigir.

O except puro é válido e funciona, mas captura QUALQUER erro, inclusive defeitos de digitação seus que o traceback denunciaria, escondendo-os atrás de uma mensagem genérica. O except específico trata o risco real (ValueError no input) e deixa os erros inesperados visíveis.

Estudar a aula: Usando try e except: tratando o erro esperado

Resposta: C. O except captura o ValueError, mostra a mensagem amigável e o while pede o número de novo.

O float("abc") levanta ValueError dentro do try, o except captura, avisa o usuário e o while volta ao input. O loop só termina no return, que roda quando a conversão dá certo: por isso a função nunca derruba o programa nem devolve valor inválido.

Estudar a aula: Prática: a calculadora à prova de erros

Resposta: B. Porque variáveis vivem na memória, que é apagada quando o programa fecha; o arquivo fica no disco.

Variáveis moram na memória RAM, uma área de trabalho que o sistema limpa quando o programa termina. O arquivo é gravado no disco e persiste: continua lá depois que o programa fecha e até depois que o computador desliga. Velocidade é o contrário: memória é mais rápida que disco.

Estudar a aula: O que é um arquivo de texto e por que salvar dados nele

Resposta: C. O conteúdo é apagado imediatamente, mesmo antes de qualquer write.

O modo w zera o arquivo no momento da abertura, sem aviso e sem chance de recuperar. Para preservar o conteúdo e escrever no fim, o modo certo é a, de append. Abrir em w um arquivo existente não gera erro nenhum, e é justamente por isso que a pegadinha é perigosa.

Estudar a aula: Criando e escrevendo arquivos com open e write

Resposta: C. O Python levanta FileNotFoundError, que pode ser tratado com try/except.

Diferente de w e a, que criam o arquivo quando ele não existe, o modo r exige que o arquivo esteja lá. Sem o arquivo, o open levanta FileNotFoundError na hora. Envolvendo a leitura num try/except FileNotFoundError, o programa trata a ausência com uma mensagem amigável em vez de quebrar.

Estudar a aula: Lendo arquivos: read, linha a linha e o arquivo que não existe

Resposta: B. O with fecha o arquivo sempre, mesmo se um erro acontecer dentro do bloco.

A garantia do with é o fechamento incondicional: terminou o bloco, por conclusão normal ou por erro, o arquivo é fechado. O close manual depende de você lembrar e de nenhum erro interromper a execução antes dele. Velocidade, conversão de tipos e o comportamento do modo r não mudam com o with.

Estudar a aula: Fechamento automático com with: o jeito certo de abrir arquivos

Resposta: B. Para acentos e ç serem gravados e lidos do mesmo jeito em qualquer máquina, sem depender do padrão do sistema.

O encoding é a tabela que traduz caracteres em números no disco. O Windows em português usa por padrão uma tabela antiga, e a mistura de tabelas quebra os acentos ou gera UnicodeDecodeError. Declarando utf-8 na escrita e na leitura, o programa se comporta igual em qualquer sistema. Espaço e velocidade não são o ponto, e o modo w cria o arquivo com ou sem encoding.

Estudar a aula: Cuidados ao salvar dados: acentos, validação e caminhos

Resposta: B. Para o programa avisar que não há tarefas quando o tarefas.txt ainda não existe, em vez de quebrar.

Na primeira execução, ninguém adicionou tarefa e o tarefas.txt não existe; abrir em modo r levantaria FileNotFoundError e derrubaria o programa. O try/except transforma essa situação esperada numa mensagem amigável. O with funciona fora de try normalmente, o modo r nunca cria arquivo e ordenação não tem relação com o tratamento de erro.

Estudar a aula: Prática: lista de tarefas que sobrevive ao fim do programa

Resposta: B. Adicionar uma parte pequena por aula, terminando cada aula com o programa acumulado funcionando.

Construção incremental é crescer em camadas: cada aula evolui o mesmo arquivo gerenciador.py com uma parte nova e termina com tudo rodando. Escrever cem linhas de uma vez multiplica os erros e esconde onde eles estão; copiar o código pronto rouba o treino.

Estudar a aula: O projeto: seu gerenciador de tarefas

Resposta: B. Porque o while True volta ao início do bloco após cada ação, e mostrar_menu é a primeira linha do bloco.

O loop principal é um while True: ao terminar uma ação, a execução volta para o topo do bloco, que chama mostrar_menu de novo e lê outra opção. O ciclo só quebra quando a opção 5 executa o break.

Estudar a aula: Estruturando o programa: o esqueleto que já funciona

Resposta: C. O número da posição (a partir do 1) e o dicionário da tarefa, juntos.

enumerate percorre a lista entregando pares: a posição e o item. Com start=1, a contagem começa em 1 em vez de 0. Por isso o for declara duas variáveis, i e tarefa, e consegue numerar a listagem sem contador manual.

Estudar a aula: Adicionando e listando tarefas

Resposta: C. Porque se o usuário digitar algo que não é número, int() levanta ValueError e, sem o except, o programa fecha na hora.

int("abc") levanta ValueError, e exceção sem tratamento derruba o programa inteiro, perdendo as tarefas da sessão. O try/except transforma essa falha numa mensagem educada e devolve o usuário ao menu, que é o comportamento de um programa profissional.

Estudar a aula: Concluindo e removendo tarefas

Resposta: C. O except FileNotFoundError captura a situação e carregar_tarefas devolve a lista vazia; o programa abre normalmente.

Abrir para leitura um arquivo inexistente levanta FileNotFoundError, mas carregar_tarefas envolve o open num try/except exatamente para isso: captura o erro, ignora com pass e devolve a lista vazia. O arquivo passa a existir na primeira gravação, feita pelo salvar_tarefas no modo w.

Estudar a aula: Salvando e carregando do arquivo

Resposta: B. Por segurança: em ação destrutiva, só um sim explícito autoriza; qualquer dúvida, erro de digitação ou Enter vazio deve preservar os dados.

É a assimetria proposital das ações sem volta: apagar exige a intenção clara (a letra s), e todo o resto, inclusive um Enter apressado ou um erro de digitação, cai no caminho seguro do cancelamento. Perder um clique é barato; perder um dado, não.

Estudar a aula: Polindo o programa: os toques finais

Resposta: C. Uma mudança por vez, testando antes de seguir e guardando uma cópia da versão que funciona.

É o mesmo método incremental do módulo: mudanças pequenas, teste após cada uma e uma cópia de segurança da versão funcionando. Mudar tudo junto esconde a origem dos erros, e buscar gabarito antes de tentar rouba exatamente o exercício de autonomia que a evolução existe para dar.

Estudar a aula: E agora? Próximos passos na trilha