Understanding Callable Objects in Python

Acallable in Python is any object that you can call using a pair of parentheses and a series of arguments if required. You’ll find different examples of callables in your daily interaction with Python. Some of them include:

• Built-in functions and classes
• User-definedfunctions that you create with thedef keyword
• Anonymous functions that you write using thelambda keyword
• Theconstructors of your customclasses
• Instance,class, andstatic methods
• Instances of classes that implement the.__call__() method
• Closures that you return from your functions
• Generator functions that you define using theyield keyword
• Asynchronous functions and methods that you create with theasync keyword

All these different callables have something in common. They all implement the.__call__()special method. To confirm this fact, you can use the built-indir() function, which takes an object as an argument andreturns the object’s list of attributes and methods:

>>>dir(abs)[    '__call__',    '__class__',    ...]>>>dir(all)[    '__call__',    '__class__',    ...]>>>defgreet():...print("Hello, World!")...>>>dir(greet)[    '__annotations__',    '__builtins__',    '__call__',    ...]

In the first two examples, you calldir() with the built-inabs() andall() functions as arguments. In both cases, you can see that the.__call__() method is present in the output.

In the final example, you define a custom function thatprints a message to the screen. This function also has.__call__(). Note how you can use this method to call the function:

>>>greet.__call__()Hello, World!

Note that using.__call__() as you did in this example produces the same effect as calling the function directly withgreet().

Now, how does all this work internally? When you run something likecallable_object(*args, **kwargs), Python internally translates the operation intocallable_object.__call__(*args, **kwargs). The arguments to the regular function are the same as those used in.__call__(). In other words, whenever you call a callable object, Python automatically runs its.__call__() method behind the scenes using the arguments you’ve passed into the callable.

Now take a look at the following custom class:

>>>classSampleClass:...defmethod(self):...print("You called method()!")...>>>type(SampleClass)<class 'type'>>>>dir(type)[    '__abstractmethods__',    '__annotations__',    '__base__',    '__bases__',    '__basicsize__',    '__call__',    ...]>>>sample_instance=SampleClass()>>>dir(sample_instance.method)[    '__call__',    '__class__',    ...]

In Python, everything is an object. Classes likeSampleClass are objects oftype, which you can confirm by callingtype() with the class object as an argument or by accessing the.__class__ attribute.

Theclass constructor ofSampleClass falls back to usingtype.__call__(). That’s why you can callSampleClass() to get a new instance. So, class constructors are callable objects that return new instances of the underlying class.

In the example above, you can observe that method objects, likesample_instance.method, also have a.__call__() special method that turns them into callable objects. The main takeaway here is that to be callable, an object needs to have a.__call__() method.

If you inspect a closure, generator function, or asynchronous function, then you’ll get similar results. You’ll always find a.__call__() method in callable objects.

Checking Whether an Object Is Callable

If you ever need to check whether a Python object is callable, then you can use the built-incallable() function like in the following examples:

>>>callable(abs)True>>>callable(all)True>>>callable(greet)True>>>callable(SampleClass)True>>>callable(sample_instance)False

Thecallable() function takes an object as an argument and returnsTrue if the object is callable. Otherwise, it returnsFalse.

In the above examples, all the tested objects are callable except forsample_instance. That’s foreseeable becauseSampleClass doesn’t implement a.__call__() method for its instances. Yes, you guessed it! You can make the instances of your custom classes callable by writing a.__call__() method. In the following section, you’ll learn the basics of turning the instances of your classes into callable objects.

But first, it’s important to note that sometimescallable() may produce false positives:

>>>classNonCallable:...def__call__(self):...raiseTypeError("not really callable")...>>>instance=NonCallable()>>>callable(instance)True>>>instance()Traceback (most recent call last):...TypeError:not really callable

In this example,callable() returnsTrue. However, instances of this custom class aren’t callable, and you get an error if you try to call them. So,callable() only guarantees that the target instance comes from a class that implements a.__call__() method.

Creating Callable Instances With.__call__() in Python

If you want the instances of a given class to be callable, then you need to implement the.__call__() special method in the underlying class. This method enables you to call the instances of your class as you’d call regular Python functions.

Unlike other special methods,.__call__() doesn’t have special requirements for what arguments it must accept. It works like any other instance method in the sense that it takesself as its first argument and can take as many extra arguments as you need.

Here’s an example of how instances of a class with a.__call__() method work:

# counter.pyclassCounter:def__init__(self):self.count=0defincrement(self):self.count+=1def__call__(self):self.increment()

In thisCounter class, you have a.countinstance attribute to keep track of the current count. Then you have an.increment() method that adds1 to the count every time you call it. Finally, you add a.__call__() method. In this example,.__call__() falls back to calling.increment(), providing a shortcut for running the increment operation.

Take a look at how the class works in practice:

>>>fromcounterimportCounter>>>counter=Counter()>>>counter.increment()>>>counter.count1>>>counter()>>>counter.count2>>>counter()>>>counter.count3

