Functions, arguments, and *args / **kwargs

A parameter can usually be filled by position or by name.

def greet(name, greeting="Hello"):
    return f"{greeting}, {name}"

greet("Nino")                    # "Hello, Nino"
greet("Nino", "Hi")               # "Hi, Nino"
greet(name="Nino", greeting="Hi") # "Hi, Nino" — same call, by keyword

def greet(name, /, greeting) forces name to be positional-only — the caller cannot write greet(name="Nino", ...). def greet(*, greeting) forces greeting to be keyword-only. Both exist to make an API's intent explicit rather than leaving it to convention.

*args and **kwargs

*args collects any number of extra positional arguments into a tuple. **kwargs collects any number of extra keyword arguments into a dict.

def total(*args, **kwargs):
    return sum(args) + sum(kwargs.values())

total(1, 2, 3, extra=10)   # 16

The names args and kwargs are convention, not syntax — the * and ** are what matter. The same stars unpack in the other direction, at a call site:

nums = [1, 2, 3]
print(*nums)          # print(1, 2, 3) — three separate arguments

opts = {"greeting": "Hi"}
greet("Nino", **opts)  # greet(name="Nino", greeting="Hi")

Try it

Closures over loop-bound state

A function defined inside another function keeps access to the enclosing function's variables even after the outer one has returned. That has a trap in a loop (the one JavaScript has with var):

def make_multipliers():
    return [lambda x: x * i for i in range(3)]

fns = make_multipliers()
[f(10) for f in fns]   # [20, 20, 20] — every lambda shares the same i

Python does not make a fresh i for each iteration; all three lambdas close over the same i, and by the time any of them run the loop has finished with i at 2. The fix is to capture the value as a default argument, evaluated once per lambda at definition time:

[lambda x, i=i: x * i for i in range(3)]   # [0, 10, 20]

Decorators wrap a function, they do not change its source

def log_calls(fn):
    def wrapper(*args, **kwargs):
        print(f"calling {fn.__name__}")
        return fn(*args, **kwargs)
    return wrapper

@log_calls
def add(a, b):
    return a + b

@log_calls above add is exactly add = log_calls(add). wrapper is what add actually refers to afterwards; it accepts anything via *args, **kwargs and forwards it, which is why a decorator can wrap a function it knows nothing about the signature of. The decorators lesson later in this course takes this further.

What interviewers ask

• What do *args and **kwargs receive? A tuple of the extra positional arguments and a dict of the extra keyword arguments; the same stars unpack a sequence or a mapping at a call site.
• What does @decorator above a def actually do? It runs once, at definition time, and rebinds the name: f = decorator(f).
• Why do these lambdas made in a loop all return the same thing? Closures capture variables, not values, and look them up when called; bind the value with a default argument or functools.partial.