Exercícios de Python intermediário com respostas

Resposta: C. Usar a mesma base com mais organização, escrevendo código legível e reaproveitável.

O intermediário reaproveita tudo do Básico (variáveis, laços, funções) e acrescenta organização: código legível, reaproveitável e confiável. Há recursos novos, como orientação a objetos, mas o fio condutor é escrever melhor, não recomeçar.

Estudar a aula: Do básico para o intermediário: o que muda

Resposta: B. Para devolver o valor e poder usá-lo depois, por exemplo passando para situacao().

return devolve o resultado para quem chamou, então dá para guardar em uma variável e passar para outra função (situacao(m)). Uma função que só imprime não permite reaproveitar o valor. Essa distinção é a base de todo o intermediário.

Estudar a aula: Revisão relâmpago do básico

Resposta: B. Para reaproveitar um módulo pronto e testado, deixando o código curto e claro.

A biblioteca padrão traz módulos prontos e testados, como statistics. Importar em vez de reescrever deixa o código mais curto, claro e confiável. É o espírito do intermediário: aproveitar o que já existe, bem feito.

Estudar a aula: Seu ambiente e o Playground do curso

Resposta: B. [n * n for n in [1, 2, 3, 4]]

A forma é [expressão for item in sequência]. Aqui a expressão é n * n (o quadrado) e a sequência é [1, 2, 3, 4], resultando em [1, 4, 9, 16]. A terceira opção não tem o for e a quarta usa parênteses, que criam um generator, não uma lista.

Estudar a aula: O que é uma compreensão de lista

Resposta: B. No fim, sem else, depois do for.

Para filtrar (descartar itens), o if vai no fim, sem else: [n for n in lista if n > 0]. O if/else no início não filtra, ele escolhe o valor de cada item e mantém todos. As duas construções fazem coisas diferentes.

Estudar a aula: Compreensão com condição

Resposta: C. [item for linha in matriz for item in linha]

Para achatar, a expressão é item (o valor de dentro), o for de fora percorre as linhas (for linha in matriz) e o de dentro percorre os itens de cada linha (for item in linha). A opção com dois colchetes recria a lista de listas em vez de achatar.

Estudar a aula: Compreensões aninhadas

Resposta: C. {letra: i for i, letra in enumerate(letras, 1)}

A compreensão de dicionário usa chaves e o par chave: valor. Com enumerate(letras, 1), i vai de 1 e letra recebe cada caractere; o par letra: i coloca a letra como chave e o número como valor. A primeira opção usa colchetes (inválido para dicionário) e a última inverte chave e valor.

Estudar a aula: Compreensão de dicionário

Resposta: C. Um generator, que produz os valores um a um quando consumido.

Parênteses em uma compreensão criam uma generator expression, não uma tupla. Ela não constrói nada na memória de imediato; produz cada valor sob demanda, quando algo a percorre (como sum ou um for). É a avaliação preguiçosa, aprofundada no módulo de geradores.

Estudar a aula: Compreensão de conjunto e a espiada em generator

Resposta: B. {a["nome"]: a["media"] for a in dados if a["media"] >= 7}

É uma compreensão de dicionário (chaves e o par nome: media) com if no fim para filtrar quem tem média a partir de sete. A primeira usa colchetes (inválido para dicionário), a terceira cria um conjunto (sem par) e a quarta inverte chave e valor.

Estudar a aula: Prática: transformar dados de alunos

Resposta: B. Porque um parâmetro com valor padrão não pode vir antes de um parâmetro sem padrão.

A regra é firme: parâmetros com valor padrão vêm sempre depois dos obrigatórios. Se um opcional viesse antes de um obrigatório, o Python não conseguiria casar os argumentos posicionais sem ambiguidade, então recusa o arquivo com SyntaxError.

Estudar a aula: Parâmetros com valor padrão

Resposta: B. A chamada fica mais clara, pois cada valor mostra a qual parâmetro pertence.

Argumentos nomeados casam pelo nome do parâmetro, então a chamada mostra o papel de cada valor e a ordem deixa de importar. Isso é ótimo para legibilidade, principalmente com True, False e números soltos, que sem nome não dizem nada.

Estudar a aula: Argumentos nomeados e posicionais

Resposta: B. Uma tupla com todos os argumentos posicionais extras recebidos.

O asterisco recolhe todos os argumentos posicionais extras em uma tupla, por convenção chamada args. Você pode percorrê-la com um laço, medir com len e indexar. Os nomeados extras ficam em **kwargs, que é um dicionário.

Estudar a aula: *args e **kwargs: quantidade variável

Resposta: B. Porque o padrão é criado uma vez só; com [] todas as chamadas compartilham a mesma lista, e com None cada chamada cria a sua.

