Python Class Variables: A Comprehensive Guide

Python class variables are shared among all instances of a class and are crucial for managing data that is common to all objects of the class. Unlike instance variables, which are unique to each instance, class variables are defined within the class and outside of any instance methods. They are an essential feature of object-oriented programming (OOP) in Python and are often used to store data that should be consistent across all instances of a class.

By the end of this guide, you’ll have a solid understanding of how to define, use, and manage Python class variables.

What are Class Variables in Python?

Class variables are variables that are shared by all instances of a class. They are defined within a class but outside of any methods, and they are bound to the class itself rather than to the individual instances. This makes class variables useful for attributes that should have the same value for every instance of the class.

Key Characteristics:

• Shared across all instances: Class variables are accessible and modifiable by all instances of the class.
• Defined at the class level: Unlike instance variables, class variables are not defined inside any method (like __init__); they are declared directly within the class block.
• Used for common properties: Class variables are ideal for data that should be consistent across all instances, such as constants or counters.

Example: Defining a Class Variable

class Dog:
    species = "Canis lupus familiaris"  # Class variable

    def __init__(self, name, age):
        self.name = name  # Instance variable
        self.age = age    # Instance variable

# Accessing the class variable
print(Dog.species)  # Output: Canis lupus familiaris

# Creating instances
dog1 = Dog("Buddy", 5)
dog2 = Dog("Lucy", 3)

# Class variable is shared among all instances
print(dog1.species)  # Output: Canis lupus familiaris
print(dog2.species)  # Output: Canis lupus familiaris

In this example, species is a class variable, meaning that all instances of Dog will have the same species. On the other hand, name and age are instance variables that are unique to each instance.

Class Variables vs Instance Variables

1. Class Variables:

• Declared inside the class but outside any methods.
• Shared among all instances of the class.
• Modifying a class variable through one instance affects the value for all other instances.

2. Instance Variables:

• Declared inside methods (usually __init__).
• Unique to each instance of the class.
• Modifying an instance variable only affects that specific instance.

Example: Class Variables vs Instance Variables

class Car:
    wheels = 4  # Class variable (same for all cars)

    def __init__(self, model, color):
        self.model = model  # Instance variable
        self.color = color  # Instance variable

# Creating instances
car1 = Car("Tesla Model S", "Red")
car2 = Car("BMW X5", "Blue")

# Accessing class and instance variables
print(car1.wheels)  # Output: 4 (class variable)
print(car2.wheels)  # Output: 4 (class variable)
print(car1.model)   # Output: Tesla Model S (instance variable)
print(car2.model)   # Output: BMW X5 (instance variable)

In this example, wheels is a class variable shared by all Car instances, while model and color are instance variables specific to each car.

Defining and Accessing Class Variables in Python

1. Defining a Class Variable

A class variable is defined directly within the class block but outside any instance methods. It is typically defined right after the class definition for clarity.

Example:

class Employee:
    company_name = "TechCorp"  # Class variable

2. Accessing a Class Variable

You can access a class variable either through the class itself or through an instance of the class. Both approaches are valid, but accessing it through the class is often more explicit and clear.

Example:

# Accessing through the class
print(Employee.company_name)

# Accessing through an instance
emp1 = Employee()
print(emp1.company_name)

3. Modifying a Class Variable

A class variable can be modified by referencing it through the class. Modifying it through an instance affects only that instance, not the class variable itself.

Example: Modifying a Class Variable

class Book:
    genre = "Fiction"  # Class variable

# Modifying through the class
Book.genre = "Science Fiction"
print(Book.genre)  # Output: Science Fiction

# Modifying through an instance (creates an instance variable)
book1 = Book()
book1.genre = "Mystery"
print(book1.genre)   # Output: Mystery
print(Book.genre)    # Output: Science Fiction (unchanged)

In this case, modifying genre through the class changes it for all instances, but modifying it through an instance creates a separate instance variable for that instance.

Use Cases for Class Variables

Class variables are particularly useful in situations where you want to track shared properties or manage data that is common to all instances. Some common use cases include:

1. Tracking Object Counts

Class variables can be used to track how many instances of a class have been created.

Example: Counting Instances

class Animal:
    count = 0  # Class variable to count instances

    def __init__(self, name):
        self.name = name
        Animal.count += 1  # Increment the count

# Creating instances
a1 = Animal("Dog")
a2 = Animal("Cat")

print(Animal.count)  # Output: 2

2. Storing Constants

Class variables are often used to store constants or default values that should be the same across all instances.

Example: Using a Class Variable for Default Settings

class GameSettings:
    resolution = "1080p"  # Default resolution (class variable)
    sound_level = 50      # Default sound level (class variable)

Advanced Concepts: Class Variables and Inheritance

Class variables are inherited by subclasses, but if you modify a class variable in a subclass, it only affects the subclass, not the parent class or other subclasses.

Example: Class Variables and Inheritance

class Vehicle:
    fuel_type = "Petrol"  # Class variable

class Car(Vehicle):
    pass

class Truck(Vehicle):
    pass

# Modifying class variable in a subclass
Car.fuel_type = "Electric"
print(Vehicle.fuel_type)  # Output: Petrol
print(Car.fuel_type)      # Output: Electric
print(Truck.fuel_type)    # Output: Petrol

In this example, modifying fuel_type in the Car class does not affect the Vehicle or Truck classes.

Best Practices for Using Class Variables

1. Use class variables for data shared among all instances: Class variables are best used for data that should be common to all objects of a class, such as default settings, object counters, or configuration options.
2. Access class variables through the class: For clarity, access class variables through the class itself (ClassName.variable) instead of through an instance, unless you have a specific reason to do otherwise.
3. Avoid modifying class variables through instances: Modifying class variables through an instance can create confusion by unintentionally creating instance variables. Modify class variables directly through the class.
4. Use instance variables for instance-specific data: If data is unique to each object, define it as an instance variable within the __init__ method.

