Как найти максимум словаря python

Are you wondering how to find the minimum and maximum values in a Python dictionary? Here you will find the answers you are looking for.

The easiest way to find the minimum or maximum values in a Python dictionary is to use the min() or max() built-in functions applied to the list returned by the dictionary values() method. You can also pass just the dictionary to the max() or min() functions but in that case you have to use the optional key argument to identify minimum or maximum based on dictionary values and not on keys.

We will go through multiple ways to solve this problem so you can choose the one you prefer.

Let’s start coding!

How Do You Find the Maximum Value in a Python Dictionary?

Let’s assume that we have created a game and that we are storing the points of all players in a dictionary.

>>> points = {'Jake': 100, 'Andy': 450, 'Kate': 230}

The first thing I can think about to calculate the maximum value in a dictionary would be to use a Python built-in function.

Python provides a built-in function called max() that returns the largest item in an iterable.

Also, one of the methods provided by Python dictionaries is values() that returns a list of all the values in the dictionary.

>>> print(points.values)
<built-in method values of dict object at 0x7f9448181500>

Firstly let’s call the values() method on our dictionary to see what we get back:

>>> print(points.values())
dict_values([100, 450, 230])

Then try to pass this list to the max function…

>>> print(max(points.values()))
450

We got back what we wanted, the maximum value in the dictionary.

In the next section we will see how to get the maximum value in the dictionary while also keep tracked of the key mapped to that value.

Get Maximum Value and Its Key From a Dictionary in Python

In the previous section we have seen that the Python max function can be used with iterables.

Is a Python dictionary an iterable?

A Python dictionary is an iterable because it has the dunder method called __iter__. To verify all the methods that belong to a dictionary you can use the command dir(dict).

>>> dir(dict)
['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']

Here is what happens if you pass the points dictionary defined in the previous section to the max function:

>>> max(points)
'Kate'

The max function returns the key with maximum value in the dictionary. In this case the keys are compared alphabetically.

This is not what we want considering that we want to get the maximum value in the dictionary and not the maximum dictionary key.

To get the maximum value we have to pass the optional argument key to the max function. The argument key is used to specify a one-argument ordering function.

This is the same approach used with the built-in sorted function.

We pass points.get as the key argument so the max function goes through all the keys in the dictionary and gets the maximum after calling the points.get() method for each key (this method returns the value associated to a given key).

>>> max(points, key=points.get)
'Andy'

Once again…

We are passing points.get to the key argument to get the maximum based on the values in the dictionary and not based on the keys.

This time the max function returns the key ‘Andy’ because it’s the key associated to the highest value in the dictionary (450).

To get the actual value we simply have to retrieve the value mapped to the dictionary key obtained with the previous code:

>>> print(points[max(points, key=points.get)])
450

And if we want to print both key and maximum value we can use the following code…

>>> print("Key associated to the maximum value: {} - Maximum value: {}".format(max(points, key=points.get), points[max(points, key=points.get)]))
Key associated to the maximum value: Kate - Maximum value: 450

To print the previous message we have used the string format method.

How Do You Get All the Keys with the Highest Value in a Dictionary?

In the previous examples there was only one maximum value in the dictionary.

But what happens if in the previous dictionary we have the same maximum value associated to different keys?

Here is what I mean…

>>> points = {'Jake': 100, 'Andy': 450, 'Kate': 450}

In this case both Andy and Kate have 450 points and when I use the code created in the previous section, here is the result:

>>> print("Key associated to the maximum value: {} - Maximum value: {}".format(max(points, key=points.get), points[max(points, key=points.get)]))
Key associated to the maximum value: Andy - Maximum value: 450

We only get back the key ‘Andy’ and this is not correct.

How can we get back a dictionary that contains both keys associated to the maximum value? (in this case Andy and Kate).

We can start with the maximum value and then identify the keys whose value matches the maximum value.

To create this new dictionary we will use a dictionary comprehension.

