The Fundamental Rule That Allows Functions to Be Passed as Arguments

When Python executes the def greet(name): statement, it does not just register a function somewhere. It creates a function object, compiles the body into a code object stored in greet.__code__, and binds the resulting function object to the name greet in the current namespace. The name greet is a variable, and its value is a function object.

This means functions participate in the same name-binding mechanics as every other value. You can assign a function to a new name, delete the original, and call through the alias — the object is the same throughout:

copydef greet(name):
    return f"Hello, {name}"

# Assign the function object to another name
say_hello = greet

# Both names reference the same object
print(say_hello is greet)       # True
print(id(say_hello) == id(greet))  # True

# Calling through either name executes the same function
print(say_hello("Alice"))       # Hello, Alice
print(greet("Alice"))           # Hello, Alice

# Delete the original name; the object survives
del greet
print(say_hello("Bob"))         # Hello, Bob

After del greet, the original name is gone, but the function object itself remains alive because say_hello still references it. The object persists as long as at least one reference to it exists. This is the same reference-counting behavior that applies to every Python object.

What a Function Object Carries

Python's function type is more than a callable wrapper around bytecode. A function object created by def carries a fixed set of attributes that expose its internals:

copydef greet(name: str) -> str:
    """Return a greeting string."""
    language = "Python"
    return f"Hello, {name} — from {language}"

# Identity and type (same as any object)
print(id(greet))             # memory address of the function object
print(type(greet))           # <class 'function'>

# Bytecode and metadata
print(greet.__name__)        # greet
print(greet.__qualname__)    # greet  (nested functions show "Outer.inner")
print(greet.__doc__)         # Return a greeting string.
print(greet.__module__)      # __main__ (or the module it was defined in)
print(greet.__code__)        # <code object greet at 0x...>

# Compiled bytecode internals
print(greet.__code__.co_varnames)   # ('name', 'language')  — local variable names
print(greet.__code__.co_consts)     # (None, 'Return a greeting string.', 'Python')
print(greet.__code__.co_argcount)   # 1  — number of positional arguments

# Type annotations (stored on the function object, not inside __code__)
print(greet.__annotations__)  # {'name': <class 'str'>, 'return': <class 'str'>}

# The namespace the function closes over (its global scope)
print(type(greet.__globals__))  # <class 'dict'>  — the module's global namespace

# Closure cells (None for a non-closure function)
print(greet.__closure__)     # None

The separation between __code__ (the compiled bytecode, shared if two functions have identical bodies) and __globals__ (the live namespace the function executes in) is what allows Python to handle module-level functions correctly: the bytecode is fixed at compile time, but the function object is a runtime artifact that carries a reference to its defining scope. This is also why two def statements with identical bodies produce two different function objects — they share the code object but hold references to the same globals dict, and they have separate identities.

copydef greet(name):
    return f"Hello, {name}"

print(type(greet))         # <class 'function'>

class Greeter:
    def greet(self, name):
        return f"Hello, {name}"

g = Greeter()
print(type(g.greet))       # <class 'method'>
# Accessing greet through an instance produces a bound method,
# not a plain function. That is why the types differ.

copydef greet(name):
    return f"Hello, {name}"

print(type(greet))         # <class 'function'>
print(type(42))            # <class 'int'>
print(type("hello"))       # <class 'str'>

# Functions, integers, and strings are all objects.
# type() works the same way on all of them.

copydef greet(name):
    return f"Hello, {name}"

print(type(greet))              # <class 'function'>
print(type(greet).__name__)     # function
print(callable(greet))         # True  — callable() is a function, not a type
# callable() returns True because greet has __call__, not because
# its type is named 'callable'.

Reference vs Call: The Parentheses Rule

There is a critical syntactic distinction between referencing a function and calling a function. Writing the name without parentheses gives you the object. Writing it with parentheses executes the object and gives you its return value. Getting this wrong is the most common mistake when working with higher-order functions.

copydef compute():
    return 42

# Reference: the function object itself
print(compute)      # 
print(type(compute))  # 

