Python callable()

Python callable() takes an object as input and returns True if that object can be called like a function (meaning it has a __call__ method) and False otherwise. It's a simple way to check if you can use parentheses with an object to execute some code associated with it, which is crucial for writing dynamic and flexible Python programs.
Table of Contents

Understanding Python callable() Function

Python callable() function is a built-in function that checks if an object can be called like a function. In Python, if something is “callable,” you can use parentheses () after it, potentially passing in arguments to execute some code. The callable() function helps determine whether a given object in Python supports this call operation. It returns True if the object is callable and False otherwise. This is useful for dynamically checking the type of an object and deciding how to interact with it.

Syntax of Python callable()

is_callable = callable(object)

Explanation

  • is_callable: Variable will store the result of the check, which is either True or False.
  • callable(): Built-in function that checks if the object is callable.
  • object: Object you want to check for callability. It is used as input for the callable() function.

Example of Python callable()

def my_function():
  pass
result = callable(my_function)
print(result)

Explanation

  • def my_function():: Defines a function named my_function.
  • pass: Placeholder that does nothing, as the function is empty.
  • result = callable(my_function): The callable() function checks if my_function is callable and stores the result in result.
  • print(result): Prints the value of result, which is True because functions are callable.

Output

True

callable() Parameters

Python callable() function takes a single parameter. This parameter, which we can call object_to_check, can be anything. You can pass a function, a class, an instance of a class, an integer, a string, a list, or any other Python object. The job of callable() is to determine whether that object_to_check can be called like a function (i.e., whether you can put parentheses () after it and potentially pass arguments).

Syntax

boolean_result = callable(object_to_check)

Explanation

  • boolean_result: Holds True or False.
  • callable(): Checks if object is callable.
  • object_to_check: Any Python object.

Example

my_variable = 10
is_variable_callable = callable(my_variable)
print(is_variable_callable)

Explanation

  • my_variable = 10: Creates an integer variable.
  • is_variable_callable = callable(my_variable): Checks if integer is callable.
  • print(is_variable_callable): Prints the result (False for integers).

Output

False

callable() Return Value

Python callable() function always returns a boolean value: True or False. It returns True if the object you passed in can be called (like a function, method, or class with a __call__ method). It returns False if the object cannot be called. It’s a simple yes/no answer to the question, “Can I call this object like a function?”.

Syntax

callability = callable(some_object)

Explanation

  • callability: Stores True or False.
  • callable(): Determines if the object is callable.
  • some_object: Object which is being checked.

Example

class MyClass:
    def __call__(self):
        print("Called!")

my_instance = MyClass()
is_instance_callable = callable(my_instance)
print(is_instance_callable)

Explanation

  • class MyClass:: Defines a class.
  • def __call__(self):: Defines the __call__ method, making instances callable.
  • print("Called!"): Print the text.
  • my_instance = MyClass(): Creates instance of the class.
  • is_instance_callable = callable(my_instance): Checks if instance is callable.
  • print(is_instance_callable): Prints the result (True because of __call__).

Output

True

Callable Function Check with Python callable()

One of the primary uses of Python callable() is to check if a regular function is callable. In Python, functions are first-class objects, meaning you can pass them around like any other variable. Before calling a function that you’ve received as an argument or retrieved dynamically, it’s often a good idea to use callable() to verify that it is a callable function. If it is a function, then callable() will return True. Otherwise, it will return False.

Syntax

is_function_callable = callable(function_name)

Explanation

  • is_function_callable: Variable will store the result (True or False).
  • callable(): Function checks if function_name is a callable function.
  • function_name: Name of the function you’re checking. It is used as input for the callable() function.

Example

def greet(name):
  print(f"Hello, {name}!")

is_greet_callable = callable(greet)
print(is_greet_callable)

Explanation

  • def greet(name):: Defines a function named greet that takes one argument.
  • print(f"Hello, {name}!"): Prints a greeting.
  • is_greet_callable = callable(greet): The callable() function checks if greet is callable and stores the result in is_greet_callable.
  • print(is_greet_callable): Prints the value of is_greet_callable, which is True.