So let’s calculate the maximum value first and store it in the variable max_value:

>>> max_value = max(points.values())

Then use a dictionary comprehension to create the new dictionary by using the keys that match the maximum value.

>>> {key:value for key, value in points.items() if value == max_value}
{'Andy': 450, 'Kate': 450}

To understand the comprehension expression above you have to remember what the dictionary items() method returns.

>>> print(points.items())
dict_items([('Jake', 100), ('Andy', 450), ('Kate', 450)])

Does it makes sense now?

In the dictionary comprehension we go through each tuple in the list and we take key and value from the tuples whose value matches the maximum value.

How to Use the Python Max Function with a Lambda Expression

Let’s go through another way to get the maximum value and the key associated to it from a Python dictionary.

Note: with this approach we are making the assumption that the maximum value in our dictionary can only be one.

Take the following dictionary:

>>> points = {'Jake': 100, 'Andy': 450, 'Kate': 200}

We will calculate the maximum tuple in the list returned by points.items().

>>> print(points.items())
dict_items([('Jake', 100), ('Andy', 450), ('Kate', 200)])

Here is the result we get by simply applying the max built-in function to the list of tuples above…

>>> max(points.items())
('Kate', 200)

Hmmm….this is not what we want…

We are getting this tuple back from the max function because the function is returning the maximum tuple using the first element of the tuple as ordering criteria.

If you want to provide a different ordering criteria to the max() function we can pass the optional key argument that allows to specify a one-argument ordering function.

In this case our ordering function will be a lambda that picks the second element in each tuple to identify the maximum tuple.

The second element in a given tuple represents a value in the original dictionary.

The lambda function we will pass is…

lambda data: data[1]

The call to the max function becomes:

>>> max(points.items(), key = lambda data: data[1])
('Andy', 450)

As you can see we are getting back the correct key / value pair from the dictionary based on the fact that 450 is the maximum value.

Using operator.itemgetter() with Max Function to Get the Maximum Value in a Dictionary

There is also another way to write the lambda function we have seen in the previous section:

lambda data: data[1]

This lambda function can be replaced by the operator.itemgetter() function, part of the operator module.

By passing the index 1 to operator.itemgetter() you get back the second item of each tuple in the points.items() list.

>>> import operator
>>> max(points.items(), key = operator.itemgetter(1))
('Andy', 450)

As you can see the itemgetter function is used as key argument to identify the maximum value in the dictionary.

If you only want to get back the maximum value you can retrieve it by accessing index 1 of the tuple returned.

>>> max(points.items(), key = operator.itemgetter(1))[1]
450

Another Way to Find the Maximum Dictionary Value Using a Lambda and the Max Function

Let’s have a look at another way to find the maximum value in a dictionary by using a lambda function together with the max function.

In the previous section we have used the lambda function to identify the maximum second item in each tuple returned by points.items().

This time we will work on the original dictionary points instead of points.items().

We want to define a lambda function that given a key returns the value mapped to that key. Then we will use this lambda as optional key argument (it will be used as ordering function by the max function).

The lambda function will be:

lambda dict_key: points[dict_key]

Given the following dictionary…

>>> points = {'Jake': 100, 'Andy': 450, 'Kate': 200}

We can use the max function as shown below:

>>> max_value = max(points, key = lambda dict_key: points[dict_key])
>>> print(max_value)
Andy

Note: in the same way we have seen in the previous section this approach doesn’t work if the same maximum value is assigned to multiple keys.

Note 2: the key argument of the max() function has nothing to do with the dictionary key. To make this clear I have used dict_key in the lambda function.

See this as an exercise to practice the use of dictionaries, lambdas and the max function.

How Do You Find the Minimum Value in a Python Dictionary?

To find the minimum value in a Python dictionary you can use the min() built-in function applied to the result of the dictionary values() method.

This is similar to the approach we have used previously to calculate the maximum value.