O valor padrão é avaliado uma única vez, na definição. Uma lista vazia como padrão é compartilhada entre todas as chamadas, então os dados vazam. Usando None e criando a lista dentro da função com um if lista is None, cada chamada ganha um objeto novo.

Estudar a aula: A armadilha do padrão mutável

Resposta: B. Não, ela é local e deixa de existir quando a função termina.

Variáveis criadas dentro de uma função são locais: existem apenas durante a execução da função e somem quando ela retorna. Tentar usá-las fora gera NameError. Para compartilhar um valor, devolva-o com return em vez de depender de escopo global.

Estudar a aula: Escopo local e global

Resposta: B. Lambda é uma função anônima de uma expressão, ideal para lógica curta usada de passagem, como o key de sorted.

A lambda é uma função anônima de uma única expressão, cujo valor é devolvido sem return. Ela serve para lógica trivial usada de passagem, como o critério de um sorted. Para lógica com if, laços ou várias linhas, ou que vá se repetir, o certo é usar def.

Estudar a aula: Funções lambda e prática do módulo

Resposta: B. dobrar aponta para o objeto função sem executá-lo; dobrar(3) executa a função com o argumento 3.

Sem parênteses, o nome apenas aponta para o objeto função, que pode ser guardado numa variável, lista ou dicionário. Com parênteses e argumentos, a função é executada e devolve um resultado. Essa distinção é a base de tratar funções como valores.

Estudar a aula: Funções são valores

Resposta: C. Receber outra função como argumento ou devolver uma função como resultado.

Função de ordem superior é a que recebe ao menos uma função como argumento ou devolve uma função como resultado. Isso separa a parte fixa (a estrutura) da parte que varia (o comportamento passado de fora), reduzindo repetição.

Estudar a aula: Funções de ordem superior

Resposta: C. sorted(pessoas, key=lambda p: p['idade'])

O parâmetro key recebe uma função. A lambda lambda p: p['idade'] recebe cada pessoa e devolve a idade, que vira o critério de comparação. key precisa ser nomeado, e a função vai sem parênteses.

Estudar a aula: Ordenar com key

Resposta: B. [x * 2 for x in nums if x % 2 == 0]

A compreensão de lista [x * 2 for x in nums if x % 2 == 0] junta o filtro e a transformação em uma expressão legível, sem lambdas aninhadas nem list() em volta. É a forma preferida na maioria dos casos que map e filter também resolvem.

Estudar a aula: map e filter

Resposta: B. Uma função interna que continua lembrando as variáveis da função externa, mesmo depois de ela terminar.

Closure é a função interna que fecha ao redor das variáveis da função externa e as mantém vivas enquanto existir, mesmo depois de a externa terminar. É o que faz uma fábrica como criar_multiplicador gerar funções que lembram o próprio fator.

Estudar a aula: Closures

Resposta: B. key=lambda a: (-a['nota'], a['nome'])

Devolver a tupla (-a['nota'], a['nome']) faz a nota ser comparada do maior para o menor (por causa do sinal de menos) e, nos empates, usa o nome em ordem alfabética crescente. Uma tupla no key permite misturar critérios decrescentes e crescentes.

Estudar a aula: Prática: ordenar e transformar

Resposta: B. import math traz o módulo inteiro (usado como math.sqrt); from math import sqrt traz só sqrt, usado direto.

import math traz o módulo todo e você acessa cada função pelo prefixo, como math.sqrt. Já from math import sqrt traz apenas a função sqrt para o seu código, usada direto, sem o prefixo. O import com prefixo costuma ser preferido por deixar clara a origem de cada nome.

Estudar a aula: O que é um módulo e como o import funciona

Resposta: B. Para separar o código que só deve rodar ao executar o arquivo direto do que deve rodar ao importá-lo.

A variável __name__ vale "__main__" quando o arquivo é executado direto, e vale o nome do módulo quando é importado. O if usa essa diferença para rodar testes e o ponto de entrada apenas na execução direta, mantendo o módulo limpo para quem o importa.

Estudar a aula: Criando seu próprio módulo

Resposta: B. random.choice(lista)

random.choice(lista) devolve um item aleatório da lista informada. A randint sorteia um inteiro num intervalo numérico, a random devolve um decimal entre 0 e 1 sem argumentos, e o math.floor arredonda um número para baixo, nada a ver com escolher itens.

Estudar a aula: Matemática e sorte: math e random

Resposta: B. Um objeto timedelta, do qual você tira os dias com o atributo .days.

Subtrair duas datas devolve um objeto timedelta, que representa uma duração. Para obter a diferença em dias, use o atributo .days desse timedelta, como em (ano_novo - hoje).days. Ele não devolve um número solto nem um texto.

Estudar a aula: Trabalhando com datas: datetime em visão geral