Common Pitfalls with Class Variables

1. Unintentionally Creating Instance Variables: If you try to modify a class variable through an instance, you might accidentally create an instance variable with the same name, which overrides the class variable only for that instance.
2. Class Variable Shared by All Instances: Be mindful that mutable objects (like lists or dictionaries) stored in class variables are shared by all instances. Modifying the object through one instance will affect all instances.

Example of Pitfall:

class MyClass:
    shared_list = []  # Class variable

obj1 = MyClass()
obj2 = MyClass()

obj1.shared_list.append(1)
print(obj2.shared_list)  # Output: [1] (because both share the same list)

To avoid this, use instance variables or ensure that class variables are immutable when sharing data among instances.

Summary of Key Concepts

• Class variables are shared among all instances of a class and are defined within the class block but outside any methods.
• Unlike instance variables, which are unique to each instance, class variables store data that should be the same for all instances.
• Class variables can be accessed and modified through the class or instances, but modifying them through an instance can create an instance variable with the same name.
• Class variables are inherited by subclasses, but modifications in the subclass do not affect the parent class or other subclasses.

Exercises

1. Track Object Creation: Write a class that tracks how many instances have been created using a class variable.
2. Class Constants: Create a class that stores configuration settings (like screen resolution and sound level) using class variables, and create multiple instances to check that they share the same values.
3. Mutable Class Variable: Create a class with a list as a class variable. Demonstrate the effect of modifying the list through different instances and show how it is shared.

Check out our FREE Learn Python Programming Masterclass to hone your skills or learn from scratch.

The course covers everything from first principles to Graphical User Interfaces and Machine Learning

Browse the official Python documentation on classes here.

FAQ

Q1: Can class variables be changed by instances of the class?

A1: Yes, class variables can be changed by instances, but modifying them through an instance only affects that specific instance. This creates an instance variable with the same name, leaving the class variable unchanged for the class and other instances.

Example:

class Car:
    wheels = 4  # Class variable

car1 = Car()
car2 = Car()

car1.wheels = 6  # Changes only for car1

print(car1.wheels)  # Output: 6 (instance variable)
print(car2.wheels)  # Output: 4 (class variable still the same)
print(Car.wheels)   # Output: 4 (class variable unchanged)

Q2: Can class variables be used for mutable types like lists or dictionaries?

A2: Yes, class variables can be used for mutable types like lists or dictionaries, but be careful! Modifying a mutable class variable from one instance will affect all other instances because the variable is shared. If you want each instance to have its own copy of a list or dictionary, use instance variables instead.

Example:

class MyClass:
    shared_list = []  # Class variable

obj1 = MyClass()
obj2 = MyClass()

obj1.shared_list.append(1)

print(obj1.shared_list)  # Output: [1]
print(obj2.shared_list)  # Output: [1] (shared between instances)

Q3: How do I prevent an instance from accidentally modifying a class variable?

A3: To prevent an instance from modifying a class variable, access and modify class variables directly through the class name rather than through an instance. You can also use properties or class methods to control how class variables are accessed or modified.

Example:

class Car:
    wheels = 4  # Class variable

    @classmethod
    def set_wheels(cls, number):
        cls.wheels = number

car1 = Car()
Car.set_wheels(6)  # Changing class variable through class method
print(Car.wheels)  # Output: 6

Q4: Are class variables inherited by subclasses?

A4: Yes, class variables are inherited by subclasses, but if you modify the class variable in the subclass, the change will only affect the subclass and not the parent class or other subclasses.

Example:

class Vehicle:
    fuel_type = "Petrol"  # Class variable

class Car(Vehicle):
    pass

class Truck(Vehicle):
    pass

Car.fuel_type = "Electric"

print(Vehicle.fuel_type)  # Output: Petrol
print(Car.fuel_type)      # Output: Electric
print(Truck.fuel_type)    # Output: Petrol

Q5: Can class variables have different values in different instances?

A5: No, class variables are shared across all instances of the class, so they will have the same value for every instance unless you create an instance variable with the same name. If you need unique values for each instance, use instance variables.

Q6: How can I modify a class variable inside an instance method?

A6: To modify a class variable inside an instance method, reference it using the class name or self.__class__.variable_name. This ensures that the class variable is modified for all instances.

Example:

class Dog:
    species = "Canis lupus"  # Class variable

    def change_species(self, new_species):
        self.__class__.species = new_species  # Modify the class variable

dog1 = Dog()
dog2 = Dog()

dog1.change_species("Canis familiaris")

print(dog1.species)  # Output: Canis familiaris
print(dog2.species)  # Output: Canis familiaris (shared change)

Q7: Can I use a class variable to track the number of instances created?

A7: Yes, a class variable is an excellent way to track how many instances of a class have been created. You can increment the class variable each time the constructor (__init__ method) is called.

Example:

class Animal:
    count = 0  # Class variable to track instances

    def __init__(self, name):
        self.name = name
        Animal.count += 1

# Creating instances
a1 = Animal("Dog")
a2 = Animal("Cat")

print(Animal.count)  # Output: 2

Q8: How do I differentiate between class and instance variables when accessing them?

A8: You can differentiate between class and instance variables by explicitly accessing class variables through the class name. If you access the variable through an instance, Python first checks if the instance has an instance variable with that name; if not, it will fallback to the class variable.

Example:

class Person:
    species = "Homo sapiens"  # Class variable

p1 = Person()
p1.species = "Homo erectus"  # Creates an instance variable

print(p1.species)  # Output: Homo erectus (instance variable)
print(Person.species)  # Output: Homo sapiens (class variable)