Get the Key with the Maximum Dictionary Value in Python

You will learn how to use Python's built-in max() function with its key argument to find the key whose dictionary value is largest. You will also learn how ties and empty dictionaries behave, and when related approaches are more suitable.

A dictionary maps keys to values. In this case, each key is a label and each value is a number:

stats = {'a': 1, 'b': 3000, 'c': 0}

To find the key with the largest associated value, iterate over the dictionary's keys and tell max() how to compare them. The key argument accepts a function that produces the comparison value for every item.

max(stats, key=stats.get)

max() considers each dictionary key ('a', 'b', and 'c'). For each key, stats.get retrieves its value. It then returns the original key that produced the greatest value.

This matters because dictionaries frequently store scores, counts, prices, timestamps, priorities, or measurements. Finding the associated key lets a program identify the most popular product, highest-scoring player, latest record, or largest category without building an unnecessary temporary list.

Think of the dictionary as a row of labelled boxes:

• Box labelled 'a' contains 1.
• Box labelled 'b' contains 3000.
• Box labelled 'c' contains 0.

max(stats, key=stats.get) asks: Which label belongs to the box with the biggest number inside?

The function returns the label, not the number. The key=stats.get part is the instruction that tells max() to look inside each labelled box before choosing.

The usual Python syntax is:

largest_key = max(dictionary, key=dictionary.get)

Example:

stats = {'a': 1, 'b': 3000, 'c': 0}

largest_key = max(stats, key=stats.get)
print(largest_key)

Output:

b

Here, iterating over stats produces its keys. stats.get turns each candidate key into the value used for comparison:

stats.get('a')  # 1
stats.get('b')  # 3000
stats.get('c')  # 0

If you need both the key and its maximum value, retrieve the value afterward:

largest_key = max(stats, key=stats.get)
largest_value = stats[largest_key]

print(largest_key, largest_value)
# b 3000

An explicit lambda is equivalent, although less concise here:

largest_key = max(stats, key=lambda name: stats[name])

Consider this code:

scores = {'Mia': 12, 'Noah': 19, 'Ava': 15}
winner = max(scores, key=scores.get)
print(winner)

Execution proceeds as follows:

1. scores is iterable, so max() receives its keys: 'Mia', 'Noah', and 'Ava'.
2. For 'Mia', scores.get('Mia') returns 12.
3. For 'Noah', scores.get('Noah') returns 19.
4. For 'Ava', scores.get('Ava') returns 15.
5. 19 is the largest comparison value.
6. max() returns the original item that produced 19, which is 'Noah'.
7. print(winner) displays Noah.

The important detail is that the key function changes how candidates are compared, but max() still returns the original candidate: the dictionary key.

Common situations include:

• Analytics: Find the page with the most visits from {'/home': 400, '/pricing': 820}.
• Gaming: Find the player with the highest score.
• Inventory: Find the product with the highest number of units sold.
• Monitoring: Find the server reporting the highest CPU usage.
• Voting: Find the candidate or option with the most votes.
• Data processing: Find the category with the largest total after grouping records.

For example, selecting a most-viewed article:

views = {
    'python-basics': 1250,
    'api-design': 980,
    'testing-guide': 1540,
}

most_viewed = max(views, key=views.get)
print(most_viewed)
# testing-guide

In production code, developers usually account for empty input and define a clear tie policy.

Handle an empty dictionary

Calling max() with no items raises ValueError. Use default when there may be no data:

stats = {}
largest_key = max(stats, key=stats.get, default=None)

if largest_key is None:
    print('No statistics are available.')

Use a guard clause in a function

def highest_scoring_user(scores):
    if not scores:
        return None
    return max(scores, key=scores.get)

Return a key-value pair when both are needed

Avoid looking up the value separately by find the largest item directly:

stats = {'a': 1, 'b': 3000, 'c': 0}
key, value = max(stats.items(), key=lambda item: item[1])

print(key, value)
# b 3000

Define behavior for ties

