Introduction

Imagine you’re working on a project and using a Config class to store settings. Everything seems smooth—until you change a setting in one instance, and suddenly every other instance of Config reflects that change. You didn’t expect this behavior. Why did it happen? The culprit is a class variable being shared across all instances. In Python, class variables are shared by default. To prevent this, a shift in your variable declaration strategy is essential.

The Issue: Class Variables vs Instance Variables

Let’s say you define your class like this:

pythonCopyEditclass Config:
    settings = {"theme": "light", "language": "en"}

Now, every time you create a new instance of Config, it uses the same settings dictionary. So if you modify it in one instance:

pythonCopyEdita = Config()
b = Config()
a.settings["theme"] = "dark"
print(b.settings["theme"])  # Output: dark

You didn’t change b.settings, yet it reflects the change made in a.settings. This happens because settings is a class variable—shared among all instances.

This behavior is what most developers intuitively expect when working with objects.

The Solution: Use Instance Variables

To prevent this behavior, define settings as an instance variable inside the __init__ method. This ensures that each instance has its own copy:

pythonCopyEditclass Config:
    def __init__(self):
        self.settings = {"theme": "light", "language": "en"}

Now each time you create a Config object, a new dictionary is created for settings. So modifying one won’t affect the others:

pythonCopyEdita = Config()
b = Config()
a.settings["theme"] = "dark"
print(b.settings["theme"])  # Output: light

This behavior is what most developers intuitively expect when working with objects.

Conclusion

In Python, understanding the difference between class and instance variables is crucial to managing state safely across objects. If you’re seeing unexpected shared state between instances, check whether your variable is defined at the class level. The fix is simple: move the variable to the constructor using self, and your instances will operate independently—just as you intended.