# Call: the function's return value
print(compute())    # 42
print(type(compute()))  # 

When you pass a function as an argument, you always pass the reference (without parentheses). If you accidentally include parentheses, you pass the result of calling the function, not the function itself:

copydef double(x):
    return x * 2

def apply(func, value):
    """Call func with value and return the result."""
    return func(value)

# Correct: pass the function object
result = apply(double, 5)
print(result)  # 10

# Wrong: pass the return value of double(5), which is 10
# apply receives 10 (an int), then tries to call 10(5)
# result = apply(double(5), 5)  # TypeError: 'int' object is not callable

This distinction is the bridge between "functions are objects" and "functions can be passed as arguments." Because double without parentheses evaluates to a function object, and function objects are values, they can be passed anywhere any other value can be passed.

lambda: Anonymous Function Objects

The lambda keyword creates a function object without giving it a name. A lambda expression produces exactly the same kind of object as def — an instance of the function class — but it is constrained to a single expression whose value becomes the implicit return value. For a full comparison of the two, see Python lambda vs def: every difference that actually matters.

copy# These two are equivalent function objects:
def double_def(x):
    return x * 2

double_lam = lambda x: x * 2

print(type(double_def))   # <class 'function'>
print(type(double_lam))   # <class 'function'>

# Both are callable and produce the same result
print(double_def(5))      # 10
print(double_lam(5))      # 10

# The difference is the __name__ attribute
print(double_def.__name__)  # double_def
print(double_lam.__name__)  # <lambda>

Because a lambda expression evaluates to a function object, it can be passed as an argument inline, without first assigning it to a name. This is the primary use case for lambda — short callables used once at the call site:

copypairs = [(3, "cat"), (1, "ant"), (2, "bee")]

# Pass a lambda inline as the key — no separate def needed
sorted_pairs = sorted(pairs, key=lambda pair: pair[0])
print(sorted_pairs)  # [(1, 'ant'), (2, 'bee'), (3, 'cat')]

# Equivalent with def — more lines, but easier to test and document
def by_first(pair):
    return pair[0]

sorted_pairs = sorted(pairs, key=by_first)
print(sorted_pairs)  # [(1, 'ant'), (2, 'bee'), (3, 'cat')]

copydef double(x):
    return x * 2

def apply(func, value):
    return func(value)

# WRONG — parentheses call double immediately
result = apply(double(5), 10)
# TypeError: 'int' object is not callable

# CORRECT — pass the function object, no parentheses
result = apply(double, 10)
print(result)  # 20

copydef double(x):
    return x * 2

def apply(func, value):
    return func(value)

# double(5) evaluates to 10 before apply is called
# apply(10, 10) then tries 10(10) — TypeError
try:
    apply(double(5), 10)
except TypeError as e:
    print(e)  # 'int' object is not callable

# Correct: pass the function object without parentheses
print(apply(double, 10))  # 20

copydef double(x):
    return x * 2

def apply(func, value):
    # apply calls func(value), it does NOT multiply func * value
    return func(value)

# double(5) = 10 (an int), so apply receives (10, 10)
# apply then does: 10(10) → TypeError
# The fix is to not call double here:
print(apply(double, 10))  # double(10) = 20

The Callable Protocol

What makes a function object callable is not something magical about the function type. It is a protocol. Any object whose type defines a __call__ method can be called with parentheses. Functions happen to implement this protocol, but so can any class you write:

copyclass Multiplier:
    def __init__(self, factor):
        self.factor = factor

    def __call__(self, value):
        return value * self.factor

triple = Multiplier(3)

# triple is an object, not a function defined with def
print(type(triple))       # 

# But it is callable because Multiplier defines __call__
print(callable(triple))   # True
print(triple(10))         # 30

# It can be passed as an argument anywhere a function is expected
numbers = [1, 2, 3, 4, 5]
print(list(map(triple, numbers)))  # [3, 6, 9, 12, 15]

