Historical Context & Motivation
Before object-oriented programming (OOP) became widespread, programmers stored data in loose collections of variables and functions. As software grew more complex in the 1960s and 1970s, developers needed a way to bundle data together with the behavior that operates on it. The concept of a class — a blueprint for creating objects — became the central organizing idea, and with it came a critical design question: should a piece of data belong to every object made from the class, or should it belong to the class blueprint itself?
The question at the heart of this lesson is deceptively simple: when you create a variable inside a class, does it belong to the blueprint itself (so every object shares it), or does it belong to each individual object (so each one can have its own value)? Getting this right is fundamental to writing clean, bug-free Python code.
Core Principles & Definitions
In Python, a class is a template or blueprint that describes what data and behavior its objects will have. When you call the class to create an object, you get an instance — a specific, concrete copy built from that template. Attributes are simply variables that store data, and the key distinction is where those variables are defined.
Class Attribute
Instance Attribute
__init__) using self.name = value. It is unique to each instance.Attribute Lookup Order
Mutability Matters
Visual Explanation
In the diagram above, notice how species lives in the class namespace and is shared. When you write dog1.species, Python doesn't find species on the instance, so it travels up to the class to retrieve it. Meanwhile, self.name and self.age are created in __init__ and stored directly on each instance. This separation is what allows two Dog objects to share a species but have completely different names.
How Attribute Lookup Works
Understanding attribute lookup is the key to mastering class and instance attributes. Every object in Python carries a hidden dictionary called __dict__ that holds its attributes. When you access obj.attribute, Python follows a specific search path.
The Lookup Chain
- Step 1: Python checks the instance's
__dict__for the attribute. - Step 2: If not found, Python checks the class's
__dict__. - Step 3: If still not found, Python checks parent classes (inheritance chain).
- Step 4: If nowhere is it found, Python raises an
AttributeError.
The Shadowing Effect
Here's where things get tricky. If you write dog1.species = "Wolf", Python does not modify the class attribute. Instead, it creates a new instance attribute called species on dog1 that shadows (hides) the class attribute. Now dog1.species returns "Wolf", but dog2.species still returns "Canis lupus" because dog2 still falls through to the class.
dog1.tricks.append("roll over") modifies the shared list in place. This means dog2.tricks will also show "roll over"! This is one of the most common bugs for Python beginners. Always define mutable data as instance attributes in __init__.Side-by-Side Comparison
| Feature | Class Attribute | Instance Attribute |
|---|---|---|
| Defined where? | Directly in class body | Inside __init__ using self |
| Scope | Shared across all instances | Unique to each instance |
| Memory | One copy in class __dict__ | One copy per instance __dict__ |
| Use case | Constants, counters, defaults | Object-specific state |
| Mutable types safe? | Risky — changes affect all instances | Safe — each instance gets its own copy |
Worked Example — Building a Student Class
Let's build a Student class that tracks the school name (shared by all students) and each student's individual name and GPA. We'll walk through every line and explain where each attribute lives.
school directly in the class body. Every student shares this value.
class Student:
school = "Lincoln High"
total_students = 0__init__, we use self to attach unique data to each instance. We also increment the class counter.
def __init__(self, name, gpa):
self.name = name
self.gpa = gpa
Student.total_students += 1s1 = Student("Alice", 3.9)
s2 = Student("Bob", 3.5)
Now s1.school returns "Lincoln High" (found in class), s1.name returns "Alice" (found in instance), and Student.total_students returns 2.s1.school = "Jefferson Academy"
This does NOT change the class attribute. Instead, Python creates a new instance attribute on s1 that shadows the class attribute. Now s1.school returns "Jefferson Academy", but s2.school still returns "Lincoln High".Student.school = "New Name". Using self.school = ... or s1.school = ... will only create a local instance attribute that shadows the class one.When to Use Class vs. Instance Attributes
Choosing the right type of attribute is a design decision. There are clear situations where each type is the best choice, and mixing them up can lead to confusing bugs or poor code organization.
| Scenario | Use Class Attribute? | Use Instance Attribute? |
|---|---|---|
| A value that should be the same for every object (e.g., pi for a Circle class) | ✅ Yes — define once, share everywhere | ❌ No — wastes memory repeating the same value |
| A counter tracking how many instances have been created | ✅ Yes — it describes the class, not one object | ❌ No — no single instance "owns" this count |
| A user's name, email, or score | ❌ No — each user is different | ✅ Yes — unique to each object |
| A list of items (e.g., a shopping cart) | ❌ Dangerous — mutable class attributes are shared! | ✅ Yes — create a new list in __init__ |
| A default configuration value that might be overridden | ✅ Works as a fallback default | ✅ Can shadow the default per instance |
Connections to Advanced OOP Concepts
Understanding class and instance attributes lays the groundwork for several more advanced Python and OOP topics you'll encounter as you continue learning. The distinction between "belongs to the class" and "belongs to the instance" recurs throughout object-oriented design.
| This Lesson's Concept | Advanced Extension |
|---|---|
| Class attribute (shared data) | Class methods — use @classmethod decorator to create methods that operate on class attributes instead of instance data |
| Instance attribute (per-object data) | Properties — use @property to add validation and computed values when getting or setting instance attributes |
| Attribute lookup chain | Inheritance — child classes add another level to the lookup chain; the MRO determines which class's attribute is found first |
| Shadowing a class attribute | Descriptors — Python's descriptor protocol (__get__, __set__) gives you fine-grained control over how attribute access is customized |
| Mutable class attribute trap | Slots — using __slots__ restricts which instance attributes can exist, saving memory and preventing accidental attribute creation |
As you progress, you'll see that the class-vs-instance pattern applies to methods too: regular methods receive self and operate on instance data, class methods receive cls and operate on class data, and static methods receive neither. Mastering attributes now makes these advanced ideas much easier to grasp.
Practice Problems
Car class.print(p2.school) output?
class Person:
school = "Westfield"
def __init__(self, name):
self.name = name
p1 = Person("Ana")
p2 = Person("Leo")
p1.school = "Eastside"print output, and why?
class Team:
members = []
def __init__(self, name):
self.name = name
Team.members.append(name)
t1 = Team("Alice")
t2 = Team("Bob")
print(t1.members)
print(t2.members)BankAccount class. The interest rate is 2.5% for all accounts, each account has its own owner name and balance, and you want to track the total number of accounts created. Write the class definition, identifying which data should be a class attribute and which should be an instance attribute. Explain your reasoning for each.Lesson Summary
In Python, class attributes are variables defined directly in the class body and are shared by all instances, making them ideal for constants, counters, and default values. In contrast, instance attributes are defined inside __init__ using self and are unique to each object, perfect for storing data that differs from one instance to another.
Python's attribute lookup chain checks the instance first, then the class, then parent classes. Assigning to an instance can shadow a class attribute without changing it. Be especially careful with mutable class attributes like lists — modifying them in place affects all instances. When in doubt, make it an instance attribute in __init__.