In this Python tutorial, We will see **what is the min() function in Python** and **how we can apply this min() function** to different data types in Python with demonstrative examples.

## What is the min() function in Python

Python’s** min() function** is a built-in function used to return the smallest item from an iterable (like a list, tuple, set, or string) or two or more arguments.

In its simplest form, this could be the smallest among the numbers, the smallest string in lexicographical order, or the smallest item in an iterable such as a Python list or a tuple. If multiple items are minimum and occur more than once, the function will return the first one encountered.

### Syntax and Parameters

Here’s the basic **syntax** of **the min() function in Python**:

`min(iterable, *[, key, default])`

Or

`min(arg1, arg2, *args[, key])`

**Parameters**:

**iterable**: An iterable like list, tuple, string, etc., from which the smallest item is to be found.******arg1, arg2, args**:*Two or more values to compare and find the smallest.**key**(optional)**:**A function to serve as a key or a basis of sort comparison.**default**(optional)**:**A value to return if the provided iterable is empty.

## Application of the min() function in Python

The **min() function** can be applied to many Data types in Python. They can be:

- Numbers
- Strings
- Lists
- Tuples
- Sets
- Dictionaries

We will see how the **min() function** works with all of these data types in Python one by one, with examples.

### Application of the min() function in Python on numbers.

The most straightforward use of** Python’s min() function** is finding the smallest number among a series of **numbers**.

Let’s just take some random numbers (Integers or Float), and try to find the minimum value out of them in Python:

`print(min(11, 22.5, 55, 88.3, 42, 64))`

**The output will be**:

`11.0`

Or, we can save these **numbers** in some **variables** and then compare those **variables** with** the min() function in Python, **

Let’s consider a scenario where we have average temperatures (in Fahrenheit) of five major cities in the USA in Python, and we want to find out which city has the lowest average temperature.

```
# Average Temperatures of major cities in Fahrenheit
new_york = 52.5
los_angeles = 63
chicago = 49.5
houston = 70
san_francisco = 57
lowest_temperature = min(new_york, los_angeles, chicago, houston, san_francisco)
print('The lowest average temp.(in F) recorded is:', lowest_temperature)
```

**The output is**:

`The lowest average temp.(in F) recorded is: 49.5`

In this Python code, we are using **the min() function** to compare the average temperatures of five major cities: New York, Los Angeles, Chicago, Houston, and San Francisco. **The min() function in Python** then returns the lowest value among these temperatures, which is 49.5, the average temperature of Chicago.

This way we can apply **the min() function to the numbers in Python**.

### Application of the min() function on strings in Python

We can use **the min() function with strings** too in Python. The function then determines the smallest string based on lexicographical order (basically, dictionary order).

Let’s consider we have names of a few US states saved as strings in Python, and we want to find out which state would come first if arranged in dictionary order, also known as lexicographical order.

```
first_state = min("Texas", "Florida", "California", "Arizona", "New York", "Alabama")
print('The first state, if we arrange this in dictionary order is :', first_state)
```

**The output is**:

`The first state, if we arrange this in dictionary order is : Alabama`

**Note:** Like **Numbers**, we can store the **strings** also in the **variable** and can compare them.

This way we can apply **the min() function on strings in Python** to find the minimum value between them.

### Application of the min() function on Python Lists

We can use **the min() function on Python lists** in Various ways:

**Case 1:** In this example, we have a **Python list with random numbers** and we will try to find the minimum value within that number stored inside the Python list using **the min() function**.

**Note:** We can do this with a **Python list containing strings** too.

```
Numbers_list = [11.5, 22, 545, 2, 402, 58, 6.91]
print(min(Numbers_list))
```

**The Output is**:

`2`

**Case 2**: **Nested lists**, or lists containing other lists, are common data structures. We can also compare numbers or strings stored within a **nested Python list using the min() function**.

Let’s say we have the average monthly rainfall (in inches) for two cities, New York and Los Angeles, for the first quarter of the year. Here is how we can find the month with the minimum rainfall:

In this example, we use **the Python min() function** twice. **The inner Python min() function **is applied to the ‘rainfall’ Python list, and it returns a list of the smallest elements from each inner list, effectively giving us the smallest rainfall for each city. Then, **the outer Python min() function** finds the smallest among these values.

