Max arg is an empty sequence python ошибка

Since you are always initialising self.listMyData to an empty list in clkFindMost your code will always lead to this error* because after that both unique_names and frequencies are empty iterables, so fix this.

Another thing is that since you’re iterating over a set in that method then calculating frequency makes no sense as set contain only unique items, so frequency of each item is always going to be 1.

Lastly dict.get is a method not a list or dictionary so you can’t use [] with it:

Correct way is:

if frequencies.get(name):

And Pythonic way is:

if name in frequencies:

The Pythonic way to get the frequency of items is to use collections.Counter:

from collections import Counter   #Add this at the top of file.

def clkFindMost(self, parent):

        #self.listMyData = []   
        if self.listMyData:
           frequencies = Counter(self.listMyData)
           self.txtResults.Value = max(frequencies, key=frequencies.get)
        else:
           self.txtResults.Value = '' 

max() and min() throw such error when an empty iterable is passed to them. You can check the length of v before calling max() on it.

>>> lst = []
>>> max(lst)

Traceback (most recent call last):
  File "<pyshell#2>", line 1, in <module>
    max(lst)
ValueError: max() arg is an empty sequence
>>> if lst:
    mx = max(lst)
else:
    #Handle this here

If you are using it with an iterator then you need to consume the iterator first before calling max() on it because boolean value of iterator is always True, so we can’t use if on them directly:

>>> it = iter([])
>>> bool(it)
True
>>> lst = list(it)
>>> if lst:
       mx = max(lst)
    else:
      #Handle this here   

Good news is starting from Python 3.4 you will be able to specify an optional return value for min() and max() in case of empty iterable.

The max() function is built into Python and returns the item with the highest value in an iterable or the item with the highest value from two or more objects of the same type. When you pass an iterable to the max() function, such as a list, it must have at least one value to work. If you use the max() function on an empty list, you will raise the error “ValueError: max() arg is an empty sequence”.

To solve this error, ensure you only pass iterables to the max() function with at least one value. You can check if an iterable has more than one item by using an if-statement, for example,

if len(iterable) > 0: 
    max_value = max(iterable)

This tutorial will go through the error in detail and how to solve it with a code example.

ValueError: max() arg is an empty sequence

What is a Value Error in Python?

In Python, a value is a piece of information stored within a particular object. You will encounter a ValueError in Python when you use a built-in operation or function that receives an argument with the right type but an inappropriate value. Let’s look at an example of a ValueError:

value = 'string'

print(float(value))

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
print(float(value))

ValueError: could not convert string to float: 'string'

The above code throws the ValueError because the value ‘string‘ is an inappropriate (non-convertible) string. You can only convert numerical strings using the float() method, for example:

value = '5'
print(float(value))

5.0

The code does not throw an error because the float function can convert a numerical string. The value of 5 is appropriate for the float function.

The error ValueError: max() arg is an empty sequence is a ValueError because while an iterable is a valid type of object to pass to the max() function, the value it contains is not valid.

Using max() in Python

The max() function returns the largest item in an iterable or the largest of two or more arguments. Let’s look at an example of the max() function to find the maximum of three integers:

var_1 = 3
var_2 = 5
var_3 = 2

max_val = max(var_1, var_2, var_2)

print(max_val)

The arguments of the max() function are the three integer variable. Let’s run the code to get the result:

5

Let’s look at an example of passing an iterable to the max() function. In this case, we will use a string. The max() function finds the maximum alphabetical character in a string.

string = "research"

max_val = max(string)

print(max_val)

Let’s run the code to get the result:

s

When you pass an iterable the max() function, it must contain at least one value. The max() function cannot return the largest item if no items are present in the list. The same applies to the min() function, which finds the smallest item in a list.

Example: Returning a Maximum Value from a List using max() in Python

Let’s write a program that finds the maximum number of bottles sold for different drinks across a week. First, we will define a list of drinks:

drinks = [

{"name":"Coca-Cola", "bottles_sold":[10, 4, 20, 50, 29, 100, 70]},

{"name":"Fanta", "bottles_sold":[20, 5, 10, 50, 90, 10, 50]},

{"name":"Sprite", "bottles_sold":[33, 10, 8, 7, 34, 50, 21]},

{"name":"Dr Pepper", "bottles_sold":[]}

]

The list contains four dictionaries. Each dictionary contains the name of a drink and a list of the bottles sold over seven days. The drink Dr Pepper recently arrived, meaning no bottles were sold. Next, we will iterate over the list using a for loop and find the largest amount of bottles sold for each drink over seven days.

for d in drinks:

    most_bottles_sold = max(d["bottles_sold"])

    print("The largest amount of {} bottles sold this week is {}.".format(d["name"], most_bottles_sold))

