# Python How to Find the Largest Number in a List

To find the largest number in a list in Python:

1. Set the first element as the largest number candidate.
2. Loop through the list of numbers.
3. Update the largest number candidate if a number is greater than it.

Here is how it looks in code:

```heights = [100, 2, 300, 10, 11, 1000]

largest_number = heights[0]

for number in heights:
if number > largest_number:
largest_number = number

print(largest_number)
```

Output:

`1000`

This is the naive implementation of finding the largest number.

But there are also some useful built-in mechanisms you can use.

In this guide, you learn different ways to find the maximum value in a list in Python.

## The max() Function — Find the Largest Element of a List

In Python, there is a built-in function `max()` you can use to find the largest number in a list.

To use it, call the `max()` on a list of numbers. It then returns the greatest number in that list.

Here is an example:

```heights = [100, 2, 300, 10, 11, 1000]

max_height = max(heights)

print(max_height)```

Output:

`1000`

## Alternative Approaches to Finding the Largest Number in a List

Now you know two straightforward ways to find the largest number in a list in Python.

Let’s take a look at some more uncommon approaches.

### Reduce() Function

You can also use the `functools` `reduce()` function to find the largest number in a list.

Before we do that, it is important to understand how the `reduce()` function works.

`reduce(function, iterable)`

The reduce function takes two parameters:

1. A function that is applied for each element of an iterable.
2. An iterable, such as a list.

It then:

• Takes the first two elements of a sequence and calls the function on them.
• Takes the previous result, and calls the function on the result and the next number in the list.
• This process continues until there are no elements left in the list.

To learn more about the `reduce()` function, check this article.

Anyway, let’s use the `reduce()` function to find the largest element in a list.

#### Reduce() with the built-in max() Function

Here is an example of how you can use reduce to find the largest number in a list:

```from functools import reduce

heights = [100, 2, 300, 10, 11, 1000]

max_height = reduce(max, heights)

print(max_height)```

Output:

`1000`

The `reduce()` function applies the `max()` function for each element as described in the previous chapter.

• It starts with the two first elements and finds the largest of the two
• Then takes the result and compares it with the third element.
• This process continues until there are no numbers left in the list.

Let’s also see another, perhaps a bit more demonstrative example.

#### Reduce() with a Custom Max Function

Another way you can use `reduce()` to find the largest number in a list is by implementing the `max()` function yourself.

For example:

```from functools import reduce

heights = [100, 2, 300, 10, 11, 1000]

def my_max(x, y):
if x < y:
return y
else:
return x

max_height = reduce(my_max, heights)

print(max_height)```

Output

`1000`

#### Reduce() with a Lambda Function

And the 3rd approach is to use `reduce()` with a lambda expression.

This means you define the max function inline in the `reduce()` function call.

For example:

```from functools import reduce

heights = [100, 2, 300, 10, 11, 1000]

max_height = reduce(lambda x, y: y if x < y else x, heights)

print(max_height)```

Output:

`1000`

The `lambda x, y: y if x < y else x` part does the same as the `my_max()` function in the previous example.

Notice that the if-else statement is shortened to a one-liner expression.

### Find The Largest Number Using a Heap Queue

The built-in `heapq` module in Python comes in with an implementation of the priority queue algorithm.

In short, a heap is a binary tree where each parent node has a value less than or equal to the value of its children.

You can use the `heapq.nlargest()` function to figure out the largest number(s) in a list.

For example:

```import heapq

heights = [100, 2, 300, 10, 11, 1000]

max_height = heapq.nlargest(1, heights)[0]

print(max_height)```

Output:

`1000`

## Conclusion

Today you learned how to find the largest number in a list.

First, you used the “brute-force” method to loop through the list while keeping track of the largest element.

Then you saw how the built-in `max()` function does the job for you.

Finally, you saw uncommon alternatives, such as using `reduce()` with lambdas or a heap queue.

Each of these approaches gets the job done for you.

Feel free to pick the approach that is best for your situation.

If I had to find the largest element, I would pick the most readable approach, that is, the built-in `max()` function.

Thanks for reading. I hope you find it useful.

Happy coding!