There are several kinds of variables in Python:
- Instance variables in a class: these are called fields or attributes of an object
- Local Variables: Variables in a method or block of code
- Parameters: Variables in method declarations
- Class variables: This variable is shared between all objects of a class
In Object-oriented programming, when we design a class, we use instance variables and class variables.
- Instance variables: If the value of a variable varies from object to object, then such variables are called instance variables.
- Class Variables: A class variable is a variable that is declared inside of class, but outside of any instance method or
__init__()
method.
After reading this article, you’ll learn:
- How to create and access instance variables
- Modify values of instance variables
- How to dynamically add or delete instance variables
- Scope of a instance variables
Table of contents
What is an Instance Variable in Python?
If the value of a variable varies from object to object, then such variables are called instance variables. For every object, a separate copy of the instance variable will be created.
Instance variables are not shared by objects. Every object has its own copy of the instance attribute. This means that for each object of a class, the instance variable value is different.
When we create classes in Python, instance methods are used regularly. we need to create an object to execute the block of code or action defined in the instance method.
Instance variables are used within the instance method. We use the instance method to perform a set of actions on the data/value provided by the instance variable.
We can access the instance variable using the object and dot (.
) operator.
In Python, to work with an instance variable and method, we use the self
keyword. We use the self
keyword as the first parameter to a method. The self
refers to the current object.

Create Instance Variables
Instance variables are declared inside a method using the self
keyword. We use a constructor to define and initialize the instance variables. Let’s see the example to declare an instance variable in Python.
Example:
In the following example, we are creating two instance variable name
and age
in the Student
class.
class Student:
# constructor
def __init__(self, name, age):
# Instance variable
self.name = name
self.age = age
# create first object
s1 = Student("Jessa", 20)
# access instance variable
print('Object 1')
print('Name:', s1.name)
print('Age:', s1.age)
# create second object
s2= Student("Kelly", 10)
# access instance variable
print('Object 2')
print('Name:', s2.name)
print('Age:', s2.age)
Output
Object 1 Name: Jessa Age: 20 Object 2 Name: Kelly Age: 10
Note:
- When we created an object, we passed the values to the instance variables using a constructor.
- Each object contains different values because we passed different values to a constructor to initialize the object.
- Variable declared outside
__init__()
belong to the class. They’re shared by all instances.
Modify Values of Instance Variables
We can modify the value of the instance variable and assign a new value to it using the object reference.
Note: When you change the instance variable’s values of one object, the changes will not be reflected in the remaining objects because every object maintains a separate copy of the instance variable.
Example
class Student:
# constructor
def __init__(self, name, age):
# Instance variable
self.name = name
self.age = age
# create object
stud = Student("Jessa", 20)
print('Before')
print('Name:', stud.name, 'Age:', stud.age)
# modify instance variable
stud.name = 'Emma'
stud.age = 15
print('After')
print('Name:', stud.name, 'Age:', stud.age)
Output
Before Name: Jessa Age: 20 After Name: Emma Age: 15
Ways to Access Instance Variable
There are two ways to access the instance variable of class:
- Within the class in instance method by using the object reference (
self
) - Using
getattr()
method
Example 1: Access instance variable in the instance method
class Student:
# constructor
def __init__(self, name, age):
# Instance variable
self.name = name
self.age = age
# instance method access instance variable
def show(self):
print('Name:', stud.name, 'Age:', stud.age)
# create object
stud = Student("Jessa", 20)
# call instance method
stud.show()
Output
Name: Jessa Age: 20