Resposta: B. Counter, que recebe uma sequência e devolve quantas vezes cada item aparece.

O Counter recebe uma sequência e já devolve um dicionário com a contagem de cada item, além de métodos como most_common para pegar os mais frequentes. O defaultdict evita o KeyError e o namedtuple dá nomes aos campos de uma tupla, cada um com outro propósito.

Estudar a aula: Coleções especiais: Counter, defaultdict e namedtuple

Resposta: B. Para que os prints de demonstração rodem só ao executar o arquivo direto, e não quando outro programa importar as funções.

O bloco sob o if __name__ == "__main__" só roda quando o arquivo é executado diretamente. Assim, a demonstração aparece ao rodar o arquivo, mas quem importa o módulo recebe apenas as funções contar_palavras e palavra_do_dia, sem os prints de teste atrapalhando.

Estudar a aula: Prática: um utilitário com Counter e random

Resposta: B. Permite que projetos diferentes usem versões diferentes do mesmo pacote sem conflito.

O ambiente virtual dá a cada projeto uma despensa isolada de pacotes. Assim, um projeto pode usar a versão 1 de uma biblioteca e outro a versão 2 ao mesmo tempo, sem que a instalação de um quebre o outro.

Estudar a aula: Por que ambientes virtuais existem

Resposta: B. Você esqueceu de ativar o ambiente virtual naquela nova sessão de terminal.

A ativação vale apenas para a janela de terminal atual. Ao abrir um terminal novo, você precisa rodar .venv\Scripts\activate de novo. Sem o prefixo (.venv), os comandos usam o Python global, que não enxerga os pacotes do projeto.

Estudar a aula: Criando um ambiente virtual no Windows

Resposta: B. O requests é instalado na instalação global do Python, e não na despensa do projeto.

Sem o (.venv) ativo, o pip usa a instalação global. O requests iria para lá, não para a despensa do projeto. Por isso vale conferir o prefixo (.venv) no terminal antes de instalar, e usar pip list para confirmar onde o pacote foi parar.

Estudar a aula: Instalando pacotes com pip

Resposta: B. Para instalar de uma vez todos os pacotes listados no arquivo, nas versões indicadas.

O -r aponta para um arquivo de requisitos. O pip lê o requirements.txt e instala cada pacote na versão travada ali, recriando a mesma despensa. É o que torna o projeto reprodutível em qualquer computador.

Estudar a aula: requirements.txt: a receita do projeto

Resposta: B. Converte o corpo JSON da resposta em dados Python, como um dicionário.

O pedido já foi feito por requests.get. O resposta.json() apenas lê o corpo da resposta, que veio em JSON, e o transforma em dados Python (em geral um dicionário ou lista), para você acessar os valores por chave.

Estudar a aula: Usando um pacote externo na prática

Resposta: B. Ativar o ambiente, para que python e pip passem a usar a despensa do projeto.

Criar o ambiente não basta: é preciso ativá-lo com .venv\Scripts\activate para que os comandos usem a despensa isolada. Só depois de ativo você instala os pacotes, congela a receita e roda o script.

Estudar a aula: Prática: montar um projeto isolado

Resposta: B. Um objeto JSON lembra um dicionário e uma lista JSON lembra uma lista, mas o nulo é null e não None.

JSON é muito parecido com as estruturas do Python: objetos lembram dicionários e arrays lembram listas. As diferenças são de grafia, como true/false em minúsculas e null no lugar de None. E dá para converter nos dois sentidos com o módulo json.

Estudar a aula: O que é JSON e por que ele está em todo lugar

Resposta: B. Passar ensure_ascii=False no json.dumps para preservar os acentos.

Por padrão, ensure_ascii vale True e escapa acentos como \u00e3. Passando ensure_ascii=False, o São Paulo aparece legível. O indent só cuida da indentação, não dos acentos, e trocar por loads faria o caminho contrário.

Estudar a aula: De Python para JSON com json.dumps

Resposta: B. json.loads, que transforma a string JSON em dicionário ou lista do Python.

Para ir de texto JSON para dados do Python usa-se json.loads. O dumps faz o contrário (dados para texto), o dump grava em arquivo e o print apenas exibe. Depois do loads, você acessa os campos como em qualquer dicionário ou lista.

Estudar a aula: De JSON para Python com json.loads

Resposta: B. Abrir o arquivo com encoding="utf-8" tanto na escrita quanto na leitura.

Passar encoding="utf-8" ao abrir o arquivo para escrever e para ler garante que os acentos sejam gravados e recuperados corretamente, sem depender do padrão do sistema operacional. O indent e o ensure_ascii ajudam na legibilidade, mas o encoding é o que resolve o encoding do arquivo em si.

Estudar a aula: Lendo e gravando arquivos JSON

