# Applying a Function to a List in Python

## Introduction

Python provides a variety of built-in functions that can be used to manipulate lists. However, sometimes we may need to apply a custom function to every element in a list. In such cases, we can use the map() function in Python.

## What is a function?

In Python, a function is a block of code that performs a specific task. It takes an input (arguments) and returns an output. Functions are used to break down large programs into smaller, more manageable pieces, making them easier to read, test, and maintain.

For example, let’s say we have a list of numbers and we want to find the square of each number in the list. We can define a function called square that takes in a number as an argument and returns its square:


def square(num):
return num ** 2


Now, we can apply this function to each item in our list using a loop or list comprehension:


my_list = [1, 2, 3, 4, 5]
squared_list = []

# Using a loop
for num in my_list:
squared_list.append(square(num))

# Using list comprehension
squared_list = [square(num) for num in my_list]


Both methods will produce the same output: [1, 4, 9, 16, 25].

Functions are an essential aspect of programming and allow us to write reusable code that can be used in different parts of our program.

## What is a list in Python?

In Python, a list is a collection of items that are stored in a specific order. Lists are one of the most commonly used data types in Python and can contain elements of different data types such as integers, strings, and even other lists.

We can create a list by enclosing a comma-separated sequence of elements in square brackets. For example, let’s create a list of numbers:


numbers = [1, 2, 3, 4, 5]


We can access individual elements of a list using indexing. The index starts from 0 for the first element and goes up to n-1 for the nth element of the list. For example:


print(numbers[0]) # Output: 1
print(numbers[2]) # Output: 3


Lists are mutable, which means we can change their contents by reassigning new values to specific indices. For example:


numbers[0] = 10
print(numbers) # Output: [10, 2, 3, 4, 5]


In addition to indexing, we can also slice lists to get a subset of elements. Slicing is done by specifying the start and end indices separated by a colon. For example:


print(numbers[1:3]) # Output: [2, 3]


Finally, we can apply functions to all elements of a list using loops or built-in functions such as map(). Applying a function to each element of a list is useful when we want to perform some operation on all elements of the list at once. We will cover this topic in more detail later in this post.

## How to apply a function to a list in Python

Python provides multiple ways to apply a function to all the elements in a list. In this section, we will explore three common methods: using a for loop, using the map() function, and using list comprehension.

### Using a for loop

One way to apply a function to each element of a list is by iterating over the list using a for loop and applying the function to each element inside the loop. Here’s an example:


numbers = [1, 2, 3, 4, 5]

# Define a function that squares its input
def square(x):
return x ** 2

# Use a for loop to apply the square() function to each element of the numbers list
squared_numbers = []
for num in numbers:
squared_numbers.append(square(num))

print(squared_numbers) # Output: [1, 4, 9, 16, 25]


In this example, we define a function called square() that takes an input x and returns its square. We then use a for loop to iterate over each element in the numbers list and apply the square() function to it. The resulting squared numbers are stored in a new list called squared_numbers.

### Using map() function

Another way to apply a function to all elements of a list is by using the map() function. The map() function takes two arguments – the first argument is the function that you want to apply and the second argument is the iterable (in our case, it’s a list). Here’s an example:


numbers = [1, 2, 3, 4, 5]

# Define a function that cubes its input
def cube(x):
return x ** 3

# Use map() to apply cube() function to each element of the numbers list
cubed_numbers = list(map(cube, numbers))

print(cubed_numbers) # Output: [1, 8, 27, 64, 125]


In this example, we define a function called cube() that takes an input x and returns its cube. We then use the map() function to apply the cube() function to each element in the numbers list. The resulting cubed numbers are stored in a new list called cubed_numbers.

### Using list comprehension

Finally, we can also use list comprehension to apply a function to all elements of a list. List comprehension provides a shorter syntax compared to using a for loop. Here’s an example:


numbers = [1, 2, 3, 4, 5]

# Define a function that doubles its input
def double(x):
return x * 2

# Use list comprehension to apply double() function to each element of the numbers list
doubled_numbers = [double(num) for num in numbers]

print(doubled_numbers) # Output: [2, 4, 6, 8, 10]


