Chave do Valor Máximo

Introdução

Em Python, os dicionários são uma estrutura de dados útil que permite armazenar pares chave-valor. Às vezes, pode ser necessário encontrar a chave do valor máximo em um dicionário. Neste desafio, você escreverá uma função que recebe um dicionário como argumento e retorna a chave do valor máximo no dicionário.

Criando a Função Básica

Vamos começar criando o núcleo da nossa função. Vamos construí-la passo a passo. Primeiro, crie um arquivo chamado key_of_max.py. Você pode usar o editor de código LabEx integrado ou um editor baseado em terminal como nano ou vim. Dentro de key_of_max.py, adicione o seguinte código:

def key_of_max(d):
  """
  Retorna a chave associada ao valor máximo no dicionário 'd'.

  Se várias chaves compartilharem o valor máximo, qualquer uma delas pode ser retornada.
  """
  return max(d, key=d.get)

Aqui está uma análise:

• def key_of_max(d):: Isso define uma função chamada key_of_max. Ela recebe um argumento, d, que representa o dicionário com o qual trabalharemos.
• return max(d, key=d.get): Este é o coração da função. Vamos analisá-lo parte por parte:
  • max(d, ...): A função max() integrada encontra o maior item. Por padrão, se você fornecer um dicionário para max(), ele encontrará a maior chave (alfabeticamente). Não queremos isso; queremos a chave associada ao maior valor.
  • key=d.get: Esta é a parte crucial. O argumento key diz a max() como comparar os itens. d.get é um método de dicionários. Quando você chama d.get(some_key), ele retorna o valor associado a some_key. Ao definir key=d.get, estamos dizendo a max(): "Compare os itens no dicionário d usando seus valores, não suas chaves." A função max() então retorna a chave correspondente a esse valor máximo.

Lidando com o Caso de Dicionário Vazio

Nossa função atual tem um problema: ela irá travar se o dicionário de entrada d estiver vazio. Vamos corrigir isso. Modifique key_of_max.py para que se pareça com isto:

def key_of_max(d):
  """
  Retorna a chave associada ao valor máximo no dicionário 'd'.

  Se várias chaves compartilharem o valor máximo, qualquer uma delas pode ser retornada.
  """
  if not d:  ## Verifica se o dicionário está vazio
      return None
  return max(d, key=d.get)

As linhas adicionadas fazem o seguinte:

• if not d:: Em Python, um dicionário vazio é considerado "falsy" (falso). Esta instrução if verifica se o dicionário d está vazio.
• return None: Se o dicionário estiver vazio, não há valor máximo, então retornamos None. Esta é uma maneira padrão de indicar a ausência de um valor em Python. Isso impede que a função max() levante um erro.

Este é um passo crucial na escrita de código robusto: sempre considere os casos de borda (edge cases)!

Criando Testes Unitários: Testes Básicos

Agora, vamos escrever alguns testes para garantir que nossa função funcione corretamente. Usaremos o módulo unittest do Python. Crie um novo arquivo chamado test_key_of_max.py e adicione o seguinte código:

import unittest
from key_of_max import key_of_max  ## Importa nossa função

class TestKeyOfMax(unittest.TestCase):

    def test_basic_case(self):
        self.assertEqual(key_of_max({'a': 4, 'b': 0, 'c': 13}), 'c')

    def test_another_case(self):
        self.assertEqual(key_of_max({'apple': 10, 'banana': 5, 'orange': 10}), 'apple')

if __name__ == '__main__':
    unittest.main()

Explicação:

1. import unittest: Importa o framework de testes.
2. from key_of_max import key_of_max: Importa a função que queremos testar.
3. class TestKeyOfMax(unittest.TestCase):: Define uma classe de teste. Classes de teste agrupam testes relacionados.
4. def test_basic_case(self):: Define um método de teste. Cada método de teste verifica um aspecto específico da nossa função. Os nomes dos métodos de teste devem começar com test_.
5. self.assertEqual(...): Esta é uma asserção (assertion). Ela verifica se dois valores são iguais. Se eles não forem iguais, o teste falha. Neste caso, estamos verificando se key_of_max({'a': 4, 'b': 0, 'c': 13}) retorna 'c', o que deveria acontecer.
6. def test_another_case(self):: Adicionado outro caso de teste para verificar a chave do valor máximo, que pode não ser único.
7. if __name__ == '__main__': unittest.main(): Este idioma Python padrão executa os testes quando você executa o script diretamente (por exemplo, python3 test_key_of_max.py).

Execute os testes do seu terminal: python3 test_key_of_max.py. Você deve ver a saída indicando que os dois testes passaram.

python3 test_key_of_max.py

----------------------------------------------------------------------
Ran 2 tests in 0.000s

OK

Testando o Dicionário Vazio (Caso de Borda)

Vamos adicionar um teste especificamente para o caso de dicionário vazio. Adicione este método à sua classe TestKeyOfMax em test_key_of_max.py:

    def test_empty_dictionary(self):
        self.assertIsNone(key_of_max({}))

• self.assertIsNone(...): Esta asserção verifica se o valor é especificamente None. Isso é importante porque self.assertEqual(..., None) poderia passar para coisas que avaliam para None, mas na verdade não são None. assertIsNone é mais rigoroso.

Execute os testes novamente (python3 test_key_of_max.py). Todos os três testes (os dois testes básicos e o teste do dicionário vazio) devem agora passar.

python3 test_key_of_max.py

----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

Testando com Todos os Valores Negativos

Como um teste final, vamos lidar com um caso em que todos os valores no dicionário são negativos. Adicione este método a TestKeyOfMax:

    def test_all_negative_values(self):
        self.assertEqual(key_of_max({'x': -5, 'y': -2, 'z': -10}), 'y')

Este teste garante que nossa função identifique corretamente o valor menos negativo (que é o máximo neste caso) e retorne sua chave associada.

Execute seus testes mais uma vez (python3 test_key_of_max.py). Todos os quatro testes devem passar. Isso nos dá alta confiança de que nossa função está funcionando corretamente.

Seu test_key_of_max.py completo agora deve ser assim:

import unittest
from key_of_max import key_of_max

class TestKeyOfMax(unittest.TestCase):

    def test_basic_case(self):
        self.assertEqual(key_of_max({'a': 4, 'b': 0, 'c': 13}), 'c')

    def test_another_case(self):
        self.assertEqual(key_of_max({'apple': 10, 'banana': 5, 'orange': 10}), 'apple')

    def test_empty_dictionary(self):
        self.assertIsNone(key_of_max({}))

    def test_all_negative_values(self):
        self.assertEqual(key_of_max({'x': -5, 'y': -2, 'z': -10}), 'y')

if __name__ == '__main__':
    unittest.main()

Execute os testes novamente (python3 test_key_of_max.py). Todos os quatro testes devem passar. Isso nos dá alta confiança de que nossa função está funcionando corretamente.

python3 test_key_of_max.py

----------------------------------------------------------------------
Ran 4 tests in 0.000s

OK

Resumo

Neste laboratório, você construiu uma função Python, key_of_max, para encontrar a chave associada ao maior valor em um dicionário. Você aprendeu como usar a função max() com um argumento key personalizado e lidou com o importante caso de borda de um dicionário vazio. Você também escreveu testes unitários completos usando o módulo unittest, cobrindo casos básicos, dicionários vazios e dicionários com todos os valores negativos. Essa combinação de código funcional e testes abrangentes demonstra boas práticas de desenvolvimento de software.