Resposta: B. Pega a lista de pedidos, depois o primeiro pedido, depois o campo valor desse pedido.

A leitura é da esquerda para a direita, descendo uma camada por colchete: dados["pedidos"] pega a lista, [0] pega o primeiro item (um dicionário) e ["valor"] pega o campo valor dele. É assim que se navega em JSON aninhado.

Estudar a aula: Dados aninhados: listas dentro de dicionários

Resposta: B. Porque foram usados ensure_ascii=False ao gravar e encoding="utf-8" ao abrir o arquivo nas duas pontas.

O ensure_ascii=False manteve os acentos legíveis no texto JSON, e o encoding="utf-8" na escrita e na leitura garantiu que o arquivo fosse gravado e recuperado sem embaralhar os caracteres. Essa dupla é o que preserva o português nos arquivos JSON.

Estudar a aula: Prática: um catálogo de produtos em JSON

Resposta: B. Uma tabela guardada como texto puro, com uma linha por registro e campos separados por vírgula ou ponto e vírgula.

CSV é texto puro: cada linha é um registro e os campos vêm separados por um caractere, quase sempre vírgula ou ponto e vírgula. Por ser texto simples, qualquer programa abre, o que o tornou o formato de troca mais comum.

Estudar a aula: O que é CSV

Resposta: B. Ele acessa os campos pelo nome da coluna, em vez de pela posição, ficando mais claro e resistente a mudanças de ordem.

O DictReader usa o cabeçalho como chaves e entrega dicionários, então você acessa linha['nota'] pelo nome. É mais legível e não quebra se a ordem das colunas mudar. Ele não converte números sozinho: a conversão com float continua sendo sua.

Estudar a aula: Lendo CSV

Resposta: B. Porque ele adiciona uma marca (BOM) que o Excel reconhece, fazendo os acentos aparecerem corretamente.

O Excel em português não assume utf-8 por padrão ao abrir CSV, então acentos podem sair errados. O utf-8-sig adiciona uma marca invisível (BOM) no início que o Excel reconhece, exibindo São Paulo e outros acentos corretamente. O Python lê os dois formatos sem problema.

Estudar a aula: Gravando CSV

Resposta: B. Porque o Path junta as partes com o separador correto de cada sistema e evita erros de barra faltando ou repetida.

Somar textos exige acertar as barras na mão e usa sempre a barra normal, o que quebra no Windows, que usa contrabarra. O operador barra do Path junta as partes com o separador certo de cada sistema e produz um objeto que ainda sabe consultar name, suffix e exists.

Estudar a aula: pathlib: caminhos modernos

Resposta: B. Porque o with fecha o arquivo automaticamente ao sair do bloco, inclusive quando ocorre um erro no meio do processamento.

O with garante o fechamento ao sair do bloco, mesmo se um erro estourar no meio, equivalendo a um try/finally sem você escrevê-lo. Chamar close na mão é frágil: um erro pularia o close e deixaria o arquivo aberto. Por isso o with é o jeito recomendado.

Estudar a aula: Context managers: o with a fundo

Resposta: B. Para devolver o total já acumulado da categoria, ou zero se ela aparece pela primeira vez, evitando erro na chave nova.

O get devolve o valor atual da chave ou o segundo argumento (0.0) quando a chave ainda não existe. Assim, ao encontrar uma categoria pela primeira vez, o acumulador começa do zero sem quebrar, e nas próximas vezes soma sobre o total já guardado. É o jeito pythônico de acumular em dicionário.

Estudar a aula: Prática: relatório de vendas em CSV

Resposta: B. Porque o tipo específico trata só o erro previsto e deixa os imprevistos aparecerem para conserto.

Capturar o tipo específico trata apenas a falha que você já esperava. Um except genérico engoliria também erros imprevistos, como um NameError de digitação, mostrando a mensagem errada e escondendo o bug real.

Estudar a aula: Relembrando try e except

Resposta: C. Sempre ao sair do try, tenha havido exceção ou não.

O finally executa em qualquer saída do try: com erro, sem erro e até quando há um return. Por isso é o lugar certo para liberar recursos, como fechar um arquivo, com a garantia de que a limpeza sempre acontece.

Estudar a aula: Os blocos else e finally

Resposta: B. Quando o valor recebido é inadequado e não dá para continuar com segurança.

O raise sinaliza que um valor recebido não faz sentido, como um percentual fora de 0 a 100. Em vez de devolver um resultado inválido ou None, a função para e explica o problema, de preferência com o valor recebido na mensagem.

Estudar a aula: Levantando erros com raise

Resposta: B. class SaldoInsuficienteError(Exception): pass

