Exercises — global and nonlocal keywords

• (i) not needed. We only read total. Rule R climbs the ladder: no local total, so it finds the global. Reading never needs a keyword.
• (ii) needed → global total. We assign total. By Rule A this makes a brand-new local total = 5 and the module one is untouched. To change the module variable you must declare global total.
• (iii) not needed. mylist.append(3) is a mutation of the object, not a rebinding of the name mylist. There is no mylist = ..., so Rule A never fires. See Mutable vs Immutable objects.
• (iv) needed → global total. Worse than (ii): here the right-hand side reads total, but Rule A already marked it local, so the read finds the local-with-no-value → UnboundLocalError. global total fixes both sides.

• (i) B (Built-in). len isn't defined locally, in an enclosing func, or at module level → it comes from the Built-in scope. (This is the final rung of LEGB.)
• (ii) E (Enclosing). inner has no local name; the nearest enclosing function outer has name = "mid", so it prints mid. It stops there — it does NOT keep climbing to the module "top".
• (iii) B (Built-in). No local, enclosing, or global len, so again Built-in.

20 global x cancels Rule A: x is the module variable everywhere in f. Start x = 10. First call: 10 + 5 = 15. Second call: 15 + 5 = 20. Print 20.

3 6 9 add is a closure over make_adder's locals total and step. nonlocal total points add's assignment back to the enclosing total (the "next-door box"), which survives between calls. step = 3. Calls: 0+3=3, 3+3=6, 6+3=9 → prints 3 6 9.

1 101 Trace carefully — this is the classic global-vs-nonlocal confusion:

• inner says global count, so it edits the module count (100), NOT outer's local count (1). Module becomes 101.
• outer returns its OWN local count, which was never touched → 1.
• So outer() → 1, and module count → 101. Prints 1 101.

UnboundLocalError n += 1 is n = n + 1, an assignment. Rule A stamps n local for all of tick. The right-hand side then reads the local n, which has no value yet → UnboundLocalError: local variable 'n' referenced before assignment. See UnboundLocalError. Fix: add global n as the first line of tick, so n refers to the module variable on both sides.

SyntaxError: no binding for nonlocal 'k' found nonlocal needs an already-existing variable in an enclosing function scope to bind to. In f there is no k defined anywhere, so g's nonlocal k has no enclosing k to point at. Unlike global (which will happily create a module-level name), nonlocal refuses at compile time. Fix: define k = 0 inside f before g uses it.

• add_ok: data.append(1) never writes data = .... It only mutates the list object the name already points to. No assignment ⇒ Rule A never fires ⇒ data stays the global one ⇒ works.
• add_bad: data = data + [1] rebinds the name data. Rule A makes data local; the right-hand side reads the not-yet-assigned local → UnboundLocalError. Fix with global data, or better, mutate: data.append(1). See Mutable vs Immutable objects.

def bank():
    money = 0
    def deposit(amount):
        nonlocal money      # rebinding the enclosing 'money'
        money += amount
    def balance():
        return money        # only reading -> no keyword needed
    return deposit, balance
 
d, b = bank()
d(100); d(50)
print(b())   # 150

money lives in bank. deposit rebinds it → needs nonlocal. balance only reads it → needs nothing (Rule R climbs to the enclosing scope). Both closures share the same money box, so deposits are visible to balance. Result: 150.

As written, global x makes inner edit the module x → module becomes "enclosing_changed", but outer's local x is untouched, so it prints "enclosing_original" then "enclosing_changed" — the opposite of the spec. Fix: change global x to nonlocal x:

def inner():
    nonlocal x
    x = "enclosing_changed"

Now inner rebinds outer's x → outer prints "enclosing_changed"; the module x is never touched → prints "global_original". ✓

E2, E2, G2 Track two separate boxes: the module v and outer's v.

1. mid: nonlocal v → binds to outer's v; sets it to "E2".
2. inner: global v → binds to the module v; sets it to "G2". This does NOT touch outer's v.
3. print(v) at (1) is inside mid, whose v is outer's v = "E2".
4. print(v) at (2) is inside outer, its v = "E2".
5. print(v) at (3) is module level = "G2". Output: E2, E2, G2.

[2, 2, 2] Each f is a closure that reads i from the enclosing scope (the module here) at call time, not creation time. By the time we call them, the loop is over and i == 2, so all three return 2. Fix — capture the value now via a default argument:

funcs = []
for i in range(3):
    def f(i=i):     # default is evaluated NOW, binding a fresh local i
        return i
    funcs.append(f)
print([g() for g in funcs])   # [0, 1, 2]

A default argument is evaluated at def time and stored per-function, so each f gets its own frozen i. Result: [0, 1, 2].

Rebinding a module-level counter from inside a top-level function ::: global Rebinding a variable that lives in the enclosing function of a closure ::: nonlocal Calling .append() on a global list ::: neither (mutation, not rebinding) print()-ing an outer variable you never assign ::: neither (pure read) x = x + 1 where x is only defined at module top ::: global (else UnboundLocalError)