Considere o dicionário abaixo com os produtos por mercado:
dProdsDoMerc= { ‘Qbarato’: {‘biscoito’: 4.3, ‘leite’: 3.2, ‘suco’: 7.1, ‘chocolate’: 6.4, ‘detergente’: 3.2, ‘cerveja’: 6.4, ‘manteiga’: 8.7},
‘UltraK’: {‘biscoito’: 3.5, ‘leite’: 3.3, ‘suco’: 8.9, ‘chocolate’: 6.9, ‘detergente’: 4.2, ‘cerveja’: 6.4, ‘manteiga’: 8.7},
Obs1: Todos os mercados têm todos os produtos.
Obs2: dicionários devem ser manipulados como dicionários. Não é para transformar para outra estrutura (como lista) e usar a outra estrutura.
Escreva a função totalDaCompra que:
  • recebe o dicionário de produtos por mercado dProdsDoMerc descrito, o nome de um supermercado e um outro dicionário que representa a lista de compras de uma pessoa. Esse dicionário (a lista de compras) tem as seguintes informações:
    dCompras = { PRODUTO1: QUANT1, PRODUTO2:QUANT2, PRODUTO3: QUANT3 …}
  • retorna o valor total da compra nesse supermercado.
Obs1: quantidades são sempre um número inteiro
Obs2: É garantido que o mercado possui todos os produtos do dicionário de compra.
EXEMPLO: A função retornaria 34.2, caso recebesse o dicionário apresentado, o nome do supermercado ‘Qbarato’ e o dicionário de compras = {‘biscoito’: 2, ‘leite’: 6, ‘chocolate’: 1}

  1. ‘Market’: {‘biscoito’: 4.5, ‘leite’: 3.2, ‘suco’: 7.5, ‘chocolate’: 6.6, ‘detergente’: 3.8, ‘cerveja’: 6.5, ‘manteiga’: 9.2},
    ‘Preferido’:{‘biscoito’: 4.65, ‘leite’: 3.4, ‘suco’: 8.1, ‘chocolate’: 8.1, ‘detergente’: 3.3,
    ‘cerveja’: 6.5, ‘manteiga’: 8.9},
    ‘Escolhido’: {‘biscoito’: 5.2, ‘leite’: 3.3, ‘suco’: 8.3, ‘chocolate’: 7.5, ‘detergente’: 3.9,
    ‘cerveja’: 6.4, ‘manteiga’: 8.6}
    }
    Este dicionário é um dicionário de dicionários onde cada item é:
    SUPERMERCADO : { dicionário_de_Preços_Por_Produto nesse supermercado }

Passo 1

O que o problema pede e o que foi dado (vou listar fielmente as informações do enunciado):
  • Entradas da função:
    • dProdsDoMerc: um dicionário cujos elementos são pares do tipo SUPERMERCADO : {produto: preço, …}. Ex.: dProdsDoMerc['Qbarato']['biscoito'] = 4,3.
    • o nome de um supermercado (uma string), por exemplo 'Qbarato'.
    • dCompras: um dicionário que representa a lista de compras, com pares produto: quantidade, por exemplo dCompras = \{'biscoito': 2, 'leite': 6, 'chocolate': 1\}. As quantidades são inteiros.
  • Saída esperada:
    • o valor total da compra naquele supermercado, ou seja, a soma dos preços unitários do supermercado multiplicados pelas quantidades pedidas.
  • Observações importantes do enunciado que vou usar sem perguntar nada:
    • Todos os mercados têm todos os produtos do dicionário de compra (ou seja, não preciso tratar ausência de chave).
    • Não devo transformar os dicionários em listas — devo manipulá-los como dicionários.

Passo 2