Uma exceção própria é uma classe que herda de Exception. O corpo pode ser apenas pass ou um docstring; a herança já fornece todo o comportamento. Depois você a levanta com raise e a captura com except pelo nome.

Estudar a aula: Criando exceções próprias

Resposta: B. Porque ele engole qualquer erro em silêncio, escondendo bugs que deveriam ser corrigidos.

O except vazio captura tudo e, com pass, ignora tudo em silêncio. Isso esconde falhas inesperadas, inclusive bugs do seu código, e um erro silencioso é pior que uma quebra, porque não avisa. Prefira capturar o tipo específico que você sabe tratar.

Estudar a aula: Encadeamento e boas práticas

Resposta: B. Para falhar cedo e nunca alterar o saldo com base em um dado inválido.

Validar antes de alterar o estado é falhar cedo: se o valor é inválido, a função levanta a exceção sem tocar no saldo. Isso mantém a invariante de que o saldo nunca fica corrompido por uma entrada ruim, e a mensagem aponta o problema na origem.

Estudar a aula: Prática: validação robusta de um saque

Resposta: B. A classe é a forma de bolo (o molde) e cada objeto é um bolo feito a partir dela.

A classe é o molde, como a forma de bolo: define o formato sem ser a coisa em si. Cada objeto (ou instância) é um bolo feito a partir da forma, com os seus próprios dados. Da mesma forma se cria a conta da Ana e a do Bruno a partir de uma classe ContaBancaria.

Estudar a aula: O que é orientação a objetos

Resposta: C. conta = Conta()

Criar um objeto (instanciar) é chamar o nome da classe seguido de parênteses: conta = Conta(). Sem os parênteses, conta = Conta apenas dá outro nome à própria classe, não cria um objeto. class Conta: define o molde, e print só o exibe.

Estudar a aula: Criando uma classe

Resposta: B. Automaticamente, no momento em que você cria o objeto com Conta(...).

O __init__ é o construtor: o Python o chama sozinho no instante em que você cria o objeto, como em Conta('Ana', 500). Ele prepara os atributos iniciais com self. Você não o chama manualmente; a criação do objeto já dispara o __init__.

Estudar a aula: O método __init__ e o self

Resposta: B. O self é o objeto antes do ponto (conta), e o Python o entrega automaticamente.

Na chamada conta.depositar(50), o objeto antes do ponto (conta) vira o self dentro do método, entregue pelo Python sozinho. Você informa só o valor (50). Por isso o método tem dois parâmetros (self e valor), mas a chamada passa apenas um.

Estudar a aula: Métodos de instância

Resposta: B. Porque existe uma cópia só, dividida por todos os objetos, então mudar em um afeta os outros.

Um atributo de classe é compartilhado: há uma cópia só, ligada à classe. Uma lista ali é a mesma para todos os objetos, então adicionar um item por um objeto aparece nos demais. Para uma lista própria por objeto, crie-a no __init__ com self.movimentos = [].

Estudar a aula: Atributos de classe e de instância

Resposta: B. Retornar uma string com o texto amigável do objeto.

O __str__ deve retornar (return) uma string com o texto amigável do objeto, sem imprimir. Quem imprime é o print, que chama o __str__ para obter a frase. Usar print dentro do __str__, ou esquecer o return, é o erro mais comum.

Estudar a aula: O método __str__

Resposta: B. Para que toda tentativa de saque passe pela mesma regra, mantendo o saldo sempre válido.

Colocar a regra dentro do método sacar (encapsular) garante que todo saque, venha de onde vier, passe pela mesma validação. Assim o objeto protege o próprio estado e o saldo nunca fica inválido, sem depender de quem chama lembrar da checagem.

Estudar a aula: Prática: a classe ContaBancaria

Resposta: C. A filha é um tipo mais específico da base (relação é-um).

Herança modela a relação é-um: a filha é um tipo mais específico da base, como Cachorro é um Animal. Quando a relação é tem-um (a filha tem um objeto), o certo é composição, não herança. Nome parecido ou mesmo arquivo não justificam herdar.

Estudar a aula: O que é herança

Resposta: B. Faz Carro herdar os atributos e métodos de Veiculo.

O nome entre parênteses indica a classe base. Assim, Carro herda os atributos e métodos de Veiculo, sem copiar código: eles continuam definidos em Veiculo e ficam acessíveis em Carro. A linha define uma classe, não cria um objeto.

Estudar a aula: Criando uma classe filha

Resposta: B. Para chamar o construtor da base e reaproveitar a inicialização dela.

super().__init__() chama o construtor da classe base a partir da filha, deixando a base cuidar da parte da inicialização que já sabe fazer. Depois, a filha acrescenta os seus atributos próprios. Assim, a lógica comum mora só na base e não é duplicada.

Estudar a aula: super() e o __init__ da base

