Функции как объекты и аннотация Callable в Python

Обновлено:

Мы уже знаем, что в Python функции являются обычными объектами.

Это означает, что функцию можно:

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

В этой теме разберём, как передавать функции в качестве аргументов и как правильно аннотировать такие параметры с помощью Callable.


1. Функция — это объект

Создадим функцию:

def greet(name: str) -> str:
    return f'Hello, {name}'

Мы уже умеем её вызывать:

print(greet('Alex'))
# Hello, Alex

Но важно различать две конструкции:

greet

Это ссылка на объект функции.

А:

greet('Alex')

Это вызов функции, после которого мы получаем результат её работы.


2. Функцию можно сохранить в другую переменную

Например:

def greet(name: str) -> str:
    return f'Hello, {name}'


say_hello = greet

print(say_hello('Emma'))
# Hello, Emma

Здесь:

say_hello = greet

не вызывает функцию.

Мы просто создали ещё одну ссылку на тот же объект.

Проверим:

print(say_hello is greet)
# True

Обе переменные ссылаются на одну и ту же функцию.

Поэтому вызвать её можно через любое из этих имён:

greet('Alex')

say_hello('Alex')

В обоих случаях выполняется одна и та же функция.


Передача функции в другую функцию

3. Функция как аргумент

Раз функция является объектом, мы можем передать её в другую функцию.

Например:

from typing import Any


def make_upper(text: str) -> str:
    return text.upper()


def process_text(
    text: str,
    operation: Any,
) -> str:
    return operation(text)

Вызовем:

result = process_text(
    'hello world',
    make_upper,
)

print(result)
# HELLO WORLD

Обратите внимание:

make_upper

передаётся без круглых скобок.

Почему?

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

Как работает алгоритм

Сначала вызываем:

process_text('hello world', make_upper)

Внутри функции:

text      → 'hello world'

operation → функция make_upper

Затем выполняется:

operation(text)

Но operation ссылается на make_upper.

Поэтому по смыслу это то же самое, что:

make_upper('hello world')

В результате получаем:

HELLO WORLD

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

В первом примере мы использовали уже знакомую аннотацию Any, не уточняя, что operation обязательно должна быть вызываемым объектом.

Теперь познакомимся с более подходящей аннотацией.


Аннотация Callable

4. Модуль collections.abc

Для аннотирования вызываемых объектов существует:

Callable

В современном Python импортируем его так:

from collections.abc import Callable

Эта аннотация используется, когда мы ожидаем получить вызываемый объект.

Например:

from collections.abc import Callable


def process_text(
    text: str,
    operation: Callable,
) -> str:
    return operation(text)

Теперь мы явно показали, что параметр:

operation

должен быть вызываемым объектом.

Однако аннотация:

Callable

пока не описывает, какие аргументы он принимает и что возвращает.

Для этого существует более точная запись.


5. Полная аннотация Callable

Общий вид:

Callable[[argument_types], return_type]

Например:

Callable[[str], str]

Это означает:

Вызываемый объект, который принимает один аргумент типа str и возвращает str.

Перепишем функцию:

from collections.abc import Callable


def process_text(
    text: str,
    operation: Callable[[str], str],
) -> str:
    return operation(text)

Теперь статический анализатор понимает, что operation должна:

  1. быть вызываемым объектом;
  2. принимать одну строку;
  3. возвращать строку.

Например:

def make_title(text: str) -> str:
    return text.title()


print(
    process_text(
        'hello world',
        make_title,
    )
)
# Hello World

Если попытаться передать функцию с неподходящими типами параметров или результата, mypy сможет обнаружить несоответствие.


6. Функция с двумя параметрами

Callable может описывать функции, принимающие несколько аргументов.

Например:

Callable[[int, int], int]

Это вызываемый объект, который:

  • принимает два int;
  • возвращает int.

Создадим пример:

from collections.abc import Callable


def add(first: int, second: int) -> int:
    return first + second


def multiply(first: int, second: int) -> int:
    return first * second


def calculate(
    first: int,
    second: int,
    operation: Callable[[int, int], int],
) -> int:
    return operation(first, second)

Используем:

print(calculate(10, 20, add))
# 30

print(calculate(10, 20, multiply))
# 200

Здесь функция:

calculate()

