Shared Class Variables Across Active Instances

🏷️ Object-Oriented Programming (OOP) Basics / Class vs Instance Attributes

📚 All-in-One📖 Theory Only💻 Code Only

🧠 Context Introduction

When you create multiple objects (instances) from the same class, each instance normally gets its own copy of instance attributes. However, class variables are different—they are shared across all active instances of that class. This means if one instance modifies a class variable, every other instance sees that change immediately. Understanding this distinction is crucial for writing predictable and bug-free Python code.

⚙️ What Are Class Variables?

Class variables are defined directly inside the class body, outside any methods.
They belong to the class itself, not to any single instance.
All instances of the class share the same memory location for that variable.
They are accessed using the class name (e.g., ClassName.variable) or through an instance (e.g., instance.variable).

🆚 Class Variables vs Instance Variables

Feature	Class Variables	Instance Variables
Where defined	Inside class, outside methods	Inside init or other methods
Ownership	Belongs to the class	Belongs to each instance
Memory	Single copy shared by all instances	Separate copy per instance
Change effect	Affects all instances	Affects only that instance
Access syntax	ClassName.variable or instance.variable	self.variable or instance.variable

🛠️ How Shared Class Variables Work

When you define a variable at the class level, Python stores it in the class's namespace.
Every instance you create can read that variable directly.
If you modify the variable using the class name, the change propagates to all instances.
If you modify it using an instance, Python creates a new instance variable that shadows the class variable for that specific instance only.

🕵️ Practical Example: Tracking All Instances

Imagine you want to keep count of how many instances of a class have been created. A class variable is perfect for this:

Define a class variable called instance_count and set it to 0.
Inside the init method, increment instance_count by 1.
Every time a new object is created, the counter increases for all existing objects.

Another common use is storing a list of all active instances:

Define a class variable called all_instances as an empty list.
Inside init, append self to that list.
Now any instance can access the complete list of all objects ever created.

⚠️ Common Pitfall: Shadowing Class Variables

A frequent mistake is accidentally creating an instance variable that hides the class variable:

If you write self.variable = new_value inside an instance, Python creates a new instance attribute.
The original class variable remains unchanged and is still accessible via ClassName.variable.
Other instances continue to see the original class variable value.

To safely modify a class variable from an instance, always use the class name: ClassName.variable = new_value.

📊 When to Use Shared Class Variables

Configuration defaults that should apply to all instances unless overridden
Tracking metadata like instance counts, creation timestamps, or logging settings
Shared resources such as database connections or API clients
Registry patterns where you need to know about all active objects

🧪 Testing Your Understanding

Consider this scenario: You have a class with a class variable default_color = "blue". You create two instances. The first instance sets self.default_color = "red". What color does the second instance see?

The second instance still sees "blue" because the first instance only created a new instance variable.
The class variable default_color remains "blue" for all other instances.

To change it for all instances, you would need to write ClassName.default_color = "red".

✅ Key Takeaways

Class variables are shared memory across all instances of a class.
Modifying a class variable via the class name affects every instance.
Modifying it via an instance creates a separate copy for that instance only.
Use class variables for data that should be consistent across all objects.
Always be deliberate about whether you intend to modify a class variable or create an instance variable.

A shared class variable is a value stored on the class itself that all instances of that class can access and modify together.

🧱 Example 1: Defining a shared class variable

This example shows how to create a variable that belongs to the class, not to any single instance.

class Employee:
    company_name = "BuildCorp"

print(Employee.company_name)

📤 Output: BuildCorp

🔗 Example 2: All instances see the same shared variable

This example demonstrates that every instance reads the same value from the class.

class Employee:
    company_name = "BuildCorp"

alice = Employee()
bob = Employee()

print(alice.company_name)
print(bob.company_name)

📤 Output: BuildCorp
BuildCorp

✏️ Example 3: Changing the shared variable through the class

This example shows how updating the class variable changes it for all existing instances.

class Employee:
    company_name = "BuildCorp"

alice = Employee()
bob = Employee()

Employee.company_name = "MegaBuild"

print(alice.company_name)
print(bob.company_name)

📤 Output: MegaBuild
MegaBuild

⚠️ Example 4: Assigning to an instance creates a separate copy

This example shows that assigning to an instance variable with the same name does not change the shared class variable.

class Employee:
    company_name = "BuildCorp"

alice = Employee()
bob = Employee()

alice.company_name = "AliceCorp"

print(alice.company_name)
print(bob.company_name)
print(Employee.company_name)

📤 Output: AliceCorp
BuildCorp
BuildCorp

📊 Example 5: Tracking active instance count with a shared variable

This example shows a practical use — counting how many instances exist at any time.

class Employee:
    active_count = 0

    def __init__(self, name):
        self.name = name
        Employee.active_count += 1

    def leave(self):
        Employee.active_count -= 1

alice = Employee("Alice")
bob = Employee("Bob")
print(Employee.active_count)

bob.leave()
print(Employee.active_count)

📤 Output: 2
1

📋 Comparison: Class Variable vs Instance Variable

Feature	Class Variable	Instance Variable
Defined where	Inside class, outside methods	Inside `__init__` or other methods
Shared across instances	Yes	No
Changed via class	Affects all instances	Does not affect class
Changed via instance	Creates a new instance variable	Only affects that instance
Typical use	Constants, counters, shared settings	Unique data per instance