Resposta: B. Definir na filha um método com o mesmo nome da base, que passa a ser usado pelos objetos dela.

Sobrescrever é redefinir na filha um método com o mesmo nome de um da base. Para os objetos da filha, o Python usa a versão dela. A base continua intacta para outras classes, e a filha pode até chamar a versão da base com super() para completá-la.

Estudar a aula: Sobrescrever métodos

Resposta: B. Porque cada classe sobrescreve falar, então o Python já usa a versão certa para cada objeto.

Como cada filha sobrescreve falar, chamar bicho.falar() faz o Python escolher a versão da classe daquele objeto. O laço não precisa saber o tipo; ele confia no método comum. Por isso adicionar um novo tipo não obriga a mudar o laço.

Estudar a aula: Polimorfismo na prática

Resposta: B. Que o atributo é interno e não deve ser acessado direto de fora, por convenção.

O underscore inicial é uma convenção: sinaliza que o atributo é interno e que se deve usar os métodos públicos, não acessá-lo direto. O Python não impede o acesso; é um acordo entre quem escreve o código. É a base do encapsulamento em Python.

Estudar a aula: Encapsulamento

Resposta: B. Porque cada filha sobrescreve area() com a sua fórmula, e o laço só confia no método comum.

Retangulo e Circulo herdam de Forma e sobrescrevem area() cada um com a sua fórmula. O laço chama forma.area() sem checar o tipo; o Python usa a versão certa para cada objeto. É polimorfismo: por isso um novo tipo de forma entra na lista sem mudar o laço.

Estudar a aula: Prática: hierarquia de formas

Resposta: B. A função interna wrapper, sem chamá-la, para ser executada depois.

com_moldura devolve o objeto wrapper (sem parênteses), que é uma closure lembrando de func. Só quando alguém chama o wrapper é que func é executada, entre as mensagens de moldura. Devolver a função em vez de chamá-la é o que torna o decorador reutilizável.

Estudar a aula: O caminho até o decorador

Resposta: B. dizer_ola = com_moldura(dizer_ola), feita automaticamente após a definição.

O símbolo @ é açúcar sintático: @com_moldura sobre def dizer_ola faz o Python executar dizer_ola = com_moldura(dizer_ola) logo após definir a função. O nome dizer_ola passa a apontar para o wrapper devolvido, sem que você escreva a reatribuição na mão.

Estudar a aula: A sintaxe do arroba

Resposta: B. A função decorada passa a devolver None, mesmo que a original calcule um valor.

Sem return, o wrapper executa a função original mas descarta o resultado, então a versão decorada devolve None. É um erro silencioso e traiçoeiro: nada quebra, o valor apenas some. Por isso o wrapper deve terminar com return func(*args, **kwargs).

Estudar a aula: Decorador para qualquer função com args e kwargs

Resposta: B. Para copiar o nome, a docstring e outros metadados da função original para o wrapper.

functools.wraps copia para o wrapper os metadados da função original, como __name__ e __doc__. Sem ele, a função decorada se apresentaria como wrapper e perderia a docstring, atrapalhando depuração, help() e documentação. É boa prática usar em todo decorador.

Estudar a aula: Preservando a identidade com functools.wraps

Resposta: B. Isola a regra de validação em um lugar só e a reaproveita em várias funções, mantendo cada função focada no seu cálculo.

A validação é um comportamento transversal: repete-se em muitas funções sem ser o objetivo delas. Um decorador escreve essa regra uma vez e a aplica com um @ onde precisar, mantendo cada função limpa e focada. É o caso de uso clássico para decoradores.

Estudar a aula: Casos de uso reais de decoradores

Resposta: B. cronometro, porque está mais próximo da def; equivale a registrar(cronometro(func)).

Decoradores empilhados se aplicam de baixo para cima. O mais próximo da def, cronometro, envolve a função original primeiro; registrar envolve o resultado já cronometrado. Isso equivale a somar_lista = registrar(cronometro(somar_lista)), por isso as mensagens de log ficam por fora das de tempo.

Estudar a aula: Prática: um decorador de log e tempo

Resposta: B. É o sinal que o iterador levanta para avisar que não há mais itens, e o for para ao recebê-lo.

Quando os itens acabam, next() levanta StopIteration. Não é um erro a se temer: é o sinal de fim de linha. O for espera por ele e encerra o laço de forma limpa, sem você precisar contar itens.

Estudar a aula: O que é um iterável

Resposta: B. O valor é entregue a quem percorre e a função pausa ali, continuando depois da linha do yield no próximo pedido.

yield entrega o valor à direita e pausa a função naquele ponto, preservando as variáveis. No próximo next() ou volta do for, ela retoma da linha seguinte ao yield. É o que diferencia yield de return, que encerra a função.

