Login
Menu

map() in Python: How to Apply a Function to Every Item of an Iterable

Python’s `map()` function does one job, and it does it well: it applies a function to every item of an iterable and gives you back the transformed results. If you have a list of words and you want them all uppercased, or a list of numbers you want doubled, `map()` is built for exactly that. The catch that trips up nearly every beginner is that `map()` does not hand you a list. It hands you a lazy `map` object that produces results on demand. Once you understand that single behavior, `map()` becomes one of the most useful tools in your Python toolkit.

This guide walks through `map()` from first principles with heavy, runnable code: the basics, lambdas, multiple iterables, the famous map-versus-list-comprehension debate, and the lazy evaluation that makes `map()` scale to huge datasets.

Key Takeaways
• `map(func, iterable)` applies `func` to every element of `iterable`.
• `map()` returns a lazy `map` object (an iterator), not a list. Wrap it in `list()` to see the values: `list(map(func, data))`.
• It works with named functions (`map(str.upper, words)`) and lambdas (`map(lambda x: x*2, nums)`).
• With multiple iterables, the function receives one argument per iterable: `map(func, list1, list2)`.
• For simple transforms, a list comprehension is often more readable; `map()` shines for existing functions and lazy pipelines over large data.

What does map() actually do in Python?

The signature is short and the mental model is simple:

“`python map(func, iterable) “`

`map()` takes a function and an iterable, then calls that function once for each element, in order. The result is a new iterable of return values. Here is the most basic possible example:

“`python def square(n): return n * n

numbers = [1, 2, 3, 4, 5] result = map(square, numbers)

print(list(result)) “`

Output:

“` [1, 4, 9, 16, 25] “`

`map()` walked through `[1, 2, 3, 4, 5]`, called `square()` on each value, and produced `[1, 4, 9, 16, 25]`. You never wrote a loop. You described *what* transformation to apply, and `map()` handled the iteration for you.

A common real-world use is applying a built-in or method to every item. To uppercase a list of words, pass `str.upper` directly:

“`python words = [“hosting”, “python”, “server”] shouted = map(str.upper, words)

print(list(shouted)) “`

Output:

“` [‘HOSTING’, ‘PYTHON’, ‘SERVER’] “`

Notice you pass `str.upper` *without* parentheses. You are handing `map()` the function itself, not calling it. `map()` is the one that calls it, once per item.

Why does map() return a “map object” instead of a list?

Here is where almost everyone gets confused. Run this:

“`python nums = [10, 20, 30] doubled = map(lambda x: x * 2, nums) print(doubled) “`

Output:

“`

“`

You expected `[20, 40, 60]`. Instead you got `

`. Many beginners conclude `map()` is broken. It is not. `map()` returns a lazy iterator, and printing the iterator just prints its identity, not its contents.

To get a concrete list, materialize it:

“`python nums = [10, 20, 30] doubled = list(map(lambda x: x * 2, nums)) print(doubled) “`

Output:

“` [20, 40, 60] “`

The single behavior that trips up Python beginners with `map()` is actually a feature, not a bug. `map()` returns a lazy `map` object, not a list, which means `map(func, data)` computes nothing at the moment you call it. People run `map()`, print the result, and see something like `

` instead of their transformed values, and they conclude `map` is broken. In reality `map` is being efficient: it produces results one at a time, on demand, rather than building an entire list in memory up front.

This laziness is genuinely useful. You can `map` over a million-line file without loading a million results into RAM, and you can chain `map` and `filter` together so that only the items actually consumed get computed. But it does mean you must explicitly materialize the result when you want a concrete list: `list(map(…))`. The mental model that fixes everything: `map` sets up a pipeline that’s ready to transform each item as it’s pulled, not a finished list of transformed items. Once you internalize “`map` returns a lazy iterator, wrap it in `list()` to see the values,” the `

` confusion disappears, and you also understand why Python’s `map`, `filter`, and friends scale to enormous datasets: they don’t do the work until something asks for the next item. (And in modern Python, when readability matters more than laziness, a list comprehension often expresses the same transformation more clearly. `map()` shines for existing functions and lazy pipelines.)

