Question 1

Reading from enclosing scope

Accepted Answer

Python's LEGB rule means a function can read a variable from an outer (global) scope without any special declaration. show() has no local x, so Python moves up to the global scope and finds x = 10. You only need global or nonlocal when you want to assign to a name in an outer scope - reading is free.

Question 2

Default argument evaluation

Accepted Answer

Default values are evaluated exactly once at function definition time, not on each call. That's why using a mutable object like a list as a default is a classic bug - all calls share the same list object. The fix is to use None as the default and create the mutable object inside the function body. Many developers assume defaults are re-evaluated per call, which is why this catches people off guard.

Question 3

Implicit None return

Accepted Answer

A function that never executes a return statement returns None. The expression x * 2 is evaluated but its result is immediately discarded because there is no return keyword. The most tempting wrong answer is 10, but that would require writing return x * 2. Forgetting return is one of the most common silent bugs in Python - the function runs without error and just hands back nothing.

Question 4

What *args does

Accepted Answer

*args in a function definition gathers all extra positional arguments passed by the caller into a single tuple. The name 'args' is a convention - the star is what matters. A common confusion: *args in a function definition collects; *iterable at a call site unpacks. They use the same syntax for opposite operations.

Question 5

What **kwargs does

Accepted Answer

**kwargs gathers all extra keyword arguments (name=value pairs) into a regular dict. It pairs naturally with *args: def f(*args, **kwargs) accepts any combination of positional and keyword arguments. This pattern is heavily used in decorator and wrapper functions where you need to forward all arguments to another function without knowing them in advance.

Question 6

Closure variable capture

Accepted Answer

Each call to make_adder creates a new closure with its own independent copy of n. add5 captures n=5 and add10 captures n=10. Calling add5(3) returns 3 + 5 = 8, and add10(3) returns 3 + 10 = 13. The closures don't share state - that's exactly what makes this pattern useful for building specialized functions from a factory.

Question 7

*args and **kwargs types

Accepted Answer

*args collects extra positional arguments into a tuple, not a list. **kwargs collects extra keyword arguments into a regular dict. The tuple vs list distinction matters when you try to do something like args.append() - that will fail because tuples are immutable. If you need to modify the collected arguments, convert with list(args) first.

Question 8

Mutable default argument bug

Accepted Answer

The default list [] is created once when the def statement runs. Every call that omits lst shares that same list object, so items accumulate across calls. The first call appends 1 and returns [1]. The second call appends 2 to the same list and returns [1, 2]. The fix is def append_to(item, lst=None) with lst = [] inside the function body.

Question 9

Assignment without global

Accepted Answer

Assigning to count inside the function (count += 1 is count = count + 1) makes Python treat count as a local variable in that function. But count is read on the right-hand side before it has been assigned locally, which raises an UnboundLocalError. To modify the global count, you must declare global count at the top of the function. The tricky part is that Python decides at compile time whether a name is local - the presence of any assignment to count anywhere in the function body is enough to make it local.

Question 10

What a closure is

Accepted Answer

When a nested function references a variable from its outer function, Python keeps that variable alive in the closure's __closure__ attribute, even after the outer call finishes. This lets you build stateful functions without classes - make_counter() returning a counter() that increments its own n is the classic example. The tricky part is that closures capture variables by reference, not value, which is why the late-binding loop bug catches people off guard.

Question 11

What nonlocal does

Accepted Answer

nonlocal is the closure counterpart to global. Without it, assigning to a name inside a nested function creates a new local variable rather than modifying the enclosing one. The classic use case is a stateful counter inside a factory function: the inner function needs nonlocal n to increment n in the outer function's scope. Unlike global, nonlocal does not reach all the way to the module level - it stops at the nearest enclosing function that has the name.

Question 12

What LEGB means

Accepted Answer

When Python sees a name like x, it looks first in the current function's local scope, then in any enclosing function scopes (for closures), then in the module-level global scope, and finally in the built-in scope where names like len and print live. The search stops at the first match. If none is found, you get a NameError. You need global or nonlocal only when assigning to a name in an outer scope - reading follows LEGB automatically.

Question 13

Closure late binding

Accepted Answer

Closures in Python capture variables by reference, not by value. All three functions close over the same i variable in the enclosing (global here) scope. By the time any of them are called, the loop has finished and i is 2, so every function returns 2. The fix is to force capture by value using a default argument: def f(i=i): return i. Default arguments are evaluated at definition time, so each function gets its own snapshot of i.

Question 14

nonlocal counter

Accepted Answer

nonlocal n tells Python that n inside counter refers to the n in make_counter's enclosing scope, not a new local variable. Without nonlocal, n += 1 would create a local n and raise UnboundLocalError on the read of n before assignment. Each call to c() increments the same n and returns the new value, so you get 1, 2, 3. This is the standard pattern for stateful closures - the counter state lives in the closure's enclosing scope rather than in a class or global variable.

Question 15

Unpacking into function call

Accepted Answer

*nums unpacks the list into three positional arguments, so add(1, 2, 3) returns 6. add(1, 2, **opts) unpacks opts as keyword arguments, passing c=10, so the call becomes add(1, 2, c=10) which returns 13. The second call would raise a TypeError if opts contained a key that isn't a parameter name - Python validates keyword argument names at call time. These unpacking operators are especially handy when forwarding arguments from one function to another.

Functions & Scope