Как найти минимальное значение словаря

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 🙂

>>> ids = [{"nonid": "-222", "id": 0}, {"id": -101}]
>>> min([val for obj in ids for key, val in obj.items() if key == 'id'])
-101
>>> ids = [{'id': 63}, { 'id': 42}]
>>> min([val for obj in ids for key, val in obj.items() if key == 'id'])
42

Try the above.

You can make this into a function definition:

def find_lowest(ids):
    return min([val for obj in ids for key, val in obj.items() if key == 'id'])

Working example.

Let me explain what I’m doing. Firstly, the min function takes in an iterable object as an argument. So, let me demonstrate:

>>> min([1,2,3,4,6,1,0])
0

So, what this means is this, we are essentially taking the minimum value of the list that we get from this, [val for obj in ids for key, val in obj.items() if key == 'id'].

Now, you might be wondering, well whats happening in there? It might be a little intimidating at first, but thats a list comprehension. Whats that you say? Well, in simple terms its a concise we in which we make a list:

Let me start with be first part, and no its not the beginning of the statement:

for obj in ids

What we are doing here, is iterating over all the dictionary objects in in side of ids. Now, we use that object here:

key, val in obj.items() if key == 'id'

Since object, is a dict, we use the items function to get a generator that gives a tuple of key, value pairs. In an object like this: {'id': 100}, the id would be they key and 100 would be the value. So, we are going over all the items in the dictionary object, and if the key happens to be id, then we append it to the list:

