Skip to main content

How to Apply a Function to Each Element of a Python List

Applying a function to every element in a list is a fundamental operation in Python data processing. Whether you are converting data types, performing mathematical calculations, or formatting strings, Python provides several ways to map functions over lists.

This guide explores the three most common techniques: List Comprehensions (the Pythonic standard), the map() function (functional style), and traditional loops.

List comprehensions provide a concise syntax to create a new list by applying an expression to each item in an existing list. This is widely considered the most "Pythonic" and readable approach.

Basic Syntax​

[function(item) for item in iterable]

Example: Squaring Numbers​

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

# ✅ Apply the logic x**2 to every item
squared = [x**2 for x in numbers]

print(f"Original: {numbers}")
print(f"Squared:  {squared}")

Output:

Original: [1, 2, 3, 4, 5]
Squared:  [1, 4, 9, 16, 25]

Example: Calling a Custom Function​

def format_price(price):
    return f"${price:.2f}"

prices = [10, 5.5, 3.99]

# ✅ Call a defined function inside the comprehension
formatted = [format_price(p) for p in prices]

print(formatted)

Output:

['$10.00', '$5.50', '$3.99']
tip

List comprehensions are generally faster than for loops because the iteration is performed at C-language speed inside the interpreter.

Method 2: Using the map() Function​

The map(function, iterable) function applies a specific function to every item of an iterable. It returns a map object (an iterator), which must be converted back to a list to see the results immediately.

Using Built-in Functions​

map is highly efficient when using Python's built-in functions written in C (like str, int, len).

str_nums = ["1", "2", "3", "4"]

# ✅ Apply int() to every string in the list
int_nums = list(map(int, str_nums))

print(f"Converted: {int_nums}")
print(f"Type: {type(int_nums[0])}")

Output:

Converted: [1, 2, 3, 4]
Type: <class 'int'>

Using Lambda Functions​

You can pair map() with lambda (anonymous) functions for quick, one-off operations.

numbers = [1, 2, 3, 4]

# ✅ Using lambda to double numbers
doubled = list(map(lambda x: x * 2, numbers))

print(doubled)

Output:

[2, 4, 6, 8]
note

If you forget to wrap map() in list(), you will get a <map object at ...> instead of the actual data.

Method 3: Traditional For Loops​

While less concise, using a standard for loop is explicit and easy to debug. It involves creating an empty list and appending transformed elements to it.

numbers = [10, 20, 30]
results = []

# ✅ Traditional iteration
for num in numbers:
    results.append(num / 2)

print(results)

Output:

[5.0, 10.0, 15.0]

Advanced: Filtering and Reducing​

Sometimes "applying a function" implies filtering data or aggregating it into a single value.

Filtering with filter()​

Use filter() to apply a function that returns True or False to decide which elements to keep.

numbers = [10, 15, 20, 25, 30]

# Keep only even numbers
evens = list(filter(lambda x: x % 2 == 0, numbers))

print(f"Evens: {evens}")

Output:

Evens: [10, 20, 30]

Aggregating with functools.reduce()​

Use reduce() to apply a rolling computation (like a cumulative sum or product) across the list.

from functools import reduce

numbers = [1, 2, 3, 4]

# Cumulative product: ((1 * 2) * 3) * 4
product = reduce(lambda x, y: x * y, numbers)

print(f"Product: {product}")

Output:

Product: 24

Conclusion​

To apply a function to a Python list:

  1. Use List Comprehensions ([func(x) for x in list]) for the best balance of readability and speed.
  2. Use map() (list(map(func, list))) when you already have a defined function or are using built-ins like str or int.
  3. Use for loops if the transformation logic is too complex to fit on one line.

Table of Contents