When multiple keys have the same maximum value, max() returns the first one encountered in dictionary iteration order. In modern Python, dictionaries preserve insertion order.

scores = {'Mia': 10, 'Noah': 10, 'Ava': 8}
print(max(scores, key=scores.get))
# Mia

If the application needs every tied key, filter instead:

highest_value = max(scores.values())
winners = [name for name, score in scores.items() if score == highest_value]
print(winners)
# ['Mia', 'Noah']

Calling max() without a comparison key

stats = {'a': 1, 'b': 3000, 'c': 0}
print(max(stats))

This compares the keys themselves, not their values. For strings, it uses lexicographic order, so it happens to return 'c' here.

Use:

print(max(stats, key=stats.get))

Returning the value when you need the key

max_value = max(stats.values())

This correctly returns 3000, but it loses the associated key. Use max(stats, key=stats.get) for the key, or use max(stats.items(), key=lambda item: item[1]) for both.

Failing on an empty dictionary

max({})  # ValueError

When an empty dictionary is possible, provide a default:

max({}, key=dict.get, default=None)

Building reversed tuples unnecessarily

inverse = [(value, key) for key, value in stats.items()]
result = max(inverse)[1]

This works for many simple cases, but creates a new list and introduces an unintended tie-break: if values tie, tuple comparison compares keys next. Prefer an explicit key function unless that tie-break is exactly what you want.

Assuming tied maxima are all returned

max() returns one item only. To get every tied key, first compute the highest value and then filter the dictionary items.

max() is preferable to sorting when only one maximum is needed. Sorting does extra work because it orders every item.

For a minimum instead, replace max with min:

least_key = min(stats, key=stats.get)

# Key with largest value
winner = max(data, key=data.get)

# Key with smallest value
loser = min(data, key=data.get)

# Largest value only
largest_value = max(data.values())

# Key and value together
key, value = max(data.items(), key=lambda item: item[1])

# Safe result for empty data
winner = max(data, key=data.get, default=None)

# Every key tied for the largest value
largest_value = max(data.values(), default=None)
winners = [key for key, value in data.items() if value == largest_value]

Rules to remember:

• Iterating over a dictionary yields keys.
• key=data.get compares keys by their mapped values.
• max() returns one item; ties return the first encountered item.
• An empty dictionary needs default=... or a prior check.

How do I get the key with the highest value in a Python dictionary?

Use max(data, key=data.get).

max({'a': 1, 'b': 3000, 'c': 0}, key=lambda_key.get)

In normal code, use the dictionary variable directly:

data = {'a': 1, 'b': 3000, 'c': 0}
max(data, key=data.get)

Why does max(my_dict) not find the largest value?

A dictionary iterates over keys by default. Therefore, max(my_dict) compares keys, not values. Supply key=my_dict.get.

How can I get both the maximum key and value?

Use dictionary items:

key, value = max(data.items(), key=lambda item: item[1])

What happens if two dictionary values are equal and largest?

max() returns the first matching key encountered during dictionary iteration. If you need all tied keys, filter the items after finding the maximum value.

What happens with an empty dictionary?

max() raises ValueError unless you provide a default:

max(data, key=data.get, default=None)

Is max(data, key=data.get) efficient?

Yes. It examines each dictionary key once, so its time complexity is O(n), where n is the number of entries. It does not need to sort all entries.

Can I use this with negative values?

Yes. It works with negative integers, floats, and other values that can be compared with one another.

temperatures = {'north': -8, 'south': -2, 'east': -5}
max(temperatures, key=temperatures.get)  # 'south'

• Python dictionaries — Learn how keys, values, and .items() work.
• The max() and min() functions — Find largest or smallest elements in iterables.
• Key functions — Customize how max(), min(), and sorted() compare items.
• Lambda functions — Write small inline functions such as lambda item: item[1].
• Dictionary comprehensions — Transform or filter dictionary data.
• List comprehensions — Build concise lists, including lists of tied winners.
• Sorting dictionaries by value — Create ordered rankings when one result is not enough.
• Guard clauses and input validation — Handle empty or missing data safely in functions.