The built-in callable() function checks whether an object has this protocol. Under the hood in CPython, calling an object triggers the tp_call slot on the object's type struct — the slot whose signature is PyObject *tp_call(PyObject *callable, PyObject *args, PyObject *kwargs). Since Python 3.8, CPython also supports a faster path called the vectorcall protocol (introduced in PEP 590), which avoids building an intermediate tuple for positional arguments. CPython prefers vectorcall for internal calls when the callable supports it; tp_call remains the general fallback. From the Python programmer's perspective, both paths arrive at the same result: calling the __call__ method on the callable's type. The callable protocol remains unified at the Python level, even as CPython optimizes the C-level dispatch underneath.

This means "passable as an argument" is not limited to def functions. It applies to any callable: lambdas, methods, classes, and instances with __call__. They are all objects, and they all implement the callable protocol.

copy# All of these are callable objects that can be passed as arguments

def func(x):
    return x + 1

lam = lambda x: x + 1

class Adder:
    def __call__(self, x):
        return x + 1

adder_instance = Adder()

for fn in [func, lam, Adder, adder_instance, int, len]:
    print(f"{str(fn):.<45} callable={callable(fn)}")

# .................. callable=True
#  at 0x...>.............. callable=True
# .................. callable=True
# <__main__.Adder object at 0x...>......... callable=True
# ............................ callable=True
# .................. callable=True

copyclass Counter:
    def __init__(self):
        self.n = 0

    def __call__(self):
        self.n += 1
        return self.n

counter = Counter()

print(callable(counter))   # True
print(counter())           # 1
print(counter())           # 2
# counter can be passed as an argument anywhere a callable is expected
nums = [1, 2, 3]
print(list(map(lambda _: counter(), nums)))  # [3, 4, 5]

copyclass Counter:
    def __init__(self):
        self.n = 0

    def __call__(self):
        self.n += 1
        return self.n

counter = Counter()

print(callable(counter))   # True
print(counter())           # 1
print(counter())           # 2

# Can be used wherever a callable is expected:
def run_twice(fn):
    return fn(), fn()

print(run_twice(counter))  # (3, 4)

copyclass Counter:
    def __init__(self):
        self.n = 0

    def __call__(self):
        self.n += 1
        return self.n

counter = Counter()

# callable() works on any object, never raises AttributeError
print(callable(counter))   # True  — has __call__
print(callable(42))        # False — integer instances are not callable (42() raises TypeError)
print(callable(print))     # True  — built-in function
print(callable("hello"))   # False — str is not callable

Higher-Order Functions in Practice

A function that takes another function as an argument, or returns a function as its result, is called a higher-order function. This pattern is the direct consequence of functions being objects. Python's standard library relies on it heavily.

Passing Functions to Built-in Functions

Several of Python's built-in functions accept a callable as an argument and invoke it internally. sorted() takes a key function and applies it to each element before comparing. map() applies a function to every element of an iterable. filter() keeps only the elements for which the function returns a truthy value:

copy# sorted() accepts a key function
words = ["banana", "apple", "cherry", "date"]
by_length = sorted(words, key=len)
print(by_length)  # ['date', 'apple', 'banana', 'cherry']

# map() applies a function to every element
def to_fahrenheit(c):
    return c * 9 / 5 + 32

temperatures_c = [0, 20, 37, 100]
temperatures_f = list(map(to_fahrenheit, temperatures_c))
print(temperatures_f)  # [32.0, 68.0, 98.6, 212.0]

# filter() keeps elements where the function returns True
def is_even(n):
    return n % 2 == 0

evens = list(filter(is_even, range(20)))
print(evens)  # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

In each case, the built-in function receives a callable object and invokes it internally. The built-in does not care whether it received a def function, a lambda, a method, or a class with __call__. It calls whatever it was given. The map() function in particular is worth studying as a standalone pattern once you understand the callable protocol.

Writing Your Own Higher-Order Functions

copyfrom collections.abc import Callable
import random
from typing import TypeVar

T = TypeVar("T")

def retry(func: Callable[[], T], attempts: int = 3) -> T:
    """Try calling func up to `attempts` times, returning the first success."""
    last_error: Exception = RuntimeError("retry called with attempts=0")
    for i in range(attempts):
        try:
            return func()
        except Exception as e:
            last_error = e
            print(f"Attempt {i + 1} failed: {e}")
    raise last_error