Estudar a aula: Função geradora com yield

Resposta: B. Porque o gerador não guarda os itens: ele produz cada um sob demanda e só armazena a receita de como gerá-los.

A avaliação preguiçosa é a chave: o gerador não materializa a sequência. Ele guarda apenas o estado e a lógica para produzir o próximo item, ocupando um tamanho fixo pequeno, enquanto a lista reserva memória para todos os itens de uma vez.

Estudar a aula: Por que usar geradores

Resposta: B. Os colchetes criam uma lista com todos os itens na memória; os parênteses criam um gerador que produz os itens sob demanda.

Colchetes formam uma compreensão de lista, que materializa todos os itens de uma vez. Parênteses formam uma generator expression, que devolve um gerador preguiçoso, produzindo cada item sob demanda e economizando memória.

Estudar a aula: Generator expressions

Resposta: B. Um item por vez atravessa todas as etapas, puxado sob demanda pelo consumo final, sem lista intermediária.

O fluxo é preguiçoso e puxado do fim. Quando o consumo final pede um item, o pedido percorre as etapas de trás para frente e um único item atravessa todo o pipeline antes do próximo começar. Nunca existe uma coleção intermediária completa na memória.

Estudar a aula: Encadeando geradores

Resposta: B. Porque o for entrega uma linha por vez sob demanda, enquanto readlines() carrega todas as linhas numa lista na memória.

O objeto arquivo é iterável e entrega uma linha por vez, lendo do disco sob demanda, como um gerador. Já readlines() traz todas as linhas para uma lista na memória de uma vez. Em arquivos grandes, a leitura preguiçosa usa memória constante, de uma linha por vez.

Estudar a aula: Prática: processar um arquivo grande

Resposta: B. d.year, sem parênteses, porque year é um atributo do objeto de data.

Um objeto date ou datetime guarda o ano no atributo .year, lido sem parênteses. Parênteses são para métodos, como .today(). Fatiar como texto (d[6:10]) só funciona em strings e é justamente o que o tipo de data evita.

Estudar a aula: Trabalhando com datas

Resposta: B. datetime.strptime("15/08/2026", "%d/%m/%Y")

Para ler texto e virar objeto, use strptime, com o molde que descreve o texto. Como está no formato dd/mm/aaaa, o molde é "%d/%m/%Y". strftime faz o contrário (objeto para texto) e o molde "%Y-%m-%d" não bate com as barras do texto.

Estudar a aula: Formatando e lendo datas

Resposta: B. dif.days, porque a subtração devolve um timedelta e .days extrai os dias.

Subtrair duas datas devolve um timedelta, não um número. Para ler o total de dias como inteiro, use o atributo .days. Converter o timedelta com int() dá erro, e a subtração sozinha ainda é uma duração, não um número.

Estudar a aula: Cálculos com datas

Resposta: B. Porque a barra invertida das regex conflita com os escapes das strings normais, e a raw string a trata de forma literal.

Regex usa muito a barra invertida (como em \d), que também é especial nas strings comuns do Python. A raw string (r"...") trata a barra de forma literal, então o padrão fica igual ao dos manuais. Funciona sem o r dobrando as barras, mas é mais confuso.

Estudar a aula: O que é uma expressão regular

Resposta: B. r"^\d+$", que exige um ou mais dígitos do início (^) ao fim ($).

As âncoras ^ e $ prendem o padrão ao começo e ao fim, e \d+ exige um ou mais dígitos. Sem as âncoras, o padrão casaria com dígitos em qualquer parte, aceitando textos como 12a34. re.fullmatch(r"\d+", texto) faria o mesmo papel.

Estudar a aula: Padrões básicos de regex

Resposta: B. datetime.strptime(d, "%d/%m/%Y") para cada d, que lê o texto e devolve o objeto.

findall devolve textos; para virar objeto de data usa-se strptime com o molde "%d/%m/%Y". date() não aceita string, int() não faz sentido para uma data e strftime é o caminho contrário (objeto para texto), além de não funcionar sobre uma string.

Estudar a aula: Prática: validar e extrair

Resposta: B. A confiança para mudar e melhorar o código sabendo que uma regressão será avisada.

Testes até ajudam a achar erros, mas o ganho central é a confiança para mexer no código. Ao rodar os testes depois de uma mudança, você é avisado na hora se quebrou algo que já funcionava, o que torna refatorar e ampliar seguro.

Estudar a aula: Por que testar o código

Resposta: B. Porque cada mudança exige refazer toda a conferência na mão, e por preguiça você acaba pulando casos.

O custo do teste manual está na repetição: a cada alteração é preciso reconferir tudo de novo. Como isso é trabalhoso, o programador acaba testando só o que mexeu, e regressões em outras partes passam despercebidas.