Example 2: Access instance variable using getattr()
getattr(Object, 'instance_variable')
Pass the object reference and instance variable name to the getattr()
method to get the value of an instance variable.
class Student:
# constructor
def __init__(self, name, age):
# Instance variable
self.name = name
self.age = age
# create object
stud = Student("Jessa", 20)
# Use getattr instead of stud.name
print('Name:', getattr(stud, 'name'))
print('Age:', getattr(stud, 'age'))
Output
Name: Jessa Age: 20
Instance Variables Naming Conventions
- Instance variable names should be all lower case. For example,
id
- Words in an instance variable name should be separated by an underscore. For example,
store_name
- Non-public instance variables should begin with a single underscore
- If an instance name needs to be mangled, two underscores may begin its name
Dynamically Add Instance Variable to a Object
We can add instance variables from the outside of class to a particular object. Use the following syntax to add the new instance variable to the object.
object_referance.variable_name = value
Example:
class Student:
def __init__(self, name, age):
# Instance variable
self.name = name
self.age = age
# create object
stud = Student("Jessa", 20)
print('Before')
print('Name:', stud.name, 'Age:', stud.age)
# add new instance variable 'marks' to stud
stud.marks = 75
print('After')
print('Name:', stud.name, 'Age:', stud.age, 'Marks:', stud.marks)
Output
Before Name: Jessa Age: 20 After Name: Jessa Age: 20 Marks: 75
Note:
- We cannot add an instance variable to a class from outside because instance variables belong to objects.
- Adding an instance variable to one object will not be reflected the remaining objects because every object has a separate copy of the instance variable.
Dynamically Delete Instance Variable
In Python, we use the del
statement and delattr()
function to delete the attribute of an object. Both of them do the same thing.
del
statement: Thedel
keyword is used to delete objects. In Python, everything is an object, so thedel
keyword can also be used to delete variables, lists, or parts of a list, etc.delattr()
function: Used to delete an instance variable dynamically.
Note: When we try to access the deleted attribute, it raises an attribute error.
Example 1: Using the del
statement
class Student:
def __init__(self, roll_no, name):
# Instance variable
self.roll_no = roll_no
self.name = name
# create object
s1 = Student(10, 'Jessa')
print(s1.roll_no, s1.name)
# del name
del s1.name
# Try to access name variable
print(s1.name)
Output
10 Jessa AttributeError: 'Student' object has no attribute 'name'
delattr()
function
The delattr() function is used to delete the named attribute from the object with the prior permission of the object. Use the following syntax.
delattr(object, name)
object
: the object whose attribute we want to delete.name
: the name of the instance variable we want to delete from the object.
Example
class Student:
def __init__(self, roll_no, name):
# Instance variable
self.roll_no = roll_no
self.name = name
def show(self):
print(self.roll_no, self.name)
s1 = Student(10, 'Jessa')
s1.show()
# delete instance variable using delattr()
delattr(s1, 'roll_no')
s1.show()
Output
10 Jessa AttributeError: 'Student' object has no attribute 'roll_no'
Access Instance Variable From Another Class
We can access instance variables of one class from another class using object reference. It is useful when we implement the concept of inheritance in Python, and we want to access the parent class instance variable from a child class.
let’s understand this with the help of an example.
In this example, the engine
is an instance variable of the Vehicle
class. We inherited a Vehicle
class to access its instance variables in Car
class
class Vehicle:
def __init__(self):
self.engine = '1500cc'
class Car(Vehicle):
def __init__(self, max_speed):
# call parent class constructor
super().__init__()
self.max_speed = max_speed
def display(self):
# access parent class instance variables 'engine'
print("Engine:", self.engine)
print("Max Speed:", self.max_speed)
# Object of car
car = Car(240)
car.display()
Output
Engine: 1500cc Max Speed: 240
List all Instance Variables of a Object
We can get the list of all the instance variables the object has. Use the __dict__
function of an object to get all instance variables along with their value.
The __dict__
function returns a dictionary that contains variable name as a key and variable value as a value
Example:
class Student:
def __init__(self, roll_no, name):
# Instance variable
self.roll_no = roll_no
self.name = name
s1 = Student(10, 'Jessa')
print('Instance variable object has')
print(s1.__dict__)
# Get each instance variable
for key_value in s1.__dict__.items():
print(key_value[0], '=', key_value[1])
Output:
Instance variable object has {'roll_no': 10, 'name': 'Jessa'} roll_no = 10 name = Jessa