Output Puzzles: Scope, Closures in Loops and Class vs Instance Attributes

45 min · Intermediate

These puzzles are about where a name lives and when its value is read. A function looks names up when it runs, not when it is defined. A class attribute is shared, until an instance gets its own attribute with the same name.

The LEGB rule

The LEGB rule is the order Python searches for a name: Local scope, Enclosing function scopes, Global (module) scope, then Built-ins. The first match wins.

Python looks for a name in four places, in order: Local, Enclosing function, Global, then Built-in. Assigning to a name anywhere inside a function makes that name local for the whole function.

Java

1count = 02
3def read():4    return count5
6def bump():7    count += 18
9print(read())10# bump() raises UnboundLocalError

Example 1 · Which x is printed?

Python

1x = 12
3def change():4    x = 25
6def show():7    print(x)8
9change()10show()11x = 2012show()

Output

1
20

What this code does

x = 2 inside change makes a new local name, so the global stays 1.
show reads the global when it runs, so it sees the new value 20 later.

read() only looks at count, so it finds the global and prints 0. In bump, the += makes count local, but it has no value yet, so the call fails.

Closures and nonlocal

A closure is a function that keeps access to variables from the function in which it was defined, even after that function has returned. It holds the variable, not a snapshot of its value.

A closure is an inner function that remembers variables of the outer function. It remembers the variable itself, not a copy of its value at that moment. To rebind such a variable, the inner function needs nonlocal.

Java

1def make_counter():2    n = 03    def inc():4        nonlocal n5        n += 16        return n7    return inc8
9a, b = make_counter(), make_counter()10a(); a()11print(a(), b())

This prints 3 1. Each call to make_counter creates its own n, so a and b count separately.

Late binding in loops

A function reads a variable when it runs. Lambdas made in a loop all share the loop variable, so they all see its final value. A default argument is read when the lambda is created, which fixes this.

Java

late = [lambda: i for i in range(3)]print([f() for f in late])fixed = [lambda i=i: i for i in range(3)]print([f() for f in fixed])

Example 2 · Lambdas in a loop, three ways

Python

1late = [lambda: n for n in range(3)]2default = [lambda n=n: n for n in range(3)]3
4def make(n):5    return lambda: n6
7factory = [make(n) for n in range(3)]8print([f() for f in late])9print([f() for f in default])10print([f() for f in factory])

Output

[2, 2, 2]
[0, 1, 2]
[0, 1, 2]

What this code does

The first list reads the shared n after the loop ends.
A default argument or a factory function captures the value at creation time.

This prints [2, 2, 2], then [0, 1, 2]. In the first list every lambda reads the same i, which ended at 2.

Class vs instance attributes

A class attribute is a variable defined in the class body and shared by every instance. Assigning the same name on one instance creates a separate instance attribute that hides it for that object only.

An attribute set in the class body is shared by all instances. Reading obj.name looks at the instance first, then the class. Assigning obj.name = ... always creates an instance attribute and does not touch the class.

Java

1class Account:2    rate = 53
4a, b = Account(), Account()5a.rate = 96Account.rate = 77print(a.rate, b.rate)8
9class Cart:10    items = []11
12x, y = Cart(), Cart()13x.items.append("pen")14print(y.items)

Example 3 · Counting instances with a class attribute

Python

1class Counter:2    count = 03
4    def hit(self):5        self.count += 16
7a, b = Counter(), Counter()8a.hit()9a.hit()10b.hit()11print(Counter.count, a.count, b.count)

Output

0 2 1

What this code does

self.count += 1 reads the class value, adds 1, then stores the result on the instance.
The class attribute is never changed, so it stays 0.

Example 4 · Subclasses and class attributes

Python

1class Base:2    level = 13    tags = []4
5class Child(Base):6    pass7
8Child.level = 29Child.tags.append("x")10print(Base.level, Child.level)11print(Base.tags)

Output

1 2
['x']

What this code does

Assigning on Child creates a new attribute there; Base.level stays 1.
append changes the one list that both classes can see.

This prints 9 7, then ['pen']. a has its own rate, but x.items.append changes the one list shared by the class.

Next step

Check your understanding

12 quick questions

The LEGB rule

The LEGB rule is the order Python searches for a name: Local scope, Enclosing function scopes, Global (module) scope, then Built-ins. The first match wins.

Python looks for a name in four places, in order: Local, Enclosing function, Global, then Built-in. Assigning to a name anywhere inside a function makes that name local for the whole function.

Closures and nonlocal

A closure is a function that keeps access to variables from the function in which it was defined, even after that function has returned. It holds the variable, not a snapshot of its value.

1late = [lambda: n for n in range(3)]2default = [lambda n=n: n for n in range(3)]3 4def make(n):5 return lambda: n6 7factory = [make(n) for n in range(3)]8print([f() for f in late])9print([f() for f in default])10print([f() for f in factory])

Class vs instance attributes

1class Account:2 rate = 53 4a, b = Account(), Account()5a.rate = 96Account.rate = 77print(a.rate, b.rate)8 9class Cart:10 items = []11 12x, y = Cart(), Cart()13x.items.append("pen")14print(y.items)