There is a subtle consequence: a `map` object is an iterator, so it is exhausted after one pass.

“`python result = map(str.upper, [“a”, “b”, “c”]) print(list(result)) # first pass print(list(result)) # second pass — already consumed “`

Output:

“` [‘A’, ‘B’, ‘C’] [] “`

The second `list()` is empty because the iterator was already drained. If you need the values more than once, store the materialized list.

How do you use map() with a lambda function?

You do not need a pre-defined function. When the transformation is small and one-off, an inline `lambda` keeps the code tight:

“`python prices = [100, 250, 80, 999]

with_tax = list(map(lambda p: round(p * 1.18, 2), prices)) print(with_tax) “`

Output:

“` [118.0, 295.0, 94.4, 1178.82] “`

The `lambda p: round(p * 1.18, 2)` is an anonymous function that takes one argument `p`. `map()` calls it once per price. If your logic gets longer than a single expression, define a named function instead, for readability and testing.

If you are new to anonymous functions, see for a full breakdown of when lambdas help and when they hurt.

How do you use map() over multiple iterables?

This is `map()`’s underrated superpower. When you pass more than one iterable, the function must accept that many arguments, and `map()` pulls one item from each iterable per call, pairing them up positionally.

“`python list1 = [1, 2, 3, 4] list2 = [10, 20, 30, 40]

sums = list(map(lambda a, b: a + b, list1, list2)) print(sums) “`

Output:

“` [11, 22, 33, 44] “`

`map()` called `lambda a, b: a + b` with `(1, 10)`, then `(2, 20)`, then `(3, 30)`, then `(4, 40)`. This pairwise pattern works with any number of iterables:

“`python quantities = [2, 5, 1] unit_prices = [50, 20, 300] discounts = [0.10, 0.00, 0.25]

totals = list(map( lambda q, price, disc: round(q * price * (1 – disc), 2), quantities, unit_prices, discounts )) print(totals) “`

Output:

“` [90.0, 100.0, 225.0] “`

One important detail: if the iterables differ in length, `map()` stops at the shortest one.

“`python a = [1, 2, 3, 4, 5] b = [10, 20, 30]

print(list(map(lambda x, y: x + y, a, b))) “`

Output:

“` [11, 22, 33] “`

The extra items `4` and `5` in `a` are simply ignored, because `b` ran out first.

Should you use map() or a list comprehension?

This is one of the longest-running style debates in Python. Both express “transform every item,” and for a simple operation they are interchangeable:

“`python nums = [1, 2, 3, 4]

squared_map = list(map(lambda x: x ** 2, nums))

squared_comp = [x ** 2 for x in nums]

print(squared_map) print(squared_comp) “`

Output:

“` [1, 4, 9, 16] [1, 4, 9, 16] “`

The community generally leans toward the list comprehension for readability when the transformation is an inline expression. `[x ** 2 for x in nums]` reads almost like English and avoids the `lambda` boilerplate. But `map()` is cleaner when you already have a named function to apply, because it skips the throwaway loop variable entirely.

Situation Cleaner choice Why
Applying an existing named function (`str.upper`, `int`, a helper) `map(func, data)` No throwaway variable, reads as “apply func to data”
Inline expression like `x * 2` or `x ** 2` List comprehension `[x*2 for x in data]` More readable, no `lambda` noise
You also need to filter items List comprehension with `if` `map` alone can’t filter; combining `map`+`filter` is harder to read
Transforming huge or streaming data lazily `map(func, data)` Lazy iterator, low memory; doesn’t build the whole list
Combining two or more sequences pairwise `map(func, a, b)` One clean call vs. `zip()` inside a comprehension

For more on the comprehension side of this comparison, see and the broader fundamentals in .

How does map() compare to a plain for loop?

Before `map()` or comprehensions, you would write an explicit loop:

“`python words = [“delhi”, “mumbai”, “chennai”]

result = [] for w in words: result.append(w.title()) print(result) “`

Output:

