Функции как объекты и аннотация 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 должна:
- быть вызываемым объектом;
- принимать одну строку;
- возвращать строку.
Например:
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(), где передача вызываемых объектов играет важную роль.