Let’s use the following dictionary…

>>> points = {'Jake': 100, 'Andy': 450, 'Kate': 450}

And here is the minimum value in the dictionary calculated using the min() function.

>>> min_value = min(points.values())
>>> print(min_value)
100

And now with a dictionary comprehension and an if statement we can create a dictionary that contains all the keys that match the minimum value.

>>> {key:value for key, value in points.items() if value == min_value}
{'Jake': 100}

Let’s confirm it also works if multiple keys are mapped to the minimum value.

>>> points = {'Jake': 100, 'Andy': 450, 'Kate': 450, 'Jeremy': 100}
>>> {key:value for key, value in points.items() if value == min_value}
{'Jake': 100, 'Jeremy': 100}

It works!

Find Maximum Value in a Python Dictionary Using an “Inverse” Dictionary

If you think we have gone through enough ways to retrieve the maximum or minimum value in a dictionary, think twice 🙂

I want to show you an alternative approach that is quite different from the ones we have seen so far.

Start from the following dictionary:

>>> points = {'Jake': 100, 'Andy': 450, 'Kate': 230}

Now…

I want to swap keys and values in the dictionary.

You will see why shortly…

The format of the original dictionary is:

{key1: value1, key2: value2, ..., keyN: valueN}

The new dictionary will be:

{value1: key1, value2: key2, ..., valueN: keyN}

Let’s do this first and then you will see how you can use the new dictionary to get the maximum value.

To swap keys and values in the dictionary we can use a dictionary comprehension.

>>> points_swapped = {value:key for key, value in points.items()}
>>> print(points_swapped)
{100: 'Jake', 450: 'Andy', 230: 'Kate'}

Make sure you understand this comprehension before you continue reading.

Now, we can use the max() function with the new dictionary to get the maximum value in the dictionary.

>>> print(max(points_swapped))
450

The same applies to the min() function that returns the minimum value in the dictionary:

>>> print(min(points_swapped))
100

Conclusion

Wow, we have seen lots of different ways to retrieve maximum and minimum values from a Python dictionary.

It has been a great opportunity to review Python concepts like:

• Built-in functions (min / max) with and without the optional key argument.
• Dictionary methods: dict.values() and dict.items().
• Lambda functions.
• The itemgetter function of the Python operator module.
• Dictionary comprehensions.

I hope you have found this article useful.

And now, what else would you like to learn?

Let me know in the comments below 🙂

In this Python tutorial, we will discuss the Python find max value in a dictionary.

To obtain the maximum value from the dictionary, use the in-built max() function of Python.

Here we will discuss the following 3 methods

• Using dict.items()
• Using max() and lambda function
• Using max() and dict()

In this Python section, we are going to discuss different methods for finding the max value in a dictionary.

Method-1: Using dict.items()

Here we will know how to find the maximum value in a dictionary using the dict.items() method:

# Import the operator module
import operator

# Create a dictionary with some key-value pairs
max_dict = {'Australia':178, 'Germany':213, 'Japan': 867}

# Use the operator.itemgetter() method in combination with the max() function to find the key with the maximum value
new_ma_val = max(max_dict.items(), key=operator.itemgetter(1))[0]

# Print the key with the maximum value
print((new_ma_val))

In the above code, we first import the operator module, which provides functions for working with operator overloading.

• Then we create a dictionary max_dict with key-value pairs. We use the operator.itemgetter() method in combination with the max() function to find the key with the maximum value.
• The operator.itemgetter() method is used to extract the value from the tuple by using the index passed to it, which is 1 in this case. The max() function compares the values and returns the key-value pair that has the maximum value.
• The key is extracted from the returned tuple by using [0] indexing and is assigned to the variable new_ma_val. Finally, we print the key with the maximum value which is “Japan” with 867 as the max value.

Method-2: Using max() and lambda function

Here we will know how to find the maximum value in a dictionary using the max() and lambda methods:

# Create a dictionary with some key-value pairs
Country_dict = {'China':982, 'Egypt':758, 'Malaysia' : 12}

# Use the max function with a lambda function to find the key with the maximum value
new_val = max(Country_dict, key= lambda x: Country_dict[x])

# Print the key with the maximum value
print("maximum value from dictionary:",new_val)

In the above code, we first create a dictionary Country_dict with key-value pairs.

• Then we use the max() function with a lambda function to find the key with the maximum value. The lambda function takes a single argument x which is the key of the dictionary and returns the value associated with the key.
• The max() function then compares the values and returns the key that has the maximum value. Finally, we print the key with the maximum value, which is ‘China’ with 982 as the max value in this case.

Method-3: Using max() and dict()

Here we will know how to find the maximum value in a dictionary using the max() and dict() methods:

# Create a dictionary with some key-value pairs
name_dict = {"Oliva": 18, "potter": 56, "Harry": 15}

# Extract the values from the dictionary and assign it to a variable
new_val = name_dict.values()

# Use the max function to find the maximum value
maximum_val = max(new_val)

# Print the maximum value
print("Maximum value from dict:",maximum_val)

In the above code, we first create a dictionary name_dict with key-value pairs.

• Then we extract the values from the dictionary using the .values() method and assign them to a variable new_val.
• We then use the max() function to find the maximum value from the extracted values. Finally, we print the maximum value which is 56 in this case.

Read: How to create an empty Python dictionary

Python find max value in a nested dictionary

In this Python section, we will learn how to find the max value in a dictionary within the dictionary.

# Create a nested dictionary 
my_dictionary = {'Micheal' : {'i' : 15, 'z' : 14},
			'George' : {'q' : 2, 'y' : 10, 'w' : 3},
			'John' : {'n' : 19}}

# Create a empty dictionary to store the result
new_out = {}

# Iterate over the outer dictionary keys and values
for new_k, new_v in my_dictionary.items():
    count_new = 0
    # Iterate over the inner dictionary values
    for element in new_v.values():
        # Check if current value is greater than the previous maximum
        if element > count_new:
            count_new = element
    # Assign the maximum value to the outer dictionary key
    new_out[new_k] = count_new

# Print the final dictionary with maximum values
print(new_out)

In the above code, we first create a nested dictionary my_dictionary with multiple keys, each key having its own dictionary as a value.

• We then create an empty dictionary new_out to store the result. We use a for loop to iterate over the outer dictionary keys and values, and another for loop to iterate over the values of the inner dictionary.
• We compare each value of the inner dictionary with a variable count_new, updating the variable if the current value is greater than the previous maximum.
• Then we assign the maximum value to the outer dictionary key by using this key as the key for the new_out dictionary and the maximum value as the value for this key.

Read: Python Dictionary to CSV

Python find max value in a dictionary of lists

In this Python section, we will discuss how to find the max value in a dictionary containing the list.

# Create a dictionary with some key-value pairs
dict_new = {'USA': [17,27,81], 'United Kingdom': [19,61,92]}

# Use max() and list comprehension to find the maximum value in the dictionary
new_val = max((max(dict_new[key]) for key in dict_new))

# Print the maximum value
print(new_val)

In the above code, we first create a dictionary dict_new with key-value pairs.

• Then we use the max() function and list comprehension to find the maximum value in the dictionary.
• The list comprehension iterates over the keys of the dictionary and for each key, it finds the maximum value in the corresponding list using the max() function.
• Finally, we print the maximum value which is 92 in this case.

You may also like to read the following tutorials on Python dictionary:

• Python dictionary pop
• Python dictionary get() method [With Examples]
• Python dictionary Copy
• Python dictionary contains
• Python dictionary multiple keys

In this Python tutorial, we have discussed the Python find max value in a dictionary. Also, we have covered the following methods:

