'self' in Python

In Python, self is a conventionally used name for the first parameter in methods within a class. It refers to the instance of the class itself and is used to access its attributes and methods. It helps differentiate between instance variables and local variables, making it clear which attribute or method belongs to the object.

Accessing Instance Variables

Within a class method, you use self to access instance variables, which are attributes unique to each object created from the class.

class MyClass: def __init__(self, value): self.value = value def display(self): print(self.value) obj1 = MyClass(10) obj1.display() # Output: 10

Calling Other Methods

Inside a class method, you use self to call other methods within the same class.

class Calculator: def __init__(self, x, y): self.x = x self.y = y def add(self): return self.x + self.y def subtract(self): return self.x - self.y calc = Calculator(5, 3) print(calc.add()) # Output: 8 print(calc.subtract()) # Output: 2

Creating and Modifying Attributes

You can use self to create and modify instance attributes.

class Person: def __init__(self, name): self.name = name self.age = None def set_age(self, age): self.age = age person = Person("Alice") person.set_age(30) print(person.name, person.age) # Output: Alice 30

Accessing Instance Methods

Inside a class method, you can use self to call other instance methods.

class Circle: def __init__(self, radius): self.radius = radius def area(self): return 3.14 * self.radius * self.radius circle = Circle(5) print(circle.area()) # Output: 78.5

The use of self is a fundamental concept in Python's object-oriented programming. It ensures that the methods and attributes belong to the specific instance of the class, allowing for encapsulation and proper interaction between objects.


The keyword "self" is used within class methods to refer to the instance of the class itself. It enables the proper referencing and manipulation of instance variables and methods, facilitating object-oriented programming principles such as encapsulation and clear differentiation between instance attributes and local variables. The use of "self" ensures that class methods operate on the specific instance they are called from, contributing to well-structured and maintainable code.