Instance vs Class Attributes

An attribute defined in the class body belongs to the class and is shared by every instance. An attribute assigned to self belongs to that one object.

class Dog:
    species = "canine"        # class attribute
    count = 0

    def __init__(self, name):
        self.name = name        # instance attribute
        Dog.count += 1


a = Dog("Rex")
b = Dog("Fido")

print(a.species, b.species)       # canine canine
print(Dog.count)                  # 2 - shared by every instance

# Assigning on an instance shadows the class attribute
a.species = "puppy"
print(a.species)                  # puppy
print(b.species)                  # canine - untouched
print(Dog.species)                # canine - untouched

Three different scopes are visible in that output. The name attribute lives on each instance separately. The species attribute was found on the class through both instances until a.species was assigned, at which point a got its own entry in its instance dictionary that shadows the class one. The count attribute was incremented on the class explicitly with Dog.count, so it stayed shared — but note that Dog.count += 1 inside a method reads the class attribute and writes back to the class, which is the standard way to keep a shared counter.

The lookup rule is the thing to state clearly: attribute access checks the instance dictionary first, then the class. That is why instance attributes shadow class attributes, and why deleting an instance attribute with del a.species makes the class attribute visible again.

A class attribute is written in the class body and lives on the class itself, so every instance sees the same object unless it shadows it. An instance attribute is written as self.something and lives in that instance's own dictionary.

Python's lookup order is instance first, then class. Reading an attribute checks the instance dictionary and falls back to the class, so instance attributes shadow class attributes of the same name.

How you change them follows from that. Assigning to an instance attribute — self.value = x — creates an entry in that instance's dictionary and leaves the class attribute alone. Assigning to a class attribute — Dog.value = x — changes it for every instance that has not shadowed it. That is the difference between the two lines that look superficially similar.

Two things catch people out. A mutable class attribute is a genuine bug source: a list in the class body is one shared list, and appending to it from any instance affects all of them. And reading a class attribute from a method that then assigns to it creates an instance attribute rather than changing the class one, which is why counters are written as Class.count += 1 explicitly.

The safe rules are simple: use class attributes for constants and for genuinely shared configuration, use instance attributes for per-object state, and never mutate a mutable class attribute from an instance method.