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

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)[0] 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[0])
(2, 'c')
>>> test = [(1, "a"), (1, "b"), (2, "d"), (2, "c")]
>>> max(test, key=lambda x: x[0])
(2, 'd')
>>> min(test, key=lambda x: x[0])
(1, 'a')
>>> test = [(1, "b"), (1, "a"), (2, "d"), (2, "c")]
>>> min(test, key=lambda x: x[0])
(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)[0] 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.)