## Unlocking the Power of Code: How to Find the Largest and Smallest Number in a List Without Built-in Functions

If you’re starting your journey into the world of programming, it’s essential to learn how to work with conditions and loops. In this article, we will be exploring two essential topics: finding the largest and smallest numbers in a list without using built-in functions, and building a reusable function to find min and max values in a list.

## 1) Finding the largest number without max()

Before diving into the code, let’s take a moment to understand the problem at hand. Imagine you have a list of numbers, and you want to find the largest one.

How would you approach this without using the max() function?

One way to solve this problem is to use a for loop.

You can create a variable called `largest_num`

and initialize it to a very small value, like -100000. Then, use the for loop to iterate over the list and check each item.

If the item is larger than the current `largest_num`

, update the variable. Here’s an example code snippet:

list_of_nums = [2, 5, 1, 9, 3]

largest_num = -100000

for num in list_of_nums:

if num > largest_num:

largest_num = num

```
```

` print(largest_num)`

In the code above, the `largest_num`

variable is initialized to -100000, which is smaller than any of the values in the list. The for loop then iterates over each element in `list_of_nums`

, and for each element, it checks whether the current number is greater than the `largest_num`

variable.

If it is, the largest number is updated to that value.

## 2) Finding the smallest number without min()

Likewise, finding the smallest number in a list is just as easy. Instead of initializing the variable with a large negative number, initialize it with a large positive number.

### Here is an example code snippet:

list_of_nums = [2, 5, 1, 9, 3]

smallest_num = 100000

for num in list_of_nums:

if num < smallest_num:
smallest_num = num
print(smallest_num)

In this code snippet, the `smallest_num`

variable is initialized with a very large positive number instead of a very small negative number. As the loop iterates, each number in the list will be compared to the current value of the `smallest_num`

variable.

If the number is smaller than the current one stored in `smallest_num`

, the variable is updated with that value.

## 3) Initializing variables for min and max values

While finding the largest and smallest numbers in a list can be accomplished with a for loop, it is not the most efficient solution. To make the process easier and reusable, you can write a function that returns both the minimum and maximum values of a given list.

Before writing the main function, let's start by initializing the variables that will hold the min and max values. For the min value, we will initialize it to a very large positive number and for the max value, a very small negative number.

### Here is an example code snippet:

def find_min_max(list_of_nums):

min_value = 1000000

max_value = -1000000

In this code snippet, the `find_min_max`

function takes a list of numbers as its argument and defines two variables to store the min and max values respectively. The `min_value`

variable is initialized to a very large positive number, and the `max_value`

variable initialized to a very small negative number.

## 4) Using for loop to update min and max values

Now that we have initialized the min and max value variables, we can create a for loop to iterate over the list and update them as necessary. Here is an example code snippet:

def find_min_max(list_of_nums):

min_value = 1000000

max_value = -1000000

for num in list_of_nums:

if num < min_value:
min_value = num
if num > max_value:

max_value = num

return (min_value, max_value)

In this code snippet, the `find_min_max`

function takes a list of numbers as its argument and defines the `min_value`

and `max_value`

variables.

The for loop then iterates over each element in the `list_of_nums`

, updating the min and max value variables as necessary. After the loop is completed, the function returns a tuple containing the min and max values.

This function can now be used to find the min and max values of any list of numbers by simply calling the function with the list of numbers as its argument. In conclusion, finding the largest and smallest numbers in a list without built-in functions can be accomplished with a for loop and basic conditional statements.

However, creating a reusable function that finds the min and max values is a more efficient and scalable solution. By following the outlined steps, you can produce a working solution that can be applied to a wide range of use-cases.

## 5) Finding the largest number in a list without max() using sorted()

In the previous section, we covered how to find the largest and smallest numbers in a list without using built-in functions, such as max() and min(). However, another approach to finding the maximum value without using the max() function is by using the `sorted()`

function.

### Using sorted() function to get a sorted list

The `sorted()`

function in Python takes an iterable and returns a new list in ascending order. If you sort the list, the last item will be the largest.

### Here is a code snippet to find the largest number:

list_of_nums = [6, 9, 1, 8, 3]

sorted_list = sorted(list_of_nums)

largest_num = sorted_list[-1]

In this code snippet, the `sorted()`

function returns a new list that is sorted in ascending order and assigns it to a variable called `sorted_list`

. To get the largest number, we can access the last index of the `sorted_list`

by using the -1 index.

### Accessing largest number in the sorted list

Using the `sorted()`

