The self variable in Python explained with Python tips

Read it in 9 Mins

Last updated on
07th Jun, 2022
Published
02nd Jul, 2020
Views
15,943
The self variable in Python explained with Python tips

If you have been working on Python, you might have across the self variable. You can find it in method definitions and in initializing variables. However, before coming to the self variable, let us have an idea about classes and instances in Python. Here is an article about sys.argv command line argument to give you deeper understanding.    

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() 
>>>obj.instance_method() 
('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. What happens is that the 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: 

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

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

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 variable 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. Let us understand this 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. 

Need for Self in Python 

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. 

Explicit definition of self 

The Zen of Python says “Explicit is better than Implicit”. Programmers of other languages often ask why 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. 

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.   

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. 

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()  
object.show()

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. 

Why "self" should 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) 
rec1=Rectangle(6,10) 
print ("Area is:", rec1.area()) 

Output:  

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.

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):  
pass 

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() 
print(“Complete”) 

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

Complete 

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() 
obj.Car() 

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() 
Vehicle.Car() 
Rolls Royce 1948 

Difference between self and __init__  

self : self 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()) 

Output:  

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: 
@classmethod 
def classmethod(cls): 
return “Class Method is called” 
obj.classmethod() 

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: 
@staticmethod 
def staticmethod(): 
return “Static Method is called” 
obj.staticmethod() 

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”) 
obj1.walk() 
obj2.walk() 
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(). 

Tips about the Python self variable 

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:

  • you define an instance method, since it is passed automatically as the first parameter when the method is called;
  • you reference a class or an instance attribute from inside an instance method;
  • you want to refer to instance variables and methods from other instance methods. 

Don’t use self when: 

  • you want to call an instance method normally;
  • referencing a class attribute inside the class definition but outside an instance method;
  • you are inside a static method.  

Conclusion 

Let us recap the key points we have covered in this article, namely:

  • Instances and Classes in Python. 
  • Self variable and its importance. 
  • The explicitness of the self variable. 
  • Python class self constructor. 
  • Passing self as a method. 
  • Skipping self in Python. 
  • Variables used for Class methods and Static methods. 
  • Bounding of self to the current instance. 
  • When to use and when not to use self in Python. 

With good knowledge about the self variable in Python and its internal working in Python, it is now time for some practice. If you, however, wish to know more about Python self, you can head right on to the official documentation of Python.

Happy coding! 

Profile

Priyankur Sarkar

Data Science Enthusiast

Priyankur Sarkar loves to play with data and get insightful results out of it, then turn those data insights and results in business growth. He is an electronics engineer with a versatile experience as an individual contributor and leading teams, and has actively worked towards building Machine Learning capabilities for organizations.