Class Attributes and Instance Attributes

Every attribute you have written so far was assigned in __init__ or listed in a dataclass, and each object got its own. There is a second place an attribute can live, and it belongs to the class rather than to any object.

One value for the whole class

default_points is assigned in the class body, not in __init__. There is exactly one of it, shared by every Question, and it can be read through the class itself without any object existing.

Instance attributes answer “what is true of this one object?” Class attributes answer “what is true of every object of this kind?”

Reading, and the surprise

Reading works through either. Assigning does not do what it looks like:

5, 1, 1.

Assigning through an object did not change the class attribute. It created a new instance attribute on first that shadows it. second and the class are untouched, and first now has its own value that will never follow the class again.

To change it for everyone, assign through the class:

first still reports 5, because it has its own now. second reports 3, because it is still reading the class.

The one that bites

That rule is mostly a curiosity. It becomes a bug when the class attribute is mutable:

The final exam contains the review’s question. self.questions.append(...) never assigned anything, so no instance attribute was created: it found the one shared list and appended to it.

This is the same trap as the mutable default from Lesson 4, arriving by a different door. The fix is the same idea: give each object its own.

class Quiz:
    def __init__(self, title):
        self.title = title
        self.questions = []

In a dataclass, use field(default_factory=list). A mutable class attribute is shared state. Use one only when that sharing is deliberate and the class owns clear operations for it; per-object collections belong on each instance.

What class attributes are actually good for

Used for their real purpose, they are useful and safe. Constants that belong to the class:

MAX_POINTS is a fact about questions in general, so keeping it in the class is more honest than a module-level variable, and it is readable as Question.MAX_POINTS from anywhere. The uppercase name is the usual signal that a value is not meant to change.

Note what @dataclass did with those two lines: nothing. They have no annotation, so they are not fields, they do not appear in __init__ or the repr, and they are not compared. For the syntax used in this chapter, an annotated name is a field and an unannotated name is a plain class attribute. Advanced annotations such as typing.ClassVar can explicitly mark an annotated class attribute, but that is outside this lesson.

No MAX_POINTS in the repr, exactly as intended.

The exercise uses class attributes for the two things they are good at, and repairs one that was used for something they are bad at.