In this example, we define a function called double() that takes an input x and returns its double. We then use list comprehension to apply the double() function to each element in the numbers list. The resulting doubled numbers are stored in a new list called doubled_numbers.

## Examples of applying functions to lists in Python

Python provides a straightforward way to apply a function to each element of a list using the map() function. The map() function takes two arguments: the function to apply and the list to apply it to. It returns a new list with the function applied to each element in the original list.

Here are some examples of applying functions to lists in Python:

## Applying mathematical functions to a list of numbers

Let’s say we have a list of numbers and we want to apply a mathematical function, such as squaring each number or finding the square root of each number. We can use the map() function to apply these functions to each element in the list.


# Squaring each number in a list
numbers = [1, 2, 3, 4, 5]
squared_numbers = map(lambda x: x**2, numbers)
print(list(squared_numbers)) # Output: [1, 4, 9, 16, 25]

# Finding the square root of each number in a list
numbers = [4, 9, 16, 25]
sqrt_numbers = map(lambda x: math.sqrt(x), numbers)
print(list(sqrt_numbers)) # Output: [2.0, 3.0, 4.0, 5.0]


## Applying string functions to a list of strings

Similarly, we can apply string functions to a list of strings using the map() function. For example, let’s say we have a list of names and we want to convert them all to uppercase.


names = ['alice', 'bob', 'charlie']
upper_names = map(lambda x: x.upper(), names)
print(list(upper_names)) # Output: ['ALICE', 'BOB', 'CHARLIE']


## Applying custom functions to a list of values

We can also define our own custom functions and apply them to a list of values using the map() function. For example, let’s say we have a list of temperatures in Celsius and we want to convert them to Fahrenheit.


# Custom function to convert Celsius to Fahrenheit
def celsius_to_fahrenheit(celsius):
return (celsius * 9/5) + 32

temperatures_c = [0, 10, 20, 30]
temperatures_f = map(celsius_to_fahrenheit, temperatures_c)
print(list(temperatures_f)) # Output: [32.0, 50.0, 68.0, 86.0]


In summary, the map() function is a powerful tool for applying functions to each element in a list. We can use it to apply mathematical functions to a list of numbers, string functions to a list of strings, or our own custom functions to a list of values.

## Conclusion

In conclusion, applying a function to a list in Python can be incredibly useful and efficient. It allows us to perform complex operations on large amounts of data in just a few lines of code.

We learned that there are several ways to apply a function to a list in Python, including using a for loop, the map() function, and list comprehension. Each method has its own advantages and disadvantages, and the choice largely depends on the specific use case.

It’s important to remember that applying a function to a list can also be resource-intensive, especially when dealing with large datasets. Therefore, it’s crucial to optimize our code and consider alternative approaches when necessary.

Overall, mastering the art of applying functions to lists is an essential skill for any Python programmer. With this knowledge in hand, we can tackle complex data analysis tasks with ease and efficiency.
Interested in learning more? Check out our Introduction to Python course!

##### Pierian Training
Pierian Training is a leading provider of high-quality technology training, with a focus on data science and cloud computing. Pierian Training offers live instructor-led training, self-paced online video courses, and private group and cohort training programs to support enterprises looking to upskill their employees.

## You May Also Like

### Guide to NLTK – Natural Language Toolkit for Python

Introduction Natural Language Processing (NLP) lies at the heart of countless applications we use every day, from voice assistants to spam filters and machine translation. It allows machines to understand, interpret, and generate human language, bridging the gap between humans and computers. Within the vast landscape of NLP tools and techniques, the Natural Language Toolkit […]

### GridSearchCV with Scikit-Learn and Python

Introduction In the world of machine learning, finding the optimal set of hyperparameters for a model can significantly impact its performance and accuracy. However, searching through all possible combinations manually can be an incredibly time-consuming and error-prone process. This is where GridSearchCV, a powerful tool provided by Scikit-Learn library in Python, comes to the rescue. […]

### Plotting Time Series in Python: A Complete Guide

Introduction Time series data is a type of data that is collected over time at regular intervals. It can be used to analyze trends, patterns, and behaviors over time. In order to effectively analyze time series data, it is important to visualize it in a way that is easy to understand. This is where plotting […]