After creating an instance ofCounter, you call.increment(). This call increments the.count attribute by1, as you can confirm by accessing the attribute. In the rest of the examples, you take advantage of the fact that your class has a.__call__() method and call the instance directly to increment the count.

In this example,.__call__() provides a quick shortcut for running the count increment operation. This feature gives your class a convenient and user-friendly interface.

The.__call__() method in the above example doesn’t take any arguments. The method doesn’t return an explicit value either. However, there are no restrictions on how to write the.__call__() method in your custom classes. So, you can make them take arguments, return values, and even causeside effects like in yourCounter class example.

For a second example, consider the following class, which allows you to create callable objects to compute different powers:

# power.pyclassPowerFactory:def__init__(self,exponent=2):self.exponent=exponentdef__call__(self,base):returnbase**self.exponent

In this example, yourPowerFactory class takesexponent as an argument, which you’ll use later to run different power operations. The.__call__() method takes abase argument and calculates its power using the previously provided exponent. Finally, the method returns the computed result.

Here’s your class in action:

>>>frompowerimportPowerFactory>>>square_of=PowerFactory(2)>>>square_of(3)9>>>square_of(6)36>>>cube_of=PowerFactory(3)>>>cube_of(3)27>>>cube_of(6)216

Here, you usePowerFactory to create two different callable instances. The first instance raises numbers to the power of2, while the second instance raises numbers to the power of3.

In this example, you need to passbase as an argument when callingsquare_of() orcube_of() because those calls fall back to calling.__call__(), which takes abase argument. Finally, note how you get the power back from every call. That’s because.__call__() returns the result of calculating the desired power.

Defining a.__call__() method in custom classes allows you to use the instances of those classes as regular Python functions. This feature can come in handy in several situations, as you’ll learn in the sectionPutting Python’s.__call__() Into Action.

Before jumping into common use cases of callable instances, you’ll explore the differences between the.__init__() and.__call__() methods. These two methods and their corresponding roles in Python classes can be confusing for people who are beginning to work with Python.

Understanding the Difference:.__init__() vs.__call__()

Differentiating the roles of.__init__() and.__call__() in a Python class can be a confusing task for developers who are starting to study the language or itsobject-oriented features. However, these two methods are pretty different, and each one has specific goals.

The.__init__() method is theinstance initializer. Python calls this method automatically whenever you create an instance of a class by calling the class constructor. The arguments to.__init__() will be the same as the arguments to the class constructor, and they’ll typically provide initial values for instance attributes.

Meanwhile, the.__call__() methodturns instances into callable objects. As you already learned, Python automatically calls this method whenever you call a concrete instance of a given class.

To illustrate the differences between both methods, consider the following example class:

>>>classDemo:...def__init__(self,attr):...print(f"Initialize an instance of{self.__class__.__name__}")...self.attr=attr...print(f"{self.attr= }")......def__call__(self,arg):...print(f"Call an instance of{self.__class__.__name__} with{arg}")...

ThisDemo class implements both.__init__() and.__call__(). In.__init__(), you print a message and initialize the.attr attribute. In.__call__(), you only print a message so that you learn when the method gets called with a given argument.

Here’s how this class works:

>>>demo=Demo("Some initial value")Initialize an instance of Demoself.attr = 'Some initial value'>>>demo("Hello!")Call an instance of Demo with Hello!

As you can see, each method has a different role in your class. The.__init__() method gets called when you create instances of the class. Its main goal is to initialize instance attributes with sensible initial values.

You’ll find.__init__() in all Python classes. Some classes will have an explicit implementation, and others willinherit the method from a parent class. In many cases,object is the class that provides this method:

>>>dir(object)[    ...    '__gt__',    '__hash__',    '__init__',    ...]

Remember thatobject is the ultimate parent class of all Python classes. So, even if you don’t define an explicit.__init__() method in one of your custom classes, that class will still inherit the default implementation fromobject.

In contrast, the.__call__() method runs when you call a concrete instance of its containing class, such asdemo in this example. The goal of.__call__() is to turn your instances into callable objects. In other words, its purpose is to create objects that you can call as you would call a regular function. Most Python classes don’t implement this method. Your custom classes will have it only if you need to use your instances as functions.

Great! After clarifying the differences between.__call__() and.__init__(), you’re ready to continue learning about.__call__() by discovering how you can take advantage of this method in your Python code.

Putting Python’s.__call__() Into Action

Writing classes that produce callable instances can be pretty useful in a few situations. For example, you can take advantage of callable instances when you need to:

• Retain state between calls
• Cache values that result fromprevious computations
• Implement straightforward and convenientAPIs

Even though you can use functions or classes with regular methods to solve all these problems, using callable instances may be a good option in some situations. This is especially true when you already have an existing class and face the need for function-like behavior.

In the following sections, you’ll write practical examples that illustrate each of these use cases of callable instances in Python.

>>>defcumulative_average():...data=[]...defaverage(new_value):...data.append(new_value)...returnsum(data)/len(data)...returnaverage...>>>stream_average=cumulative_average()>>>stream_average(12)12.0>>>stream_average(13)12.5>>>stream_average(11)12.0>>>stream_average(10)11.5