Ideia geral do método (passo a passo conceitual, nada de código ainda):
  • Para cada produto e sua quantidade em dCompras:
    1. Obter o preço unitário daquele produto no supermercado indicado consultando dProdsDoMerc pelo nome do supermercado e em seguida pelo produto.
    2. Calcular o custo parcial multiplicando o preço unitário pela quantidade.
    3. Somar esse custo parcial a um acumulador que guarda o total da compra.
  • No final, retornar o acumulador.
Em linguagem comum: “para cada item da lista de compras, pego o preço daquele item no supermercado e multiplico pela quantidade; somo tudo”.

Passo 3

Noções práticas (mini-aula sobre dicionários e operações que usaremos):
  • Como acessar valores em dicionários aninhados:
    • Se dProdsDoMerc é o dicionário principal e nomeMercado é uma string com o nome do supermercado, então a tabela de preços daquele mercado é dProdsDoMerc[nomeMercado] (isso devolve outro dicionário).
    • O preço de um produto produto nesse mercado é dProdsDoMerc[nomeMercado][produto].
  • Como iterar em um dicionário de compras:
    • A operação “percorrer os pares produto–quantidade” usa a iteração sobre os itens do dicionário (em Python: .items()).
  • Tipos e operações numéricas:
    • Preços são números de ponto flutuante (por ex. 4,3).
    • Quantidades são inteiros (por ex. 2).
    • A multiplicação preço × quantidade produz um número (float), e a soma acumulada também será float.
  • Garantia do enunciado:
    • Não é necessário tratar exceções de chave ausente porque foi garantido que o mercado possui todos os produtos do dicionário de compra.

Passo 4

Descrevendo linha a linha o que a função deve fazer (sem colocar o código literal aqui, apenas explicação detalhada para você entender e conseguir escrever rápido na prova):
  1. Inicializar uma variável total com 0,0 (float). Esse será o acumulador.
  2. Para cada par (produto, quant) em dCompras:
    • Buscar preco = dProdsDoMerc[nomeMercado][produto].
    • Calcular custo\_parcial = preco \times quant.
    • Atualizar total = total + custo\_parcial.
  3. Após processar todos os pares, retornar total.
Observação prática: usar total iniciado em 0,0 evita problemas de soma com inteiros; mantém o resultado em float.

Passo 5

Exemplo numérico com o caso do enunciado (faço as contas passo a passo para você ver que o resultado é 34,2):
  • Dados do exemplo: supermercado ='Qbarato' e dCompras = \{'biscoito': 2, 'leite': 6, 'chocolate': 1\}.
  • Vou pegar os preços do supermercado Qbarato (peguei estes valores de dProdsDoMerc conforme o enunciado):
    • preço do biscoito = 4,3,
    • preço do leite = 3,2,
    • preço do chocolate = 6,4.
  • Cálculo dos custos parciais:
    • biscoito:\; 4,3 \times 2 = 8,6.
    • leite:\; 3,2 \times 6 = 19,2.
    • chocolate:\; 6,4 \times 1 = 6,4.
  • Soma total: total = 8,6 + 19,2 + 6,4 = 34,2.
  • Portanto a função, quando invocada com esses dados, deve retornar 34,2 — bate com o exemplo do enunciado.

Passo 6

Complexidade e observações finais rápidas (para prova):
  • Complexidade: a função faz uma iteração por item de dCompras, então a complexidade é O(n) onde n é o número de produtos na lista de compras.
  • Não é preciso ordenar nada.
  • Como o enunciado garante presença das chaves, não há necessidade de usar métodos defensivos como .get(...) com fallback, mas se quiser tratar casos reais, poderia incluir verificação de existência das chaves.
  • Mantenha em mente de retornar o total como número (float). Se quiser exibir com duas casas decimais, isso é apresentação — a função pedida deve apenas retornar o número.

Resposta

def totalDaCompra(dProdsDoMerc, nomeMercado, dCompras):
total = 0.0
for produto, quant in dCompras.items():
preco = dProdsDoMerc[nomeMercado][produto]
total += preco * quant
return total

Exercícios relacionados