Метод __call__: от объектно-ориентированного программирования к функциональному стилю

Продвинутые примеры использования __call__

1. LRU-кэш с ограниченным размером

Реализация кэша с вытеснением наименее используемых записей (LRU) на основе OrderedDict.

from collections import OrderedDict

class LRUCache:
    def __init__(self, func, maxsize=128):
        self.func = func
        self.maxsize = maxsize
        self.cache = OrderedDict()
    def __call__(self, *args, **kwargs):
        key = (args, tuple(sorted(kwargs.items())))
        if key in self.cache:
            self.cache.move_to_end(key)
            return self.cache[key]
        result = self.func(*args, **kwargs)
        self.cache[key] = result
        if len(self.cache) > self.maxsize:
            self.cache.popitem(last=False)
        return result

@LRUCache
def power(base, exp):
    return base ** exp

print(power(2, 10))  # 1024 (вычислено)
print(power(2, 10))  # 1024 (из кэша)

1024
1024

Пояснение: при каждом вызове ключ формируется из аргументов. Если ключ уже есть, запись перемещается в конец (недавно использованная). При превышении лимита удаляется наименее используемая запись (первая).

2. Многоуровневый вызов (chaining) для построения запросов

Класс, который при вызове возвращает новый callable объект, накапливающий параметры.

class QueryBuilder:
    def __init__(self, table=''):
        self.table = table
    def __call__(self, table=None):
        if table:
            return QueryBuilder(table)
        return self
    def where(self, condition):
        return QueryBuilder(f'{self.table} WHERE {condition}')
    def order_by(self, field):
        return QueryBuilder(f'{self.table} ORDER BY {field}')
    def __str__(self):
        return f'SELECT * FROM {self.table}' if self.table else ''

query = QueryBuilder()('users').where('age > 18').order_by('name')
print(str(query))  # SELECT * FROM users WHERE age > 18 ORDER BY name

SELECT * FROM users WHERE age > 18 ORDER BY name

Пояснение: первый вызов ('users') создаёт экземпляр с таблицей. Методы возвращают новый экземпляр с обновлённым запросом. Это напоминает fluent-интерфейсы.

3. Прокси для функций с логированием аргументов

Обёртка, которая логирует все вызовы и сохраняет метаданные исходной функции.

import functools

class LogProxy:
    def __init__(self, func):
        functools.update_wrapper(self, func)
        self.func = func
    def __call__(self, *args, **kwargs):
        print(f'Вызов {self.func.__name__} с аргументами {args}, {kwargs}')
        return self.func(*args, **kwargs)

@LogProxy
def greet(name, greeting='Hello'):
    return f'{greeting}, {name}!'

print(greet('Alice'))
print(greet('Bob', greeting='Hi'))

Вызов greet с аргументами ('Alice',), {}
Hello, Alice!
Вызов greet с аргументами ('Bob',), {'greeting': 'Hi'}
Hi, Bob!

Пояснение: functools.update_wrapper копирует имя, документацию и другие атрибуты. Прокси ведёт себя как оригинальная функция, но с дополнительным логированием.

4. Асинхронный вызываемый объект

Метод __call__ может быть корутиной, если класс предназначен для асинхронного контекста.

import asyncio

class AsyncCounter:
    def __init__(self):
        self.count = 0
    async def __call__(self):
        await asyncio.sleep(0.1)
        self.count += 1
        return self.count

async def main():
    counter = AsyncCounter()
    print(await counter())
    print(await counter())

asyncio.run(main())

1
2

Пояснение: объявление async def __call__ делает экземпляр await-совместимым. Такие объекты удобно использовать в асинхронном коде на месте функций.

5. Callable объект с управлением через свойства

Комбинация __call__ и @property для создания объектов с настраиваемым поведением.

class TemperatureConverter:
    def __init__(self, scale='C'):
        self.scale = scale
    def __call__(self, value):
        if self.scale == 'C':
            return (value - 32) * 5/9  # Fahrenheit to Celsius
        else:
            return value * 9/5 + 32    # Celsius to Fahrenheit
    @property
    def to_celsius(self):
        return TemperatureConverter('C')
    @property
    def to_fahrenheit(self):
        return TemperatureConverter('F')

converter = TemperatureConverter('C')
print(converter(100))        # 100°F -> 37.78°C
print(converter.to_fahrenheit(0))  # 0°C -> 32°F

37.77777777777778
32.0

Пояснение: свойства возвращают новый экземпляр с изменённой шкалой. Сам объект вызывается как функция преобразования. Это пример гибридного дизайна.

6. Реализация паттерна «Одиночка» (Singleton) через __call__

Метакласс или декоратор класса, но можно также использовать callable объект, который всегда возвращает один и тот же экземпляр.

class Singleton:
    _instance = None
    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance
    def __init__(self, name):
        self.name = name
    def __call__(self, new_name=None):
        if new_name:
            self.name = new_name
        return self.name

a = Singleton('Alpha')
b = Singleton('Beta')
print(a is b)        # True
print(a())           # Beta (последнее значение)
print(b('Gamma'))    # Gamma
print(a())           # Gamma

True
Beta
Gamma
Gamma

Пояснение: механизм __new__ гарантирует единственный экземпляр. Метод __call__ позволяет изменять атрибуты и возвращать их, словно функция.