# cumulative_average.pyclassCumulativeAverager:def__init__(self):self.data=[]def__call__(self,new_value):self.data.append(new_value)returnsum(self.data)/len(self.data)

>>>fromcumulative_averageimportCumulativeAverager>>>stream_average=CumulativeAverager()>>>stream_average(12)12.0>>>stream_average(13)12.5>>>stream_average(11)12.0>>>stream_average(10)11.5>>>stream_average.data[12, 13, 11, 10]

# factorial.pyclassFactorial:def__init__(self):self.cache={0:1,1:1}def__call__(self,number):ifnumbernotinself.cache:self.cache[number]=number*self(number-1)returnself.cache[number]

>>>fromfactorialimportFactorial>>>factorial_of=Factorial()>>>factorial_of(4)24>>>factorial_of(5)120>>>factorial_of(6)720>>>factorial_of.cache{0: 1, 1: 1, 2: 2, 3: 6, 4: 24, 5: 120, 6: 720}

classMainWindow:defshow(self):print("Showing the app's main window...")def__call__(self):self.show()# ...

window=MainWindow()window()# Or window.show()

# logger.pyclassLogger:def__init__(self,filename):self.filename=filenamedef__call__(self,message):withopen(self.filename,mode="a",encoding="utf-8")aslog_file:log_file.write(message+"\n")

Exploring Advanced Use Cases of.__call__()

So far, you’ve learned a lot about creating callable instances using the.__call__() method in your classes. This method also has some advanced use cases in Python. One of these use cases is when you want to createclass-based decorators. In this situation, the.__call__() method is the only way to go because it enables callable instances.

Another interesting use case of.__call__() is when you need to implement thestrategy design pattern in Python. In this case, you can take advantage of.__call__() to create classes that provide implementations for your different strategies.

In the following sections, you’ll learn how to use.__call__() to create class-based decorators and also to implement the strategy pattern in Python.

# timing.pyimporttimeclassExecutionTimer:def__init__(self,func):self.func=funcdef__call__(self,*args,**kwargs):start=time.perf_counter()result=self.func(*args,**kwargs)end=time.perf_counter()print(f"{self.func.__name__}() took{(end-start)*1000:.4f} ms")returnresult

>>>fromtimingimportExecutionTimer>>>@ExecutionTimer...defsquare_numbers(numbers):...return[number**2fornumberinnumbers]...>>>square_numbers(list(range(100)))square_numbers() took 0.0069 ms[    0,    1,    4,    9,    16,    25,    ...]

# timing.pyimporttimeclassExecutionTimer:def__init__(self,repetitions=1):self.repetitions=repetitionsdef__call__(self,func):deftimer(*args,**kwargs):result=Nonetotal_time=0print(f"Running{func.__name__}(){self.repetitions} times")for_inrange(self.repetitions):start=time.perf_counter()result=func(*args,**kwargs)end=time.perf_counter()total_time+=end-startaverage_time=total_time/self.repetitionsprint(f"{func.__name__}() takes "f"{average_time*1000:.4f} ms on average")returnresultreturntimer

>>>fromtimingimportExecutionTimer>>>@ExecutionTimer(repetitions=100)...defsquare_numbers(numbers):...return[number**2fornumberinnumbers]...>>>square_numbers(list(range(100)))Running square_numbers() 100 timessquare_numbers() takes 0.0073 ms on average[    0,    1,    4,    9,    16,    25,    ...]

# serializing.pyimportjsonimportyamlclassJsonSerializer:def__call__(self,data):returnjson.dumps(data,indent=4)classYamlSerializer:def__call__(self,data):returnyaml.dump(data)classDataSerializer:def__init__(self,serializing_strategy):self.serializing_strategy=serializing_strategydefserialize(self,data):returnself.serializing_strategy(data)

>>>fromserializingimportDataSerializer,JsonSerializer,YamlSerializer>>>data={..."name":"Jane Doe",..."age":30,..."city":"Salt Lake City",..."job":"Python Developer",...}>>>serializer=DataSerializer(JsonSerializer())>>>print(f"JSON:\n{serializer.serialize(data)}")JSON:{    "name": "Jane Doe",    "age": 30,    "city": "Salt Lake City",    "job": "Python Developer"}>>># Switch strategy>>>serializer.serializing_strategy=YamlSerializer()>>>print(f"YAML:\n{serializer.serialize(data)}")YAML:age: 30city: Salt Lake Cityjob: Python Developername: Jane Doe

Conclusion

You’ve learned a lot aboutcallable instances in Python, especially how to define them using the.__call__() special method in your custom classes. Now you know how to create classes that produce objects that you can call just like regular functions. This allows you to add flexibility and functionality to your object-oriented programs.

In this tutorial, you’ve learned how to:

• Comprehendcallables in Python
• Writecallable instances by using the.__call__() method
• Grasp thedifference between.__init__() and.__call__()
• Implement various examples of using callable instances to tacklepractical issues

With this knowledge, you can design and implement callable instances in your Python code. This will allow you to solve various common problems, such as retaining state between calls, caching data, writing class-based decorators, and more.