def unreliable_fetch() -> dict:
    if random.random() < 0.7:
        raise ConnectionError("Network timeout")
    return {"status": "ok", "data": [1, 2, 3]}

# Pass the function object (no parentheses) to retry
result = retry(unreliable_fetch, attempts=5)
print(result)

The retry function knows nothing about what func does. It only knows that func is callable. The retry logic and the business logic are entirely independent, which is only possible because the business logic arrives as a value.

Storing Functions in Data Structures

Because functions are objects, they can be stored in lists, dictionaries, or any other container:

copydef add(a, b):
    return a + b

def subtract(a, b):
    return a - b

def multiply(a, b):
    return a * b

operations = {
    "+": add,
    "-": subtract,
    "*": multiply,
}

def calculate(expression):
    """Parse and evaluate a simple 'a op b' expression."""
    parts = expression.split()
    a, op, b = int(parts[0]), parts[1], int(parts[2])

    func = operations.get(op)
    if func is None:
        raise ValueError(f"Unknown operator: {op}")
    return func(a, b)

print(calculate("10 + 5"))   # 15
print(calculate("10 - 3"))   # 7
print(calculate("10 * 4"))   # 40

The dictionary maps operator strings to function objects. Looking up operations["+"] returns the add function object, which is then called with the operands. This dispatch pattern eliminates long chains of if/elif statements and makes it trivial to add new operations by inserting new entries into the dictionary.

Partial Application with functools.partial

Sometimes you have a function that takes several arguments, but you want to pass it somewhere that will only supply some of them. functools.partial solves this by producing a new callable object that wraps the original function with some arguments pre-filled. The result is itself a first-class object and can be passed, stored, or called like any other callable.

copyimport functools

def power(base, exponent):
    return base ** exponent

# Create a new callable with exponent pre-filled
square = functools.partial(power, exponent=2)
cube   = functools.partial(power, exponent=3)

print(square(5))   # 25  — equivalent to power(5, exponent=2)
print(cube(3))     # 27  — equivalent to power(3, exponent=3)

# The partial object is callable and inspectable
print(type(square))           # <class 'functools.partial'>
print(callable(square))       # True
print(square.func)            # <function power at 0x...>
print(square.keywords)        # {'exponent': 2}

The most practical application is when an API accepts a single-argument callable but the function you want to use requires more than one argument:

copyimport functools

# sorted() key must be a single-argument callable
words = ["banana", "Apple", "cherry", "date"]

# str.lower takes one argument (the string itself)
# No partial needed here — it already has the right signature
print(sorted(words, key=str.lower))
# ['Apple', 'banana', 'cherry', 'date']

# But suppose we want to sort by the Nth character:
def nth_char(s, n):
    return s[n] if n < len(s) else ""

# sorted() needs a one-argument key function.
# Wrap nth_char with n=1 pre-filled:
by_second_char = functools.partial(nth_char, n=1)
print(sorted(words, key=by_second_char))
# ['banana', 'date', 'cherry', 'Apple']  (sorted by index 1: a, a, h, p)

Partial application is conceptually the same as a closure-based factory: both produce a new callable that carries fixed configuration. The difference is that functools.partial is explicit, inspectable, and does not require you to write a wrapper function by hand.

Closures: Functions That Remember

Because functions are objects, they can be created inside other functions and returned as values. When an inner function references variables from its enclosing scope, it captures those variables. The resulting combination of the inner function and its captured variables is called a closure.

copydef make_greeter(greeting):
    """Return a function that greets with a specific greeting."""
    def greeter(name):
        return f"{greeting}, {name}!"
    return greeter

hello = make_greeter("Hello")
howdy = make_greeter("Howdy")

print(hello("Alice"))   # Hello, Alice!
print(howdy("Bob"))     # Howdy, Bob!

# The inner function carries its captured variable
print(hello.__closure__)
# (,)
print(hello.__closure__[0].cell_contents)
# Hello