не знает заранее, какую именно математическую операцию нужно выполнить.

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

Это позволяет использовать одну общую конструкцию для разных операций.


7. Функция без параметров

Если передаваемая функция не принимает аргументов, используем пустые квадратные скобки внутри Callable:

Callable[[], str]

Например:

from collections.abc import Callable


def get_message() -> str:
    return 'Hello Python'


def execute(
    operation: Callable[[], str],
) -> str:
    return operation()

Вызов:

print(execute(get_message))
# Hello Python

Здесь operation не принимает аргументов, поэтому внутри используется:

operation()

8. Возвращаемый результат

В аннотации:

Callable[[int, int], int]

последний int описывает результат вызываемого объекта.

Функция всегда возвращает один объект, если результат возвращается явно. При отсутствии явного возвращаемого значения результатом становится None.

При этом одним объектом может быть и целый кортеж.

Например:

Callable[[int], tuple[int, int]]

Это функция, которая принимает один int и возвращает кортеж из двух целых чисел.


Методы тоже можно передавать

9. Методы являются вызываемыми объектами

Мы уже знакомы со строковыми методами:

upper()
lower()
title()

Обычно мы вызываем их так:

text = 'hello world'

print(text.upper())
# HELLO WORLD

Но многие методы встроенных классов можно вызывать и через сам класс.

Например:

text = 'hello world'

print(str.upper(text))
# HELLO WORLD

В данном случае:

text.upper()

и:

str.upper(text)

выполняют одинаковую операцию.

В первом случае метод уже связан с конкретной строкой.

Во втором случае мы получаем метод через класс str и передаём строку первым аргументом.


10. Передаём строковый метод в функцию

Рассмотрим:

from collections.abc import Callable


def process_text(
    text: str,
    operation: Callable[[str], str],
) -> str:
    return operation(text)

Теперь можем передать:

str.upper

Например:

print(
    process_text(
        'hello world',
        str.upper,
    )
)
# HELLO WORLD

Или другой метод:

print(
    process_text(
        'hello world',
        str.title,
    )
)
# Hello World

Или:

print(
    process_text(
        'HELLO WORLD',
        str.lower,
    )
)
# hello world

Обратите внимание: мы передаём методы без вызова:

str.upper
str.title
str.lower

И только внутри process_text() происходит настоящий вызов:

operation(text)

Не все методы всех классов имеют одинаковые правила вызова, но для приведённых строковых методов такой способ отлично подходит.


11. Связанный метод

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

Например:

text = 'hello world'

operation = text.upper

Теперь метод не требует отдельного аргумента text:

print(operation())
# HELLO WORLD

Поэтому соответствующая аннотация:

Callable[[], str]

А при передаче:

str.upper

аннотация будет:

Callable[[str], str]

поскольку строку нужно передать при вызове.

Это важное различие между методом, полученным от класса, и методом, связанным с конкретным экземпляром.


12. Callable и встроенная функция callable()

Мы уже знакомы со встроенной функцией:

callable()

Она проверяет, является ли объект вызываемым.

Например:

print(callable(str.upper))
# True

print(callable(len))
# True

print(callable(100))
# False

Но не следует путать:

callable()

и:

Callable
callable() Callable
Встроенная функция Аннотация
Не требует импорта Импортируется из collections.abc
Проверяет объект во время выполнения Описывает ожидаемый вызываемый объект
Возвращает bool Используется в аннотациях типов

Главное по теме

Функции в Python являются объектами.

Поэтому их можно сохранять в переменные:

another_name = original_function

И передавать другим функциям без вызова:

process_text('Python', str.upper)

При этом:

function

означает получение самого объекта функции.

А:

function()

означает её вызов.


Для аннотирования вызываемых объектов используем:

from collections.abc import Callable

Примеры:

Аннотация Значение
Callable Вызываемый объект без уточнения сигнатуры
Callable[[], str] Не принимает аргументов, возвращает str
Callable[[int], int] Принимает int, возвращает int
Callable[[str], str] Принимает str, возвращает str
Callable[[int, int], int] Принимает два int, возвращает int
Callable[[int], tuple[int, int]] Принимает int, возвращает кортеж

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

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

В следующих темах мы познакомимся со встроенными функциями map() и filter(), где передача вызываемых объектов играет важную роль.