function can be useful when there is a need to obtain a sorted list alongside finding the largest item. Here's an example that combines the use of `sorted()`

and printing the last item to obtain the largest item in a list:

list_of_nums = [6, 9, 1, 8, 3]

sorted_list = sorted(list_of_nums)

print(sorted_list[-1])

You can even sort the list in descending order using the `reverse`

parameter,

list_of_nums = [6, 9, 1, 8, 3]

sorted_list = sorted(list_of_nums, reverse=True)

print(sorted_list[0])

In this code snippet, the `sorted()`

function now sorts the list in descending order since `reverse=True`

which makes the last item the smallest number.

We access the first index of `sorted_list`

by using index 0.

## 6) Finding the min and max values in a list without built-in functions using sorted()

Similar to the previous section, we can also use the `sorted()`

function to find both the minimum and maximum values of a list at the same time.

### Using sorted() function to get a sorted list

To obtain a sorted list, we would use the `sorted()`

function as explained in the previous section. Here is a code snippet for creating a function to find the min and max values of a list:

def find_min_max(list_of_nums):

sorted_list = sorted(list_of_nums)

min_value = sorted_list[0]

max_value = sorted_list[-1]

return (min_value, max_value)

In this code snippet, we define a function called `find_min_max`

that takes a list of numbers as input.

The `sorted()`

function is used to sort the list and assign the new sorted list to the `sorted_list`

variable. The minimum value in the list is now the value at the first index of the sorted list, while the maximum value is at the last index.

### Accessing smallest and largest numbers in the sorted list

The function defined in the previous section, `find_min_max`

, returns a tuple containing both the minimum and maximum values. Here is an example code snippet that uses the function to find the min and max values of a list:

list_of_nums = [6, 9, 1, 8, 3]

(min_value, max_value) = find_min_max(list_of_nums)

print("Minimum value:", min_value)

print("Maximum value:", max_value)

In this code snippet, we define `list_of_nums`

to be the list we want to find the min and max values for.

We then call the `find_min_max`

function with our `list_of_nums`

as input. Lastly, we use tuple unpacking to assign the returned min and max values to their respective variables and print them to the console.

In conclusion, using the `sorted()`

function allows us to find the maximum number in a list without using max(), and obtain both the minimum and maximum values of a list without using built-in functions like min() and max(). Python provides us with multiple ways to approach a problem, so choosing the method that works best for you and your problem can be critical.

## 7) Additional Resources

Programming is a vast field, and there is always something new to learn, especially when it comes to Python. In this section, we will look at additional resources to assist you in learning more about related topics that were discussed in the previous sections.

### Tutorials

Tutorials are an excellent way to learn new concepts and topics in programming. They can provide you with hands-on experience and practical examples of how to solve different problems.

### Here are some tutorials that may help you learn more about the topics covered in this article:

- Python for Everybody - A beginner-friendly course on Python programming that covers the basics of Python, including loops and conditions. The course also covers how to use built-in functions like max() and min().
- Python Lists - A tutorial on how to work with lists in Python, including sorting, filtering, and slicing.
- DataCamp - DataCamp offers a wide range of courses on Python programming, including courses on loops, conditions, and functions.

### Learn More

If you're interested in learning more about Python programming, here are some resources that can help you expand your knowledge and skills:

- Python Official Documentation - The official Python documentation is an extensive resource that covers all aspects of Python, including loops, conditions, and functions.
- Stack Overflow - Stack Overflow is an excellent resource for finding answers to specific programming questions. It's a community-driven site where programmers can ask and answer questions related to programming, including Python.
- Python Weekly - Python Weekly is a weekly newsletter that provides you with the latest news, articles, and tutorials related to Python programming.

## Conclusion

In conclusion, learning how to work with loops, conditions, and functions in Python is crucial for any programmer. By understanding how to find the largest and smallest numbers in a list without using built-in functions and creating reusable functions to find min and max values, you can write more efficient and scalable programs.

With the additional resources mentioned above, you can further improve your Python skills and knowledge. Remember to always keep learning and stay up-to-date with the latest trends and best practices in programming.

In summary, this article covered vital topics in Python programming, including finding the largest and smallest numbers in a list without using built-in functions, as well as creating reusable functions to find min and max values in a list. We also explored the use of `sorted()`

to obtain sorted lists and extract the smallest and largest numbers in a list.

Aspiring programmers must understand the concepts of loops, conditions, and functions in Python to write efficient, scalable code. The additional resources provided can help to expand your knowledge, skills and improve your proficiency in Python programming.

Remember to keep learning and stay up-to-date with the latest trends and best practices in programming.