When make_greeter("Hello") returns, its local variable greeting would normally be garbage collected. But the inner greeter function references greeting, so Python keeps it alive inside a cell object stored in the function's __closure__ attribute. The function object carries its environment with it.

Closures are the mechanism behind function factories, a pattern where one function produces customized functions on demand:

copydef make_validator(min_val, max_val):
    """Return a function that checks if a value is within range."""
    def validate(value):
        if not (min_val <= value <= max_val):
            raise ValueError(
                f"{value} is outside [{min_val}, {max_val}]"
            )
        return value
    return validate

validate_percentage = make_validator(0, 100)
validate_temperature = make_validator(-273.15, 1000)

print(validate_percentage(85))     # 85
print(validate_temperature(-40))   # -40

try:
    validate_percentage(150)
except ValueError as e:
    print(e)  # 150 is outside [0, 100]

Each call to make_validator creates a new function object with its own captured min_val and max_val. The returned functions are independent of each other, each carrying its own enclosed state.

copydef make_greeter(greeting):
    def greeter(name):
        return f"{greeting}, {name}!"
    return greeter

hello = make_greeter("Hello")

# make_greeter has returned, but greeting is still alive:
print(hello.__closure__)                        # (<cell at 0x...>,)
print(hello.__closure__[0].cell_contents)       # Hello
print(hello("Alice"))                           # Hello, Alice!

copydef make_greeter(greeting):
    def greeter(name):
        return f"{greeting}, {name}!"
    return greeter

hello = make_greeter("Hello")

# All functions have __closure__; it is None if no captures:
def plain(): pass
print(plain.__closure__)                        # None

# hello captures greeting, so __closure__ is a tuple of cells:
print(hello.__closure__)                        # (<cell at 0x...>,)
print(hello.__closure__[0].cell_contents)       # Hello

copydef make_greeter(greeting):
    def greeter(name):
        return f"{greeting}, {name}!"
    return greeter

hello = make_greeter("Hello")
howdy = make_greeter("Howdy")

# Each closure carries its own captured greeting independently
print(hello.__closure__[0].cell_contents)   # Hello
print(howdy.__closure__[0].cell_contents)   # Howdy

print(hello("Alice"))   # Hello, Alice!
print(howdy("Bob"))     # Howdy, Bob!

The Late-Binding Pitfall

Closures capture variable references, not values. This distinction is invisible with simple factories like make_greeter, because the captured variable never changes after the inner function is returned. But it becomes a trap as soon as you create closures inside a loop.

copy# BROKEN: all three functions capture the same variable i
multipliers = []
for i in range(3):
    multipliers.append(lambda x: x * i)

print(multipliers[0](10))  # 20 — expected 0, got 2 * 10
print(multipliers[1](10))  # 20 — expected 10, got 2 * 10
print(multipliers[2](10))  # 20 — correct by accident

# Why? All three lambdas close over the same variable i.
# By the time you call them, the loop has finished and i == 2.
# Each lambda looks up i at call time, not at creation time.

The standard fix is to force early binding by passing the loop variable as a default argument. Default argument values are evaluated at function definition time, so the value is captured immediately:

copy# FIX 1: default argument captures the current value of i
multipliers = []
for i in range(3):
    multipliers.append(lambda x, factor=i: x * factor)

print(multipliers[0](10))  # 0
print(multipliers[1](10))  # 10
print(multipliers[2](10))  # 20

# FIX 2: use functools.partial (see the next section)
import functools

def multiply(x, factor):
    return x * factor

multipliers = [functools.partial(multiply, factor=i) for i in range(3)]
print(multipliers[0](10))  # 0
print(multipliers[1](10))  # 10
print(multipliers[2](10))  # 20

Both fixes work for the same reason: they evaluate the loop variable's current value immediately and bind it to something that does not change. The default-argument trick is the more common idiom; functools.partial is discussed in the next section.

Mutating Captured Variables with nonlocal

Closures capture variable references, which means reading a captured variable works naturally. Mutating one does not — at least not without help. If you assign to a name inside an inner function, Python treats that name as a new local variable, shadowing the one from the enclosing scope rather than updating it. The nonlocal keyword fixes this by explicitly declaring that the assignment should reach into the enclosing scope.