“` [‘Delhi’, ‘Mumbai’, ‘Chennai’] “`

The same thing with `map()` collapses to one line:

“`python words = [“delhi”, “mumbai”, “chennai”] print(list(map(str.title, words))) “`

Output:

“` [‘Delhi’, ‘Mumbai’, ‘Chennai’] “`

The `for` loop is more flexible. It can do multiple operations per iteration, branch with `if`/`else`, log, or break early. Reach for `map()` when the loop body is purely “transform this one item.” If the loop is doing real work beyond a single transformation, keep the explicit loop.

Approach Best use
`map(func, iterable)` Apply one existing function to every item; lazy, memory-light pipelines
List comprehension Inline transformations and filtering; most readable for simple cases
`for` loop Complex bodies, side effects, early exit, multi-step logic per item

Why does lazy evaluation make map() memory-efficient?

Because `map()` doesn’t compute until iterated, it can process data far larger than memory. Imagine a file with millions of lines. A list comprehension would build a list of millions of transformed strings all at once. A `map()` pipeline transforms one line at a time, only as you consume it.

“`python

def line_lengths(path): with open(path) as f:

for length in map(len, f): yield length

“`

You can also see laziness directly. `map()` will not even call the function until you pull a value:

“`python def noisy(x): print(f” computing {x}”) return x * 10

m = map(noisy, [1, 2, 3]) print(“map created — nothing computed yet”)

print(“now pulling first value:”) print(next(m)) “`

Output:

“` map created — nothing computed yet now pulling first value: computing 1 10 “`

Only the first item was computed, exactly when it was requested. The values `2` and `3` are still untouched. This is why `map`, `filter`, and generators chain so well: each stage does the minimum work needed to satisfy the next.

Build and run Python pipelines on infrastructure you control

Lazy `map()` pipelines that stream through large files or datasets are exactly the kind of workload that needs real, guaranteed resources rather than a cramped shared box. DarazHost VPS and dedicated servers give developers a real, controllable Python environment: write efficient data-processing pipelines and run them on guaranteed resources with full root access, so you install the exact Python version and libraries your project needs. It’s the dependable home your Python work deserves, backed by 24/7 support. When your `map()`-driven scripts graduate from your laptop to production, DarazHost gives them a place to run reliably.

Frequently asked questions about map() in Python

Why does `print(map(…))` show `

` instead of my values? Because `map()` returns a lazy iterator, not a list. Printing the iterator prints its identity. Wrap it in `list()` to materialize and see the values: `print(list(map(func, data)))`.

Can I call `list()` on a `map` object twice? No. A `map` object is an iterator and is exhausted after one full pass. The second `list()` returns an empty list. Store the result once: `result = list(map(…))`.

How does `map()` handle iterables of different lengths? When you pass multiple iterables, `map()` stops at the shortest one and ignores the remaining items in the longer iterables.

Is `map()` faster than a list comprehension? For applying an existing built-in function (like `str.upper`), `map()` can be marginally faster because it avoids per-item bytecode for a lambda. With a `lambda`, a comprehension is usually as fast or faster and more readable. Choose based on clarity first; both are fine for most workloads.

Do I always need `lambda` with `map()`? No. If a named function or method already does the job, pass it directly: `map(str.strip, lines)` or `map(int, string_numbers)`. Use `lambda` only for small, inline, one-off transformations.

Wrapping up

`map(func, iterable)` applies a function to every item and returns a lazy `map` object. Pass named functions for clarity, lambdas for quick transforms, and multiple iterables when you want pairwise processing. Remember the one rule that clears up all the early confusion: `map` returns a lazy iterator, so wrap it in `list()` to see the values. That same laziness is what lets `map()` power memory-efficient pipelines over enormous data. For everyday inline transforms, a list comprehension may read better, but for existing functions and streaming workloads, `map()` is hard to beat.

This article is part of our developer-focused series. For the bigger picture on running Python and other languages on infrastructure you actually control, read the pillar guide: Hosting for Developers: The Complete Guide to a Real Environment You Control.

About the Author
Ravi Subramanian

Leave a Reply