Useful Python Built-in Functions: map, filter, zip, enumerate, sorted

Python comes with dozens of functions that are always available, no imports needed. You've already used some of them, like print(), len() and range(). In this lesson, you'll learn the Python built-in functions that make working with lists much easier: map(), filter(), zip(), enumerate() and sorted(), plus a few quick helpers like sum(), any() and all(). They often replace a whole loop with a single, readable line.

What are built-in functions in Python?

A built-in function is a function that Python provides automatically. It lives in the built-in scope (the "B" in the LEGB rule), so you can call it from anywhere in your program. Python 3.12 has around 70 of them. This lesson covers the ones you'll use most when working with collections of data.

enumerate(): numbering items in a loop

enumerate() gives you each item and its position at the same time. Without it, you'd need a separate counter variable.

playlist = ["Blinding Lights", "Levitating", "Shape of You"]

for number, song in enumerate(playlist, start=1):
    print(f"{number}. {song}")

1. Blinding Lights
2. Levitating
3. Shape of You

By default, counting starts at 0 (like list indexes). The start=1 argument makes it start at 1, which is what people expect to see in a numbered list.

zip(): pairing items from several lists

zip() takes two or more lists and walks through them side by side, giving you one tuple per position: the first items together, then the second items, and so on. It works like a zipper joining two sides, tooth by tooth.

players = ["Ava", "Ben", "Cleo"]
scores = [920, 1150, 870]

for name, score in zip(players, scores):
    print(f"{name}: {score} points")

Ava: 920 points
Ben: 1150 points
Cleo: 870 points

You can turn the pairs into a list, or even straight into a dictionary:

players = ["Ava", "Ben", "Cleo"]
scores = [920, 1150, 870]

print(list(zip(players, scores)))
print(dict(zip(players, scores)))

[('Ava', 920), ('Ben', 1150), ('Cleo', 870)]
{'Ava': 920, 'Ben': 1150, 'Cleo': 870}

sorted(): ordering items with a key

sorted() returns a new sorted list and leaves the original unchanged (unlike the list.sort() method, which changes the list in place). Use reverse=True for descending order and key= to choose what to sort by.

temperatures = [18, 25, 12, 30, 21]

print(sorted(temperatures))
print(sorted(temperatures, reverse=True))
print(temperatures)          # unchanged

[12, 18, 21, 25, 30]
[30, 25, 21, 18, 12]
[18, 25, 12, 30, 21]

The key argument takes a function, often a lambda, that is applied to each item before comparing:

cities = ["Rome", "Amsterdam", "Lima", "Oslo", "Barcelona"]

print(sorted(cities, key=len))
print(sorted(cities, key=lambda city: city[-1]))

['Rome', 'Lima', 'Oslo', 'Amsterdam', 'Barcelona']
['Lima', 'Barcelona', 'Rome', 'Amsterdam', 'Oslo']

The second line sorts by the last letter of each city. When two items have the same key (like "Rome", "Lima" and "Oslo", all 4 letters), sorted() keeps them in their original order.

Building a leaderboard with zip, sorted and enumerate

Here's the leaderboard from the real-life example. Each function does one small job:

players = ["Ava", "Ben", "Cleo", "Dev"]
scores = [920, 1150, 870, 1010]

pairs = zip(players, scores)
ranked = sorted(pairs, key=lambda pair: pair[1], reverse=True)

for rank, (name, score) in enumerate(ranked, start=1):
    print(f"#{rank} {name:<5} {score}")

#1 Ben   1150
#2 Dev   1010
#3 Ava   920
#4 Cleo  870

zip() pairs names with scores, sorted() orders the pairs by score from highest to lowest, and enumerate() adds the rank. The (name, score) part unpacks each pair, and :<5 pads the name to 5 characters so the scores line up (see f-strings).

map(): applying a function to every item

map(function, items) calls the function on every item and gives back the results. It returns a lazy map object that produces values only when asked, so wrap it in list() to see them all.

prices_text = ["4.99", "12.50", "3.25"]
prices = list(map(float, prices_text))
print(prices)

