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.  

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 – 

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”: 

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: 

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

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: 

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. 

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. 

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. 

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: 

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.   

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: 

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: 

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. 

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

Output:  

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. 

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.

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: 

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

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

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. 

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: 

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: 

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

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: 

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: 

Output:  

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 – 

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 – 

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 – 

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

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. 

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

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! 

Research & References of The self variable in Python explained with Python tips|A&C Accounting And Tax Services
Source

Share on Facebook

Tweet

Follow us