How to Apply a Function to Every Element in a List in Python

Transforming a list of data, known as mapping, is a fundamental operation in programming. Whether you need to square numbers, uppercase strings, or parse objects, Python offers several effective approaches.

This guide covers the three main techniques and when to use each one.

Using List Comprehensions

For most cases, list comprehensions are the recommended approach. They are readable, fast, and considered the most Pythonic solution.

prices = [10.00, 20.00, 30.00]

# Add 10% tax to every price
taxed_prices = [price * 1.10 for price in prices]

print(taxed_prices)

Output:

[11.0, 22.0, 33.0]

Applying Custom Functions

def format_currency(amount: float) -> str:
    return f"${amount:.2f}"

prices = [10.00, 20.00, 30.00]
formatted = [format_currency(price) for price in prices]

print(formatted)

Output:

['$10.00', '$20.00', '$30.00']

Filtering While Transforming

List comprehensions can filter and transform in a single expression:

numbers = range(10)

# Square only even numbers
even_squares = [x ** 2 for x in numbers if x % 2 == 0]

print(even_squares)

Output:

[0, 4, 16, 36, 64]

Using the map() Function

The map() function comes from functional programming. It applies a function to every item in an iterable.

names = ["alice", "bob", "charlie"]

# Apply str.upper to each name
upper_names = list(map(str.upper, names))

print(upper_names)

Output:

['ALICE', 'BOB', 'CHARLIE']

Iterator Return Value

The map() function returns an iterator, not a list. You must wrap it with list() if you need to access elements multiple times or see the results directly.

Using map() with Lambda Functions

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

squared = list(map(lambda x: x ** 2, numbers))

print(squared)

Output:

[1, 4, 9, 16, 25]

Mapping Multiple Iterables

The map() function can apply a function to corresponding elements from multiple iterables:

prices = [100, 200, 300]
discounts = [0.1, 0.2, 0.15]

final_prices = list(map(lambda p, d: p * (1 - d), prices, discounts))

print(final_prices)

Output:

[90.0, 160.0, 255.0]

Using NumPy for Numerical Data

When working with large numerical datasets, standard Python lists become slow. NumPy arrays support vectorization, which applies operations to entire arrays at once using optimized C code.

import numpy as np

numbers = np.array([1, 2, 3, 4, 5])

# Operations apply to all elements simultaneously
squared = numbers ** 2
doubled = numbers * 2
roots = np.sqrt(numbers)

print(f"Squared: {squared}")
print(f"Doubled: {doubled}")
print(f"Roots: {roots}")

Output:

Squared: [ 1  4  9 16 25]
Doubled: [ 2  4  6  8 10]
Roots: [1.         1.41421356 1.73205081 2.         2.23606798]

Applying Custom Functions with NumPy

Use np.vectorize() to apply custom Python functions to arrays:

import numpy as np

def classify_score(score):
    if score >= 90:
        return 'A'
    elif score >= 80:
        return 'B'
    elif score >= 70:
        return 'C'
    return 'F'

scores = np.array([95, 82, 67, 73, 88])
classify = np.vectorize(classify_score)

grades = classify(scores)
print(grades)

Output:

['A' 'B' 'F' 'C' 'B']

Performance Note

While np.vectorize() is convenient, it doesn't provide the same performance benefits as true NumPy vectorization. For maximum speed, use built-in NumPy operations and np.where() for conditional logic.

Choosing the Right Method

Method	Syntax	Best For
List Comprehension	[f(x) for x in items]	General use. Best readability and flexibility.
map()	map(func, items)	When you have an existing function to apply.
NumPy	array * 2	Large numerical datasets. Essential for data science.

Performance Comparison

For small to medium lists, the performance difference is negligible. For large datasets:

import time
import numpy as np

# Create a large dataset
data = list(range(1_000_000))
np_data = np.array(data)

# List comprehension
start = time.time()
result = [x * 2 for x in data]
print(f"List comprehension: {time.time() - start:.4f}s")

# map()
start = time.time()
result = list(map(lambda x: x * 2, data))
print(f"map(): {time.time() - start:.4f}s")

# NumPy
start = time.time()
result = np_data * 2
print(f"NumPy: {time.time() - start:.4f}s")

Typical Output:

List comprehension: 0.0272s
map(): 0.1681s
NumPy: 0.0078s

Summary

• Use list comprehensions as your default choice for readability and flexibility.
• Use map() when applying an existing function, especially with multiple iterables.
• Use NumPy for numerical computations on large datasets where performance matters.