Estudar a aula: Por que testar o código

Resposta: B. O Python levanta um AssertionError, interrompendo a execução, com a mensagem opcional se houver.

Quando a condição é verdadeira, o assert passa em silêncio. Quando é falsa, o Python levanta um AssertionError e interrompe a execução, mostrando junto a mensagem escrita depois da vírgula, quando ela existe.

Estudar a aula: O comando assert

Resposta: B. Com self.assertEqual(obtido, esperado), que compara e, ao falhar, mostra os dois valores.

Dentro de um TestCase, o método self.assertEqual(obtido, esperado) faz a comparação de igualdade e, quando falha, mostra automaticamente o valor obtido e o esperado no relatório, sem você precisar montar a mensagem à mão.

Estudar a aula: Testes com unittest

Resposta: B. É um pacote externo, instalado com pip, e permite escrever testes como funções com assert direto.

O pytest não faz parte da biblioteca padrão: é instalado com pip install pytest. Seu diferencial é a simplicidade, pois cada teste é uma função test_ que usa o assert nativo, sem classe nem métodos especiais, e ele ainda roda testes escritos em unittest.

Estudar a aula: Conhecendo o pytest

Resposta: B. Porque, com um comportamento por teste, uma falha aponta exatamente o que quebrou e o nome do teste explica a história.

Com um comportamento por teste e um nome descritivo, uma falha localiza o problema com precisão e o próprio nome do método conta o que deveria acontecer. Um teste que mistura vários casos só avisa que algo no bolo quebrou, sem dizer o quê.

Estudar a aula: Testando casos de borda

Resposta: B. Porque zero é uma borda (só a bandeirada) e negativo é entrada inválida (deve levantar ValueError), e é aí que os bugs aparecem.

O caso de 10 km é o caminho feliz. Zero é uma borda importante, onde o preço deve ser só a bandeirada, e a distância negativa é uma entrada inválida que a função deve rejeitar com ValueError. Cobrir borda e entrada inválida é onde os testes mais pegam bugs.

Estudar a aula: Prática: testar uma função

Resposta: B. Para manter o programa sempre funcionando e saber onde procurar quando algo quebrar.

Construir de forma incremental mantém o programa rodando a cada passo. Como só uma coisa muda por vez, quando um erro aparece você sabe exatamente onde ele foi introduzido. É mais seguro do que escrever tudo e testar só no fim.

Estudar a aula: A visão do projeto

Resposta: B. Definir o texto legível que aparece quando o contato é impresso com print.

__str__ devolve a representação em texto do objeto. Com ele, print(contato) mostra uma linha legível como Ana | 11999998888 | ... em vez do endereço técnico do objeto na memória. Quem cria o objeto é o __init__.

Estudar a aula: Modelando a agenda com classes

Resposta: B. Para ignorar maiúsculas e minúsculas, fazendo 'ana' encontrar 'Ana Souza'.

Comparar tudo em minúsculo com lower torna a busca insensível a maiúsculas: 'ana', 'Ana' e 'ANA' encontram o mesmo contato. Sem isso, o usuário precisaria digitar o nome com a grafia exata, o que seria frustrante.

Estudar a aula: Os métodos da agenda

Resposta: B. Porque só o menu tem contexto para responder ao usuário; a agenda apenas sinaliza o erro.

O método levanta a exceção onde o problema é descoberto, mas quem sabe como responder ao usuário é o menu. Tratar no menu mantém a agenda reaproveitável: ela sinaliza o erro e deixa cada interface decidir como reagir.

Estudar a aula: Tratando erros com uma exceção própria

Resposta: B. Porque o JSON guarda tipos básicos como dicionários, não objetos Contato, então é preciso traduzir nos dois sentidos.

O JSON entende textos, números, listas e dicionários, mas não a classe Contato. para_dicionario traduz o objeto para salvar e de_dicionario reconstrói o objeto ao carregar. Sem essas pontes, o json.dump não saberia como gravar um Contato.

Estudar a aula: Salvando a agenda em JSON

Resposta: B. Para garantir que a mudança persista mesmo que o usuário feche o programa em seguida.

Salvar logo após cada mudança garante que nada se perca se o programa for fechado. Assim a próxima execução carrega o estado mais recente. É a diferença entre uma agenda que lembra e uma que esquece ao sair.

Estudar a aula: Exportar para CSV e o menu

Resposta: B. Para afirmar que aquela chamada deve levantar ContatoNaoEncontradoError, testando o caminho de erro.

assertRaises verifica que o bloco levanta a exceção esperada. Se buscar_por_nome não levantasse ContatoNaoEncontradoError, o teste falharia. Testar o caminho de erro garante que o tratamento continua funcionando quando você mexe no código.

Estudar a aula: Testando a agenda e próximos passos