Basic Concept

Callability determines whether an object can be invoked. Similar to many contemporary languages, invoking an object in Python is performed using a pair of parentheses, commonly referred to as the call operator. If an object can be used with this operator, it is classified as callable; if not, it is deemed non-callable.

Here are a few straightforward examples:

As illustrated, a function is indeed callable, and we invoke it accordingly. Conversely, a list object cannot be called. Python classes are callable, enabling us to create instance objects through their invocation. For checking an object's callability, we can utilize the built-in callable() function, as demonstrated below:

The boolean results align with the behaviors exhibited when applying the call operator to these objects.

Practical Implication 1: Distinguishing Classes from Functions

One key insight is to recognize the distinction between classes and functions. Python boasts nearly 70 built-in functions, yet many of these are technically classes, such as bool(), int(), list(), and dict(), rather than traditional functions like sum(), callable(), and hash().

While this difference may not be syntactically crucial, it holds semantic significance. Invoking a class yields an instance object of that class, with parameters guiding the instantiation. In contrast, true functions do not produce instance objects tied to their names. For example, calling sum() will not yield a sum object.

Practical Implication 2: Reviewing Map and Filter

Despite its classification as an OOP language, Python integrates functional programming paradigms. A notable feature is the inclusion of higher-order functions, such as map and filter. The following code snippet illustrates basic use cases for these functions:

Upon inspection, you may find:

>>> map

<class 'map'>

>>> filter

<class 'filter'>

Contrary to common belief, both map and filter are classes. This misunderstanding likely stems from the notion that classes typically construct instances from non-function objects. However, in Python, functions are also objects, allowing map and filter classes to utilize functions for their instantiation.

This does not imply we should cease referring to map and filter as higher-order functions; rather, we should acknowledge their underlying class implementations.

Practical Implication 3: Utilizing the Key Parameter

Numerous Python functions feature a key parameter, often employed during sorting or comparison processes. Regardless of the function's specific role, the key parameter consistently requires a callable.

Consider this example demonstrating the use of a standard function and a lambda function within the sorted() function:

We can also pass any callable to the key parameter, as shown below:

Here, we define a custom class named PokerSorter that assigns numeric values to non-numeric cards. This class can be applied to the sorted() function to achieve the desired sorting of cards.

Practical Implication 4: Employing Classes as Decorators

Typically, decorators are higher-order functions that enhance the functionality of other functions without altering their intended operations. This is why we refer to them as decorators.

The following code demonstrates how to create a decorator function:

The logging_time function acts as the decorator, accepting a function as its parameter. It includes an inner function, logger, where the decoration logic occurs, such as recording the time taken for execution.

Using the decorator is straightforward—simply place it above the function with an @ sign. Post-decoration, invoking calculate_sum_n will yield the execution time of the function.

Given the similarities between classes and functions, it is feasible to implement decorators using classes. Below is an illustration:

We create a custom class, TimeLogger, where the constructor takes a function as an argument. Within the __init__ method, we create a logger function similar to that in the decorator. The difference lies in storing it as an instance attribute.

The syntax for decorating remains unchanged, but note that the decorated function is now an instance of the TimeLogger class. To enable this instance to function as a callable, we must override the __call__ special method, which allows us to invoke the logger function.

Utilizing classes as decorators can be beneficial for several reasons:

1. They facilitate the creation of more complex decorators that accept parameters, making implementation more flexible.
2. Additional attributes can be incorporated into the instance object, enabling the retention of calculated results, which can save time during repetitive computations.

Conclusion

This article explored the concept of callability in Python objects, emphasizing four practical implications. Essentially, both classes and functions in Python are callable, leading to various interaction opportunities between them. Acknowledging callability allows us to write more versatile and effective code.