Python Built-in Functions

The Story That Explains Functional Tools

Python's functional tools — lambda, map, filter, reduce, zip, enumerate, and friends — are the vocabulary for expressing "do this to every item", "keep only these", and "combine into one" without writing explicit loops. Learn them once and your code shrinks by half.

Lambda — The Anonymous Function

Before map and filter can shine, you need lambda — Python's way of writing a one-line function without giving it a name. Think of it as a disposable function you write inline and throw away.

The Two Sides of the Same Coin

# The traditional way — named function
def square(x):
    return x * x

# The lambda way — anonymous, one-liner
square_lambda = lambda x: x * x

print(square(5))         # 25
print(square_lambda(5))  # 25 — identical result

Lambda With Multiple Arguments

add       = lambda x, y: x + y
distance  = lambda x1, y1, x2, y2: ((x2-x1)**2 + (y2-y1)**2) ** 0.5
greet     = lambda name, greeting="Hello": f"{greeting}, {name}!"

print(add(3, 4))
print(distance(0, 0, 3, 4))
print(greet("Alice"))
print(greet("Bob", "Hey"))

Lambda With a Ternary — Conditional Return

# You CAN'T write if/else statements — but ternary IS an expression
grade = lambda score: "pass" if score >= 50 else "fail"

print(grade(75))   # pass
print(grade(32))   # fail

Visual Diagram — Map vs Filter vs Reduce

These three functions look similar in syntax but do fundamentally different things to the data. Once you can picture the shape of each, you'll never confuse them again.

map() — Transform Every Item

map(function, iterable) applies function to every element of iterable, returning a lazy iterator. Use list() to materialize the results.

# Traditional way: for loop with append
nums = [1, 2, 3, 4, 5]
squared = []
for n in nums:
    squared.append(n ** 2)

# map + lambda way — one line
squared = list(map(lambda n: n ** 2, nums))
print(squared)

Map With a Named Function

# Any function works — not just lambdas
words = ["apple", "BANANA", "Cherry"]
lower = list(map(str.lower, words))
lengths = list(map(len, words))

print(lower)
print(lengths)

Map With Multiple Iterables

# The lambda takes as many args as you pass iterables
prices    = [10, 20, 30]
quantities = [2, 3, 1]

totals = list(map(lambda p, q: p * q, prices, quantities))
print(totals)  # [20, 60, 30]

filter() — Keep Only What Passes

filter(function, iterable) keeps only elements for which function returns True. Same lazy iterator behaviour as map.

nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

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

# Keep only strings that aren't empty
raw = ["Alice", "", "Bob", None, "Charlie", ""]
clean = list(filter(None, raw))    # None as function = truthy filter
print(clean)

reduce() — Collapse to a Single Value

reduce() lives in functools. It takes a function of two arguments and applies it cumulatively across the iterable, reducing everything to a single accumulated value.

from functools import reduce

# Sum: (((1+2)+3)+4)+5 = 15
total = reduce(lambda acc, x: acc + x, [1, 2, 3, 4, 5])

# Product: 1*2*3*4*5 = 120
product = reduce(lambda acc, x: acc * x, [1, 2, 3, 4, 5])

# Max (manual): iteratively compare
biggest = reduce(lambda a, b: a if a > b else b, [3, 7, 1, 9, 4])

print(total, product, biggest)

Reduce With an Initial Value

# The 3rd argument is the STARTING accumulator
# Useful when the iterable might be empty or you need a non-default seed

reduce(lambda acc, x: acc + x, [], 0)      # returns 0, no error
reduce(lambda acc, x: acc + x, [1, 2, 3], 100)  # 100 + 1 + 2 + 3 = 106

# Building a dict from key-value pairs
pairs = [("a", 1), ("b", 2), ("c", 3)]
result = reduce(lambda d, kv: {**d, kv[0]: kv[1]}, pairs, {})
print(result)

zip() — Pair Up Iterables

zip() takes any number of iterables and yields tuples of their paired elements. It stops at the shortest input.

names  = ["Alice", "Bob", "Charlie"]
scores = [85, 92, 78]
ages   = [30, 25, 35]

# Pair two lists — most common use
for name, score in zip(names, scores):
    print(f"{name}: {score}")

# Any number of iterables works
for name, score, age in zip(names, scores, ages):
    print(f"{name} ({age}): scored {score}")

# Build a dict from parallel lists
report = dict(zip(names, scores))
print(report)

Unzipping With zip(*data)

# The unpacking star reverses a zip — like a matrix transpose
pairs = [("Alice", 85), ("Bob", 92), ("Charlie", 78)]

names, scores = zip(*pairs)
print(names)   # ('Alice', 'Bob', 'Charlie')
print(scores)  # (85, 92, 78)

enumerate() — Index + Value Together

enumerate() is the anti-pattern-killer for for i in range(len(...)). It pairs each element with a counter, starting at 0 (or whatever you specify).

fruits = ["apple", "banana", "cherry"]

# The anti-pattern — DON'T do this
for i in range(len(fruits)):
    print(f"{i}: {fruits[i]}")

# The Pythonic way
for i, fruit in enumerate(fruits):
    print(f"{i}: {fruit}")

# Start counting from 1 (useful for user-facing lists)
for rank, name in enumerate(["Gold", "Silver", "Bronze"], start=1):
    print(f"#{rank} - {name}")

sorted() With a Lambda Key

sorted() can sort by any derived value using the key argument. This is where lambdas really shine — you describe the sort criterion in one line.

students = [
    {"name": "Alice",   "score": 85, "age": 22},
    {"name": "Bob",     "score": 92, "age": 20},
    {"name": "Charlie", "score": 78, "age": 25},
    {"name": "Diana",   "score": 92, "age": 23},
]

