Self Keyword in Python

The self represents the class instance. We may access the class's properties and methods in Python using the "self" keyword. The keyword associates the properties with the class's arguments provided.

Since Python does not employ the @ syntax to create references to the instance attributes, we must use self. Python opted to implement methods so that the instance of the classes to which the method corresponds is automatically supplied but not immediately received: the first argument of any method is the instance on which the method is executed.

Exploring Object references with self

Example 1 : self keyword program

Code

# Python program to show the use of the self keyword
  
class Class: 
    def __init__(self): 
        print("The reference id of the self method is: ",id(self)) 
  
# Creating an instance of the class
obj = Class() 
print("The reference id of the object is: ",id(obj))

Output

The reference id of the self method is:  139904481668400
The reference id of the object is:  139904481668400

Why is the Self Method Defined Every Time?

Even though we understand the purpose of self, it may appear strange, particularly to developers who have learned other programming languages, that self is explicitly supplied as a parameter every time we construct a method. It is believed that explicit is always better than implicit.

Example 2:

We have a Position class which has a method called distance for calculating the distance of the given point from the origin.

Code

# Python program to calculate the distance using the class Distance

class Distance(object):
    def __init__(self, x = 0, y = 0):
        self.x = x
        self.y = y

    def distance(self):
        """Finding the distance of point_ from the origin"""
        return (self.x**2 + self.y**2) ** 0.5

object_ = Distance(3, 4)
dist = object_.distance()
print("The distance of the point (3, 4) from the origin is: ", dist)

Output

The distance of the point (3, 4) from the origin is:  5.0

In the above scenario, __init__() declares three arguments, but we only passed two (3 and 4). Similarly, distance() takes one input but receives none.

Example 3:

Why is the Python interpreter not reporting the mismatched argument numbers? Let's see in the below code.

Code

# Python program to calculate the distance using the class Distance

class Student(): 
      
    # calling the __init__ method or constructor 
    def __init__(self, name, age): 
        self.name = name 
        self.age = age 
          
    def details(self): 
        print("The name of the student is", self.name ) 
        print("The age of the student is", self.age ) 
          
# both the objects, Harry and Louis, have their own self arguments, which contain their distinct attributes 
Harry = Student("Harry", 29) 
Louis = Student("Louis", 30) 

# Using the method details
Harry.details() # This will show same output as Studnet.details(Harry) 
Louis.details()  # This will show same output as Studnet.details(Louis) 
  
# We can also execute the following commands 
print("The age of Harry is ",Harry.age) 
print("The age of Louis is ",Louis.age)

Output

The name of the student is Harry
The age of the student is 29
Name of the student is Louis
Age of the student is 30
The age of Harry is  29
The age of Louis is  30

This occurs because after assigning attributes in the function Object() , they are associated with that specific object; in this case, attributes (name, age) are attached to objects (Harry and Louis) when we initialize them.

Example 4:

The self argument must be sent to the Instance function and constructor as the first parameter. It will result in an error if we do not give it.

Code

# Python program to show that the self argument is always the first argument 

# Creating a class
class Paint: 
    def __init__(): 
        print("This command is inside the constructor") 

# Creating an instance of the class
object_ = Paint() 
print("This command shows the instance is created") 

Output

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
 in 
      7 
      8 # Creating an instance of the class
----> 9 object_ = Paint()
     10 print("This command shows the instance is created")
     11 

TypeError: __init__() takes 0 positional arguments but 1 was given

How to Avoid Self Parameter?

We can see by now that the class object or instance itself is automatically given over as the first parameter. When creating a static method, this implicit behavior may be prevented. Look at the following basic example:

Code

# Python program to show how to avoid the self parameter by creating a static method

# Creating a class
class Class(object):
    # Creating a static method
    @staticmethod

    # Creating a method without the self keyword
    def without_self():
        print("We did not pass the self parameter to this method")

# Creating an instance of the class and calling the method without_self
instance = Class()
instance.without_self()

Output

We did not pass the self parameter to this method

init() is not a Constructor

The __init__() function is not a constructor, which is a crucial conclusion from the information. Many inexperienced Python programmers are perplexed by it because __init__() is executed when we build an object.

As we know, the instance itself is the first parameter of the __init__() method. The method __init__() is used to initialize the object right after it is constructed.

In technical terms, a function Object() is a method that builds the object itself. This function is called new () in Python. This method's syntax is:

Syntax

When the __new__() method is invoked, the class itself would be automatically provided as the first parameter (cls).

cls, like self, is only a naming convention. Additionally, the *args and **kwargs parameters are utilized in Python function calls to accept an arbitrary amount of parameters.

While implementing __new__(), keep the following in mind:

__new__() is always executed before __init__().
The first parameter is the class name, which is implicitly given.
__new__() should always return a legitimate object. It is not required, but its primary function is to construct and return a Python object.

Consider the following example:

Code

# Python program to show how to use the __new__() method in a class

# Creating a class
class Class(object):

    # Creating the __new__() method before the __init__() method
    def __new__(cls, *args, **kwargs):
        print("This is under the new method")
        print("The class argument: ", cls)
        print("The args: ", args)
        print("The kwargs: ", kwargs)

        # Creating an object of the class and returning that object as required by the __new__() method
        object_ = super().__new__(cls)
        return object_

    # Creating the __init__() method
    def __init__(self, a = 0, b = 0):
        print("This is under the init method")
        self.a = a
        self.b = b

# Calling the class
c = Class(3,4)

Output

This is under the new method
The class argument:  <class '__main__.Class'>
The args:  (3, 4)
The kwargs:  {}
This is under the init method

This scenario shows how __new__() is invoked before __init__() (). We can also observe that the class is sent as an argument to __new__() (Point). Lastly, the object is formed using the object base class's __new__() function.

In Python, the base class, i.e., the class from which all subsequent classes are derived, is the object. In the preceding example, we used super() to do this.

Conclusion:

All in all, the self keyword in Python is a show utilized inside class strategies to allude to the case of the actual class. It permits getting to and controlling the occurrence's attributes and strategies. While characterizing techniques inside a class, the self boundary is commonly the principal boundary included, in spite of the fact that it tends to be named diversely whenever wanted.

Next TopicSpotify API Python

← prev next →