```
# Average rainfall in inches
# [New York], [Los Angeles] respectively
rainfall = [[3.2, 3.1, 4.4], [2.8, 2.6, 2.3]]
lowest_rainfall = min(min(rainfall))
print(lowest_rainfall)
```

**The output is**:

`2.3`

This way we can apply **the min() function with lists in Python**.

### Application of the min() function on tuples in Python

Same like the Python list, we can easily apply **the min() on tuples in Python**.

Suppose we have a tuple containing the populations (in millions) of the five most populous cities in the USA. We want to find out which city has the smallest population among these cities.

In this example, we have a **Python tuple** of the populations of the five most populous cities in the USA. The populations are in the same order as the cities they represent (i.e., New York, Los Angeles, Chicago, Houston, and Phoenix).

When we pass this tuple to **the min() function in Python**, it goes through all the elements of the tuple and returns the smallest value it finds. In this case, the smallest population is 1.7 million, which belongs to Phoenix.

```
# Populations in millions
# New York, Los Angeles, Chicago, Houston, Phoenix respectively
city_populations = (8.4, 4.0, 2.7, 2.3, 1.7)
smallest_population = min(city_populations)
print('The smallest population(in millions) of the city is: ', smallest_population)
```

**The output is**:

`The smallest population(in millions) of the city is: 1.7`

This way we can apply **the min function in Python to find the minimum value stored in a tuple**.

### Application of the min() function in Python on sets

The** min() function** can also be used on** sets** in Python. A **set** in Python is an unordered collection of unique elements. Like **lists** and **tuples**, we can find the minimum value in a set using the **min() function**.

let’s consider a** Python set** that represents the finish times (in minutes) of the top five runners in the Boston Marathon:

In this example, the set** finish_times **contains the finish times for the top five runners in the Boston Marathon. When we pass this set to **the min() function in Python**, it iterates over all the elements in the set and returns the smallest value.

```
# Finish times in minutes
# Times for runners 1 to 5 respectively
finish_times = {125, 128, 127, 130, 132}
fastest_time = min(finish_times)
print('The fastest timing is:', fastest_time)
```

**The Output is**: In this case 125 is the smallest value. This corresponds to the fastest finish time among the top five runners.

`The fastest timing is: 125`

This way we can apply **the min() function on sets in Python** to find the minimum values stored in it.

### Application of the min() function on dictionaries in Python

We can also apply **the min() function on a Python dictionary**. Let’s check what happens when we apply:

For instance, Suppose we have a **dictionary** in Python with the names of five US states as keys and their populations in millions as values. We want to find out which state among these has the smallest population.

When we pass this** Python dictionary to the min() function**, it would normally return the key with the smallest value in lexicographical order. However, we’re interested in the state with the smallest population, not the smallest key.

To achieve this, we use **the key parameter of the min() function**, specifying **state_populations.get**. This makes **the min() function in Python** operate on the dictionary’s values rather than its keys.

**The min() function** then goes through all the values of **the Python dictionary** and returns the key of the smallest value it finds.

```
# Populations in millions
state_populations = {
"California": 39.51,
"Texas": 28.99,
"Florida": 21.48,
"New York": 19.45,
"Pennsylvania": 12.80
}
smallest_population_state = min(state_populations, key=state_populations.get)
print(smallest_population_state)
```

**The Output is**: In this case, ‘Pennsylvania’ has the smallest population of 12.80 million among the given states.

`Pennsylvania`

This way we can apply t**he min() function to a dictionary in Python**.

## Conclusion

Python’s built-in **min() function** is an incredibly powerful and versatile tool that can help find the smallest item in various types of iterable objects including **lists, tuples, sets, and dictionaries.** It can even be extended to find minimums in more complex structures such as **nested lists.**

You may also like to read:

- How to find smallest number in a Python list [9 different ways]
- Find Largest and Smallest Number in Python Without List
- Find function in Python string
- Count function in Python string

I am Bijay Kumar, a Microsoft MVP in SharePoint. Apart from SharePoint, I started working on Python, Machine learning, and artificial intelligence for the last 5 years. During this time I got expertise in various Python libraries also like Tkinter, Pandas, NumPy, Turtle, Django, Matplotlib, Tensorflow, Scipy, Scikit-Learn, etcâ€¦ for various clients in the United States, Canada, the United Kingdom, Australia, New Zealand, etc. Check out my profile.