Functions

*args collects extra positional arguments into a tuple; **kwargs collects extra keyword arguments into a dict. If none are passed they are an empty tuple/dict, not None. They enable variadic or forwarding signatures.

[1] then [1, 2]. The default [] is created once, at function-definition time, and reused across calls, so state leaks between them. Fix with a sentinel: def add(item, bucket=None): bucket = [] if bucket is None else bucket.

Functions are objects of type function: you can assign them to variables, pass them as arguments, return them, store them in containers, and attach attributes. The object is created once when its def statement runs.

A lambda is an anonymous function whose body is a single expression, not statements like pass, raise, or assignments. It returns that expression's value implicitly and is often passed to map, filter, or sorted.

Yes. A nested inner function is visible only inside the enclosing function's local scope; outside code can't reach it unless it is returned or assigned out. A fresh inner object is created each time the outer runs.

Python passes by assignment, also called call by sharing: the parameter is bound to the same object the caller passed. Rebinding the name inside doesn't affect the caller, but mutating a mutable object does.

A closure is an inner function that captures references, via cell objects, to variables from its enclosing scope, keeping them alive after the outer function returns. Each outer call makes a new closure with its own bindings.

Default values are evaluated once when the def runs and stored on the function object, so a mutable default like def f(x=[]) is shared and accumulates across calls. Fix: default to None and create a fresh object inside.

[2, 2, 2]. The closures capture the variable i, not its value at creation time (late binding). By the time the lambdas run, the loop has finished and i == 2. Fix by binding per-iteration with a default arg: [lambda i=i: i for i in range(3)].

UnboundLocalError: local variable 'x' referenced before assignment. Because x is assigned anywhere in the function (line 2), Python treats it as local for the entire function, so the read on line 1 fails. Fix: add global x, or don't shadow it. This is the LEGB scoping rule.

A lambda body must be an expression, but raise (like pass, return, and assignments) is a statement, which a lambda body can't contain. So it fails at parse/compile time with SyntaxError, before any call ever runs.

lst[:] = [1] is slice-assignment: it mutates the existing object the caller still references, so the change is visible. lst = [1] rebinds only the local name to a new object; the caller's binding is untouched. The distinction is mutation of the shared object vs rebinding a local name.