# Sort by score, high to low
by_score = sorted(students, key=lambda s: s["score"], reverse=True)

# Sort by score DESC, then age ASC (tie-breaker)
compound = sorted(students, key=lambda s: (-s["score"], s["age"]))

# Sort strings by their length
words = ["banana", "pi", "apple", "kiwi"]
by_length = sorted(words, key=len)

print("By score:  ", [s["name"] for s in by_score])
print("Compound:  ", [s["name"] for s in compound])
print("By length: ", by_length)

any() and all() — Quick Truth Tests

Two of Python's cleanest built-ins. any() returns True if at least one element is truthy. all() returns True only if every element is. Both short-circuit — they stop the moment the answer is decided.

nums = [2, 4, 6, 8, 10]

# any: is there AT LEAST ONE match?
print(any(n > 5 for n in nums))    # True — 6, 8, 10 exist
print(any(n > 100 for n in nums))  # False — none qualify

# all: does EVERY element match?
print(all(n % 2 == 0 for n in nums))  # True — all even
print(all(n > 5 for n in nums))       # False — 2 and 4 fail

# Practical: validate user input
form = {"name": "Alice", "email": "a@x.com", "age": 30}
required = ["name", "email", "age"]

if all(k in form and form[k] for k in required):
    print("Form is complete")

min(), max(), sum() — With Keys and Defaults

nums = [3, 7, 1, 9, 4]

# Basics
print(min(nums), max(nums), sum(nums))   # 1 9 24

# With a key function — most powerful use
words = ["apple", "kiwi", "blueberry", "fig"]
print(min(words, key=len))   # 'fig' — shortest
print(max(words, key=len))   # 'blueberry' — longest

# Find the student with the highest score
students = [
    {"name": "Alice", "score": 85},
    {"name": "Bob",   "score": 92},
    {"name": "Charlie", "score": 78},
]
top = max(students, key=lambda s: s["score"])
print(f"Top student: {top['name']} with {top['score']}")

# Sum with a start value (avoids crash on empty)
print(sum([], 0))                 # 0 — safe default
print(sum([10.5, 20.5, 30], 100))    # 161.0 — starts at 100

Practical Real-World Examples

Example 1 — Cleaning & Normalising User Input

raw_emails = [
    "  Alice@Example.com ",
    "",
    "BOB@example.com",
    None,
    "  charlie@example.COM",
]

# Chain: filter out empty/None → strip → lowercase
clean = list(map(str.lower,
                map(str.strip,
                    filter(None, raw_emails))))

print(clean)

Example 2 — Building a Leaderboard

scores = [
    ("Alice",   85),
    ("Bob",     92),
    ("Charlie", 78),
    ("Diana",   92),
    ("Eve",     65),
]

# Top 3, sorted by score desc, then alphabetically for ties
leaderboard = sorted(scores, key=lambda s: (-s[1], s[0]))[:3]

for rank, (name, score) in enumerate(leaderboard, start=1):
    print(f"#{rank}  {name:8s} {score}")

Example 3 — Aggregating Financial Data

from functools import reduce

transactions = [
    {"type": "credit", "amount": 500},
    {"type": "debit",  "amount": 120},
    {"type": "credit", "amount": 250},
    {"type": "debit",  "amount": 75},
    {"type": "credit", "amount": 1000},
]

# Total credits
credits = sum(map(lambda t: t["amount"],
                  filter(lambda t: t["type"] == "credit", transactions)))

# Running balance using reduce
balance = reduce(
    lambda acc, t: acc + t["amount"] if t["type"] == "credit"
                        else acc - t["amount"],
    transactions, 0
)

print(f"Total credits: £{credits}")
print(f"Net balance:   £{balance}")

Example 4 — Merging Parallel Data

ids     = [101, 102, 103, 104]
names   = ["Alice", "Bob", "Charlie", "Diana"]
active  = [True, False, True, True]

# Build a list of dicts from three parallel lists
users = [
    {"id": i, "name": n, "active": a}
    for i, n, a in zip(ids, names, active)
]

# Keep only active users
active_users = list(filter(lambda u: u["active"], users))

for u in active_users:
    print(u)

Map/Filter vs Comprehensions — Which to Use?

Every map or filter call can be rewritten as a comprehension. The community leans towards comprehensions for readability, but there are cases where the functional form is genuinely better.

Same Task, Two Styles

nums = [1, 2, 3, 4, 5, 6]

# map + filter — the functional style
result_a = list(map(lambda n: n ** 2,
                  filter(lambda n: n % 2 == 0, nums)))

# List comprehension — the Pythonic style
result_b = [n ** 2 for n in nums if n % 2 == 0]

print(result_a)
print(result_b)   # Both: [4, 16, 36]

Performance — Are They Faster?

import timeit
from functools import reduce

setup = "nums = list(range(100_000))"

# Squaring 100,000 numbers — four ways
t_loop = timeit.timeit(
    "r = []\nfor n in nums: r.append(n*n)",
    setup=setup, number=100
)
t_comp = timeit.timeit(
    "r = [n*n for n in nums]",
    setup=setup, number=100
)
t_map_lambda = timeit.timeit(
    "r = list(map(lambda n: n*n, nums))",
    setup=setup, number=100
)
t_map_named = timeit.timeit(
    "r = list(map(f, nums))",
    setup=setup + "\nf = lambda n: n*n", number=100
)

print(f"For loop:            {t_loop:.3f}s")
print(f"Comprehension:       {t_comp:.3f}s")
print(f"map + inline lambda: {t_map_lambda:.3f}s")
print(f"map + named func:    {t_map_named:.3f}s")

Quick Reference Table

Golden Rules