Функция foo() ищет пересечение произвольного числа последовательностей (одной и более), используя форму сопоставления с переменным количеством аргументов *аргументы для сбора всех переданных аргументов. Поскольку аргументы поступают в виде кортежа, мы можем обрабатывать произвольное число аргументов с целью сбора элементов, имеющихся во всех операндах:

def foo(*args):
    res = []
    for x in args[0]: # Просмотр последовательности
        if x in res: continue # Пропуск дубликатов
        for other in args[1:]: # Для всех остальных аргументов
            if x not in other: break # Элемент находится во всех последовательностях?
    else: # Нет: выйти из цикла
        res.append(x) # Да: добавить в конец
    return res
    
lst = (1, 3, 4, 3, 5)
print(foo(lst)) # [5]

В данном случае все сводится к блоку else (выходу из цикла) и добавлению последнего элемента в res.

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

lst = ((1, 3, 4), (3, 4, 5))
print(foo(lst)) # [(3, 4, 5)]

Код выводит 1 (2, 3), поскольку 1 передается а и *pargs собирает оставшиеся позиционные аргументы в новый объект кортежа. Мы можем проходить по кортежу с добавочными позиционными аргументами посредством любого итерационного инструмента (например, for arg in pargs: . . .).

Код выводит 1 { ’ Ь ’ : 2, ’ с ’ : 3}, т.к. 1 передается а по имени и **kargs собирает оставшиеся ключевые аргументы в словарь. Мы можем проходить по ключам словаря с добавочными ключевыми аргументами с помощью любого итерационного инструмента (скажем, for key in kargs: . . .). Обратите внимание, что порядок следования ключей в словаре может варьироваться в зависимости от версии Python и других аспектов.

Код выводит (1, [ ’ х ’ ], { ’ а ’ : ’ у ’ }) — первое присваивание в функции не оказывает влияния на вызывающий код, но остальные два оказывают, поскольку они модифицируют переданный изменяемый объект на месте.

Концепции проектирования функций

Приступив к серьезному использованию функций, вы столкнетесь с необходимостью выбора того, как увязывать компоненты вместе — скажем, каким образом разложить задачу на содержательные функции (известно как сцепление), как функции должны взаимодействовать (называется связностью) и т.д. Вам также придется учитывать такие понятия, как размер функции, поскольку они напрямую влияют на удобство работы с кодом. Некоторые концепции относятся к категории структурного анализа и проектирования, но они применимы к коду на Python как и на любом другом языке.

Ниже приведен обзор нескольких универсальных рекомендаций для читателей, не знакомых с принципами проектирования функций.
• Связность: используйте аргументы для входных данных и оператор return для выходных данных. Как правило, вы должны стремиться сделать функцию независимой от вещей, находящихся за ее пределами. Аргументы и оператор return часто будут наилучшими способами изоляции внешних зависимостей небольшим количеством хорошо известных мест в коде.
• Связность: применяйте глобальные переменные, только когда они по-настоящему нужны. Глобальные переменные (т.е. имена во включающем модуле) обычно являются неудачным способом взаимодействия для функций. Они могут создать
зависимости и проблемы синхронизации, которые затрудняют отладку, изменение и многократное использование программ.
• Связность: не модифицируйте изменяемые аргументы, если только такое изменение не ожидается вызывающим кодом. Функции могут модифицировать части передаваемых изменяемых объектов, но это (как и глобальные переменные)
создает сильную связность между вызывающим и вызываемым кодом, которая может сделать функцию слишком специфичной и хрупкой.
• Сцепление: каждая функция должна иметь единственное унифицированное назначение. При надлежащем проектировании каждая функция должна делать что-то одно — то, что может быть резюмировано в простом повествовательном предложении. Если такое предложение оказывается слишком широким (например, “данная функция реализует всю мою программу”) или содержит много союзов (скажем, “данная функция дает сотруднику повышение и отправляет заказ пиццы”), тогда имеет смысл подумать о разбиении функции на несколько отдельных более простых функций. В противном случае не удастся повторно применять код, который лежит в основе действий, смешанных в функции.
• Размер: каждая функция должна быть относительно небольшой. Цель естественным образом следует из предыдущей цели, но если ваши функции начали занимать несколько страниц на экране редактора, то видимо пришло время их разбить. Прежде всего, учитывая присущую коду Python лаконичность, длинная или глубоко вложенная функция зачастую служит признаком проблем с проектным решением. Сохраняйте функции простыми и короткими.
• Связность: избегайте прямого изменения переменных из другого файла модуля. Тем не менее, для справки помните о том, что изменение переменных через границы файлов приводит к появлению связности между модулями подобно тому, как глобальные переменные связывают функции — модули становятся труднее понимать и многократно использовать. При любой возможности применяйте функции доступа вместо прямых операторов присваивания.

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