# FAQ: Code Challenge: Dictionaries - Largest Value

This community-built FAQ covers the “Largest Value” exercise from the lesson “Code Challenge: Dictionaries”.

Paths and Courses
This exercise can be found in the following Codecademy content:

Learn Python 3

## Join the Discussion. Help a fellow learner on their journey.

Agree with a comment or answer? Like () to up-vote the contribution!

Found a bug? Report it!

Have a question about your account or billing? Reach out to our customer support team!

None of the above? Find out where to ask other questions here!

8 posts were split to a new topic: Solution Sharing

Just want to confirm, there is no method or function i.e. ‘.whatever’ to return all the keys holding a given value?

Confirmed. There is no built-in method to do that.

1 Like

This is another exercise that needs some tweaking. We need to use -inf which is something that never came up before, there’s just no way for newbie like me to do this without checking the hint which is demotivating.

1 Like

don’t need it. do you use inf to determine which of three carrots is the largest?

According to the instructions:

The function should return the key associated with the largest value in the dictionary.

What if the largest value corresponds to more than one key in the dictionary?
It might be a possibility which is not outside the context of the exercise.
The solution given, does not seem to cover that case.

If we try to

print(max_key({1:100, 2:100, 3:4, 4:10}))

the output is 1 (the first key in order, corresponding to the largest value), although the output should be 1,2.

if both keys refer to a maximum value then either is a valid response

you’ve got a bigger problem if there isn’t a max, if it’s empty

I apologize if this has been addressed elsewhere but I’ve Googled around a lot at this point and it’s driving me insane: Is there a simple way to turn the values of a dictionary into a true list? I’ve tried various operations on the dictionary – including getting a list of tuples, making each value a float, creating an empty list and then appending each value… and many more. While I am able to get what looks like a list through several of these strategies, trying any list methods on it (such as list.sort(), which seems like it could be very useful in this context!) always gets me either an error or “None.”

I realize that the data in dictionaries is unsorted but I can’t help but think that if a script is returning the dictionary value “3” then there must be a not-overly-complicated way to take that “3” and say, “great, now I’m going to add the integer ‘3’ to a list with other integers so that I can sort them later” without breaking the list. Even if what I’m adding to my list isn’t the dictionary value itself but rather an integer derived from reading it.

I’m not 100% sure of the question you have but from my basic interpretation-

Turning the values of a dcitionary into a list can be done fairly quickly using the calling list() on the.values() method of the dictionary, e.g.

``````test_dict = {'a': 2, 'b': 3, 'c': 'hat'}
test_list = list(test_dict.values())
``````

Something a bit more complex like adding only integer types to a list would be straightforward with a list comprehension, e.g.

``````test_list = [value for value in test_dict.values() if type(value) is int]
``````

If you’re trying to avoid creating a new list for some reason you could look at the creating a new OrderedDict but this is insertion order rather than ordered in place-
https://docs.python.org/2/library/collections.html#collections.OrderedDict

Apologies if this doesn’t answer your query. I wasn’t 100% sure what you were trying to do.

Not to pile on, but I’ve been slogging through these modules over the course of the past week and I distinctly remember one of the previous lessons/projects/examples using “inf.”

Mind you, I had to Google it because it was “a long time ago” and I couldn’t remember how to represent it anymore, so I definitely get where you’re coming from – but there was for sure a use of positive inf at some point prior to this challenge. I did -1*float(‘inf’) but it’s nice to know that ‘-inf’ is a thing too.

I’m not trying to avoid creating a new list at all, but the thing is, I did try your method and it isn’t working for me! (And while I think I understand why this would be, what I’m really looking for is a method of getting a true list out of these values – e.g. one that can take methods like .sort().)

Here is my code for reference in case I have made one of my classic dumb errors somewhere else:

``````dictionary = {'a': 8, 'b': 25, 'c': 3}
def highest_val(dictionary):
val_list = list(dictionary.values())
val_list_sorted = val_list.sort()
return val_list_sorted

print(highest_val(dictionary))
``````

The output is “None”.

a dict is iterable, if something is iterable you can iterate through it and stick those things in a list
…which you probably already know. not sure what you perceive to be stopping you

It’s probably just a moment of forgetfulness but you are close. The .sort method on lists, sorts in place. It is not used to return values.

which can be discovered with some use of print between each action to find out where the ball gets dropped

if the goal is to find the largest value, then sorting is way overkill
finding one largest value is much less work than ordering all of them

My god. It WAS in the “classic dumb errors” category. Thank you. The good news is, I am never forgetting that .sort() sorts in place now :-p

no such thing as dumb error
observe what’s done, adjust where different

if you don’t observe the steps carried out then you more likely to miss things than to get it right

nobody “writes correct code”

Thanks, ionatan. I was doing lots and lots of printing, but I was mistakenly believing that the results (i.e. “none”) had something to do with the fact that an unsortable dictionary object was being referenced. Could you explain your comment above about how sorting is overkill? Do you mean “less work” as in there is a way to do it with fewer lines of code, or “less work” as in executed faster? Asking because the Codecademy solution is significantly longer (in terms of lines of code) than doing list(dict.values()).sort(), then return list[-1].

Write down 100 unsorted numbers on paper.

What’s more difficult, sorting them, or finding the largest one?

I’m going to take that to mean that the answer to my question is “executed faster.” Thanks for your help.