х = echo # Теперь x тоже ссылается на объект функции
х('Indirect call!') # Вызов объекта через имя х путем добавления ()

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

def indirect(func, arg) :
    func(arg) # Вызов переданного объекта путем добавления ()

indirect (echo, 'Argument call!') # Передача функции другой функции

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

>>> schedule = [(echo, 'Spam!'), (echo, 'Ham?')]
>>> for (func, arg) in schedule:
>>>     func(arg) # Вызов функций, встроенных в контейнер
... Spam!
... Ham!

В коде просто производится проход по списку schedule и вызов функции echo с одним аргументом на каждой итерации (обратите внимание в заголовке цикла for на распаковывающее присваивание кортежа, представленное в главе 13). Функции также можно создавать и возвращать для применения где-то в другом месте — замыкания, созданные в таком режиме, еще и предохраняют состояние из объемлющей области видимости.

Код возвращает 6 из-за того, что функция func складывает три аргумента: a, b и c. Давайте разберем, что происходит в коде более подробно.

1. Функция func:

   def func(a: 'spam', b: (1, 10), c: float) -> int:
   

- a: 'spam': Это аннотация для параметра a. Текст 'spam' здесь не имеет особого значения в самом коде, скорее всего, это просто строка, которая может использоваться для документации или информации о том, какой тип ожидался. В действительности, это просто строка, и Python не проводит никаких проверок типов на основе этой аннотации.
- b: (1, 10): Это также аннотация, которая указывает, что b должен быть значением, соответствующим кортежу (1, 10). Однако, как и в случае с аннотацией для a, эта информация не проверяется в самом коде.
- c: float: Это аннотация, указывающая, что параметр c должен быть типа float.
- -> int: Это аннотация, которая указывает, что функция будет возвращать значение типа int.

2. Сложение аргументов:
Когда вы вызываете func(1,2,3), переданная строка 1, 2 и 3 становятся значениями a, b и c соответственно. То есть:
- a = 1
- b = 2
- c = 3

>>> func.__annotations__
... {'с': class 'float’>, ’b’: (1, 10), 'a': 'spam', 'return': <class ’int’>}

Вы можете использовать стандартные значения для аргументов в случае снабжения их аннотациями — аннотация (и ее символ :) появляется перед стандартным значением (и символом =). В показанном ниже коде а: 'spam' = 4 означает, что аргумент а имеет стандартное значение 4 и аннотирован строкой 'spam':

>>> def func(a: 'spam' = 4, b: (1, 10) = 5, c: float = 6) -> int:
>>>     return a + b + c
>>> func (1, 2, 3) 
... 6
>>> func() # 4 + 5 + 6 (все стандартные значения)
... 15
>>> func(1, с=10) # 1+5 + 10 (ключевые аргументы нормально работают)
... 16
>>> func.__annotations__
{'с': <class 'float;>, 'b': (1, 10), 'a': 'spam', 'return': class 'int'>}

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

lambda аргумент!, аргумент2, . . . аргументы : выражение , использующее аргументы

Как и в случае def, для аргументов lambda можно указывать стандартные значения:

x = (lambda a="fee", b="fie", c="foe": a + b + c)
print(x("wee")) # weefiefoe

Вы можете использовать словари и другие структуры данных в Python для построения более универсальных разновидностей таблиц действий. Вот пример:

key = 'got'
{'already': (lambda: 2 + 2), 'got': (lambda: 2 * 4), 'one': (lambda: 2 ** 6)}[key]()

Когда Python создает временный словарь, каждое вложенное выражение lambda генерирует и оставляет после себя функцию, подлежащую вызову в будущем. Индексация по ключу извлекает одну из функций, а круглые скобки приводят к вызову извлеченной функции. При такой реализации словарь становится более универсальным инструментом для множественного ветвления, нежели оператор if.

— Функция pow(x, y) возвращает x, возведённое в степень y.

— map(function, iterable1, iterable2) применяет заданную функцию (в данном случае pow()) к элементам двух (или более) итерируемых объектов (в данном случае списков [1, 2, 3] и [2, 3, 4]).

map(pow, [1, 2, 3], [2, 3, 4]) выполнит следующее:

1. pow(1, 2) возвращает 1^2 = 1
2. pow(2, 3) возвращает 2^3 = 8
3. pow(3, 4) возвращает 3^4 = 81.

Затем, когда мы оборачиваем это в list(), то получаем полный список:

>>> list(map(pow, [1, 2, 3], [2, 3, 4])) # 1 ** 2, 2 ** 3, 3 ** 4
... [1, 8, 81]