Solucionado (ver solução)
Solucionado
(ver solução)
1
resposta

Determinar a chave de um dicionário que contém a maior quantidade de valores

animals = { 'a': ['aardvark'], 'b': ['baboon'], 'c': ['coati']}

animals['d'] = ['donkey']
animals['d'].append('dog')
animals['d'].append('dingo')

Seja o dicionário animals definido acima. A função aplicada a ele deve devolver a chave "d":

biggest(animals)

resultado: 'd'

O meu código:

def biggest(aDict):
    '''
    aDict: A dictionary, where all the values are lists.

    returns: The key with the largest number of values associated with it
    '''


    maior = []
    key_maior = []
    for i in aDict.keys():
        #print(i)
        key_maior.append(i)
        maior.append(len(aDict[i]))
    #print(key_maior)
    #print(maior)

    maximo = max(maior)
    #print(maximo)
    #print(maior.index(maximo))
    return key_maior[maior.index(maximo)]


animals = { 'a': ['aardvark'], 'b': ['baboon'], 'c': ['coati']}

animals['d'] = ['donkey']
animals['d'].append('dog')
animals['d'].append('dingo')


print(biggest(animals))

O código funciona mas eu acho que está muito mal escrito. Existe uma outra maneira de resolver o problema?

1 resposta
solução!

Oi, Edson! Tudo bem? A função max() tem uma funcionalidade bem legal que nos permite reduzir todo esse código em apenas uma linha! Isso é através do parâmetro opcional key, que nos permite especificar uma função para como deve funcionar a comparação.

Conhecendo isso, a princípio a ideia que vem é a de usar a função len(), que retorna o comprimento de uma variável, como parâmetro key. Vamos tentar:

animals = {'a': ['aardvark'], 'b': ['baboon'], 'c': ['coati'], 'd': ['donkey', 'dog', 'dingo'], 'e': ['elefante']}

longest = max(animals, key=len)
print(longest)

Mas olha a resposta:

'a'

Retornou a chave 'a'! Isso porque o max() está comparando as chaves em si, não os valores. Como todas as chaves têm o mesmo tamanho, ela retorna a primeira. Vamos, então, precisar criar nossa própria função. Como ela é bem simples, podemos até fazer uma função anônima com lambda que retorna o comprimento do valor (dado a chave) do dicionário, dessa forma:

animals = {'a': ['aardvark'], 'b': ['baboon'], 'c': ['coati'], 'd': ['donkey', 'dog', 'dingo'], 'e': ['elefante']}

longest = max(animals, key = lambda chave: len(animals[chave]))
print(longest)

Dessa vez o resultado é o correto:

'd'

Se você achar o lambda confuso (ele pode ser, mesmo!), pode definir a função com def mesmo, olha:

animals = {'a': ['aardvark'], 'b': ['baboon'], 'c': ['coati'], 'd': ['donkey', 'dog', 'dingo'], 'e': ['elefante']}

def get_value_len(chave):
    return len(animals[chave])

longest = max(animals, key=get_value_len)

Assim pode ficar mais claro, mas temos a desvantagem de criarmos uma função que não é reutilizável, porque só funciona com um dicionário específico. Na verdade, podemos até resolver isso dando um argumento opcional para a função, que tem como padrão o dicionário animals, olha:

def get_value_len(chave, dicionario=animals):
    return len(dicionario[chave])

Agora vai funcionar muito bem e ainda nos dar chance de usar com outros dicionários (mas não com outros dicionários na função max()). Talvez o ideal ainda fosse pegar o valor do dicionário com o método get(), para evitar um KeyError, assim:

def get_value_len(chave, dicionario=animals):
    return len(dicionario.get(chave, ''))

Isso, claro, apenas se você não quiser usar o lambda, haha!

PS: Percebi que misturei inglês com português no meu código, mas isso não é muito legal! O melhor é sempre ser consistente, escolhendo uma.

Espero que tenha conseguido ajudar. Abraços e bons estudos, Edson!