Class Attributes: Solutions

# exercise_1.py
class Stars:
    rating = 5

a = Stars()
b = Stars()
a.rating = 1  # Shadows the class attribute on 'a' only
Stars.rating = 9  # Changes the shared class attribute
c = Stars()
print(c.rating)
#: 9

c is a brand-new instance with no instance attribute of its own, so reading c.rating falls back to the class attribute, which is now 9. c.rating differs from a.rating (still 1) because a got its own shadowing instance attribute when a.rating = 1 ran, before Stars.rating = 9 ran. c shadows nothing, so it sees whatever the class attribute currently holds.

# exercise_2.py
from typing import ClassVar

class Base:
    shared: ClassVar[int] = 0

class Left(Base):
    pass

class Middle(Base):
    pass

class Right(Base):
    shared = 100  # Its own class attr, separate from Base's

print(Left.shared, Middle.shared, Right.shared)
#: 0 0 100
Base.shared = 9
print(Left.shared, Middle.shared, Right.shared)
#: 9 9 100
Left.shared = 5
print(Base.shared, Left.shared, Middle.shared, Right.shared)
#: 9 5 9 100

Middle behaves like Left: neither declares its own shared, so both track Base.shared through the normal attribute lookup chain, until something assigns to Left.shared or Middle.shared directly. Right holds 100 throughout, because it creates its own separate class attribute the moment its class body runs shared = 100.

# exercise_3.py
from dataclasses import dataclass

@dataclass
class B:
    x: int = 100  # Constructor default, not class attribute

b = B()
b.x = -1
b2 = B()
print(b.x, b2.x)
#: -1 100

Each call to B() runs the generated __init__(), which assigns 100 to self.x as a fresh instance attribute for that particular object. b.x = -1 touches b’s own attribute. b2 comes from its own B() call and keeps its own 100. real_defaults.py demonstrates the same guarantee with A: a constructor default creates one value per instance, unlike a class-body attribute, which creates one value shared by all instances until something shadows it.

# exercise_5.py
from dataclasses import dataclass, field

@dataclass
class Cart:
    items: list[str] = field(default_factory=list)

a, b = Cart(), Cart()
a.items.append("apple")
print(a.items, b.items)
#: ['apple'] []

Build a list per instance. default_factory=list calls list() once per construction, so the generated __init__() assigns a brand-new list to self.items on every Cart. Each object owns its list from birth, and a’s append cannot reach b.

@dataclass refuses to build the same class written with a bare items: list[str] = [], so the shared-list bug cannot arise:

# exercise_5_rejected.py
from dataclasses import dataclass
from exceptions import expected

with expected(ValueError):
    @dataclass
    class Cart:
        items: list[str] = []
#: [ValueError] mutable default <class 'list'> for field
#: items is not allowed: use default_factory

Fail at class definition. @dataclass raises the ValueError at class-definition time, not at first use, and the full message ends with the remedy: use default_factory. @dataclass detects the mistake because it inspects every default before generating the constructor. Nobody inspects a plain class body, so shared_mutable.py’s Cart builds without complaint.

# exercise_6.py
from exceptions import expected

class A:
    x = 100

a = A()
a.x = 1
print(vars(a), a.x)
#: {'x': 1} 1
del a.x
print(vars(a), a.x)
#: {} 100
with expected(AttributeError):
    del a.x
#: [AttributeError] 'A' object has no attribute 'x'

Remove the shadow. del a.x removes the entry from the instance dictionary, which is the only place assignment writes. vars(a) is empty again, and a.x reads 100, because the lookup falls back to the class the way it did before any assignment. The class attribute keeps its 100 throughout: the assignment and the del both stay on the instance.

Show that deletes stop at the instance. The second del a.x fails because the instance dictionary is empty. del stops at the instance, the way assignment does, so vars(A)["x"] keeps its 100. Deleting the class attribute takes del A.x, naming the class. The asymmetry is the same one assignment has: reads fall back to the class, writes and deletes do not.

# exercise_8.py
from typing import ClassVar

class Base:
    shared: ClassVar[list[int]] = []

class Left(Base):
    pass

class Right(Base):
    pass

Left.shared.append(1)
Right.shared.append(2)
print(Base.shared, Left.shared, Right.shared)
#: [1, 2] [1, 2] [1, 2]
print(Left.shared is Base.shared)
#: True

class Base2:
    shared: ClassVar[list[int]] = []

class Left2(Base2):
    pass

class Right2(Base2):
    shared = []  # Its own list, separate from Base2's

Left2.shared.append(1)
Right2.shared.append(2)
print(Base2.shared, Left2.shared, Right2.shared)
#: [1] [1] [2]

Share one list across the hierarchy. Base.shared holds [1, 2], and so do both subclasses, because all three names share one list. Neither Left nor Right declares its own, so both names read through to Base, and .append() mutates what it finds there. Left.shared is Base.shared proves they are one object, not three equal lists.

Here the mutable-value trap of shared_mutable.py meets the inheritance rule of class_var_inheritance.py. Each is harmless on its own: an immutable ClassVar survives inheritance because nothing can change it in place, and a mutable one in a single class keeps the sharing visible. Together they produce a base-class list that every subclass writes to and none of them declares.

Give one subclass its own list. Giving Right2 its own shared = [] splits off Right2 alone. The assignment in the class body creates a new entry in Right2’s own dictionary, so Right2.shared stops reading through to Base2, while Left2 still shares Base2’s list. The result, [1] [1] [2], follows the same rule the integer shared in exercise 2 shows: one value per class that declares it.

The bug this listing models is a list each subclass treats as its own, declared once on the base class. Every subclass appends its entries, and they all arrive in the one list. When one shared table is the intent, as in a registry of subclasses, the same code is correct. When each owner needs its own list, build the mutable value per owner rather than once in the class body. A default_factory field gives each instance its own list, and __init_subclass__() gives each subclass its own.