After this lesson, you will be able to:

• Distinguish attributes belonging to the class from attributes belonging to each instance.
• Read and update a shared class setting without accidentally overriding only one object.
• Recognize how an instance attribute can shadow a class attribute with the same name.
• Avoid accidentally sharing mutable lists between instances by creating them in __init__.

An instance attribute is stored on one object, usually assigned in __init__ as self.name = name. A class attribute is written in the class body and is shared as a default by every instance of that class:

class Worker:
    region = "eu"

    def __init__(self, name):
        self.name = name

Worker.region reads the class setting. worker.region also reads it until that particular object has its own region attribute. If you assign worker.region = "us", that object now shadows the class setting; it does not update the other workers.

For genuinely shared configuration, update Worker.region (the class), not one instance. For per-object state such as a worker's name, retries, or event history, use self.attribute inside __init__.

Important mutable-state pitfall: a list defined in the class body can be shared by all instances. If each instance needs its own list, create self.events = [] in the constructor.

1. A class attribute supplies a shared setting

class ApiClient:
    scheme = "https"

    def __init__(self, service):
        self.service = service

first = ApiClient("users")
second = ApiClient("billing")
print(f"{first.service}: {first.scheme}")
print(f"{second.service}: {second.scheme}")

Output:

users: https
billing: https

Both objects read the same class setting while keeping their own service names.

2. Changing the class setting affects unshadowed instances

class Job:
    mode = "safe"

first = Job()
second = Job()
Job.mode = "fast"
print(first.mode)
print(second.mode)

Output:

fast
fast

No instance defines its own mode, so both still read the class attribute.

3. Assignment on one instance shadows the class setting

class Storage:
    tier = "standard"

primary = Storage()
backup = Storage()
primary.tier = "premium"
print(primary.tier)
print(backup.tier)
print(Storage.tier)

Output:

premium
standard
standard

primary.tier became an instance attribute; the shared class default was unchanged.

4. Keep mutable event lists separate

class Monitor:
    def __init__(self, name):
        self.name = name
        self.events = []

    def record(self, event):
        self.events.append(event)

api = Monitor("api")
queue = Monitor("queue")
api.record("started")
print(api.events)
print(queue.events)

Output:

['started']
[]

Each constructor call creates a fresh list for one monitor.

• obj.setting = value does not change ClassName.setting; it creates or updates an instance attribute.
• A list declared as a class attribute is a single list unless each instance replaces it with its own list.
• Assigning self.name in the class body is not how instance initialization works; use __init__.
• A class attribute is appropriate only when its shared behavior is deliberate.