copydef make_counter(start=0):
    count = start

    def increment():
        nonlocal count   # without this, count += 1 creates a new local
        count += 1
        return count

    def reset():
        nonlocal count
        count = start

    return increment, reset

inc, rst = make_counter(10)
print(inc())   # 11
print(inc())   # 12
print(inc())   # 13
rst()
print(inc())   # 11  — reset worked

Without nonlocal count, the line count += 1 would raise an UnboundLocalError because Python would see count on the left side of an assignment and classify it as a local variable, then fail to find it in the local scope before the increment. The nonlocal declaration tells Python to look one scope outward instead of creating a fresh local. This pattern produces a stateful callable without needing a class.

Methods Are First-Class Objects Too

The first-class function model extends to methods. When you access a method through an instance (obj.method), Python does not return the raw function defined on the class. It returns a bound method object — a wrapper that pairs the function with the instance, so that self is automatically supplied on every call. Bound methods are themselves first-class objects.

copyclass Greeter:
    def __init__(self, greeting):
        self.greeting = greeting

    def greet(self, name):
        return f"{self.greeting}, {name}!"

g = Greeter("Hello")

# Accessing g.greet produces a bound method
print(type(g.greet))       # <class 'method'>
print(callable(g.greet))   # True

# Assign the bound method to a variable — it carries g with it
fn = g.greet
print(fn("Alice"))         # Hello, Alice!

# Pass it as an argument — works exactly like any callable
names = ["Alice", "Bob", "Carol"]
results = list(map(fn, names))
print(results)
# ['Hello, Alice!', 'Hello, Bob!', 'Hello, Carol!']

# Unbound access through the class returns the plain function
print(type(Greeter.greet))    # <class 'function'>
# Must supply self explicitly when calling through the class
print(Greeter.greet(g, "Dave"))  # Hello, Dave!

The practical consequence: any instance method can be extracted and passed around as a callable, with no boilerplate. This shows up constantly in real code — passing list.append to a callback, registering self.handle_event with an event system, or passing str.lower as a key function to sorted(). Each of these is a bound method being treated as a first-class value.

From First-Class Functions to Decorators

Decorators are the highest-profile application of first-class functions in Python. A decorator is a function that takes a function as its argument and returns a new function (or the same function, modified). Every piece of this sentence depends on functions being objects.

copyimport functools
import time

def timer(func):
    """Decorator that prints how long a function takes to run."""
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        elapsed = time.perf_counter() - start
        print(f"{func.__name__} took {elapsed:.4f}s")
        return result
    return wrapper

@timer
def slow_sum(n):
    return sum(range(n))

print(slow_sum(10_000_000))
# slow_sum took 0.1823s
# 49999995000000

Step by step: Python executes def slow_sum(n): and creates a function object. The @timer syntax passes that function object to timer() as the argument func. Inside timer, a new function object wrapper is created. wrapper is a closure that captures the original func. timer returns wrapper. Python rebinds the name slow_sum to the returned wrapper object.

Every step requires functions to be objects: passing slow_sum as an argument to timer, creating wrapper inside timer, capturing func in the closure, returning wrapper as a value, and assigning it back to the name slow_sum.

Why @functools.wraps Matters

After @timer runs, the name slow_sum points to wrapper, not to the original function. Without @functools.wraps, the function's identity metadata would reflect that replacement:

copyimport functools, time

# WITHOUT functools.wraps
def timer_naive(func):
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        print(f"elapsed: {time.perf_counter() - start:.4f}s")
        return result
    return wrapper

@timer_naive
def slow_sum(n):
    """Return the sum of range(n)."""
    return sum(range(n))

print(slow_sum.__name__)  # wrapper   — WRONG
print(slow_sum.__doc__)   # None      — WRONG

# WITH functools.wraps
def timer(func):
    @functools.wraps(func)           # copies __name__, __doc__, __annotations__, etc.
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        print(f"elapsed: {time.perf_counter() - start:.4f}s")
        return result
    return wrapper

