Python OOP Tutorial 2: Class Variables

Class variables let one shared value live on a class and be reused across every instance—perfect for data that should stay consistent company-wide, like an annual raise rate or a global employee counter. The tutorial contrasts this with instance variables, which store per-object data such as each employee’s name, email, and pay.

To make the difference concrete, the lesson starts with an Employee class that has an apply_raise method. Initially, the raise percentage is hard-coded inside apply_raise (pay multiplied by 1.04). That works, but it creates two problems: there’s no clean way to read the raise rate as employee.raise_amount, and updating the rate would require hunting through the code wherever the number appears. Moving the 4% value into a class variable (raise_amount = 1.04) fixes both issues—now the rate is defined once at the class level and can be accessed as either Employee.raise_amount or employee_instance.raise_amount.

The tutorial then digs into why instance access still works for class variables. When an attribute is requested on an instance, Python first checks the instance’s own namespace. If the attribute isn’t found there, Python falls back to the class (and its base classes). That’s why employee_instance.raise_amount returns the class’s raise_amount even though the instance itself doesn’t store that attribute. The lesson reinforces this by printing employee_instance.__dict__ (showing no raise_amount there) while also inspecting the class attribute via the class namespace.

A key nuance follows: assigning to a class variable through an instance can create an instance-specific override. When raise_amount is changed via employee_instance.raise_amount = 1.05, Python adds raise_amount to that instance’s namespace, so only that employee sees the new value; other instances still fall back to the original class value. This is why the tutorial recommends using self.raise_amount inside apply_raise: it allows per-instance overrides when needed, while still defaulting to the class value.

The lesson closes with a second class-variable example where self is less appropriate: tracking the total number of employees. A num_employees class variable starts at 0 and increments inside __init__ each time a new Employee instance is created. Accessing Employee.num_employees yields the shared count across all instances, and the increment happens reliably because __init__ runs for every instantiation.

Overall, the takeaway is practical: use instance variables for data unique to each object, use class variables for shared constants or global counters, and understand Python’s attribute lookup rules so you know when changes affect everyone versus only one instance.