Summary: In this tutorial, we will learn what is __call__ in Python, what does it do, and when we should use it in our Python programs.

What is __call__ in Python?

__call__ is a special function in Python that, when implemented inside a class, gives its instances (objects) the ability to behave like a function.

It means after implementing __call__ method inside the Python class, we can invoke its instances like a function.

Example 1:

class Student():
    def __init__(self, name, roll):
        self.name = name
        self.roll = roll
        
    def __call__(self):
        print(f"Name: {self.name}, Roll: {self.roll}")
        
#creating an instance of the Student class        
stud1 = Student("Newton", "007")

#Using the instance like a function
stud1()

Output:

Name: Newton, Roll: 007

As you can see, the stud1() is calling the __call__ method of the instance. This means we can even pass arguments like normal functions.

Example 2:

class Student():
    def __init__(self, name, roll):
        self.name = name
        self.roll = roll
        
    def __call__(self, remarks):
        print(f"Name: {self.name}, Roll: {self.roll}")
        print(f"Remarks: {remarks}")
        
#creating an instance of the Student class        
stud1 = Student("Newton", "007")

#Using the instance like a funciton
stud1("Good Student")

Output:

Name: Newton, Roll: 007
Remarks: Good Student

How is this happening?

In Python, object() is the shorthand notation for object.__call__().

For example, in the following Python code, instead of function(), we are using the function.__call__() statement to invoke the function and it runs without any error:

def function():
    print("function called")

function.__call__()

Output:

function called

Therefore, when we use the () operator on any object, we are indirectly calling the __call__ method of that particular object.

It is important to note that functions in Python are also objects.

When should we use __call__ in Python?

When we want the instances of a class to behave like a function, we should implement the __call__ method.

Since __call__ method makes instance callable, we can use it as a decorator.

Example:

class Cloud:
    def __init__(self, func):
        self.func = func
        
    def __call__(self):
        print("Connected to cloud")
        self.func()
        print("Connection to cloud Closed")

@Cloud
def upload_file():
    print("Uploading File....")
    
upload_file()

Output:

Connected to cloud
Uploading File….
Connection to cloud Closed

Conclusion

The __call__ is a reserved method in Python that makes the instances of a class callable.

We should implement __call__ inside the class, if we want its instances to behave like functions.

Leave a Reply

twenty − five =