Class vs. Instance Variables

1. Instance vs. Class Variables: The Core Idea

Let's start with a quick formal definition of what you were already using in the last lesson.

• Instance Variables: These are owned by a specific instance of a class. Each object has its own copy of these variables. They are for data that is unique to each object. You've been creating these inside __init__ using self (e.g., self.name = "Alice").

• Class Variables: These are owned by the class itself. They are shared among all instances of the class. If you change a class variable, the change is reflected in all instances (with a crucial exception we'll cover shortly). They are perfect for storing data that is constant or shared across all objects of that class.

To dive deep into how this works in practice, we'll watch a detailed video from Corey Schafer, a highly-respected Python educator. His explanation of the nuances here is excellent.

2. The Mechanics of Access and Modification

As the video explained, the way you access and, more importantly, modify these variables is what truly defines their behavior.

Let's summarize the key points with our own code example. Imagine we're building the Task class for our project. We can use a class variable to define a set of approved statuses.

class Task:
    # Class variable: shared by all Task objects
    VALID_STATUSES = ('Not Started', 'In Progress', 'Completed')
    
    def __init__(self, title, description):
        # Instance variables: unique to each task
        self.title = title
        self.description = description
        self.status = 'Not Started' # Default instance variable
        
    def set_status(self, new_status):
        # We can access the class variable using the class name
        if new_status in Task.VALID_STATUSES:
            self.status = new_status
        else:
            print(f"'{new_status}' is not a valid status.")

# --- Let's create some tasks ---
task1 = Task("Design Homepage", "Create a mockup in Figma.")
task2 = Task("Setup Database", "Install PostgreSQL and create DB.")

# Accessing the class variable (best practice is through the class)
print(f"Valid statuses are: {Task.VALID_STATUSES}")

# You can also access it through an instance, because of the lookup chain
print(f"Task 1 knows the valid statuses: {task1.VALID_STATUSES}") 

task1.set_status('In Progress')
print(f"Task 1 status: {task1.status}")

task2.set_status('Done') # This will fail
print(f"Task 2 status: {task2.status}")

The "Shadowing" Effect: Modifying Variables

This is the most critical concept to grasp. What happens when you try to change a class variable's value?

Continue with the same video to see this behavior in action. This is where the difference becomes crystal clear.

To summarize this crucial point:

• Modifying via the Class (Task.SOME_VAR = ...): This changes the class variable itself. All instances that don't have their own overriding instance variable will see this new value.
• Modifying via an Instance (task1.SOME_VAR = ...): This does not change the class variable. Instead, it creates a new instance variable for task1 that "shadows" or hides the class variable. Other instances (like task2) are completely unaffected.

3. A Practical Use Case: Counting Instances

So, when should you use a class variable? One of the most common use cases is to keep track of data related to the class as a whole, such as counting how many objects have been created.

This final clip from the video demonstrates this perfectly.

Let's apply this to our Task class. We'll add a counter to track how many tasks have been created in total.

class Task:
    # Class variable to count tasks
    task_count = 0
    
    def __init__(self, title):
        self.title = title
        # Increment the CLASS variable each time a new instance is created
        Task.task_count += 1
        # We can assign an instance-specific ID as well
        self.id = Task.task_count

    def display(self):
        print(f"ID: {self.id}, Title: {self.title}")

# --- Using the counter ---
print(f"Initial task count: {Task.task_count}") # Output: 0

t1 = Task("Learn Class Variables")
t2 = Task("Practice with an exercise")
t3 = Task("Read documentation")

print(f"Final task count: {Task.task_count}") # Output: 3

t1.display() # Output: ID: 1, Title: Learn Class Variables
t2.display() # Output: ID: 2, Title: Practice with an exercise

In this example, Task.task_count is the single source of truth for the total number of tasks. Each task also gets its own unique id as an instance variable, derived from the counter at the moment of its creation.

4. Summary and Quick Reference

To consolidate your understanding, the following article provides a concise textual summary and a very useful comparison table.

class Project:
    # Class variables
    project_prefix = "PROJ"
    project_counter = 0

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

        # Update class counter and create instance-specific ID
        Project.project_counter += 1
        self.project_id = f"{Project.project_prefix}-{Project.project_counter}"

    def display_info(self):
        print(f"ID: {self.project_id}, Name: {self.name}")

# --- Testing the implementation ---

print("--- Creating initial projects ---")
p1 = Project("Website Redesign")
p2 = Project("API Development")
p3 = Project("Mobile App Launch")

p1.display_info()
p2.display_info()
p3.display_info()

print(f"\nTotal projects created: {Project.project_counter}")

print("\n--- Updating project prefix and creating a new project ---")
# Modify the class variable
Project.project_prefix = "TASKFORCE"

p4 = Project("Q4 Marketing Campaign")
p4.display_info()

# Expected Output:
# --- Creating initial projects ---
# ID: PROJ-1, Name: Website Redesign
# ID: PROJ-2, Name: API Development
# ID: PROJ-3, Name: Mobile App Launch
#
# Total projects created: 3
#
# --- Updating project prefix and creating a new project ---
# ID: TASKFORCE-4, Name: Q4 Marketing Campaign

Conclusion

Great job! You now have a solid understanding of the difference between class and instance variables, which is a key piece of the object-oriented puzzle. This knowledge helps you decide where data should live in your classes, leading to more organized and maintainable code.

Key Takeaways:

• Instance variables are for data unique to each object (e.g., task.title). They are defined in __init__ using self.
• Class variables are for data shared by all objects of a class (e.g., Task.task_count). They are defined directly within the class.
• Accessing an attribute follows a chain: Python checks the instance first, then the class.
• Modifying a class variable via the class (ClassName.var) changes it for everyone. Modifying it via an instance (instance.var) creates a new, shadowing instance variable for that object only.

Preview of the Next Lesson:

Now that we are comfortable with how a single class works, we are ready to explore one of the most powerful features of OOP: inheritance. In the next lesson, you will learn how to implement inheritance by creating a child class that extends a parent class. This will allow us to create specialized versions of our classes (e.g., a BugReport that is a special kind of Task) without duplicating code.