Functional Programming: Advanced

Write concise inline lambda functions

Sometimes you need a simple function for a single purpose, and defining it with def feels like overkill. Python provides lambda functions for exactly this situation. A lambda is an anonymous function defined in a single expression. Lambdas are perfect for short, throwaway functions that you'll only use once.

The term "lambda" comes from lambda calculus, a mathematical system for expressing computation. Do not let the fancy name intimidate you. lambda functions are simply a concise way to write small functions inline.

A lambda has the form lambda arguments: expression. Unlike regular functions, lambdas do not use the return keyword. They automatically return the result of their single expression:

Notice how the lambda version is more compact. We go from three lines to one. But this comes with a limitation: lambdas can only contain a single expression. They cannot have multiple statements, loops, or complex logic.

Each lambda defines a different operation inline. This is much more concise than defining five separate named functions that you would only use once.

One of the most common uses for lambdas is with sorted() or list's sort() method. The key parameter accepts a function that extracts a comparison value from each element:

The lambda tells Python how to compare elements. Without it, Python would compare tuples by their first element then second element. The lambda lets you control exactly what gets compared.

employees = [("Alice", 75000), ("Bob", 95000), ("Carol", 60000)]

result = sorted(employees, key=___lambda e: e[1]lambda e: e[0]lambda e: len(e), reverse=True)
for name, sal in result:
    print(name, sal)

The loop pitfall catches many programmers. The lambda captures a reference to i, not its current value. Using a default argument i=i forces Python to copy the current value.

Pass and store functions as values

Notice the difference: greet is the function object, while greet("Alice") calls the function and returns its result ("Hello, Alice!"). Adding parentheses changes everything.

The apply_twice function does not know what operation will be performed. It just calls whatever function is passed to it. This is the essence of higher-order programming.

def double(x):
    return x * 2

nums = [1, 2, 3, 4]
result = ___(___(double, nums))
print(result)

The map() and filter() built-ins are direct expressions of higher-order programming. Once you are comfortable with functions as values, these patterns become natural building blocks for clean, expressive code.

Wrap functions with @ decorators

The announce decorator wraps square in a wrapper that prints messages before and after calling the original function. The wrapper is a closure that remembers func.

Python provides the @ syntax as shorthand for applying decorators. This is cleaner and makes the decoration obvious:

Using @announce above a function definition is exactly equivalent to writing double = announce(double) after the definition. The @ syntax is just cleaner.

Real-world decorators need to work with functions that have different signatures. Use *args and **kwargs to handle any combination of arguments:

*args collects all positional arguments as a tuple. **kwargs collects all keyword arguments as a dictionary. The wrapper passes them along to the original function unchanged.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

def add_greeting(func):
  def wrapper(*args):
    print("Hello!")
    func(*args)
  return wrapper

@add_greeting
def say_name(name):
  return "I am " + name

result = say_name("Alice")
print(result)

The @ syntax applies a decorator at definition time. Using @timer above a function is exactly equivalent to writing timer(my_function) after the definition. The shorthand keeps decoration visible and close to the function being decorated.

Decorators compose well with each other. Stacking @bold, @italic, and @uppercase above a single function applies each decorator in order from bottom to top, creating layered behavior without modifying any function's internal logic.

Solve nested problems with recursion

factorial(5) calls factorial(4), which calls factorial(3), and so on. Each call waits for its recursive call to return before it can compute its result.

def factorial(n):
    if n ___ 1:
        return 1
    return n ___ factorial(n - 1)

print(factorial(5))

The trade-off between recursion and iteration is always worth considering. Recursion is expressive for tree-shaped problems, while iteration is more memory-efficient for linear sequences. Python's default recursion limit of 1000 (adjustable via sys.setrecursionlimit()) is a practical guide for when to switch approaches.

Chain functions into data pipelines

compose(f, g) creates a new function that first applies g then applies f to the result. Note the order: g runs first (inner), f runs second (outer).

With pipe, the functions are listed in the order they execute. Many developers find this easier to read and reason about than right-to-left composition.

Python's standard library includes functools.partial for this purpose. It is commonly used to adapt functions for composition when their signatures do not quite match.