callable() в Python: вызываемые объекты и __call__

Функция callable в Python проверяет, можно ли вызвать объект с помощью круглых скобок, и возвращает True или False. Она полезна там, где в переменную может попасть как значение, так и функция: в обработчиках событий, настройках по умолчанию, реестрах команд. Ниже разобрано, какие объекты считаются вызываемыми, как на результат влияет метод __call__ и почему True еще не гарантирует успешный вызов.

Синтаксис и возвращаемое значение

Функция принимает ровно один аргумент и не имеет дополнительных параметров. Импортировать ничего не нужно, она встроена в язык.

callable(obj)

• True - объект поддерживает вызов obj();
• False - вызов гарантированно закончится ошибкой TypeError: 'X' object is not callable.

def greet():
    return "Привет"

x = 5
print(callable(greet))  # True
print(callable(x))      # False
print(callable(len))    # True
print(callable("abc"))  # False

Обратите внимание: в callable() передают саму функцию, без скобок. Запись callable(greet()) сначала вызовет функцию и проверит уже ее результат, строку "Привет", поэтому вернет False.

Какие объекты считаются вызываемыми

Вызываемым считается любой объект, у типа которого определен метод __call__. На практике это несколько групп объектов.

Классы вызываемы всегда: вызов класса создает новый экземпляр. А вот экземпляры по умолчанию вызывать нельзя, пока в классе нет метода __call__. Подробнее о разных видах функций, включая лямбда-функции, рассказано в отдельных статьях.

Метод __call__ и экземпляры классов

Если определить в классе метод __call__, его объекты можно вызывать как обычные функции. При этом объект сохраняет собственное состояние между вызовами, чего нет у простой функции без глобальных переменных.

class Multiplier:
    def __init__(self, factor):
        self.factor = factor

    def __call__(self, value):
        return value * self.factor

triple = Multiplier(3)
print(callable(Multiplier))  # True - класс
print(callable(triple))      # True - есть __call__
print(triple(10))            # 30

Сравним с классом без этого метода. Сам класс вызываемый, а его экземпляр нет:

class Printer:
    def print_line(self):
        print("строка")

p = Printer()
print(callable(Printer))  # True
print(callable(p))        # False
# p()  -> TypeError: 'Printer' object is not callable

Метод __call__ ищется в классе, а не в объекте. Если присвоить функцию атрибуту экземпляра p.__call__ = ..., объект от этого вызываемым не станет. Другие специальные методы с двойным подчеркиванием разобраны в статье магические методы.

Почему True не гарантирует успешный вызов

callable() проверяет только наличие механизма вызова. Число и типы аргументов функция не анализирует, поэтому вызов может упасть, даже если проверка прошла.

def add(a, b):
    return a + b

print(callable(add))  # True
add(1)  # TypeError: add() missing 1 required positional argument: 'b'

Ошибка может возникнуть и внутри самой функции. Обратная ситуация невозможна: если callable() вернул False, вызов точно не сработает.

Где callable() пригодится на практике

Типичный случай - параметр, который принимает либо готовое значение, либо функцию для его вычисления. Так устроены значения по умолчанию во многих библиотеках: функция вызывается при каждом обращении, а обычное значение возвращается как есть.

from datetime import datetime

def resolve(default):
    return default() if callable(default) else default

print(resolve(42))            # 42
print(resolve(datetime.now))  # текущие дата и время
print(resolve(list))          # [] - новый список при каждом вызове

Второй пример - выбор вызываемых атрибутов объекта, например при построении меню команд или документации. Комбинация с getattr() и dir() позволяет отделить методы от обычных полей.

class Bot:
    name = "helper"
    def start(self): ...
    def stop(self): ...

bot = Bot()
commands = [n for n in dir(bot)
            if not n.startswith("_") and callable(getattr(bot, n))]
print(commands)  # ['start', 'stop']

Такая проверка часто встречается в декораторах, которые можно применять и со скобками, и без них: декоратор смотрит, передали ему функцию или параметры настройки.

callable() или try/except

В Python распространен подход "проще попросить прощения, чем разрешения": сначала выполнить действие, а ошибку обработать. Для вызова функции он выглядит так:

try:
    result = handler(data)
except TypeError:
    result = None

Минус этого способа в том, что TypeError может прилететь изнутри handler, и настоящая ошибка будет замаскирована. Поэтому когда нужно именно различить функцию и значение, callable() надежнее. Если же объект по логике программы всегда должен быть функцией, проверку лучше не писать вовсе и дать ошибке проявиться.

Тип Callable в аннотациях

Для подсказок типов существует Callable из модуля collections.abc. Он описывает, какие аргументы принимает функция и что она возвращает. Это не замена callable(): аннотация проверяется линтером, а не во время работы программы.

from collections.abc import Callable
def apply(func: Callable[[int, int], int], a: int, b: int) -> int:
    return func(a, b)
print(apply(max, 3, 7))  # 7

Запись Callable[[int, int], int] означает функцию с двумя целыми аргументами, которая возвращает целое число. Остальные возможности подсказок собраны в статье аннотации типов, а официальное описание функции есть в документации Python.

Частые вопросы

Коротко о том, что чаще всего спрашивают про callable().

Чем callable() отличается от isinstance(obj, Callable)?

Для большинства объектов результат совпадает: isinstance(obj, collections.abc.Callable) тоже проверяет наличие __call__. Встроенная функция короче и не требует импорта.

Почему callable() возвращает True для класса?

Потому что класс можно вызвать: MyClass() создает объект. Вызываемость экземпляров зависит только от метода __call__ в классе.

Как исправить ошибку object is not callable?

Чаще всего имя функции перезаписано переменной, например list = [1, 2] или sum = 0, а потом вызывается list(...). Переименуйте переменную, чтобы она не перекрывала встроенное имя.

Есть ли callable() во всех версиях Python 3?

Функцию убрали в Python 3.0 и вернули в 3.2. Во всех актуальных версиях она доступна без импорта.