@timer
def slow_sum(n):
    """Return the sum of range(n)."""
    return sum(range(n))

print(slow_sum.__name__)  # slow_sum  — correct
print(slow_sum.__doc__)   # Return the sum of range(n).  — correct
print(slow_sum.__wrapped__)  # <function slow_sum at 0x...>  — points to original

Without the decorator syntax, the same operation looks like this, making the first-class nature even more explicit:

copydef slow_sum(n):
    return sum(range(n))

# This is exactly what @timer does:
slow_sum = timer(slow_sum)

The expression timer(slow_sum) passes a function object as an argument. The expression slow_sum = timer(slow_sum) assigns the returned function object to a variable. Both operations are only possible because functions are objects.

copydef square(x):
    return x ** 2

# BUG: square() called immediately — TypeError before map runs
# results = list(map(square(), [1, 2, 3, 4]))

# FIX: pass the function object without parentheses
results = list(map(square, [1, 2, 3, 4]))
print(results)  # [1, 4, 9, 16]

copydef make_counter():
    count = 0

    def increment():
        nonlocal count   # ← this line is the fix
        count += 1
        return count

    return increment

c = make_counter()
print(c())  # 1
print(c())  # 2
print(c())  # 3

copyimport functools, time

def timer(func):
    @functools.wraps(func)   # ← this is the fix
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        print(f"took {time.perf_counter()-start:.4f}s")
        return result
    return wrapper

@timer
def compute(n):
    """Sum up to n."""
    return sum(range(n))

print(compute.__name__)   # compute  — correct
print(compute.__doc__)    # Sum up to n.  — correct
print(compute.__wrapped__)  # <function compute at 0x...>

Key Takeaways

1. 1

   The fundamental rule is that functions are objects. Every def statement creates an object of type function with an identity, a type, and attributes. This is not a special feature — it is a consequence of Python's unified object model where everything is an object.

2. 2

   Referencing a function and calling a function are different operations. func gives you the object. func() executes the object and gives you its return value. Passing a function as an argument requires the reference form without parentheses.

3. 3

   lambda creates anonymous function objects. A lambda expression produces the same type of object as def, constrained to a single expression. Use it for simple, throwaway callables passed inline; prefer def when the logic needs a name, a docstring, or independent testing.

4. 4

   The callable protocol unifies all invocation. Functions, lambdas, methods, classes, and objects with __call__ are all callable through the same mechanism. The callable() built-in checks for this capability.

5. 5

   Higher-order functions are the direct consequence. Because functions are values, they can be passed to other functions, returned from functions, and stored in data structures. This enables patterns like callbacks, dispatch tables, function factories, and decorators.

6. 6

   functools.partial fixes arguments without writing a wrapper. It produces a new callable with one or more arguments pre-filled. Use it instead of a manual closure when the configuration is simple and you want the result to be inspectable.

7. 7

   Closures keep functions connected to their creation context — by reference, not by value. Captured variables are resolved at call time, not at definition time. This causes the late-binding pitfall in loops. Fix it with a default argument or functools.partial to force immediate evaluation.

8. 8

   Always apply @functools.wraps inside decorators. Without it, the wrapper function replaces the original's __name__, __doc__, and __annotations__, breaking introspection, debugging, and documentation tools.

9. 9

   Use nonlocal to mutate a captured variable. Python treats any name on the left side of an assignment inside a function as a local variable. If you need to increment or reassign a variable from an enclosing scope rather than read it, the nonlocal declaration tells Python to bind that name one scope outward instead.

10. 10

    Bound methods are first-class objects. Accessing obj.method returns a bound method that carries obj as its implicit first argument. You can assign bound methods to variables, store them in containers, and pass them as arguments anywhere a callable is expected — exactly like any other function object.

Everything in Python's higher-order ecosystem — decorators, functools.wraps, functools.partial, map, filter, sorted with key, callback registrations in web frameworks, event-driven architectures — traces back to one decision: def creates an object. Once that rule is internalized, the rest is just applying it.