[val

Thats what the first part does. The first part of the list comprehension appends something to the final list, and that is val.

UPDATE:

If for some reason, the list does not containt anything with id as a key, then it will throw a ValueError as min does not accept an empty list, so to remedy this, we can check:

def find_lowest(ids):
    _ret = [val for obj in ids for key, val in obj.items() if key == 'id']
    if _ret:
        return min(_ret)
    else:
        return None

Автор оригинала: Chris.

Я провел утренние часы на важной миссии. Что такое самый чистый, самый быстрый и самый краткий ответ на следующий вопрос: как вы находите ключ с минимальным значением в словаре Python? Большинство ответов на Интернете говорят, что вам нужно использовать библиотеку, но это не правда!

Просто используйте минимальную функцию с клавишным аргументом, установленным на Dict.get :

income = {'Anne' : 1111,
          'Bert' : 2222,
          'Cara' : 9999999}

print(min(income, key=income.get))
# Anne

Минимальная функция переходит на все ключи, к в словаре доходов и принимает минимальное значение после применения доход. Получить (k) метод. Получить () Метод возвращает значение, указанное для ключа, к в словаре.

Играйте с этим сами в нашем интерактивном коде Shell:

Теперь прочитайте 4-минутную статью или посмотрите короткое видео, чтобы полностью понять эту концепцию.

Скорее всего, вы уже знаете функцию Python Min (…). Вы можете использовать его, чтобы найти минимальное значение любого намерения или любого количества значений. Вот несколько примеров, использующих минимальную функцию, не указав какие-либо дополнительные аргументы.

income = {'Anne' : 1111,
          'Bert' : 2222,
          'Cara' : 9999999}

print(min(income, key=income.get))
# Anne

# Key that starts with 'smallest' letter of the alphabet
print(min(income))
# Anne

# Smallest value in the dictionary income
print(min(income.values()))
# 1111

# Smallest value in the given list
print(min([1,4,7,5,3,99,3]))
# 1

# Compare lists element-wise, min is first list to have a larger
# element 
print(min([1,2,3],[5,6,4]))
# [1, 2, 3]

# Smallest value in the given sequence of numbers
print(min(5,7,99,88,123))
# 5

Все идет нормально. Минимальная функция очень гибкая. Он работает не только для цифр, но и для строк, списков и любого другого объекта, который вы можете сравнить с другими объектами.

Теперь давайте посмотрим на необязательные аргументы минимальной функции. Один из них – «ключ» Отказ Давайте узнаем, что это делает.

Как Ключевым аргументом работы Python Min () работает?

Последние примеры показывают интуитивные разработки минимальной функции: вы проходите один или несколько повторных документов в качестве позиционных аргументов.

Intermezzo : Что такое иеристы? Итализатор является объектом, из которого вы можете получить итератор. ITERATOR – это объект, на котором вы можете позвонить следующему () методу. Каждый раз, когда вы звоните следующим (), вы получаете «следующий» элемент, пока не получите все элементы из итератора. Например, Python использует итераторы для петлей, чтобы пройти все элементы списка, все символы строки или все клавиши в словаре.

Когда вы указываете клавишный аргумент, определите функцию, которая возвращает значение для каждого элемента Iterable. Тогда каждый элемент сравнивается на основе возвращаемого значения этой функции, а не указанным элементом (поведение по умолчанию).

Вот пример:

lst = [2, 4, 8, 16]

def inverse(val):
   return -val

print(min(lst))
# 2

print(min(lst, key=inverse))
# 16

Мы определяем функцию обратная () Это возвращает значение, умноженное на -1. Теперь мы печатаем два исполнения мин () функция.

• Первый – это выполнение по умолчанию: минимум списка [2, 4, 8, 16] 2.
• Второй использует ключ. Мы указываем обратная в качестве ключевой функции. Python применяет эту функцию ко всем значениям [2, 4, 8, 16] . Это сравнивает эти новые значения друг с другом и возвращает мин. Использование обратной функции Python делает следующие сопоставления:

Python рассчитывает минимальный на основе этих отображений. В этом случае значение 16 (с сопоставлением -16) является минимальным значением, потому что -2> -4> -8> -16.

Теперь давайте вернемся к начальному вопросу:

Как получить ключ с минимальным значением в словаре?

Мы используем тот же пример, что и выше. Словарь хранит доход от трех человек Иоанна, Мэри и Алиса. Предположим, вы хотите найти человека с наименьшим доходом. Другими словами, каков ключ с минимальным значением в словаре?

Теперь не путайте ключ словаря с дополнительным клавишным аргументом мин () функция. У них ничего общего нет – это просто несчастное совпадение, которое у них есть то же имя!

От проблемы, мы знаем, что результат является ключом словаря. Итак, мы называем мин () на ключах словаря. Обратите внимание, что мин (доход. keys ()) такой же, как мин (доход) Отказ

Чтобы узнать больше о словарях, ознакомьтесь с нашей статьей Python словарь – окончательное руководство.

Однако мы хотим сравнить значения словаря, а не ключи. Мы будем использовать ключ аргумента мин () сделать это. Мы должны пройти его функцию, но которая?

Чтобы получить значение «Анна» мы можем использовать нотацию кронштейна – Доход ['Anne'] . Но нотация кронштейна не является функцией, так что не работает. К счастью, доход. Получить ('anne') делает (почти) так же, как Доход ['Anne'] И это функция! Единственное отличие в том, что он возвращает Нет Если они ключ нет в словаре. Итак, мы передадим это к ключевому аргументу мин () Отказ

income = {'Anne' : 1111,
          'Bert' : 2222,
          'Cara' : 9999999}

print(min(income, key=income.get))
# Anne

Как получить ключ с максимальным значением в словаре?

Если вы поняли предыдущий фрагмент кода, это будет легко. Чтобы найти ключ с максимальным значением в словаре, вы используете Макс () функция.

income = {'Anne' : 1111,
          'Bert' : 2222,
          'Cara' : 9999999}

print(max(income, key=income.get))
# Cara

Единственное отличие состоит в том, что вы используете встроенный Макс () функция вместо встроенного мин () функция. Вот и все.

Связанная статья:

• Как получить ключ с максимальным значением в словаре?

Найдите ключ с минимальным значением в словаре – альтернативные методы

Есть много разных способов решить эту проблему. Они не такие красивые или чистые, как вышеуказанный метод. Но для полноты, давайте рассмотрим некоторые пути достижения того же.

В оформлении Ответ в Stackoverflow , пользователь по сравнению с девятью (!) различными способами найти ключ с минимальным значением в словаре. Они здесь:

income = {'Anne' : 11111,
          'Bert' : 2222,
          'Cara' : 9999999}

# Convert to lists and use .index(max())
def f1(): 
    v=list(income.values())
    k=list(income.keys())
    return k[v.index(min(v))]

# Dictionary comprehension to swap keys and values
def f2():
   d3={v:k for k,v in income.items()}
   return d3[min(d3)]

# Use filter() and a lambda function
def f3():
   return list(filter(lambda t: t[1]==min(income.values()), income.items()))[0][0]   

# Same as f3() but more explicit
def f4():
   m=min(income.values())
   return list(filter(lambda t: t[1]==m, income.items()))[0][0] 
      
# List comprehension
def f5():
   return [k for k,v in income.items() if v==min(income.values())][0]  
 
# same as f5 but remove the max from the comprehension
def f6():
   m=min(income.values())
   return [k for k,v in income.items() if v==m][0]   
    
# Method used in this article
def f7():
   return min(income,key=income.get)    

# Similar to f1() but shortened to 2 lines
def f8():
    v=list(income.values())
    return list(income.keys())[v.index(min(v))] 
  
# Similar to f7() but use a lambda function
def f9():
    return min(income, key=lambda k: income[k])    

print(f1())
print(f2())
print(f3())
print(f4())
print(f5())
print(f6())
print(f7())
print(f8())
print(f9())
# Bert (all outputs)

В оформлении ориентир Выполненные в большом словаре пользователя Stackoverflow, F1 () оказался самым быстрым.

Таким образом, второй лучший способ получить ключ с минимальным значением из словаря:

income = {'Anne' : 11111,
          'Bert' : 2222,
          'Cara' : 9999999}

v=list(income.values())
k=list(income.keys())
print(k[v.index(min(v))])
# Bert

Найти ключ с кратчайшим значением в словаре

Мы знаем, как найти минимальное значение, если значения являются номерами. Как насчет ли они списков или строки?

Допустим, у нас есть словарь, который записывает количество дней, которые каждый человек работал в этом месяце. Если они работали в день, мы добавляем 1 к списку этого человека. Если они не работали, мы ничего не делаем.   В конце месяца наш словарь выглядит так.

days_worked = {'Anne': [1, 1, 1, 1],
               'Bert': [1, 1, 1, 1, 1, 1],
               'Cara': [1, 1, 1, 1, 1, 1, 1, 1]}

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

# Length 2 is less than length 4
>>> [1, 1] < [1, 1, 1, 1]
True

Таким образом, мы можем использовать тот же код, который мы использовали в статье, чтобы найти ключ с минимальным значением.

>>> min(days_worked, key=days_worked.get)
'Anne'

Если мы обновим наш словарь, так что Bert работал в большинстве дней и подать заявку мин () Опять же, Python возвращает «Анна» Отказ

>>> days_worked = {'Anne': [1, 1, 1, 1],
                   'Bert': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
                   'Cara': [1, 1, 1, 1, 1, 1, 1, 1]}

# Anne has now worked the least
>>> min(days_worked, key=days_worked.get)

Найти ключ с минимальным значением в списке словарей

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

income1 = {'Anne': 1111,
           'Bert': 2222,
           'Cara': 3333}

income2 = {'Dani': 4444,
           'Ella': 5555,
           'Fred': 6666}

income3 = {'Greg': 7777,
           'Hope': 8888,
           'Igor': 999999999999}

list_of_dicts = [income1, income2, income3]

Мы можем видеть, что «Анна» имеет самый низкий доход, поэтому мы ожидаем, что его возвращено.

Есть несколько способов сделать это. Самое простое состоит в том, чтобы поставить все пары клавишных пар в один словарь с использованием контура для цикла. Тогда мы называем мин () как обычно.

# Initialise empty dict
>>> big_dict = {}

# Use for loop and .update() method to add the key-value pairs
>>> for dic in list_of_dicts:
        big_dict.update(dic)

# Check the result is as expected
>>> big_dict
{'Anne': 1111,
'Bert': 2222,
'Cara': 3333,
'Dani': 4444,
'Ella': 5555,
'Fred': 6666,
'Greg': 7777,
'Hope': 8888,
'Igor': 999999999999}

# Call min() and specify key argument
>>> min(big_dict, key=big_dict.get)
'Anne' 

Куда пойти отсюда?

Каждый мастер Python должен знать основы. Улучшение вашего базового кодового понимания навыков на 20% улучшит вашу производительность намного больше всего на свете. Почему? Потому что все остальное основывается на основах.

Но большинство материальных онлайн утомительно и скучно. Вот почему я написал новый и захватывающий способ изучения Python, при этом измеряя и сравнивая свои навыки против других кодеров. Проверьте книгу «Кофе-брейк Python». Это LeanPub 2019 Bestseller в категории Python!

Работая в качестве исследователя в распределенных системах, доктор Кристиан Майер нашел свою любовь к учению студентов компьютерных наук.

Чтобы помочь студентам достичь более высоких уровней успеха Python, он основал сайт программирования образования Finxter.com Отказ Он автор популярной книги программирования Python одноклассники (Nostarch 2020), Coauthor of Кофе-брейк Python Серия самооставленных книг, энтузиаста компьютерных наук, Фрилансера и владелец одного из лучших 10 крупнейших Питон блоги по всему миру.

Его страсти пишут, чтение и кодирование. Но его величайшая страсть состоит в том, чтобы служить стремлению кодер через Finxter и помогать им повысить свои навыки. Вы можете присоединиться к его бесплатной академии электронной почты здесь.

Python’s built-in min() and max() functions come in handy when you need to find the smallest and largest values in an iterable or in a series of regular arguments. Even though these might seem like fairly basic computations, they turn out to have many interesting use cases in real-world programing. You’ll try out some of those use cases here.

In this tutorial, you’ll learn how to:

• Use Python’s min() and max() to find smallest and largest values in your data
• Call min() and max() with a single iterable or with any number of regular arguments
• Use min() and max() with strings and dictionaries
• Tweak the behavior of min() and max() with the key and default arguments
• Use comprehensions and generator expressions as arguments to min() and max()

Once you have this knowledge under your belt, then you’ll be prepared to write a bunch of practical examples that will showcase the usefulness of min() and max(). Finally, you’ll code your own versions of min() and max() in pure Python, which can help you understand how these functions work internally.

To get the most out of this tutorial, you should have some previous knowledge of Python programming, including topics like for loops, functions, list comprehensions, and generator expressions.

min(iterable, *[, default, key]) -> minimum_value

max(iterable, *[, default, key]) -> maximum_value

>>> min([3, 5, 9, 1, -5])
-5

>>> min([])
Traceback (most recent call last):
    ...
ValueError: min() arg is an empty sequence

>>> max([3, 5, 9, 1, -5])
9

>>> max([])
Traceback (most recent call last):
    ...
ValueError: max() arg is an empty sequence

>>> min([3, 5.0, 9, 1.0, -5])
-5

>>> max([3, 5.0, 9, 1.0, -5])
9

>>> min([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'str' and 'int'

>>> max([3, "5.0", 9, 1.0, "-5"])
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'str' and 'int'

min(arg_1, arg_2[, ..., arg_n], *[, key]) -> minimum_value

max(arg_1, arg_2[, ..., arg_n], *[, key]) -> maximum_value

>>> min(3, 5, 9, 1, -5)
-5

>>> max(3, 5, 9, 1, -5)
9

>>> min("abcdefghijklmnopqrstuvwxyz")
'a'

>>> max("abcdefghijklmnopqrstuvwxyz")
'z'

>>> min("abcdWXYZ")
'W'

>>> max("abcdWXYZ")
'd'

>>> # UTF-8 characters

>>> min("abc123ñ")
'1'

>>> max("abc123ñ")
'ñ'

>>> ord("A")
65

>>> ord("a")
97

>>> min("aA")
'A'

>>> max("aA")
'a'

>>> min(["Hello", "Pythonista", "and", "welcome", "world"])
'Hello'

>>> max(["Hello", "Pythonista", "and", "welcome", "world"])
'world'

>>> prices = {
...    "banana": 1.20,
...    "pineapple": 0.89,
...    "apple": 1.57,
...    "grape": 2.45,
... }


>>> min(prices)
'apple'

>>> max(prices)
'pineapple'

>>> min(prices.keys())
'apple'

>>> max(prices.keys())
'pineapple'

>>> min(prices.values())
0.89

>>> max(prices.values())
2.45

>>> min(prices.items())
('apple', 1.57)

>>> max(prices.items())
('pineapple', 2.45)

>>> min(["20", "3", "35", "7"])
'20'

>>> max(["20", "3", "35", "7"])
'7'

>>> min(["20", "3", "35", "7"], key=int)
'3'

>>> max(["20", "3", "35", "7"], key=int)
'35'

>>> min([], default=42)
42

>>> max([], default=42)
42

>>> letters = ["A", "B", "C", "X", "Y", "Z"]

>>> min(letters)
'A'
>>> min([letter.lower() for letter in letters])
'a'

>>> max(letters)
'Z'
>>> max([letter.lower() for letter in letters])
'z'

>>> letters = ["A", "B", "C", "X", "Y", "Z"]

>>> min([letter.lower() for letter in letters])
'a'

>>> min(letters, key=str.lower)
'A'

>>> letters = ["A", "B", "C", "X", "Y", "Z"]

>>> min(letters)
'A'
>>> min(letter.lower() for letter in letters)
'a'

>>> max(letters)
'Z'
>>> max(letter.lower() for letter in letters)
'z'

>>> sample = [4, 5, 7, 6, -12, 4, 42]

>>> sample.remove(min(sample))
>>> sample
[4, 5, 7, 6, 4, 42]

>>> sample.remove(max(sample))
>>> sample
[4, 5, 7, 6, 4]

>>> matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

>>> [min(x) for x in matrix]
[1, 4, 7]

>>> [max(x) for x in matrix]
[3, 6, 9]

>>> # Clip values to the largest interval's edge

>>> upper = 100
>>> numbers = [42, 78, 200, -230, 25, 142]

>>> [min(number, upper) for number in numbers]
[42, 78, 100, -230, 25, 100]

>>> # Clip values to the smallest interval's edge

>>> lower = 10
>>> numbers = [42, 78, 200, -230, 25, 142]

>>> [max(number, lower) for number in numbers]
[42, 78, 200, 10, 25, 142]

>>> # Clipping values to 10 - 100

>>> lower, upper = 10, 100
>>> numbers = [42, 78, 100, -230, 25, 142]

>>> [max(min(number, upper), lower) for number in numbers]
[42, 78, 100, 10, 25, 100]

>>> import math

>>> point_pairs = [
...     ((12, 5), (9, 4)),
...     ((2, 5), (3, 7)),
...     ((4, 11), (15, 2))
... ]

>>> min(point_pairs, key=lambda points: math.dist(*points))
((2, 5), (3, 7))

>>> prices = {
...    "banana": 1.20,
...    "pineapple": 0.89,
...    "apple": 1.57,
...    "grape": 2.45,
... }

>>> min(prices.items(), key=lambda item: item[1])
('pineapple', 0.89)

>>> max(prices.items(), key=lambda item: item[1])
('grape', 2.45)

>>> def are_coprime(a, b):
...     for i in range(2, min(a, b) + 1):
...         if a % i == 0 and b % i == 0:
...             return False
...     return True
...

>>> are_coprime(2, 3)
True
>>> are_coprime(2, 4)
False

>>> import timeit

>>> min(
...     timeit.repeat(
...         stmt="[i ** 2 for i in range(100)]",
...         number=1000,
...         repeat=3
...     )
... )
0.022141209003166296

>>> min(
...     timeit.repeat(
...         stmt="list(map(lambda i: i ** 2, range(100)))",
...         number=1000,
...         repeat=3
...     )
... )
0.023857666994445026

>>> "__lt__" in dir(int) and "__gt__" in dir(int)
True

>>> "__lt__" in dir(float) and "__gt__" in dir(float)
True

>>> "__lt__" in dir(str) and "__gt__" in dir(str)
True

>>> "__lt__" in dir(list) and "__gt__" in dir(list)
True

>>> "__lt__" in dir(tuple) and "__gt__" in dir(tuple)
True

>>> "__lt__" in dir(dict) and "__gt__" in dir(dict)
True

# person.py

from datetime import date

class Person:
    def __init__(self, name, birth_date):
        self.name = name
        self.birth_date = date.fromisoformat(birth_date)

    def __repr__(self):
        return (
            f"{type(self).__name__}"
            f"({self.name}, {self.birth_date.isoformat()})"
        )

    def __lt__(self, other):
        return self.birth_date > other.birth_date

    def __gt__(self, other):
        return self.birth_date < other.birth_date

>>> from person import Person

>>> jane = Person("Jane Doe", "2004-08-15")
>>> john = Person("John Doe", "2001-02-07")

>>> jane < john
True
>>> jane > john
False

>>> min(jane, john)
Person(Jane Doe, 2004-08-15)

>>> max(jane, john)
Person(John Doe, 2001-02-07)

>>> class Number:
...     def __init__(self, value):
...         self.value = value
...

>>> x = Number(21)
>>> y = Number(42)

>>> min(x, y)
Traceback (most recent call last):
    ...
TypeError: '<' not supported between instances of 'Number' and 'Number'

>>> max(x, y)
Traceback (most recent call last):
    ...
TypeError: '>' not supported between instances of 'Number' and 'Number'

>>> def find_min(iterable):
...     minimum = iterable[0]
...     for value in iterable[1:]:
...         if value < minimum:
...             minimum = value
...     return minimum
...

>>> find_min([2, 5, 3, 1, 9, 7])
1

>>> def find_max(iterable):
...     maximum = iterable[0]
...     for value in iterable[1:]:
...         if value > maximum:
...             maximum = value
...     return maximum
...

>>> find_max([2, 5, 3, 1, 9, 7])
9

min_max(*args, operator, key=None, default=None) -> extreme_value

# min_max.py

def min_max(*args, operator, key=None, default=None):
    if len(args) == 1:
        try:
            values = list(args[0])  # Also check if the object is iterable
        except TypeError:
            raise TypeError(
                f"{type(args[0]).__name__} object is not iterable"
            ) from None
    else:
        values = args

# min_max.py
# ...

def min_max(*args, operator, key=None, default=None):
    # ...

    if not values:
        if default is None:
            raise ValueError("args is an empty sequence")
        return default

# min_max.py
# ...

def min_max(*args, operator, key=None, default=None):
    # ...

    if key is None:
        keys = values
    else:
        if callable(key):
            keys = [key(value) for value in values]
        else:
            raise TypeError(f"{type(key).__name__} object is not a callable")

# min_max.py
# ...

def min_max(*args, operator, key=None, default=None):
    # ...

    extreme_key, extreme_value = keys[0], values[0]
    for key, value in zip(keys[1:], values[1:]):
        if operator(key, extreme_key):
            extreme_key = key
            extreme_value = value
    return extreme_value

# min_max.py

from operator import gt, lt

# ...

def custom_min(*args, key=None, default=None):
    return min_max(*args, operator=lt, key=key, default=default)

def custom_max(*args, key=None, default=None):
    return min_max(*args, operator=gt, key=key, default=default)

# min_max.py

from operator import gt, lt

def min_max(*args, operator, key=None, default=None):
    if len(args) == 1:
        try:
            values = list(args[0])  # Also check if the object is iterable
        except TypeError:
            raise TypeError(
                f"{type(args[0]).__name__} object is not iterable"
            ) from None
    else:
        values = args

    if not values:
        if default is None:
            raise ValueError("args is an empty sequence")
        return default

    if key is None:
        keys = values
    else:
        if callable(key):
            keys = [key(value) for value in values]
        else:
            raise TypeError(f"{type(key).__name__} object is not a callable")

    extreme_key, extreme_value = keys[0], values[0]
    for key, value in zip(keys[1:], values[1:]):
        if operator(key, extreme_key):
            extreme_key = key
            extreme_value = value
    return extreme_value

def custom_min(*args, key=None, default=None):
    return min_max(*args, operator=lt, key=key, default=default)

def custom_max(*args, key=None, default=None):
    return min_max(*args, operator=gt, key=key, default=default)