• Using dict.items()
• Using max() and lambda function
• Using max() and dict()

Вступление

В этом руководстве мы рассмотрим, как найти максимальный элемент нескольких распространенных структур данных в Python, таких как список, словарь и кортеж.

Метод max(), встроенный в пространство имен Python, творит чудеса для встроенных типов.

Как получить максимальный элемент списка Python

Список – это встроенный тип Python, который используется для последовательного хранения нескольких ссылок в одном объекте в памяти.

По сравнению с другими языками программирования, список Python по сути представляет собой простой массив. Элементы индексируются на основе их положения в списке, и может быть несколько элементов с одинаковым значением.

Основное отличие в том, что списки в Python могут содержать элементы разных типов. Они разнородны.

# List of different type elements 
example_list = ["string", 5, "five", 4, "4"]

Примечание: если элементы не сопоставимы с помощью операторов сравнения (<,>,==,!=), функция max() не будет работать. Таким образом, мы убедимся, что список однороден, прежде чем пытаться найти максимальный элемент.

Пока вы правильно сравниваете элементы, вы можете найти максимальный элемент независимо от типа. Большую часть времени вы будете работать с целыми числами:

integer_list = [24, 9, 20, 17, 201, 16, 7]

Самый простой способ получить максимальный элемент списка – использовать встроенный метод max():

max_element = max(integer_list)
print("Max element of a list: ", max_element)

Ожидаемый результат:

Max element: 201

Вы можете сравнить строки лексикографически и найти лексикографически наибольшую строку в списке с помощью функции max():

string_list = ["string", "five",  "4"]
max_element = max(string_list)

print("Max element:", max_element)

Результат:

Max element: string

Другой способ найти максимальный элемент списка – отсортировать его с помощью метода sort(), а затем получить последний элемент отсортированного списка, поскольку метод sort() сортирует список в порядке возрастания:

integer_list = [24, 9, 20, 17, 201, 16, 7]
integer_list.sort()
# myList = [7, 9, 16, 17, 20, 24, 201]
max_element = integer_list[-1]

print("Max element of a list: ", max_element)

Этот код также будет иметь тот же результат:

Max element of a list: 201

Если мы также хотим найти индекс элемента max, самый простой способ – использовать встроенный метод index():

integer_list = [24, 9, 20, 17, 201, 16, 7]

max_element = max(integer_list)
max_element_index = integer_list.index(max_element)

print("Max element of a list: ", max_element, " at index: ", max_element_index)

Результат:

Max element of a list:  201  at index:  4

Как получить максимальный элемент словаря Python

Словари в Python используются для хранения пар ключ-значение. Пары с одним и тем же ключом не допускаются, и, начиная с Python 3.7, пары в словаре считаются упорядоченными.

Словари определяются списком пар key-value между парой фигурных скобок:

dictionary = {
    "key24": 24, 
    "key7": 9,
    "key20": 201,
    "key17": 17, 
    "key201": 201, 
}

Самый простой способ получить значение элемента max словаря также заключается в использовании встроенного метода max() со списком значений, передаваемых в качестве аргумента:

max_element = max(dictionary.values())
print("Max element of a dict: ", max_element)

Всё сводится к предыдущему методу, поскольку values() возвращает значения, хранящиеся в списке. Это даст правильный результат:

Max element of a dict: 201

Если вы хотите найти ключ первого элемента с максимальным значением, самый простой способ – использовать метод max(), предоставляющий словарь и извлекающий элемент через dictionary.get().

max_val = max(dictionary.values())
max_val_key = max(dictionary, key=dictionary.get)

print("Max element of a dict:", max_val, "with the key:", max_val_key)

Так мы выведем значение элемента max и первого соответствующего ключа:

Max element of a dict: 201 with the key: key20

Примечание: у вас может возникнуть соблазн использовать max(dictionary), чтобы найти ключ с максимальным значением. Однако так вы вернёте сам максимальный ключ. В нашем случае программа вернула бы ключ с максимальным лексикографическим значением в словаре.

