Course: Python Training
Topic: Understanding Instance Variables and Class Variables
Course Link: Python Training Course
Demo Link: Register for a Free Course Demo
Website: JustAcademy
Python is an object-oriented programming language that allows developers to organize code using classes and objects. Variables defined within a class help store information about objects and the class itself.
In Python, variables associated with classes are commonly divided into two categories: instance variables and class variables. Understanding the difference between them is essential for designing reusable, maintainable, and efficient object-oriented programs.
Instance variables store data specific to an individual object, whereas class variables store data shared by instances through the class.
class Student:
school_name = "Bright Future School" # Class variable
def __init__(self, name, age):
self.name = name # Instance variable
self.age = age # Instance variable
student1 = Student("Rahul", 20)
student2 = Student("Priya", 22)
print(student1.name)
print(student2.name)
print(student1.school_name)
print(student2.school_name)Output:
Rahul
Priya
Bright Future School
Bright Future SchoolIn this example, each student has a different name and age, while both objects access the same class-level school name.
self parameter.Instance variables are variables associated with a particular object of a class. Each instance can maintain its own value independently of other instances.
Instance variables are generally created inside instance methods using the self parameter. They are commonly initialized inside the __init__() constructor.
class ClassName:
def __init__(self, value):
self.variable_name = valueHere, self.variable_name represents an instance attribute belonging to the current object.
class Employee:
def __init__(self, name, salary):
self.name = name
self.salary = salary
employee1 = Employee("Amit", 35000)
employee2 = Employee("Neha", 42000)
print(employee1.name)
print(employee1.salary)
print(employee2.name)
print(employee2.salary)Output:
Amit
35000
Neha
42000Explanation:
name is an instance variable because every employee can have a different name.salary is an instance variable because each employee can earn a different salary.employee1 and employee2 maintain separate values.self: This associates the attribute with the current object.class Car:
def __init__(self, brand, color):
self.brand = brand
self.color = color
car1 = Car("Toyota", "White")
car2 = Car("Honda", "Black")
car1.color = "Blue"
print(car1.color)
print(car2.color)Output:
Blue
BlackChanging car1.color does not change car2.color, because the two objects have separate instance attributes.
Class variables are attributes defined directly inside a class body, outside instance methods. They belong to the class and can be accessed through the class name or through instances.
Class variables are useful when information should be shared among instances, such as a company name, a standard interest rate, a category label, or a common configuration value.
class ClassName:
class_variable = valueclass Employee:
company_name = "Tech Solutions"
def __init__(self, name):
self.name = name
employee1 = Employee("Amit")
employee2 = Employee("Neha")
print(Employee.company_name)
print(employee1.company_name)
print(employee2.company_name)Output:
Tech Solutions
Tech Solutions
Tech SolutionsExplanation: The variable company_name is defined once in the class. Both employee objects can access it without requiring a separate value for each employee.
Employee.company_name.| Basis | Instance Variables | Class Variables |
|---|---|---|
| Definition | Associated with an individual object. | Associated with the class. |
| Declaration | Usually declared using self inside an instance method. |
Declared directly inside the class body. |
| Storage concept | Normally stored in the individual object's attribute dictionary. | Normally stored in the class's attribute dictionary. |
| Value | Can differ between objects. | Commonly shared when accessed through instances. |
| Access | Usually accessed through an object. | Accessed through the class or an instance. |
| Modification | Changes the selected object's attribute. | Assignment through the class name changes the class attribute. |
| Typical examples | Student name, employee salary, product price. | School name, company name, default category. |
| Memory behavior | Separate attribute values may exist for each instance. | One class attribute is defined on the class and can be accessed by many instances. |
The self parameter refers to the current instance of a class. It allows an instance method to access and modify attributes belonging to that particular object.
Python passes the instance automatically when an instance method is called through an object.
class Student:
def __init__(self, name):
self.name = name
def display(self):
print("Student name:", self.name)
student = Student("Rahul")
student.display()Output:
Student name: RahulIn this example, self.name refers to the name attribute of the particular student object. If another student object is created, its name can be different.
Python allows variables to be accessed using either an object or a class, depending on the variable and the intended behavior.
class Product:
category = "Electronics"
def __init__(self, name, price):
self.name = name
self.price = price
product1 = Product("Laptop", 65000)
print(product1.name)
print(product1.price)
print(Product.category)
print(product1.category)Output:
Laptop
65000
Electronics
ElectronicsThe object's name and price are instance attributes. The category attribute is found on the class because the instance does not define its own attribute with that name.
Instance variables can be modified by assigning a new value through a particular object. Other instances remain unchanged unless they share a referenced mutable object or are modified separately.
class BankAccount:
def __init__(self, owner, balance):
self.owner = owner
self.balance = balance
account1 = BankAccount("Amit", 5000)
account2 = BankAccount("Priya", 8000)
account1.balance = 7000
print(account1.balance)
print(account2.balance)Output:
7000
8000Only the balance attribute of account1 changes. The balance of account2 remains the same.
A class variable can be modified through the class name. Instances that have not overridden that attribute will then see the updated class-level value.
class Employee:
company = "ABC Technologies"
def __init__(self, name):
self.name = name
employee1 = Employee("Amit")
employee2 = Employee("Priya")
Employee.company = "XYZ Technologies"
print(employee1.company)
print(employee2.company)Output:
XYZ Technologies
XYZ TechnologiesBoth objects resolve company through the class, so they display the updated value.
Attribute shadowing occurs when an instance defines an attribute with the same name as a class attribute. For ordinary attribute lookup, the instance's attribute takes precedence over the class attribute.
class Student:
school = "Green Valley School"
student1 = Student()
student2 = Student()
student1.school = "City Public School"
print(student1.school)
print(student2.school)
print(Student.school)Output:
City Public School
Green Valley School
Green Valley SchoolExplanation:
Student.school remains "Green Valley School".student1.school now resolves to the instance attribute containing "City Public School".student2.school continues to resolve to the class attribute.Assigning student1.school creates or updates an instance attribute; it does not modify the class variable. To change the shared class attribute, use Student.school = "New School".
A class variable can track how many objects have been created. This pattern is useful for simple counters, identifiers, and learning how class-level state works.
class Student:
student_count = 0
def __init__(self, name):
self.name = name
Student.student_count += 1
student1 = Student("Amit")
student2 = Student("Neha")
student3 = Student("Rahul")
print("Total students:", Student.student_count)Output:
Total students: 3Every time the constructor runs, it increments the class variable. Accessing it through Student.student_count makes it clear that the counter belongs to the class.
Important: This is a basic in-memory counter, not a persistent or thread-safe global record. In applications with concurrency, multiple processes, or database-backed records, additional mechanisms may be required.
Class variables can hold mutable objects such as lists, dictionaries, and sets. When instances access the same mutable class attribute, they can modify the same underlying object. This behavior can be useful, but it can also cause unexpected results.
class Team:
members = []
team1 = Team()
team2 = Team()
team1.members.append("Amit")
print(team1.members)
print(team2.members)Output:
['Amit']
['Amit']Both instances access the same class-level list. Appending an item through one instance changes the shared list seen by the other.
class Team:
def __init__(self):
self.members = []
team1 = Team()
team2 = Team()
team1.members.append("Amit")
print(team1.members)
print(team2.members)Output:
['Amit']
[]Here, each instance creates its own list. This is the preferred approach when every object needs an independent collection.
For ordinary Python classes without special attribute storage restrictions, the __dict__ attribute can help inspect instance and class attributes.
class Employee:
department = "IT"
def __init__(self, name, salary):
self.name = name
self.salary = salary
employee = Employee("Amit", 40000)
print(employee.__dict__)
print(Employee.__dict__["department"])Example output:
{'name': 'Amit', 'salary': 40000}
ITThe instance dictionary contains the attributes created on the employee object. The class dictionary contains the class attribute named department, along with other class metadata. The exact representation of a class dictionary includes additional entries that are omitted from this example.
Note: Classes using __slots__ or custom attribute behavior may not expose instance attributes through __dict__ in the same way.
This example combines instance variables and class variables in a small student management program.
class Student:
school_name = "JustAcademy Learning Center"
total_students = 0
def __init__(self, name, course, marks):
self.name = name
self.course = course
self.marks = marks
Student.total_students += 1
def display_details(self):
print("Name:", self.name)
print("Course:", self.course)
print("Marks:", self.marks)
print("School:", Student.school_name)
student1 = Student("Amit", "Python", 85)
student2 = Student("Priya", "Data Analytics", 92)
student1.display_details()
print()
student2.display_details()
print()
print("Total students:", Student.total_students)Output:
Name: Amit
Course: Python
Marks: 85
School: JustAcademy Learning Center
Name: Priya
Course: Data Analytics
Marks: 92
School: JustAcademy Learning Center
Total students: 2name, course, and marks are instance variables.school_name is a class variable shared through the class.total_students is a class variable used to count created student objects.display_details() method accesses the current object's attributes through self.Student.total_students, making its class-level purpose explicit.class Student:
def __init__(self, name):
name = name # Does not create self.nameProblem: The assignment only assigns the local parameter to itself. It does not create an instance attribute.
Correction:
class Student:
def __init__(self, name):
self.name = nameclass Employee:
company = "ABC"
employee = Employee()
employee.company = "XYZ"
print(Employee.company)
print(employee.company)Output:
ABC
XYZCorrection: Use Employee.company = "XYZ" if the intention is to update the class attribute for instances that have not created their own attribute with that name.
class ShoppingCart:
items = []Problem: Every instance accesses the same list unless an instance attribute shadows it.
Correction:
class ShoppingCart:
def __init__(self):
self.items = []A class variable is not automatically copied into every instance. An instance usually accesses the class attribute through Python's attribute lookup unless it has its own attribute with that name.
class Student:
count = 0
def __init__(self):
self.count += 1Problem: If the instance does not already have count, the augmented assignment reads the class value and then assigns a new instance attribute. It will not reliably increment the shared class counter.
Correction:
class Student:
count = 0
def __init__(self):
Student.count += 1company_name, employee_id, and total_students.Create an Employee class with instance variables for employee name, ID, and salary. Create two objects and display their details.
Add a class variable named company_name. Access it through the class and through two employee objects. Update it through the class name and observe the result.
Create a Book class with instance variables for title and author, and a class variable named library_name. Create three book objects and display their details.
Create a Product class with a class variable that counts how many product objects have been created. Increment the counter inside the constructor and print the final value.
class Demo:
value = 10
obj1 = Demo()
obj2 = Demo()
obj1.value = 20
print(obj1.value)
print(obj2.value)
print(Demo.value)Expected output:
20
10
10Explain why changing obj1.value does not change the class attribute or the value accessed by obj2.
Answer: An instance variable is an attribute associated with an individual object. It is commonly initialized using self inside the constructor.
Answer: A class variable is an attribute defined directly inside a class body. Instances can access it through the class unless an instance attribute with the same name takes precedence.
Answer: Instance variables store object-specific information, while class variables represent information associated with the class and commonly shared across its instances.
Answer: Yes. An object can access a class variable if it does not have an instance attribute with the same name.
Answer: For normal attribute lookup, the instance attribute takes precedence over the class attribute. This is called attribute shadowing.
Answer: Assign a new value through the class name, such as Student.school_name = "New School".
Answer: Yes. Each object can maintain its own instance attribute value.
Answer: Mutable objects such as lists and dictionaries can be shared across instances. A modification made through one instance may affect what other instances observe.
Answer: Define a class-level counter and increment it in the constructor using the class name, for example, Student.count += 1.
Answer: In ordinary classes, instance attributes are commonly stored in the instance's __dict__, while class attributes are stored in the class's __dict__. Some Python classes use other storage mechanisms.
self is used to access and assign instance attributes.Instance variables and class variables are fundamental concepts in Python object-oriented programming. Instance variables allow each object to maintain its own state, while class variables represent information associated with the class and accessible to its instances.
By learning how to declare, access, modify, and distinguish these variables, developers can build clearer and more reliable Python applications. Pay particular attention to attribute shadowing, mutable class variables, and the use of the class name when updating shared data.
To continue learning Python programming, explore the JustAcademy Python Training Course, visit the JustAcademy website, or register for a course demo.
