HomeBlogProgrammingUnderstanding Self in Python With Examples [Beginners Guide]

Understanding Self in Python With Examples [Beginners Guide]

24th May, 2024
view count loader
Read it in
9 Mins
In this article
    Understanding Self in Python With Examples [Beginners Guide]

    Understanding the significance of the self variable in Python classes and object-oriented programming (OOP) is paramount for effective manipulation and construction of Python objects. The self variable establishes a crucial link to the class instance, facilitating access to its attributes and methods. In the realm of class methods, it is a convention to designate the first parameter as self, though it can be named differently if necessary.

    This concept of self proves pivotal in distinguishing between instance-specific variables and class variables, empowering developers to efficiently utilize and modify object parameters. To delve deeper into the relevance and practical application of the self-variable, let's explore self in Python illustrated instances that exemplify its role in Python classes. To delve deeper into the relevance and practical application of the self variable, consider enrolling in a Python Programming online course.

    What is Self in Python? 

    Unlike this variable in C++, self is not a keyword rather it is more of a coding convention. It represents the instance or objects of a class and binds the attributes of a class with specific arguments. The use of self in Python helps to differentiate between the instance attributes (and methods) and local variables. 

    If you do not want the variables of your class to be shared by all instances of the class, you can declare variables within your class without self. 

    Syntax of Self in Python

    Let us understand the syntax of self in Python with an example: 

    class Car: 
        def __init__(self, model): 
    self.model = model 
        def Car_info(self): 
    print("Model : ", self.model) 

    Here, we have declared a class Car with one instance variable self.model = model. The value of the instance variable will be unique to the instance objects of the class that might be declared. However, if you want the variables to be shared by all instances of the class, you need to declare the instance variables without self. Otherwise, it would be ambiguous since all cars will have the same model. 

    What is the Need of Self in Python Class

    The self variable is used to represent the instance of the class which is often used in object-oriented programming. It works as a reference to the object. Python uses the self parameter to refer to instance attributes and methods of the class.  

    Unlike other programming languages, Python does not use the “@” syntax to access the instance attributes. This is the sole reason why you need to use the self variable in Python. The language contains methods that allow the instance to be passed automatically but not received automatically. 

    Why is Self Defined Explicitly in Python?

    The Zen of Python says “Explicit is better than Implicit”. Programmers of other languages often ask why the self is passed as an explicit parameter every time to define a method. There are a few reasons for this. 

    • Firstly, since Python uses a method or instance attribute instead of a local variable when we read self.name or self.age, it makes it absolutely clear you are using an instance variable or method even if you have no knowledge about the class definition. 
    • Secondly, if you explicitly refer or call a method from a particular class in Python, you do not need to use any special syntax for that.  
    • Finally, the third reason is that the explicit definition of self helps Python understand whether to assign to an instance variable or to a local variable. In simpler terms, local variables and instances exist in two separate namespaces and we need to inform Python which namespace should be used.

    How to Use Self in Python with Examples?

    Let us see an example to understand it: 

    class myClass:  
    def show(another):  
    print(“another is used in place of self”)  

    If you compare this code with the code for the Python class self constructor, you will notice that here we have used the name another in place of self. Now let us create an object of this class and see the output: 

    object = myClass()  

    another is used in place of self

    You can see that the program works even if we use some other name in place of the self variable. It works exactly the same way as the self variable does. 

    What are Instance Methods and Class Methods in Python?

    You might have heard of instances and classes while working on Python. Class variables are defined within a class and they are shared with all the instances (objects) of the class whereas instance variables are owned by the instances of a class. For different instances, the instance variables are different. 

    Likewise, Python also contains class methods and instance methods. The class methods inform about the status of the class. On the other hand, instance methods are to set or get details about instances or objects.  

    If you want to define an instance method, the foremost parameter of the method should always have to be self. Let us understand this with the help of example code – 

    class myClass: 
        def instance_method(self): 
            return “Instance method is called”, self 

    The method “instance_method” is a regular instance method. The method accepts one single parameter – self. The self variable points to an instance of the class myClass when the method is revoked. Though the method takes only one parameter here, it can also accept more than one parameter. 

    The instance methods can easily access different attributes and other methods on the same object with the help of the self variable. The self variable also has the power to modify the state of an object and using the self.__class__  attribute, instance methods can also access the class. Thus, the instance methods are also able to modify the class state. 

    Now, let us see what happens when we call “instance_method”:

    >>>obj = myClass() 
    ('Instance method is called', <myClass instance at 1x09255d103>) 

    This shows that “instance_method” can access the object instance (printed as <myClass instance>) through the self parameter in Python. What happens is that the Python self parameter is replaced with the instance object obj when the method is called. However, if you pass the instance object manually, you will get the same result as before: 

    ('Instance method is called', <myClass instance at 1x09255d103>) 

    Note that self is actually not a defined keyword in Python but a convention.  

    Why Should "Self" be Used as the First Parameter of Instance Methods in Python?

    This can be understood by the below example. We have a Rectangle class which defines a method area to calculate the area : 

    class Rectangle (): 
        def __init__(self,x = 0,y = 0): 
            self.x = x 
            self.y = y 
        def area (self): 
            """Find area of rectangle""" 
            return (self.x * self.y) 
    print ("Area is:", rec1.area()) 


    Area is: 60    

    In the above example, __init__() defines three parameters but only 2 arguments are passed (6 and 10). Similarly, area () requires one but no arguments are passed.  

    Rectangle.area and rec1.area in the above example are different and not exactly the same. 

    >>> type(Rectangle.area ) 
    <class 'function'> 
    >>> type(rec1.area) 
    <class 'method'> 

    Here, the first one is a function and the second one is a method. A unique feature of Python is that the object itself is passed as the first argument to the corresponding function. 

    In the above example, the method call:  rec1.area()is equivalent to:  Rectangle.area(rec1). 

    Generally, when the method is called with some arguments, the corresponding class function is called by placing the method's object before the first argument.  

    Therefore: obj.method(args) becomes Class.method(obj, args). 

    This is the reason the first parameter of a function in a class must be the object itself. Writing this parameter as self is merely a convention and not a keyword so it has no special meaning in Python. We could use other names (like this, that) but it is not preferred as it degrades code readability.

    What is a Python Class Self Constructor? 

    The self variable in Python can also be used to access a variable field within the class definition. Let us understand this with the help of example code: 

    class Student: 

        def __init__(self, Alex): 
            self.name = Alex    #name created in constructor 
        def get_student_name(self): 
            return self.name 

    In the example above, self refers to the variable age of the class Student. The variable age is local to the method. While the method is running, the variable age exists within the class. 

    If there is a variable within a method, the self variable will not work. If you wish to define global fields, you need to define variables outside the class methods. For a deeper understanding of such concepts and their practical application, consider enrolling in Programming Certification Courses.

    Should We Pass Self to a Method?

    Since we can use any other name instead of using the self variable, then what will happen if we just pass self to a method definition. Let us consider the class myClass we have used earlier.  

    A method named something is defined within the class with a parameter another and two arguments: 

    class myClass:  
    def something(another, argument1, argument2):  

    Now, let us declare an instance obj of myClass and call the method something with the help of the instance object: 

    obj = myClass() 
    obj.something(argument1, argument2) 

    Python performs an internal work on the method call and converts it into something like this: 

    myClass.something(obj, argument1, argument2)  

    This shows that another variable (used in place of self) refers to the instance object of the class. 

    Note that the pass keyword used in the method something does nothing. It is used as a dummy in situations where you do not want any operation to be performed but there is a syntax requirement of a certain programming element. 

    How Can We Skip Self in Python? 

    Consider a situation where the instance method does not need to have access to the instance variables. In such cases, we can consider skipping the self variable in defining methods. Let us have a clear understanding of the fact with example code: 

    class Vehicle: 
    def Car(): 
    print(“Rolls Royce 1948”) 
    obj = Vehicle() 

    If you run the following code, the output will be as follows: 


    We have not declared the self variable here but there is still no error in the program and the output comes out fine. However, what will be the case if we call the Car() method: 

    obj = Vehicle() 

    When we compile the code after calling the Car() method, it shows an error like this: 

    Traceback (most recent call last): 
      File "<string>", line 11, in <module> 
    TypeError: Car() takes 0 positional arguments but 1 was given 

    The output shows an error since the method Car() takes 0 positional arguments but we have given 1 positional argument to it. This is because when the instance obj is created, it is automatically passed as the first argument to the method Car() even if we have not declared the self variable. 

    However, if you try to access the instance method Car() with the help of the class reference, there will be no errors and the program will work fine: 

    class Vehicle: 
    def Car(): 
    print("Rolls Royce 1948") 
    obj = Vehicle() 
    Rolls Royce 1948 

    Difference Between self and __init__  

    selfself represents the instance of the class. By using the "self" keyword all the attributes and methods of the python class can be accessed.
    __init__ "__init__" is a reserved method in python classes. It is known as a constructor in object oriented concepts. This method is called when an object is created from the class and allows the class to initialize class attributes.

    Usage of "self" in class to access the methods and attributes: 

    class Rectangle: 
       def __init__(self, length, breadth, cost_per_unit =0): 
           self.length = length 
           self.breadth = breadth 
           self.cost_per_unit = cost_per_unit 
       def perimeter(self): 
           return 2 * (self.length + self.breadth) 
       def area(self): 
           return self.length * self.breadth 
       def calculate_cost(self): 
           area = self.area() 
           return area * self.cost_per_unit 
    # length = 40 cm, breadth = 30 cm and 1 cm^2 = Rs 100 
    r = Rectangle(40, 30, 100) 
    print("Area of Rectangle:",r.area()) 
    print("Cost of rectangular field is : Rs ",r.calculate_cost()) 


    Area of Rectangle: 1200 
    Cost of rectangular field is : Rs  120000 

    We have created an object of Rectangle class. While creating the Rectangle object, we passed 3 arguments – 40,30,100; all these arguments are passed to "__init__"method to initialize the object. 

    Here, the keyword "self” represents the instance of the class. It binds the attributes with the given arguments. 

    Self represents the same object or instance of the class. If you see, inside the method "area” , self.length" is used to get the value of the attribute "length".  attribute "length" is bind to the object (instance of the class) at the time of object creation. "self" represents the object inside the class. "self" works just like "r" in the statement “r = Rectangle(40,30, 100)".  If you see the method definition "def area(self): ” , here "self" is used as a parameter in the method because whenever we call the method,  the object (instance of class) is automatically passed as a first argument along with other arguments of the method. If no other arguments are provided only "self" is passed to the method. That's the reason "self" is used to call the method inside the class("self.area()").  We used object (instance of class) to call the method outside of the class definition("r.area()").  

    "r" is the instance of the class when the method "r.area()” is called; the instance "r" is passed as first argument in the place of self. 

    Miscellaneous Implementations of self 

    Let us now discuss some of the miscellaneous implementations of the self variable. 

    Similar variables for Class Method and Static Method 

    A class method is a method that is bound to the class. Let us understand a class method with an example – 

    class myClass: 
    def classmethod(cls): 
    return “Class Method is called” 

    The same behavior of the self variable is present with the Class methods too but the only difference is that for class methods, the convention is to use cls as the variable name instead of self. 

    The class methods take a cls parameter instead of the self parameter. When the method is called, it points to the class. The class method cannot modify the object state but it can modify the class state of all the class instances. 

    On the other hand, static methods are self-sufficient functions and this type of method takes neither a self nor a cls parameter. Let us see an example of a static method –

    class myClass: 
    def staticmethod(): 
    return “Static Method is called” 

    Since a static method does not accept any parameter, they cannot modify object state or even class state. They are primarily used to namespace different methods and Python restricts them in the data they can access. 

    Note that both the methods here are marked with @classmethod and @staticmethod decorators to flag it as a class method and static method respectively. 

    • The self variable is bound to the current instance 
    • The self variable allows us to access the properties of the current instance. 

    Let us understand this with an example – 

    class Person: 
    def __init__(self, n): 
    self.name = n 
    def walk(self): 
    print(f“{self.name} is walking”) 
    obj1 = Person(“Alex”) 
    obj2 = Person(“Charles”) 
    Alex is walking 
    Charles is walking 

    Here, we have a class Person with two methods __init__ and walk declared with the self parameter. We have created two different instances of the class – obj1 and obj2. When the first instance is revoked, “Alex” is printed with the method walk() whereas when the second instance is revoked, “Charles” gets printed with the properties of the instance method walk(). 

    Is Self a Keyword in Python? 

    There is a question that always hovers among Python programmers. Is self actually a keyword in Python? 

    Unlike other programming languages like C++, where self is considered to be a keyword, in Python it is a convention that programmers tend to follow. It is basically a parameter in a method definition. However, you can use any other name in place of self like another or me or anything else for the first parameter of a method. Another reason why it is suggested by most people is that it enhances the readability of your code. 

    Tips About the Python Self Keyword 

    Since we have now reached the end of the article, let me give you some tips about when to use and when not to use the self variable in Python. 

    Use self when
    Don’t use self when
    you define an instance method, since it is passed automatically as the first parameter when the method is called
    you want to call an instance method normally
    you reference a class or an instance attribute from inside an instance method
    referencing a class attribute inside the class definition but outside an instance method
    you want to refer to instance variables and methods from other instance methods
    you are inside a static method

    Top Cities Where Knowledgehut Conduct Python Certification Course Online

    Python Course in BangalorePython Course in ChennaiPython Course in Singapore
    Python Course in DelhiPython Course in DubaiPython Course in Indore
    Python Course in PunePython Course in BerlinPython Course in Trivandrum
    Python Course in NashikPython Course in MumbaiPython Certification in Melbourne
    Python Course in HyderabadPython Course in KolkataPython Course in Noida


    Mastering the self variable Python is essential for proficient object-oriented programming (OOP). This variable plays a pivotal role in maintaining code organization by distinguishing between traits shared across all instances of a class and those specific to each instance, enhancing overall code clarity. Knowledge of self fosters modular, reusable programming, which improves scalability and reliability. Developers can achieve every advantage of OOP by using self in Python to create strong systems with clearer architecture and greater readability.

    My experience with this leading programming language says continuous practice and self-exploration within Python knowledge are essential for refining your programming skills. It lets developers like you and me construct efficient, flexible approaches that adhere to OOP principles, hence boosting code reuse and extension. Embracing self in Python empowers programmers to create complex apps, simplifying debugging and improving code comprehension. Enrolling in KnowledgeHut's Python course is an excellent way to deepen your understanding of the self-variable and its role in Python programming.  

     Lastly, mastering self variable in Python denotes not just a thorough comprehension of Python's OOP framework but also provides developers with the tools necessary to design refined, scalable software programs.! 

    Frequently Asked Questions (FAQs)

    1What does self () do in Python?

    Self is not a function in Python but a convention utilized as the initial parameter in class methods. It contains the class's instance, giving access to its variables and methods. This option makes a distinction between instance and class variables, letting specific object characteristics within the class be manipulated. Its application is required for method functionality and allows interaction with instance-specific characteristics.

    2What is an example of a self-reference?

    The example of self-reference is as follows:

    class Car:

    def __init__(self, design, series):

    self.design = design

    self.series = series

    def display_info(self):

    print(f"This car is a {self.design {self.series}") 

    # Creating instances of the Car class 

    car1 = Car("Maruti", "Ciaz") 

    car2 = Car("BMW", "Model X5") 

    # Accessing instance-specific attributes using self 

    car1.display_info()  # Output: This car is a Maruti Ciaz 

    car2.display_info()  # Output: This car is a BMW Model X5 

    The Car class in the above illustration has a __init__ function that establishes instance-specific variables (design and series. When displaying information about every automobile instance, the display_info function uses self to get these characteristics. When invoking display_info() on every instance (car1 and car2), self belongs to the instance in query, providing access to its distinct properties. 

    3What is self reference in python?

    In Python, the self reference is utilized within class definitions to provide access to the class's instance. It is the standard term for the initial parameter of instance-based methods within a class. When a method is executed on a class instance, Python gives this instance as the method's initial argument, denoted as self.

    The self reference gives access to the unique instance's properties and methods, differentiating between instance-specific variables and those shared by all class instances. It facilitates proper enclosure and object-oriented programming methods in Python by allowing modification and interaction with the instance's attributes within the class.


    Ramulu Enugurthi

    Blog Author

    Ramulu Enugurthi, a distinguished computer science expert with an M.Tech from IIT Madras, brings over 15 years of software development excellence. Their versatile career spans gaming, fintech, e-commerce, fashion commerce, mobility, and edtech, showcasing adaptability in multifaceted domains. Proficient in building distributed and microservices architectures, Ramulu is renowned for tackling modern tech challenges innovatively. Beyond technical prowess, he is a mentor, sharing invaluable insights with the next generation of developers. Ramulu's journey of growth, innovation, and unwavering commitment to excellence continues to inspire aspiring technologists.

    Share This Article
    Ready to Master the Skills that Drive Your Career?

    Avail your free 1:1 mentorship session.

    Your Message (Optional)

    Upcoming Programming Batches & Dates

    NameDateFeeKnow more
    Course advisor icon
    Course Advisor
    Whatsapp/Chat icon