euros = [10, 25, 40]
dollars = list(map(lambda amount: round(amount * 1.08, 2), euros))
print(dollars)

[4.99, 12.5, 3.25]
[10.8, 27.0, 43.2]

A common use is converting text to numbers, for example when a user types several values separated by spaces: list(map(int, "3 7 9".split())) gives [3, 7, 9].

filter(): keeping only matching items

filter(function, items) keeps each item for which the function returns True (or a truthy value) and drops the rest. Like map(), it returns a lazy object.

ratings = [4.8, 3.2, 4.5, 2.9, 5.0]
top_rated = list(filter(lambda stars: stars >= 4.5, ratings))
print(top_rated)

usernames = ["sam", "", "lee", "", "kai"]
print(list(filter(None, usernames)))

[4.8, 4.5, 5.0]
['sam', 'lee', 'kai']

Passing None as the function keeps only the truthy items, which is a quick way to remove empty strings.

Other handy built-ins: sum, min, max, any, all and reversed

sum(), min() and max()

These three answer the most common questions about a list of numbers. min() and max() also accept a key, just like sorted().

cart = [19.99, 5.49, 42.00, 8.25]
print(sum(cart))
print(min(cart), max(cart))

runners = {"Kim": 52.3, "Luis": 49.8, "Nora": 50.6}
print(min(runners, key=lambda name: runners[name]))

75.73
5.49 42.0
Luis

The last line finds the runner with the fastest (smallest) time by comparing each name's value in the dictionary.

any() and all()

any() returns True if at least one item is true. all() returns True only if every item is true. They pair nicely with a generator expression, which looks like a list comprehension without the square brackets (you'll learn more in Python generators).

stock = {"milk": 4, "eggs": 0, "bread": 7}

print(any(count == 0 for count in stock.values()))
print(all(count > 0 for count in stock.values()))

True
False

Read them as questions: "Is any product sold out?" Yes. "Are all products in stock?" No.

reversed(): looping backwards

reversed() gives you the items of a sequence from last to first without changing the original. Like map(), it's lazy, so use list() to see the result at once.

launch_steps = ["fuel", "check systems", "ignite"]
print(list(reversed(launch_steps)))

for number in reversed(range(1, 4)):
    print(number)

['ignite', 'check systems', 'fuel']
3
2
1

Python built-in functions reference table

Common mistakes with built-in functions

1. Printing a map, filter or zip object directly

print(map(float, prices_text)) shows something like <map object at 0x...>, not the values. Wrap the result in list(), or loop over it.

2. Using a map or zip object twice

These lazy objects can be used only once. After you loop over them, they're empty:

pairs = zip(["Ava", "Ben"], [920, 1150])
print(list(pairs))
print(list(pairs))

[('Ava', 920), ('Ben', 1150)]
[]

If you need the results more than once, store them in a list first: pairs = list(zip(...)).

3. Expecting sorted() to change the original list

sorted(scores) returns a new list. If you don't save the result (scores = sorted(scores)), nothing changes.

4. Hiding a built-in with your own variable

A variable called sum, max or list hides the built-in function, and calling it later gives TypeError: 'int' object is not callable. Use names like total or highest.

Practice exercise

drinks = ["Latte", "Espresso", "Mocha", "Cold brew"]
prices = [4.50, 3.00, 5.25, 4.75]

menu = sorted(zip(drinks, prices), key=lambda item: item[1])

for number, (drink, price) in enumerate(menu, start=1):
    print(f"{number}. {drink} - ${price:.2f}")

print(f"Average price: ${sum(prices) / len(prices):.2f}")
print("All under $6:", all(price < 6 for price in prices))

1. Espresso - $3.00
2. Latte - $4.50
3. Cold brew - $4.75
4. Mocha - $5.25
Average price: $4.38
All under $6: True

What's next?

Congratulations, you've finished the Functions chapter! Built-in functions are always available, but Python has thousands more tools waiting in its standard library. Next, learn how to use them with Python modules.