We use the max() function in the above code to get the largest item in the bottles_sold list. Let’s run the code to get the result:

The largest amount of Coca-Cola bottles sold this week is 100.
The largest amount of Fanta bottles sold this week is 90.
The largest amount of Sprite bottles sold this week is 50.

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
      1 for d in drinks:
      2     most_bottles_sold = max(d["bottles_sold"])
      3     print("The largest amount of {} bottles sold this week is {}.".format(d["name"], most_bottles_sold))
      4 

ValueError: max() arg is an empty sequence

The program raises the ValueError because Dr Pepper has an empty list.

Solution

To solve this error, we can add an if statement to check if any bottles were sold in a week before using the max() function. Let’s look at the revised code:

for d in drinks:

    if len(d["bottles_sold"]) > 0:

        most_bottles_sold = max(d["bottles_sold"])

        print("The largest amount of {} bottles sold this week is {}.".format(d["name"], most_bottles_sold)

    else:

        print("No {} bottles were sold this week.".format(d["name"]))

The program will only calculate the maximum amount of bottles sold for a drink if it was sold for at least one day. Otherwise, the program will inform us that the drink was not sold for that week. Let’s run the code to get the result:

The largest amount of Coca-Cola bottles sold this week is 100.
The largest amount of Fanta bottles sold this week is 90.
The largest amount of Sprite bottles sold this week is 50.
No Dr Pepper bottles were sold this week.

The program successfully prints the maximum amount of bottles sold for Coca-Cola, Fanta, and Sprite. The bottles_sold list for Dr Pepper is empty; therefore, the program informs us that no Dr Pepper bottles were sold this week.

Summary

Congratulations on reading to the end of this tutorial! The error: “ValueError: max() arg is an empty sequence” occurs when you pass an empty list as an argument to the max() function. The max() function cannot find the largest item in an iterable if there are no items. To solve this, ensure your list has items or include an if statement in your program to check if a list is empty before calling the max() function.

For further reading of ValueError, go to the articles:

• How to Solve Python ValueError: cannot convert float nan to integer
• How to Solve Python ValueError: if using all scalar values, you must pass an index

For further reading on using the max() function, go to the article:

How to Find the Index of the Max Value in a List in Python

Go to the Python online courses page to learn more about coding in Python for data science and machine learning.

Have fun and happy researching!

The max() method only works if you pass a sequence with at least one value into the method.

If you try to find the largest item in an empty list, you’ll encounter the error “ValueError: max() arg is an empty sequence”.

In this guide, we talk about what this error means and why you may encounter it. We walk through an example to help you figure out how to resolve this error.

ValueError: max() arg is an empty sequence

The max() method lets you find the largest item in a list. It is similar to the min() method which finds the smallest item in a list.

For this method to work, max() needs a sequence with at least one value. This is because you cannot find the largest item in a list if there are no items. The largest item is non-existent because there are no items to search through.

A variation of the “ValueError: max() arg is an empty sequence” error is found when you try to pass an empty list into the min() method. This error is “ValueError: min() arg is an empty sequence”. This min() error occurs for the same reason: you cannot find the smallest value in a list with no values.

An Example Scenario

We’re going to build a program that finds the highest grade a student has earned in all their chemistry tests. To start, define a list of students:

students = [
	   { "name": "Ron", "grades": [75, 92, 84] },
	   { "name": "Katy", "grades": [92, 86, 81] },
	   { "name": "Rachel", "grades": [64, 72, 72] },
	   { "name": "Miranda", "grades": [] }
]

Our list of students contains four dictionaries. These dictionaries contain the names of each student as well as a list of the grades they have earned. Miranda does not have any grades yet because she has just joined the chemistry class.

Next, use a for loop to go through each student in our list of students and find the highest grade each student has earned and the average grade of each student:

for s in students:
	     highest_grade = max(s["grades"])
	     average_grade = round(sum(s["grades"]) / len(s["grades"]))
	     print("The highest grade {} has earned is {}. Their average grade is {}.".format(s["name"], highest_grade, average_grade))

We use the max() function to find the highest grade a student has earned. To calculate a student’s average grade, we divide the total of all their grades by the number of grades they have received.

We round each student’s average grade to the nearest whole number using the round() method.

Run our code and see what happens:

The highest grade Ron has earned is 92. Their average grade is 84.
The highest grade Katy has earned is 92. Their average grade is 86.
The highest grade Rachel has earned is 72. Their average grade is 69.
Traceback (most recent call last):
  File "main.py", line 10, in <module>
	     highest_grade = max(s["grades"])
ValueError: max() arg is an empty sequence

Our code runs successfully until it reaches the fourth item in our list. We can see Ron, Katy, and Rachel’s highest and average grades. We cannot see any values for Miranda.

The Solution

Our code works on the first three students because each of those students have a list of grades with at least one grade. Miranda does not have any grades yet. 

Because Miranda does not have any grades, the max() function fails to execute. max() cannot find the largest value in an empty list.

To solve this error, see if each list of grades contains any values before we try to calculate the highest grade in a list. If a list contains no values, we should show a different message to the user.

Let’s use an “if” statement to check if a student has any grades before we perform any calculations:

for s in students:
	     if len(s["grades"]) > 0:
	               highest_grade = max(s["grades"])
	               average_grade = round(sum(s["grades"]) / len(s["grades"]))
	               print("The highest grade {} has earned is {}. Their                average grade is {}.".format(s["name"], highest_grade, average_grade))
	     else:
		           print("{} has not earned any grades.".format(s["name"]))

Our code above will only calculate a student’s highest and average grade if they have earned at least one grade. Otherwise, the user will be informed that the student has not earned any grades. Let’s run our code:

The highest grade Ron has earned is 92. Their average grade is 84.
The highest grade Katy has earned is 92. Their average grade is 86.
The highest grade Rachel has earned is 72. Their average grade is 69.
Miranda has not earned any grades.

Our code successfully calculates the highest and average grades for our first three students. When our code reaches Miranda, our code does not calculate her highest and average grades. Instead, our code informs us that Miranda has not earned any grades yet.

Conclusion

The “ValueError: max() arg is an empty sequence” error is raised when you try to find the largest item in an empty list using the max() method.

To solve this error, make sure you only pass lists with at least one value through a max() statement. Now you have the knowledge you need to fix this problem like a professional coder!

In Python, an inbuilt function “max()” is used in a program to find the maximum value of the input sequence. Trying to execute the “max()” function on an empty sequence will throw the “max() arg is an empty sequence” error in Python. To resolve this error, various solutions are provided by Python.

This Python write-up will give you the reason and various solutions for “ValueError: max() arg is an empty sequence”.

• Reason: Passing Empty Sequence
• Solution 1: Passing Sequence With Values
• Solution 2: Using the “default” Parameter
• Solution 3: Using len() Function
• Solution 4: Using try-except

Reason: Passing Empty Sequence

One of the prominent reasons which cause this error in Python programs is initializing an empty sequence as an argument to the “max()” function.

The above snippet shows “ValueError” because an empty dictionary sequence “dict_value” is passed inside the max() function.

Solution 1: Passing Sequence With Values

To resolve this error, a sequence containing at least one value must be passed to the max() function.

Code:

dict_value = {5:'Lily', 10: 'John'}
Output = max(dict_value)
print(Output)

In the above code, a sequence “dict_value” with multiple elements is initialized in the program. The “max()” function accepts the “dict_value” variable as an argument and returns the dictionary key having the maximum value.

Output:

The above output shows that the max() function retrieves the maximum dictionary key from the input dictionary sequence.

Solution 2: Using the “default” Parameter

This error can also be overcome in Python by assigning the “default” parameter value to “0”.

Code:

dict_value = {}
Output = max(dict_value, default=0)
print(Output)

In the above code, the dictionary variable “dict_value” is initialized with an empty value. The “max()” function accepts two arguments, the input variable “dict_Value” and the default parameter “default=0”. Whenever the input sequence is empty, the “max()” function returns the value “0” by default.

Output:

The above output verified that the input sequence is empty.

Solution 3: Using len() Function

To overcome this error, the “len()” function is also used in Python programs. The “len()” function is used along with the “if-else” statement to get the length and perform the operation on the input sequence based on the specified condition.

Code;

dict_value = {}
if len(dict_value)>0:
    Output = max(dict_value)
    print(Output)
else:
    print('Input Sequence is Empty')

In the above code, the “dict_value” dictionary sequence variable is initialized in the program. The “max()” function will be used on the input sequences if the length of the sequence is greater than “0”; otherwise, the “else” block will execute.

Output:

The above output shows that the input sequence is empty.

Solution 4: Using try-except

The “try-except” is also used to handle the “ValueError: max() arg is an empty sequence” in Python. Let’s see it via the following code:

Code:

dict_value = {}

try: 
    Output = max(dict_value)
    print(Output)
except:
    print('Input Sequence is Empty')

In the above code, the variable “dict_value” is initialized in the program. The “try” block executes its code and finds the maximum value of the input sequence using the “max()” function. But if the error arises, the “except” block will execute its code.

Output:

The above output shows that the “except” block executes its code because the input sequence is empty.

Conclusion

The “ValueError: max() arg is an empty sequence” occurs when a user tries to pass an empty sequence as an argument to the max() function. To resolve this error, various solutions are used in Python, such as passing sequence value, using default parameters, using the len() function, and using the try-except block. The “len()” function can be utilized along with the “if-else” statement to resolve this error. This article delivered multiple solutions for the error “max() arg is an empty sequence” in Python.

ValueError: max( ) arg is an empty sequence

In this article, we will learn about the error ValueError: max( ) arg is an empty sequence.
In python, the max( ) method returns the largest or greatest value in an iterable object.
An iterable object could be anything a list, a tuple, a set, or a dictionary.

Let’s understand it more with the help of an example.

Example:

#Creating list 'MyList'
MyList= [ ]

#Using max() method
print(max(MyList))

Output:

file "intobj.py", line 5, in <module>
print(max(MyList))
ValueError: max() arg is an empty sequence

In the above example, we created an empty list i.e a list with no items. Then we passed it as an argument for max( ) method. Then, when we tried compiling the program. We encountered an error in line 5 i.e ValueError: max() arg is an empty sequence. This Is because max( ) method has an empty iterable as an argument.

Solution: How the max method works when passed a non-empty list?

Example:

#Creating list ‘MyList’
MyList= [3,34,123]

#Using max() method
print(max(MyList))

Output:

123

In the above example we created a list with 3 items in it. Then we passed ‘MyList’ as an argument in max( ) method. And the max( ) method returned the largest number among the 3 available numbers or items.

When I run the code like below.
I’ve got stack at the titled error.
why??

Using TensorFlow backend.
2018-05-22 11:47:25.286883: I tensorflow/core/platform/cpu_feature_guard.cc:137] Your CPU supports instructions that this TensorFlow binary was not compiled to use: SSE4.2 AVX AVX2 FMA
Epoch 1/15
Traceback (most recent call last):
File «test.py», line 9, in
model.train(x_train, y_train, x_valid, y_valid)
File «/Users/norio.kosaka/anaconda3/envs/py36/lib/python3.6/site-packages/anago/wrapper.py», line 50, in train
trainer.train(x_train, y_train, x_valid, y_valid)
File «/Users/norio.kosaka/anaconda3/envs/py36/lib/python3.6/site-packages/anago/trainer.py», line 51, in train
callbacks=callbacks)
File «/Users/norio.kosaka/anaconda3/envs/py36/lib/python3.6/site-packages/keras/legacy/interfaces.py», line 91, in wrapper
return func(*args, **kwargs)
File «/Users/norio.kosaka/anaconda3/envs/py36/lib/python3.6/site-packages/keras/engine/training.py», line 2145, in fit_generator
generator_output = next(output_generator)
File «/Users/norio.kosaka/anaconda3/envs/py36/lib/python3.6/site-packages/keras/utils/data_utils.py», line 770, in get
six.reraise(value.class, value, value.traceback)
File «/Users/norio.kosaka/anaconda3/envs/py36/lib/python3.6/site-packages/six.py», line 693, in reraise
raise value
File «/Users/norio.kosaka/anaconda3/envs/py36/lib/python3.6/site-packages/keras/utils/data_utils.py», line 635, in _data_generator_task
generator_output = next(self._generator)
File «/Users/norio.kosaka/anaconda3/envs/py36/lib/python3.6/site-packages/anago/reader.py», line 137, in data_generator
yield preprocessor.transform(X, y)
File «/Users/norio.kosaka/anaconda3/envs/py36/lib/python3.6/site-packages/anago/preprocess.py», line 115, in transform
sents, y = self.pad_sequence(words, chars, y)
File «/Users/norio.kosaka/anaconda3/envs/py36/lib/python3.6/site-packages/anago/preprocess.py», line 148, in pad_sequence
word_ids, sequence_lengths = pad_sequences(word_ids, 0)
File «/Users/norio.kosaka/anaconda3/envs/py36/lib/python3.6/site-packages/anago/preprocess.py», line 197, in pad_sequences
max_length = len(max(sequences, key=len))
ValueError: max() arg is an empty sequence

import anago
from anago.reader import load_data_and_labels

x_train, y_train = load_data_and_labels('./data/train.txt')
x_valid, y_valid = load_data_and_labels('./data/valid.txt')
x_test, y_test = load_data_and_labels('./data/test.txt')

model = anago.Sequence()
model.train(x_train, y_train, x_valid, y_valid)
model.eval(x_test, y_test)
words = 'President Obama is speaking at the White House.'.split()
model.analyze(words)

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)