# Which maximum does Python pick in the case of a tie?

Each Answer to this Q is separated by one/two green lines.

When using the `max()` function in Python to find the maximum value in a list (or tuple, dict etc.) and there is a tie for maximum value, which one does Python pick? Is it random?

This is relevant if, for instance, one has a list of tuples and one selects a maximum (using a `key=`) based on the first element of the tuple but there are different second elements. How does Python decide which one to pick as the maximum?

It picks the first element it sees. See the documentation for `max()`:

If multiple items are maximal, the function returns the first one encountered. This is consistent with other sort-stability preserving tools such as `sorted(iterable, key=keyfunc, reverse=True)` and `heapq.nlargest(1, iterable, key=keyfunc)`.

In the source code this is implemented in `./Python/bltinmodule.c` by `builtin_max`, which wraps the more general `min_max` function.

`min_max` will iterate through the values and use `PyObject_RichCompareBool` to see if they are greater than the current value. If so, the greater value replaces it. Equal values will be skipped over.

The result is that the first maximum will be chosen in the case of a tie.

From empirical testing, it appears that `max()` and `min()` on a list will return the first in the list that matches the `max()`/`min()` in the event of a tie:

``````>>> test = [(1, "a"), (1, "b"), (2, "c"), (2, "d")]
>>> max(test, key=lambda x: x)
(2, 'c')
>>> test = [(1, "a"), (1, "b"), (2, "d"), (2, "c")]
>>> max(test, key=lambda x: x)
(2, 'd')
>>> min(test, key=lambda x: x)
(1, 'a')
>>> test = [(1, "b"), (1, "a"), (2, "d"), (2, "c")]
>>> min(test, key=lambda x: x)
(1, 'b')
``````

And Jeremy’s excellent sleuthing confirms that this is indeed the case.

For Python 3, the behavior of `max()` in the case of ties is no longer just an implementation detail as detailed in the other answers. The feature is now guaranteed, as the Python 3 docs explicitly state:

If multiple items are maximal, the function returns the first one
encountered. This is consistent with other sort-stability preserving
tools such as `sorted(iterable, key=keyfunc, reverse=True)` and
`heapq.nlargest(1, iterable, key=keyfunc)`.

Your question somewhat leads to a note. When sorting a data structure, there is often a desire to keep relative order of objects that are considered equal for the purposes of comparison. This would be known as a stable sort.

If you absolutely needed this feature, you could do a `sort()`, which will be stable and then have knowledge of the order relative to the original list.

As per python itself, I don’t believe that you get any guarantee of which element you will get when you call `max()`. Other answers are giving the cpython answer, but other implementations (IronPython, Jython) could function differently.

For Python 2 versions, IMO, I believe you cannot assume that `max()` returns the first maximal element in the list in the case of ties. I have this belief because `max()` is supposed to implement the true mathematical function `max`, which is used on sets that have a total order, and where elements do not have any “hidden information”.

(I will assume that others have researched correctly and the Python documentation does not give any guarantees for `max()`.)

(In general, there are an endless number of questions you can ask about the behavior of a library function, and almost all of them can’t be answered. For example: How much stack space will `max()` use? Will it use SSE? How much temporary memory? Can it compare the same pair of objects more than once (if comparison has a side effect)? Can it run faster than O(n) time for “special” known data structures? etc. etc.) The answers/resolutions are collected from stackoverflow, are licensed under cc by-sa 2.5 , cc by-sa 3.0 and cc by-sa 4.0 .