Python built-in utility that checks if the given object appears callable. callable()

python @

In Python, the callable() function is a built-in utility that checks if the given object appears callable. A callable object is anything that can be called, like a function or a method. If the object seems callable, the function returns True, otherwise False.

Real-World Example:

Let’s explore callable() with a practical example:

# Defining a function
def sample_function():
    return "Hello, World!"

# Checking if various entities are callable
print(callable(sample_function))  # True
print(callable(sample_function()))  # False
print(callable("Hello, World!"))  # False
print(callable(lambda x: x+1))  # True
print(callable(5))  # False

Here, while the sample_function itself is callable, its return value (sample_function()) is not. Likewise, the lambda function is callable, but a string or an integer isn’t.

Importance of callable():

  1. Dynamic Calling: In dynamic programming or when working with plugins, it’s often uncertain whether an object is a callable function or a simple data attribute. callable() assists in making this distinction.
  2. Safe Code Execution: Before attempting to call an object, checking its callable status can prevent potential runtime errors.
  3. Introspection: callable() aids in introspecting Python objects, making it invaluable for tools and libraries that build atop Python’s reflection capabilities.


  1. Simplicity: The function provides a straightforward way to determine an object’s callability.
  2. Versatility: It can be used with any object, be it a class, method, function, lambda, or even a module with a __call__ method.
  3. Enhanced Code Reliability: It aids in writing more robust and error-resistant code.

Use Cases:

  1. Plugin Systems: When developing systems that allow third-party plugins, callable() can verify if provided hooks or extensions are indeed functions or methods.
  2. Function Wrappers: In decorators or function wrappers, checking if an object is callable ensures the right entities are being wrapped.
  3. Custom Class Definitions: For classes with a __call__ method, callable() can ascertain if instances of this class can be called like functions.
Refer more on python here :
Author: user