Как получить максимальный элемент кортежа

Кортеж – это встроенный тип Python, последовательно хранящий ссылки на несколько объектов в памяти. Они во многом похожи на списки. Различие лишь в том, что кортеж – это неизменяемая структура данных, в отличие от списка.

Обычно они используются для хранения только нескольких результатов, в виде типов возвращаемых функций.

В Python мы описываем кортежи с помощью пары скобок:

# Tuple of different element types 
exampleTuple = ("string", 5, "five", 4, "4")

Вы можете запускать метод max() только для совместимых типов данных:

int_tuple = (24, 9, 20, 17, 201, 16, 7)
string_tuple = ('one', 'two', 'three')

Вероятно, самый простой способ получить максимальный элемент кортежа – использовать встроенный метод max():

int_tuple = (24, 9, 20, 17, 201, 16, 7)
string_tuple = ('one', 'two', 'three')

max_int = max(int_tuple)
print("Max element of a tuple: ", max_int)

max_str = max(string_tuple)
print("Max element of a tuple: ", max_str)

Опять-таки, это приводит к наибольшему целому числу и лексикографически наибольшей строке:

Max element of a tuple:  201
Max element of a tuple:  two

Заключение

Поиск максимального элемента структуры данных – довольно распространенная задача. Все стандартные структуры данных в Python имеют аналогичный способ поиска элемента max – полагаясь на метод max() во всех случаях.

В этом руководстве мы рассмотрели, как найти максимальный элемент нескольких наиболее популярных структур данных в Python, принимая во внимание особенности каждой из них.

Просмотры: 9 208

In this tutorial, you’ll learn how to use Python to get the dictionary key with max value in a given dictionary, including if multiple keys have the same value. You’ll also learn how to simply get the max value of all keys in a dictionary. You’ll learn how to do this using the operator library, the max() function, and with dictionary comprehensions. You’ll also learn the benefits and the drawbacks of each of these approaches.

Let’s get started!

The Quick Answer: Use the max() function to get the dictionary key with the max values

What are Python Dictionaries?

Dictionaries in Python are one of the main, built-in data structures. They are collections of items, each consisting of a key:value pairs. Python dictionaries are optimized to retrieve values, when the corresponding dictionary key is known.

Values themselves can be repeated, however keys must be unique. Values can also be of any data type (including other dictionaries), while keys must be immutable data types (such as strings, numbers, or tuples).

Let’s take a look at how dictionaries look in Python. They’re created using {} curly brackets and the key:value pairs are separated by commas.

Let’s create a dictionary called ages, which, well, contains the ages of different people:

ages = {
    'Matt': 30,
    'Katie': 29,
    'Nik': 31,
    'Jack': 43,
    'Alison': 32,
    'Kevin': 38
}

We can then access a dictionary item, either by using [] square bracket notation or, better yet, using the .get() dictionary method. Let’s see how we can get the age for Nik:

>> print(ages.get('Nik'))
31

Now that we’ve covered some of the basics of Python dictionaries, let’s take a look at how we can find the max value of a Python dictionary.

The simplest way to get the max value of a Python dictionary is to use the max() function. The function allows us to get the maximum value of any iterable.

Let’s see how it works with a list, before diving into a more complex example with a Python dictionary:

some_list = [30, 29, 31, 43, 32, 38]
max_value = max(some_list)
print(max_value)

# Returns: 43

What we can see here, is that we’ve passed in an iterable, a list, and were able to return max value of that iterable.

But how does this work with dictionaries?

Let’s give it a try just by passing in the dictionary:

max_value = max(ages)
print(max_value)

# Returns: Nik

This isn’t exactly what we’d expected. We were hoping to return 43, or at least a number!

Python dictionaries come built-in with a .values() method, which extracts the values of our list. If you have a keen eye, you’ll notice that our some_list list contains all the values of our dictionary. We can simply pass in our .values() method into the max function.

