Instance Variables vs. Class Variables

What Are Instance and Class Variables?

When you create a class, you can define fields—variables that belong to that class. These fields come in two distinct flavors. Instance variables belong to each individual object created from the class; every instance gets its own copy. Class variables, by contrast, belong to the class itself and are shared across all instances of that class. Think of a class as a blueprint for a house: the instance variables are like the furniture inside each house (each house has its own set), while class variables are like the architectural style (all houses built from the same blueprint share that style).

Understanding Scope and Lifetime

The fundamental difference between these two variable types lies in their scope and lifetime. An instance variable exists only for the lifetime of a specific object. When you create a new instance, that instance gets its own set of instance variables. When that instance is destroyed, its instance variables disappear. A class variable, however, exists for the lifetime of the class itself—from the moment the class is defined until the program ends. It persists even if no instances of the class currently exist.

The diagram above shows how a class variable (count) lives at the class level and is shared, while instance variables (name and age) are stored separately for each instance. Each instance has its own copy of name and age, but all instances reference the same class variable.

How Storage and Access Work

Instance variables are stored in the memory space allocated for each individual object. When you access an instance variable through an object, the runtime looks up that specific object's memory location and retrieves the value stored there. Class variables are stored in the memory space allocated for the class itself, not in any individual instance. When you access a class variable through an instance, the runtime first checks if the instance has its own version of that variable; if not, it looks up the class-level variable.

This two-tier lookup mechanism is crucial to understanding how class variables work. When you modify a class variable, you are changing the value in the class's memory space, so all instances see that change. When you modify an instance variable, you are changing only that instance's copy, leaving other instances unaffected.

Predicting Changes: What Happens When You Modify a Variable?

Worked Example: A Student Class

Common Mistakes

• Assuming that modifying a class variable through one instance does not affect other instances

  If count is a class variable, there is only one copy shared by all instances. Modifying it through any instance changes the shared value for all instances.

  Fix: If you want each instance to have its own independent count, make count an instance variable initialized in the constructor, not a class variable.

• Confusing class variables with instance variables when reading code

  Variables defined at the class level (outside methods) are class variables, not instance variables. Instance variables are typically defined inside the constructor or other methods.

  Fix: Look at where the variable is defined. If it is at the class level, it is a class variable. If it is defined inside a method (especially the constructor) using self, it is an instance variable.

• Forgetting that class variables persist even when no instances exist

  Class variables belong to the class, not to instances. They exist for the lifetime of the class, independent of whether any instances currently exist.

  Fix: If you need a variable that resets for each instance, use an instance variable. If you need a persistent counter across all instances, use a class variable and manage its lifecycle explicitly.

• Accidentally creating an instance variable that shadows a class variable

  When you assign to self.variable_name, you create an instance variable. If a class variable with the same name exists, the instance variable shadows it for that instance only.

  Fix: Be intentional about whether you want to modify the class variable or create an instance variable. Use ClassName.variable_name to access and modify class variables explicitly if you need to avoid shadowing.

When to Use Each Type

Use instance variables when each object needs its own independent copy of a value. Examples include a person's name, an account's balance, or a student's grade. These values are specific to that object and should not be shared with other instances.

Use class variables when you need a value that is shared across all instances or that represents a property of the class itself. Examples include a counter tracking how many instances have been created, a configuration setting that applies to all instances, or a constant that defines the class's behavior. Class variables are also useful for storing data that should persist even when no instances currently exist.

Understanding Objects as Instances of Classes

When you write i = 5 in Python, you are creating an object (an instance) of the int class and assigning it to the variable i. The variable i holds a reference to that integer object. Similarly, when you create an instance of a custom class, you are creating an object that is an instance of that class. The class serves as a blueprint or template; the instance is the actual object created from that blueprint. This relationship between class and instance is fundamental to understanding how instance and class variables work together.

Practice

Summary

Instance variables and class variables are two distinct types of fields in a class. Instance variables belong to individual objects; each instance has its own independent copy. Class variables belong to the class itself and are shared across all instances. Changes to an instance variable affect only that instance; changes to a class variable affect all instances simultaneously. Instance variables are typically defined in the constructor or methods using self; class variables are defined at the class level. Understanding this distinction is essential for designing classes correctly and predicting how your code will behave when you create and modify objects.