Python callable() Function

Spread the love

The primary purpose of the callable() function is to check if an object appears to be callable. In essence, it helps ascertain if an object can be invoked like a function.


  • Parameter: object – the object that you want to check.
  • Return Value:
    • True if the object appears callable.
    • False otherwise.

The Essence of “Callable”

In Python, many objects can be called. Most commonly, functions and methods are callable. But other objects might be callable as well, especially if they define a special method named __call__().

For instance:

  • Regular functions
  • Lambda functions
  • Classes (invoking a class constructs an instance)
  • Objects that have a __call__() method

Usage Examples of callable( )

a. Regular Functions and callable( ) :

The primary purpose of the callable() function is to check if an object can be invoked like a function. Given that regular functions are designed to be invoked, when you pass a regular function to callable(), it will always return True.

def sample_function():
    return "I'm a regular function."

# Check if sample_function is callable
print(callable(sample_function))  # Outputs: True

Unassigned Functions:

Even if you have a function’s name without the parentheses (i.e., you’re referencing the function but not calling it), callable() will still return True.

print(callable(sample_function))  # Outputs: True

On the other hand, if you were to call the function and then pass the result of that call to callable(), the outcome would depend on the return value of the function. If the function returns another callable object (like another function), callable() would return True. Otherwise, it would return False.


def return_function():
    def inner_function():
    return inner_function

print(callable(return_function()))  # Outputs: True, because inner_function is callable

Function Objects:

Every function in Python is an object. When you define a function using the def keyword, you’re actually creating a function object. This object can be assigned to variables, stored in data structures, passed as arguments, etc. Regardless of how you reference or store this object, it remains callable.

# Assigning function to a variable
func_var = sample_function

# Checking callability
print(callable(func_var))  # Outputs: True

Functions without return :

Whether a function explicitly returns a value using the return statement or not doesn’t affect its callability. All functions, by default, return None if no return statement is specified. The callable() function is not concerned with what is returned but rather if the object can be invoked.

def function_without_return():
    print("No return here.")

print(callable(function_without_return))  # Outputs: True

In summary, for regular functions, the callable() function will always return True. This holds regardless of how you reference the function, whether it’s directly by name, via a variable, or even if it’s nested inside another function. The essence of a function is that it is inherently designed to be called, and thus callable() reflects this intrinsic property.

b. Lambda Functions and callable( ) :

Just like regular functions, lambda functions are inherently callable. When passed to the callable() function, it will return True.


square = lambda x: x**2

# Check if the lambda function is callable
print(callable(square))  # Outputs: True

Assigning Lambda to a Variable:

Lambda functions are often assigned to variables to give them a name and make them more usable. Even when assigned to a variable, the result of callable() remains True for the variable pointing to the lambda.


add = lambda a, b: a + b
print(callable(add))  # Outputs: True

Passing Lambda as an Argument:

Lambda functions can be passed as arguments to other functions. If you pass a lambda function, without invoking it, to callable(), it will always return True.


def check_callable(func):
    return callable(func)

result = check_callable(lambda x: x + 1)
print(result)  # Outputs: True

Lambda’s Return Value and callable( ) :

It’s important to distinguish between checking the callability of the lambda function itself and checking the callability of its return value. callable() checks the object itself, not the result of invoking the object.

For example, if a lambda function returns a number, string, or any other non-callable value, and you pass this result to callable(), it will return False.

lambda_returning_int = lambda: 42
print(callable(lambda_returning_int()))  # Outputs: False, because 42 (the result of the lambda) is not callable

However, if a lambda function returns another function (either regular or lambda), invoking the lambda and then checking the result with callable() will return True.

lambda_returning_lambda = lambda: (lambda x: x + 1)
print(callable(lambda_returning_lambda()))  # Outputs: True, because the returned lambda is callable

In essence, lambda functions in Python are just like regular functions in terms of callability. They are always callable, regardless of how they are defined, assigned, or used. The callable() function provides a consistent way to verify this property, reinforcing the flexible nature of functions (both regular and lambda) in Python.

c. Classes and callable( ) :

At its core, the callable() function is used to determine if an object can be “called” like a function. While functions (both regular and lambda) are the most straightforward callable objects, classes in Python can also be callable.

Instantiation as a “Call”:

When you “call” a class, you are essentially creating a new instance of that class. This process is known as instantiation. Because of this behavior, classes in their basic form are always callable in Python.

class MyClass:

# Checking if the class is callable
print(callable(MyClass))  # Outputs: True

# Instantiate the class by "calling" it
instance = MyClass()

The __call__ Method:

While classes are callable, the instances of those classes are not necessarily so. However, if an instance needs to be callable, the class can define a special method called __call__. This method allows the instances of the class to be called as if they were functions.

class CallableClass:
    def __call__(self, x):
        return f"Called instance with: {x}"

# Create an instance
instance = CallableClass()

# Check if the instance is callable
print(callable(instance))  # Outputs: True

# Call the instance
print(instance(10))  # Outputs: Called instance with: 10

In this example, the CallableClass has a __call__ method, making its instances callable. When we invoke an instance of this class, the __call__ method gets executed.

Classes without __call__ Method:

For classes that do not define a __call__ method, their instances are typically not callable.

class NotCallableClass:
    def method(self):
        return "A regular method"

instance = NotCallableClass()
print(callable(instance))  # Outputs: False

In this case, the NotCallableClass does not have a __call__ method, so its instances are not callable.

Practical Applications:

The __call__ method can be leveraged in various design patterns and scenarios. One common use is in creating function-like objects that maintain state across calls. Because they can store state (as instance variables), callable objects can offer more flexibility in some scenarios than regular functions.

For example, a class representing a polynomial might use the __call__ method to evaluate the polynomial at a given x-value, storing the coefficients as instance variables.

d. Non-Callable Objects in Python:

While many objects in Python are callable (like functions, classes, and objects with a defined __call__ method), there are also plenty of objects that are not designed to be “called”. When such an object is passed to the callable() function, it returns False.

Common Non-Callable Objects:

Here are some typical examples of non-callable objects:

Integers, Floats, and Complex Numbers:

num = 42
print(callable(num))  # Outputs: False


Strings, despite having a plethora of methods, are not callable in themselves.

text = "Hello, World!"
print(callable(text))  # Outputs: False

Lists, Tuples, Dictionaries, and Sets:

These common data structures are also not callable. They can contain callable objects, but the data structures themselves cannot be invoked like functions.

my_list = [1, 2, 3]
print(callable(my_list))  # Outputs: False


Imported modules are not callable. However, they might contain callable entities inside them (like functions or classes).

import math
print(callable(math))  # Outputs: False

What Makes an Object Non-Callable:

In the context of Python’s object-oriented architecture, the absence of the __call__ method in an object’s class usually makes it non-callable. This is a simplification, but it’s the primary reason behind most objects being non-callable. When an object doesn’t define or inherit this special method, attempts to call it like a function will result in a TypeError.

Attempting to Call Non-Callable Objects:

If you try to call a non-callable object, Python will raise a TypeError indicating that the object is not callable.

num = 42
num()  # Raises TypeError: 'int' object is not callable

Why is callable( ) Useful?

Dynamic Programming:

Python is a dynamically-typed language, meaning that you don’t need to declare the type of a variable when you create it. This provides a lot of flexibility, but it also means that you might not always be certain about the type or nature of an object at runtime, especially when dealing with user input or external libraries. In such situations, before attempting to call an object as if it were a function, you can check its callability using callable() to prevent potential runtime errors.

Plugin Systems:

If you’re designing a system that allows for plugins or extensions, you might be loading external modules or objects. Not every object in these modules might be intended for direct invocation. Using callable(), you can discern which objects are meant to be called and which are not, thereby maintaining the integrity and functionality of your system.

API & Library Development:

When developing an API or library, especially one that will be used by other developers, you can use callable() to ensure that the appropriate functions or methods are being called. This can be crucial for error handling, ensuring that if a developer tries to use your API in an unexpected way, your code can provide a meaningful error message or handle the situation gracefully.

Advanced Object-Oriented Programming:

In Python’s OOP paradigm, not only functions and methods are callable. Classes can be callable (as they can be instantiated), and instances can be made callable by defining a __call__ method. Using callable(), you can differentiate between regular objects and objects intended to be called, allowing for more flexible and dynamic code structures.

Function Callbacks:

In scenarios where functions are passed as arguments (higher-order functions), callable() can be used to ensure that the passed argument is indeed a function before trying to execute it. This is common in event-driven programming, GUI development, or any situation where callbacks are used.

Decorators and Wrappers:

When implementing decorators or wrappers around functions, callable() can be used to ensure that the object being decorated or wrapped is actually a function or method. This provides an extra layer of security and robustness to such utilities.


The callable() function, while simple in its operation, serves as a powerful tool in the arsenal of a Python developer. It ensures safer code execution in dynamic scenarios and provides clarity on the nature of objects. By understanding and employing callable(), developers can write cleaner, more efficient, and less error-prone code.

Leave a Reply