Output

True

Callable Object Check with Python callable()

In Python, custom class objects can be callable by implementing the special __call__ method within the class. When you use Python callable() with such an object, it checks for the presence of this __call__ method. Callable() returns True if the method exists, indicating that the object can be called like a function. Otherwise, it returns False. This allows you to create objects that behave like functions, which can be helpful in creating function-like objects with internal states or behavior.

Example

class Counter:
    def __init__(self):
        self.count = 0

    def __call__(self):
        self.count += 1
        return self.count

my_counter = Counter()
is_counter_callable = callable(my_counter)
print(is_counter_callable)

Explanation

  • class Counter:: Defines a class named Counter.
  • def __init__(self):: Defines the constructor for the class.
  • self.count = 0: Initializes a counter variable.
  • def __call__(self):: Defines the __call__ method, making the object callable.
  • self.count += 1: Increments the counter.
  • return self.count: Returns the current count.
  • my_counter = Counter(): Creates an instance of the Counter class.
  • is_counter_callable = callable(my_counter): The callable() function checks if my_counter is callable and stores the result in is_counter_callable.
  • print(is_counter_callable): Prints the value of is_counter_callable, which is True.

Output

True

Object Appears Callable but Isn’t

Sometimes, an object might seem like it should be callable because it has a method named call, but if it doesn’t have the special __call__ method, Python callable() will return False. This distinction is important because the __call__ method is specifically what Python looks for to determine if an object can be called using the function call syntax (). A regular method named call does not make an object callable in Python’s sense.

Example

class MyClass:
    def call(self):
        print("call method invoked")

my_object = MyClass()
is_callable = callable(my_object)
print(is_callable)

Explanation

  • class MyClass:: Defines a class named MyClass.
  • def call(self):: Defines a method named call but this is not the special __call__ method.
  • print("call method invoked"): Prints a message when the call method is invoked.
  • my_object = MyClass(): Creates an instance of MyClass.
  • is_callable = callable(my_object): The callable() function checks if my_object is callable (it is not because it does not have __call__ method) and stores the result in is_callable.
  • print(is_callable): Prints the value of is_callable, which is False.

Output

False

Callable Built-in Function Check with Python callable()

Built-in functions in Python, such as print(), len(), and str(), are callable. When you use Python callable() to check a built-in function, it will return True. This is because built-in functions are designed to be called with parentheses to perform their respective operations.

Example

is_len_callable = callable(len)
print(is_len_callable)

is_print_callable = callable(print)
print(is_print_callable)

Explanation

  • is_len_callable = callable(len): The callable() function checks if len is callable and stores the result in is_len_callable.
  • print(is_len_callable): Prints the value of is_len_callable, which is True.
  • is_print_callable = callable(print): The callable() function checks if print is callable and stores the result in is_print_callable.
  • print(is_print_callable): Prints the value of is_print_callable, which is also True.

Output

True
True

Callable String Check with Python callable()

In Python, strings are not callable. If you use Python callable() to check a string, it will always return False. This is because strings do not have a __call__ method and are not designed to be invoked like functions.

Example

my_string = "Hello, World!"
is_string_callable = callable(my_string)
print(is_string_callable)

Explanation

  • my_string = "Hello, World!": Creates a string variable my_string.
  • is_string_callable = callable(my_string): The callable() function checks if my_string is callable and stores the result in is_string_callable.
  • print(is_string_callable): Prints the value of is_string_callable, which is False.

Output

False

Conclusion

Python callable() function is essential for determining whether an object in Python can be called like a function. It helps you check if functions, methods, or objects of custom classes with a __call__ method are callable. Understanding how Python callable works in different scenarios, such as with built-in functions, strings, and custom objects, is important for writing flexible and robust Python code. Using callable() function you can determine if you can call an object with () or not.

Also Read

Python bytearray()

Python bytes()

Python Reference

python callable()