Quick answer: Call min(iterable) or min(value1, value2, …). Use key to compare objects by a field, default when an empty iterable is valid, and remember that ties return the first minimum encountered.
The Python min() function returns the smallest item from an iterable or the smallest of several arguments. It is the standard built-in tool for finding minimum values in ordinary Python data.
The official Python documentation covers min().
Use min() when the data is already in memory and you need one smallest item. Use NumPy tools for array-heavy numeric work, and use a heap when you repeatedly need the smallest item from a changing collection.
The examples below cover the common patterns: a list of numbers, several direct arguments, default values for empty input, key functions, dictionaries, and custom records.
The main design choice is what “smallest” means for your data. Sometimes it is the lowest number. Sometimes it is the shortest string, the cheapest product, the earliest timestamp, or the object with the lowest score. The key argument is how you make that rule explicit.
Keep the comparison rule simple and deterministic. If two items compare equally, Python returns the first one it sees, so input order can decide ties.
Find The Smallest Number
Pass a list or another iterable to min().
numbers = [8, 3, 12, 5]
smallest = min(numbers)
print(smallest)
This prints 3.
The items must be comparable with each other. A list of numbers works because Python knows how to order them.
If the list may be empty, decide whether that is an error or a normal case before calling min(). Empty input without a default raises ValueError.
Compare Several Arguments
min() can also compare separate arguments.
smallest = min(14, 9, 27, 3)
print(smallest)
This form is concise when the values are already separate and you do not need to build a list first.
Use the iterable form when the number of items changes at runtime. Use direct arguments when the values are known in the code.
Both forms return one value. The difference is only how the candidates are supplied to the function.
Use default For Empty Input
min([]) raises ValueError. Use default when empty input is allowed.
numbers = []
smallest = min(numbers, default=None)
print(smallest)
The default is returned only when the iterable is empty.
Choose a default that the caller can handle clearly. None is common when “no minimum exists” is a valid result.
Do not choose a default that could be confused with real data. For example, 0 is a poor default if zero might also be a valid minimum.
Use key For Custom Ordering
The key argument tells min() how to compare items.
words = ["python", "go", "rust", "java"]
shortest = min(words, key=len)
print(shortest)
This returns the shortest word because len is used for comparison.
The original item is returned, not the key value. Here, "go" is returned, not 2.
This makes key useful for selecting a whole record while comparing only one field or derived property.
Find A Dictionary Key With The Lowest Value
Use key=dictionary.get to compare dictionary values while returning the matching key.
scores = {
"Ava": 91,
"Noah": 78,
"Mia": 84,
}
lowest_name = min(scores, key=scores.get)
print(lowest_name)
print(scores[lowest_name])
Iterating over a dictionary gives its keys, and scores.get supplies the comparison value for each key.
This pattern is useful for finding the lowest score, cheapest option, earliest timestamp, or smallest count stored in a mapping.
If you need the value as well, read it with the returned key as shown in the example. That avoids scanning the dictionary twice.
Find A Custom Record
A key function can compare objects or dictionaries by one field.
products = [
{"name": "basic", "price": 12},
{"name": "pro", "price": 29},
{"name": "trial", "price": 0},
]
cheapest = min(products, key=lambda item: item["price"])
print(cheapest)
This returns the entire dictionary for the cheapest product.
Use a named helper function instead of a lambda when the comparison rule is complex or reused in several places.
For custom classes, the same approach works with attribute access. You can pass a small helper that returns an object’s price, size, priority, or timestamp.
Common min Mistakes
Do not mix unrelated types in one call unless Python can compare them. For example, numbers and strings are not ordered against each other in modern Python.
Also remember that min() returns the first item with the smallest comparison value when there is a tie. If ties need special handling, sort with a compound key or write explicit tie logic.
For large numeric arrays, a vectorized library can be faster and more convenient. For normal Python lists, dictionaries, and records, the built-in function is usually the clearest choice.
In short, use min(items) for the smallest comparable item, default for allowed empty input, and key when the smallest item should be chosen by a derived value.
Compare An Iterable Or Arguments
The iterable form consumes one iterable, while the multiple-argument form compares the arguments directly. Do not pass a list as several arguments accidentally; use min(values) when the list itself is the input.
values = [8, 3, 5]
print(min(values))
print(min(8, 3, 5))
Use key For Records
key receives each candidate and returns the comparison value, but min returns the original candidate. This is useful for the smallest score, shortest string, earliest timestamp, or lowest-cost record.
records = [
{"name": "slow", "seconds": 4.2},
{"name": "fast", "seconds": 1.8},
]
fastest = min(records, key=lambda record: record["seconds"])
print(fastest)Handle Empty Input And Ties
min raises ValueError for an empty iterable unless default is supplied. When values tie, the first item in iteration order wins, so stable order can be part of the function’s behavior. Use a separate filter or tie-breaking key when needed.
values = []
print(min(values, default=None))
records = [("A", 2), ("B", 2)]
print(min(records, key=lambda item: item[1]))Python’s min() reference documents iterable and argument forms, key comparison, default, and tie behavior.
For related comparison helpers, compare max(), NumPy amin(), and argmin() when the smallest value or its position is the real requirement.
Frequently Asked Questions
How do I find the smallest value in Python?
Call min(iterable) or min(value1, value2, …) when the values are directly available.
How do I find the smallest object by a field?
Pass key= to compute a comparison value while returning the original object.
How do I avoid min raising on an empty iterable?
Pass default= when an empty input is valid and a fallback value is meaningful.
What happens when values tie?
min returns the first minimum encountered in the input order, so preserve or document order when tie-breaking matters.
