Functions and Comprehensions

*args collects the leftover positional arguments into a tuple; **kwargs collects the leftover keyword arguments into a dict. Both types are fixed, and both are empty rather than None when nothing extra is passed.

Give the parameter a default of None and build the list inside the body when the caller omitted it. Writing items=[] creates one list while the def statement runs, and every call that omits the argument shares that same list.

A call binds the parameter name to the same object the caller passed; nothing is copied. Assigning to that name repoints only the function's local name, while calling a method like append changes the one shared object.

Both iterables are flattened into one positional argument list, in source order, and both mappings are merged into the keyword arguments. Python 3.5 (PEP 448) allowed more than one star and double-star unpacking per call.

It closes the positional part of the signature. Every parameter written after the bare * is keyword-only, so the caller must pass it by name: f(1, b=2) works and f(1, 2) raises TypeError.

A free variable is a name an inner function reads but does not bind, whose binding belongs to an enclosing function. CPython moves that variable out of the frame into a one-slot cell object, and the inner function holds the same cell, so the value outlives the enclosing call.

Python decides scope at compile time: an assignment to x anywhere in the body makes x local for the whole function, so the read on the right-hand side hits an unset local slot instead of the module-level global.

global name makes assignments inside a function rebind the module-level name; nonlocal name rebinds the name in the nearest enclosing function. Without either declaration, an assignment simply creates a new local that shadows the outer one.

Each lambda captures the variable i itself, not a snapshot of its value at creation time. The lambdas are called after the comprehension has finished, when i holds its final value 2, so all three return 2.

LEGB is the order Python searches namespaces for a bare name: Local, then any Enclosing function scopes, then the module's Global namespace, then the built-ins. The first namespace holding the name wins; if none does, Python raises NameError.

A def statement runs at runtime, builds a function object and binds it to a name, exactly like an assignment. That object can be stored in a dict, passed as an argument or returned again, which is what first-class means.

It returns the two-element tuple (row[2], row[0]), in the order the indices were given. With a single index, operator.itemgetter returns that one item itself, not a one-element tuple.

key= takes a one-argument callable applied to every element; sorted, min and max then compare the values it returns instead of the elements themselves. The elements come back unchanged, only reordered.

A lambda expression builds an anonymous function whose body is a single expression, returned implicitly. def is a statement that names the function and can contain any block of code. Both create the same kind of function object.

Both return a lazy, one-shot iterator object, not a list. Nothing is computed until you iterate. Wrap the result in list() or tuple(), or feed it straight to a for loop, sum(), any() or all().

functools.lru_cache stores each call's result in a dictionary keyed by the arguments, so a repeat call returns the stored value without running the body. functools.cache, added in 3.9, is lru_cache(maxsize=None): unbounded, and it never evicts.

The wrapper builds a dictionary key out of the call's arguments, so every argument must be hashable. A list is not, so the lookup raises TypeError before the function body ever runs. Pass a tuple, or a frozenset for set-like input.

Returning NotImplemented for an operand type you do not handle lets Python try the other operand's reflected method and then raise a clear TypeError. Returning False instead answers a question you cannot answer, silently.

pickle stores a function by its importable qualified name, and a lambda has none, so pickling one fails. A functools.partial defines its own reduction — the wrapped callable plus the bound arguments — so it pickles whenever those pieces are themselves picklable.

It takes the class of the first positional argument, walks that class's method resolution order, and uses the implementation registered for the nearest ancestor, falling back to object. Registration order is irrelevant; specificity decides.

The leftmost one. Clauses read left to right in the same order you would write nested for statements, so for row in rows is the outer loop and for x in row the inner one. The result is one flat list.

Since Python 3, a comprehension evaluates its body in its own implicit function scope, so the name bound by its for clause is local to the comprehension and gone afterwards. Python 2 list comprehensions leaked it; generator expressions never did.

The square-bracket form builds the whole list in memory immediately. The parenthesised form builds a generator object that computes each value only when asked, uses near-constant memory, and can be iterated only once.

Square brackets build a list, braces with a colon per item build a dict, and braces without a colon build a set. All three share one shape: an output expression, a for clause, and an optional trailing if filter.

An if written after the for clause is a filter, so failing items are skipped and the result gets shorter. An if/else written before the for clause is a conditional expression choosing each emitted value, so every item still appears.

sys.getrecursionlimit() reports the ceiling on how many Python frames may be stacked at once, 1000 by default. When a call would go past it, CPython raises RecursionError instead of letting the thread run out of stack.

CPython performs no tail-call optimization: returning a call compiles to an ordinary call, so a new frame is pushed while the caller's frame stays alive to receive the result. Depth grows with every recursive step.

Seed a list with the root, then loop while it is non-empty: pop an item, do that node's work, and push its children. The list holds the pending work the frames used to hold.

sys.setrecursionlimit() moves CPython's own frame counter; it does not enlarge the thread's machine stack. Push far past what that stack really holds and the interpreter can die outright instead of raising a catchable RecursionError.

Copying builds an instance without running init, so _client is absent. Probing that blank object for a hook name falls through to getattr, which reads self._client, which is also absent, so getattr calls itself forever.