Python Class Variables

In the last lesson you learned about Instance Variables, the data that belongs to each object on its own. Two objects, two separate copies. That is what you want most of the time. But sometimes you need the opposite. You want one value that every object shares. That is what a class variable is for.

🤔 Why Class Variables?

Say you are building a game. You want to know how many Player objects have been created so far. With instance variables you cannot do this cleanly. Each player only knows about itself. None of them knows the total.

So you need one number that lives with the class, not with any single object. Every player adds to it. And every player can read the same value. A class variable gives you exactly that. One shared piece of data that all objects look at together.

🧩 What Is a Class Variable?

A class variable is a value that belongs to the class itself. It is shared by every object made from that class.

Think of a classroom. Each student has their own name and their own marks. That is personal. That is instance data. But the room number is the same for everyone in that class. You do not give each student their own copy of the room number. It belongs to the class as a whole. A class variable is that room number.

Here is the key difference in one line:

• An instance variable is defined inside __init__ using self. Each object gets its own copy.
• A class variable is defined in the class body, outside any method. All objects share the one copy.

🛠️ The Syntax

You write a class variable right inside the class body, before __init__, like a normal assignment.

This small class has one class variable called school.

class Student:
    school = "Greenwood High"   # class variable, shared by all students

    def __init__(self, name):
        self.name = name        # instance variable, personal to each student

Let’s read that code top to bottom.

• school = "Greenwood High" sits in the class body, not inside any method. So it is a class variable.
• self.name = name sits inside __init__ and uses self. So it is an instance variable.

The why is simple. Every student goes to the same school. So it makes sense to store that once on the class. But every student has their own name. So that has to live on each object.

🎯 A Simple Example

Let’s create two students and read both kinds of variable.

This code makes two Student objects. It prints their personal name and their shared school.

class Student:
    school = "Greenwood High"

    def __init__(self, name):
        self.name = name


riya = Student("Riya")
arjun = Student("Arjun")

print(riya.name, "goes to", riya.school)
print(arjun.name, "goes to", arjun.school)

When you run it, you get this.

Riya goes to Greenwood High
Arjun goes to Greenwood High

See what happened? riya and arjun have different names. That is because name is personal. But they both report the same school. That is because school is shared. We only wrote that school value once. And both objects can read it.

🔢 A Real Example: A Shared Counter

Here is the classic use. We want to count how many Player objects have been created. The counter has to be shared. So it is a perfect shared counter.

This code keeps a running count on the class. It bumps the count up by one every time a new player is made.

class Player:
    count = 0   # class variable, shared running total

    def __init__(self, name):
        self.name = name
        Player.count += 1   # add one to the shared total


p1 = Player("Alex")
p2 = Player("Riya")
p3 = Player("Arjun")

print("Total players created:", Player.count)

Running this prints the total.

Total players created: 3

Let’s walk through it line by line.

• count = 0 is the class variable. It starts at zero and is shared by every Player.
• Each time __init__ runs, Player.count += 1 adds one to that single shared number.
• We create three players. So __init__ runs three times. So the count ends at 3.
• Player.count reads the shared value straight from the class.

Notice we wrote Player.count, using the class name, not self.count. That is on purpose. We want to change the one shared counter. We do not want to make a new personal one on each object. More on that in a moment.

⚙️ A Shared Default Value

Class variables are also handy for a default that is the same for everyone until you change it.

This BankAccount class gives every new account the same starting interest rate. The rate is stored once on the class.

class BankAccount:
    interest_rate = 0.04   # shared default, same for all accounts

    def __init__(self, owner, balance):
        self.owner = owner
        self.balance = balance


a1 = BankAccount("Alex", 1000)
a2 = BankAccount("Riya", 5000)

print(a1.owner, "rate:", a1.interest_rate)
print(a2.owner, "rate:", a2.interest_rate)

Both accounts read the same rate.

Alex rate: 0.04
Riya rate: 0.04

The nice thing is you store the rate in one place. If the bank changes it later, you update BankAccount.interest_rate once. Then every account sees the new value. You do not need to touch each account one by one.

🆚 Class Variable vs Instance Variable

Here is the contrast side by side so it sticks. Notice how the one shared copy is the real dividing line.

⚠️ Common Mistakes

A few things trip people up with class variables. Watch for these.

Using self when you meant to update the shared value. When you assign with self, Python does not change the class variable. It quietly creates a new instance variable on that one object. The shared value stays untouched.

class Player:
    count = 0

    def __init__(self, name):
        self.name = name
        # ❌ Avoid: this makes a personal count on the object, not the shared one
        # self.count += 1
        # ✅ Good: this updates the one shared counter on the class
        Player.count += 1

Forgetting that all objects see the same value. Changing a class variable through the class changes it for everyone. That is the whole point. But it can surprise you if you expected each object to be separate. If the data should be personal, it belongs in __init__ as an instance variable.

Using a mutable class variable like a list by accident. A shared list is truly shared. So when one object appends to it, every object sees that new item too. If you wanted each object to have its own list, create it in __init__ with self. Do not create it in the class body.

class Team:
    # ❌ Avoid: one shared list for every team, often not what you want
    members = []

# ✅ Good: give each team its own list
class Team:
    def __init__(self):
        self.members = []

✅ Best Practices

A few simple habits keep class variables clean and predictable. The word to remember here is shared.

• Use a class variable only when the value really is shared by all objects, like a count, a default, or a constant.
• Update a shared value through the class name, like Player.count, so it is clear you mean the shared one.
• Keep personal data such as name or balance as instance variables inside __init__.
• Be careful with mutable class variables like lists or dictionaries, since every object shares the same one. If each object needs its own, create it in __init__.

🧩 What You’ve Learned

A quick recap of the ideas from this lesson.

• ✅ A class variable is defined in the class body, outside __init__, and is shared by every object of the class.
• ✅ An instance variable lives inside __init__ with self and gives each object its own copy.
• ✅ Class variables are great for shared counters, shared defaults, and constants.
• ✅ Update a shared value through the class name, like Player.count, not through self.
• ✅ Assigning with self makes a new personal variable instead of changing the shared one.
• ✅ A mutable class variable like a list is shared by all objects, so use self in __init__ when each object needs its own.

🚀 What’s Next?

You now know how to store data that is shared across every object. Next we will look at how objects actually do things. These are the functions that live inside a class.

Methods