Let’s take a look!

max_value = max(ages.values())
print(max_value)

# Returns: 43

What we’ve done here is first extracted all the values from our dictionary, and then passed that iterable into our max() function.

Now let’s take a look at how you can return the corresponding key with a max value in Python!

Check out some other Python tutorials on datagy.io, including our complete guide to styling Pandas and our comprehensive overview of Pivot Tables in Pandas!

How To Get Dictionary Key with the Max Value in Python

One helpful skill to learn when working with Python dictionaries is how to get the dictionary key that corresponds with the highest value.

The Python max() function actually accepts a parameter to make this much easier: the key= parameter. The way that this parameter works is to define a function that returns a value for each element of the iterable. So, we can simply pass in a function to compare against!

We can use the .get() method we covered earlier to get the max value of a dictionary in Python. You may recall, from the earlier recap of Python dictionaries, that the .get() method is used to return the value for a key. Let’s see what applying this function to our key= parameter does:

ages = {
    'Matt': 30,
    'Katie': 29,
    'Nik': 31,
    'Jack': 43,
    'Alison': 32,
    'Kevin': 38
}

max_value = max(ages, key=ages.get)
print(max_value)

# Jack

We can see here that by passing in key=ages.get that we return the key with the highest value in a Python dictionary.

How to Get Multiple Dictionary Keys with the Max Values in Python

There may be many times when you want to return the key that has the highest value in a Python dictionary. But what if you dictionary has multiple keys that have the highest value?

Unfortunately, the max() function will simply return the first key it finds.

Fortunately, we can find some alternative solutions to this problem!

We can break down our problem as below:

1. Get the max value
2. Create a list comprehension that includes a dictionary key if the key’s value is equal to the max value

Let’s see how we can do this:

ages = {
    'Matt': 30,
    'Katie': 29,
    'Nik': 31,
    'Jack': 43,
    'Jill': 43,
    'Alison': 32,
    'Kevin': 38
}

max_keys = [key for key, value in ages.items() if value == max(ages.values())]

print(max_keys)

# Returns: ['Jack', 'Jill']

In the code above, we loop over the key:value pairs in our dictionary and see if the value is equal to the maximum value. If that’s the case, we add it to our list.

Want to learn more? Check out my in-depth tutorial on Python list comprehensions to learn all you need to know! Or, check out my video on the topic below:

How to Get the Max Value From a List of Dictionaries in Python

You may find yourself working often, with lists of dictionaries. In these cases, it can be helpful to know how to get the max value, across all dictionaries in that list of dictionaries.

Doing this is quite easy! We’ll first do this with a for-loop method, followed by a list comprehension. Let’s take a look at the for-loop method first:

ages = [{'Matt': 30, 'Katie': 29}, {'Nik': 31, 'Jack': 43,}, {'Alison': 32, 'Kevin': 38}]

max_age = int()

for dict in ages:
    if max(dict.values()) > max_age:
        max_age = max(dict.values())

print(max_age)

# Returns 43

We can also re-write this as a list comprehension:

ages = [{'Matt': 30, 'Katie': 29}, {'Nik': 31, 'Jack': 43,}, {'Alison': 32, 'Kevin': 38}]

max_age = max([max(dict.values()) for dict in ages])
print(max_age)

# Returns: 43

Conclusion

In this post, you learned how to get the max value from a dictionary in Python. In addition, you learned how to get the corresponding key or keys that have the max value in a dictionary. Finally, you learned how to get the max value from a list of Python dictionaries.

To learn more about the Python .get() method, check out the official documentation here.

Additional Resources

To learn more about related topics, check out these tutorials:

• Python Dictionaries: A Complete Overview
• Python: Add Key:Value Pair to Dictionary
• Python Defaultdict: Overview and Examples
• Python: Sort a Dictionary by Values