> **Источник:** https://python-all.ru/2.7/howto/functional.html
>
> «Документация Python на русском» – неофициальный перевод официальной документации Python: версии от 2.6 до 3.16, полнотекстовый поиск, английский оригинал рядом с переводом. Эта Markdown-версия страницы предназначена для работы с LLM: вставьте её в ChatGPT, Claude или Cursor.

---

# Руководство по функциональному программированию

**Автор**

A. M. Kuchling

**Версия**

0.31

В этом документе мы рассмотрим возможности Python, подходящие для реализации программ в функциональном стиле. После введения в концепции функционального программирования мы рассмотрим такие языковые средства, как [итератор](https://python-all.ru/2.7/glossary.html#term-iterator)ы и [генератор](https://python-all.ru/2.7/glossary.html#term-generator)ы, а также соответствующие библиотечные модули, такие как [`itertools`](https://python-all.ru/2.7/library/itertools.html#module-itertools) и [`functools`](https://python-all.ru/2.7/library/functools.html#module-functools).

## Введение

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

Языки программирования поддерживают декомпозицию задач несколькими различными способами:

- Большинство языков программирования являются **процедурными**: программы представляют собой списки инструкций, которые указывают компьютеру, что делать с входными данными программы. C, Pascal и даже оболочки Unix являются процедурными языками.
- В **декларативных** языках пишется спецификация, описывающая решаемую задачу, а реализация языка самостоятельно определяет, как эффективно выполнить вычисления. SQL – это декларативный язык, с которым вы, скорее всего, знакомы; SQL-запрос описывает набор данных, который вы хотите получить, а механизм SQL решает, сканировать таблицы или использовать индексы, какие подзапросы выполнять в первую очередь и т.д.
- **Объектно-ориентированные** программы манипулируют коллекциями объектов. Объекты имеют внутреннее состояние и поддерживают методы, которые запрашивают или изменяют это внутреннее состояние определённым образом. Smalltalk и Java являются объектно-ориентированными языками. C++ и Python – языки, поддерживающие объектно-ориентированное программирование, но не навязывающие использование объектно-ориентированных возможностей.
- **Функциональное** программирование разбивает задачу на набор функций. В идеале функции только принимают входные данные и выдают результаты, не имея внутреннего состояния, влияющего на вывод для заданного входа. К известным функциональным языкам относятся семейство ML (Standard ML, OCaml и другие варианты) и Haskell.

Разработчики некоторых языков программирования выбирают акцент на одном конкретном подходе к программированию. Это часто затрудняет написание программ, использующих другой подход. Другие языки являются мультипарадигмальными и поддерживают несколько различных подходов. Lisp, C++ и Python – мультипарадигмальные; на всех этих языках можно писать программы или библиотеки, которые в значительной степени являются процедурными, объектно-ориентированными или функциональными. В большой программе разные разделы могут быть написаны с использованием разных подходов; например, графический интерфейс может быть объектно-ориентированным, а логика обработки – процедурной или функциональной.

В функциональной программе входные данные проходят через набор функций. Каждая функция обрабатывает свой вход и выдаёт некоторый результат. Функциональный стиль не одобряет функции с побочными эффектами, изменяющими внутреннее состояние или вносящими другие изменения, невидимые в возвращаемом значении функции. Функции, не имеющие побочных эффектов вообще, называются **чисто функциональными**. Избегание побочных эффектов означает отказ от использования структур данных, которые обновляются в процессе выполнения программы; результат каждой функции должен зависеть только от её входных данных.

Некоторые языки очень строги в отношении чистоты и даже не имеют операторов присваивания, таких как `a=3` или `c = a + b`, но избежать всех побочных эффектов сложно. Например, вывод на экран или запись в файл на диске – это побочные эффекты. Например, в Python оператор `print` или `time.sleep(1)` не возвращают полезного значения; они вызываются только ради побочных эффектов: отправки текста на экран или приостановки выполнения на секунду.

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

Функциональное программирование можно считать противоположностью объектно-ориентированного. Объекты – это небольшие капсулы, содержащие некоторое внутреннее состояние вместе с набором вызовов методов, позволяющих изменять это состояние, а программы состоят из выполнения правильного набора изменений состояния. Функциональное программирование стремится максимально избегать изменений состояния и работает с данными, передаваемыми между функциями. В Python вы можете комбинировать эти два подхода, написав функции, которые принимают и возвращают экземпляры, представляющие объекты в вашем приложении (сообщения электронной почты, транзакции и т.д.).

Функциональный дизайн может показаться странным ограничением для работы. Зачем избегать объектов и побочных эффектов? У функционального стиля есть теоретические и практические преимущества:

- Формальная доказуемость.
- Модульность.
- Композируемость.
- Лёгкость отладки и тестирования.

### Формальная доказуемость

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

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

Метод, используемый для доказательства корректности программ, заключается в записи **инвариантов** – свойств входных данных и переменных программы, которые всегда истинны. Для каждой строки кода затем показывается, что если инварианты X и Y истинны **до** выполнения строки, то слегка изменённые инварианты X’ и Y’ истинны **после** выполнения строки. Это продолжается до конца программы, после чего инварианты должны соответствовать желаемым условиям на выход программы.

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

К сожалению, доказательство корректности программ в значительной степени непрактично и не применимо к программному обеспечению на Python. Даже тривиальные программы требуют доказательств длиной в несколько страниц; доказательство корректности для умеренно сложной программы было бы огромным, и мало какие (или вообще никакие) из программ, которые вы используете ежедневно (интерпретатор Python, ваш XML-парсер, веб-браузер), могли бы быть доказаны корректными. Даже если бы вы записали или сгенерировали доказательство, возник бы вопрос его проверки; возможно, в нём есть ошибка, и вы ошибочно полагаете, что доказали корректность программы.

### Модульность

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

### Лёгкость отладки и тестирования

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

Отладка упрощается, потому что функции обычно малы и чётко определены. Когда программа не работает, каждая функция является точкой интерфейса, где можно проверить корректность данных. Можно просмотреть промежуточные входные и выходные данные, чтобы быстро изолировать функцию, ответственную за ошибку.

Тестирование проще, потому что каждая функция является потенциальным объектом для модульного теста. Функции не зависят от состояния системы, которое нужно воспроизводить перед запуском теста; вместо этого нужно только синтезировать правильный вход и затем проверить, что выход соответствует ожиданиям.

### Композируемость

В процессе работы над программой в функциональном стиле вы напишете ряд функций с различными входными и выходными данными. Некоторые из этих функций будут неизбежно специализированы для конкретного приложения, но другие будут полезны в самых разных программах. Например, функция, принимающая путь к каталогу и возвращающая все XML-файлы в нём, или функция, принимающая имя файла и возвращающая его содержимое, могут применяться во многих различных ситуациях.

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

## Итераторы

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

Итератор – это объект, представляющий поток данных; этот объект возвращает данные по одному элементу за раз. Итератор Python должен поддерживать метод `next()`, который не принимает аргументов и всегда возвращает следующий элемент потока. Если в потоке больше нет элементов, `next()` должен возбуждать исключение `StopIteration`. Однако итераторы не обязательно должны быть конечными; вполне допустимо написать итератор, который порождает бесконечный поток данных.

Встроенная функция [`iter()`](https://python-all.ru/2.7/library/functions.html#iter) принимает произвольный объект и пытается вернуть итератор, который будет возвращать содержимое или элементы объекта, возбуждая [`TypeError`](https://python-all.ru/2.7/library/exceptions.html#exceptions.TypeError), если объект не поддерживает итерацию. Некоторые встроенные типы данных Python поддерживают итерацию, наиболее распространёнными из которых являются списки и словари. Объект называется **итерируемым**, если для него можно получить итератор.

Можно поэкспериментировать с интерфейсом итерации вручную:

```python
>>> L = [1,2,3]
>>> it = iter(L)
>>> print it
<...iterator object at ...>
>>> it.next()
1
>>> it.next()
2
>>> it.next()
3
>>> it.next()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
>>>
```

Python ожидает итерируемые объекты в нескольких различных контекстах, наиболее важным из которых является оператор `for`. В операторе `for X in Y` Y должен быть итератором или объектом, для которого `iter()` может создать итератор. Эти два оператора эквивалентны:

```python
for i in iter(obj):
    print i

for i in obj:
    print i
```

Итераторы можно материализовать в списки или кортежи с помощью функций-конструкторов `list()` или [`tuple()`](https://python-all.ru/2.7/library/functions.html#tuple):

```python
>>> L = [1,2,3]
>>> iterator = iter(L)
>>> t = tuple(iterator)
>>> t
(1, 2, 3)
```

Распаковка последовательностей также поддерживает итераторы: если известно, что итератор вернёт N элементов, их можно распаковать в N-кортеж:

```python
>>> L = [1,2,3]
>>> iterator = iter(L)
>>> a,b,c = iterator
>>> a,b,c
(1, 2, 3)
```

Встроенные функции, такие как [`max()`](https://python-all.ru/2.7/library/functions.html#max) и [`min()`](https://python-all.ru/2.7/library/functions.html#min), могут принимать один аргумент-итератор и возвращать наибольший или наименьший элемент. Операторы `"in"` и `"not in"` также поддерживают итераторы: `X in iterator` истинно, если X найден в потоке, возвращаемом итератором. С бесконечным итератором возникнут очевидные проблемы: `max()` и `min()` никогда не завершатся, а если элемент X никогда не появится в потоке, операторы `"in"` и `"not in"` тоже не вернут результат.

Обратите внимание, что итератор можно обходить только вперёд; нет способа получить предыдущий элемент, сбросить итератор или сделать его копию. Объекты-итераторы могут опционально предоставлять эти дополнительные возможности, но протокол итератора определяет только метод `next()`. Поэтому функции могут потребить весь вывод итератора, и если потребуется сделать что-то другое с тем же потоком, придётся создать новый итератор.

### Типы данных, поддерживающие итераторы

Мы уже видели, как списки и кортежи поддерживают итераторы. На самом деле любой тип последовательности Python, например строки, автоматически поддерживает создание итератора.

Вызов [`iter()`](https://python-all.ru/2.7/library/functions.html#iter) для словаря возвращает итератор, который будет перебирать ключи словаря:

```python
>>> m = {'Jan': 1, 'Feb': 2, 'Mar': 3, 'Apr': 4, 'May': 5, 'Jun': 6,
...      'Jul': 7, 'Aug': 8, 'Sep': 9, 'Oct': 10, 'Nov': 11, 'Dec': 12}
>>> for key in m:
...     print key, m[key]
Mar 3
Feb 2
Aug 8
Sep 9
Apr 4
Jun 6
Jul 7
Jan 1
May 5
Nov 11
Dec 12
Oct 10
```

Порядок по существу случаен, так как он основан на хеш-упорядочении объектов в словаре.

Применение `iter()` к словарю всегда выполняет итерацию по ключам, но у словарей есть методы, возвращающие другие итераторы. Если нужно выполнить итерацию по ключам, значениям или парам ключ/значение, можно явно вызвать методы `iterkeys()`, `itervalues()` или `iteritems()`, чтобы получить соответствующий итератор.

Конструктор [`dict()`](https://python-all.ru/2.7/library/stdtypes.html#dict) может принимать итератор, возвращающий конечный поток кортежей `(key, value)`:

```python
>>> L = [('Italy', 'Rome'), ('France', 'Paris'), ('US', 'Washington DC')]
>>> dict(iter(L))
{'Italy': 'Rome', 'US': 'Washington DC', 'France': 'Paris'}
```

Файлы также поддерживают итерацию путём вызова метода `readline()` до тех пор, пока в файле не останется строк. Это означает, что можно читать каждую строку файла следующим образом:

```python
for line in file:
    # сделать что-то для каждой строки
    ...
```

Множества могут принимать своё содержимое из итерируемого объекта и позволяют перебирать элементы множества:

```python
S = set((2, 3, 5, 7, 11, 13))
for i in S:
    print i
```

## Генераторные выражения и списковые включения

Две распространённые операции над выводом итератора: 1) выполнение некоторого действия для каждого элемента, 2) выбор подмножества элементов, удовлетворяющих некоторому условию. Например, имея список строк, можно удалить завершающие пробелы из каждой строки или извлечь все строки, содержащие заданную подстроку.

Списковые включения и генераторные выражения (сокращённо «listcomps» и «genexps») – это краткая запись для таких операций, заимствованная из функционального языка программирования Haskell ([https://www.haskell.org/](https://python-all.ru/2.7/howto/functional.html)). Удалить все пробелы из потока строк можно следующим кодом:

```python
line_list = ['  line 1\n', 'line 2  \n', ...]

# Генераторное выражение – возвращает итератор
stripped_iter = (line.strip() for line in line_list)

# Списочное выражение – возвращает список
stripped_list = [line.strip() for line in line_list]
```

Можно выбрать только определённые элементы, добавив условие `"if"`:

```python
stripped_list = [line.strip() for line in line_list
                 if line != ""]
```

При использовании спискового включения возвращается список Python; `stripped_list` – это список, содержащий результирующие строки, а не итератор. Генераторные выражения возвращают итератор, который вычисляет значения по мере необходимости, не требуя материализации всех значений сразу. Это означает, что списковые включения бесполезны при работе с итераторами, возвращающими бесконечный поток или очень большой объём данных. В таких ситуациях предпочтительнее генераторные выражения.

Генераторные выражения заключаются в круглые скобки («()»), а списковые включения – в квадратные скобки («\[\]»). Генераторные выражения имеют вид:

```python
( expression for expr in sequence1
             if condition1
             for expr2 in sequence2
             if condition2
             for expr3 in sequence3 ...
             if condition3
             for exprN in sequenceN
             if conditionN )
```

Опять же, для спискового включения отличаются только внешние скобки (квадратные вместо круглых).

Элементами генерируемого вывода будут последовательные значения `expression`. Все предложения `if` являются необязательными; если они присутствуют, `expression` вычисляется и добавляется в результат только тогда, когда `condition` истинно.

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

```python
obj_total = sum(obj.count for obj in list_all_objects())
```

Предложения `for...in` содержат последовательности, по которым производится итерация. Последовательности не обязательно должны быть одинаковой длины, поскольку они перебираются слева направо, **не** параллельно. Для каждого элемента в `sequence1`, `sequence2` перебирается с начала. Затем `sequence3` перебирается для каждой результирующей пары элементов из `sequence1` и `sequence2`.

Другими словами, списковое включение или генераторное выражение эквивалентно следующему коду Python:

```python
for expr1 in sequence1:
    if not (condition1):
        continue   # Пропустить этот элемент
    for expr2 in sequence2:
        if not (condition2):
            continue   # Пропустить этот элемент
        ...
        for exprN in sequenceN:
            if not (conditionN):
                continue   # Пропустить этот элемент

            # Вывести значение
            # выражения.
```

Это означает, что при наличии нескольких предложений `for...in`, но отсутствии предложений `if`, длина результирующего вывода будет равна произведению длин всех последовательностей. Если есть два списка длины 3, выходной список будет длиной 9 элементов:

```pycon
>>> seq1 = 'abc'
>>> seq2 = (1,2,3)
>>> [(x,y) for x in seq1 for y in seq2]
[('a', 1), ('a', 2), ('a', 3),
 ('b', 1), ('b', 2), ('b', 3),
 ('c', 1), ('c', 2), ('c', 3)]
```

Чтобы избежать неоднозначности в грамматике Python, если `expression` создаёт кортеж, его необходимо заключить в круглые скобки. Первое списковое включение ниже является синтаксической ошибкой, а второе – правильным:

```python
# Синтаксическая ошибка
[ x,y for x in seq1 for y in seq2]
# Верно
[ (x,y) for x in seq1 for y in seq2]
```

## Генераторы

Генераторы – это особый класс функций, упрощающих написание итераторов. Обычные функции вычисляют значение и возвращают его, а генераторы возвращают итератор, который возвращает поток значений.

Вы, несомненно, знакомы с тем, как работают обычные вызовы функций в Python или C. Когда функция вызывается, она получает приватное пространство имён, в котором создаются её локальные переменные. Когда функция достигает оператора `return`, локальные переменные уничтожаются, а значение возвращается вызывающему. Последующий вызов той же функции создаёт новое приватное пространство имён и новый набор локальных переменных. Но что, если бы локальные переменные не отбрасывались при выходе из функции? Что, если бы можно было позже возобновить функцию с того места, где она остановилась? Именно это и обеспечивают генераторы; их можно рассматривать как возобновляемые функции.

Вот простейший пример функции-генератора:

```python
def generate_ints(N):
    for i in range(N):
        yield i
```

Любая функция, содержащая ключевое слово `yield`, является генераторной функцией; это обнаруживается компилятором [байт-кода](https://python-all.ru/2.7/glossary.html#term-bytecode) Python, который в результате компилирует функцию особым образом.

При вызове генераторной функции она возвращает не одно значение, а объект-генератор, поддерживающий протокол итератора. При выполнении выражения `yield` генератор выводит значение `i`, подобно оператору `return`. Большое различие между `yield` и оператором `return` заключается в том, что при достижении `yield` состояние выполнения генератора приостанавливается, а локальные переменные сохраняются. При следующем вызове метода `.next()` генератора функция возобновит выполнение.

Вот пример использования генератора `generate_ints()`:

```python
>>> gen = generate_ints(3)
>>> gen
<generator object generate_ints at ...>
>>> gen.next()
0
>>> gen.next()
1
>>> gen.next()
2
>>> gen.next()
Traceback (most recent call last):
  File "stdin", line 1, in <module>
  File "stdin", line 2, in generate_ints
StopIteration
```

Можно также написать `for i in generate_ints(5)` или `a,b,c = generate_ints(3)`.

Внутри генераторной функции оператор `return` может использоваться только без значения и сигнализирует об окончании последовательности значений; после выполнения `return` генератор не может вернуть никаких дальнейших значений. `return` со значением, например `return 5`, внутри генераторной функции является синтаксической ошибкой. Окончание результатов генератора также можно обозначить, вручную возбудив `StopIteration`, или просто позволив потоку выполнения дойти до конца функции.

Эффекта генераторов можно добиться вручную, написав собственный класс и сохраняя все локальные переменные генератора как переменные экземпляра. Например, возврат списка целых чисел можно реализовать, установив `self.count` в 0, и заставив метод `next()` увеличивать `self.count` и возвращать его. Однако для сколько-нибудь сложного генератора написание соответствующего класса может быть гораздо более запутанным.

Набор тестов, входящий в библиотеку Python, `test_generators.py`, содержит ряд более интересных примеров. Вот один генератор, который рекурсивно реализует симметричный обход дерева с помощью генераторов.

```python
# Рекурсивный генератор, порождающий листья дерева в порядке in-order.
def inorder(t):
    if t:
        for x in inorder(t.left):
            yield x

        yield t.label

        for x in inorder(t.right):
            yield x
```

Два других примера в `test_generators.py` дают решения задачи о N ферзях (размещение N ферзей на шахматной доске NxN так, чтобы ни один ферзь не угрожал другому) и о ходе коня (поиск маршрута, который проводит коня через каждую клетку доски NxN, не посещая ни одну клетку дважды).

### Передача значений в генератор

В Python 2.4 и ранее генераторы только выдавали результат. Как только код генератора вызывался для создания итератора, не было способа передать новую информацию в функцию при возобновлении её выполнения. Можно было сымитировать эту возможность, заставив генератор обращаться к глобальной переменной или передавая изменяемый объект, который затем изменяли вызывающие стороны, но эти подходы были громоздкими.

В Python 2.5 появился простой способ передачи значений в генератор. [`yield`](https://python-all.ru/2.7/reference/simple_stmts.html#yield) стал выражением, возвращающим значение, которое можно присвоить переменной или иным образом обработать:

```python
val = (yield i)
```

Рекомендуется **всегда** заключать выражение `yield` в скобки, когда вы что-то делаете с возвращаемым значением, как в примере выше. Скобки не всегда обязательны, но проще всегда их добавлять, чем запоминать, когда они нужны.

(PEP 342 объясняет точные правила: выражение `yield` всегда должно быть заключено в скобки, за исключением случая, когда оно находится на верхнем уровне выражения в правой части присваивания. Это означает, что можно написать `val = yield i`, но необходимо использовать скобки при наличии операции, как в `val = (yield i) + 12`.)

Значения отправляются в генератор вызовом его метода `send(value)`. Этот метод возобновляет код генератора, и выражение `yield` возвращает указанное значение. Если вызывается обычный метод `next()`, то `yield` возвращает `None`.

Вот простой счётчик, который увеличивается на 1 и позволяет изменять значение внутреннего счётчика.

```python
def counter (maximum):
    i = 0
    while i < maximum:
        val = (yield i)
        # Если передано значение, изменить counter.
        if val is not None:
            i = val
        else:
            i += 1
```

А вот пример изменения счётчика:

```python
>>> it = counter(10)
>>> print it.next()
0
>>> print it.next()
1
>>> print it.send(8)
8
>>> print it.next()
9
>>> print it.next()
Traceback (most recent call last):
  File "t.py", line 15, in <module>
    print it.next()
StopIteration
```

Поскольку `yield` часто будет возвращать `None`, всегда следует проверять этот случай. Не следует использовать его значение в выражениях без уверенности, что метод `send()` будет единственным методом, используемым для возобновления генераторной функции.

В дополнение к `send()`, у генераторов есть два других новых метода:

- `throw(type, value=None, traceback=None)` используется для возбуждения исключения внутри генератора; исключение возбуждается выражением `yield` в точке, где выполнение генератора приостановлено.
- `close()` возбуждает исключение [`GeneratorExit`](https://python-all.ru/2.7/library/exceptions.html#exceptions.GeneratorExit) внутри генератора для завершения итерации. При получении этого исключения код генератора должен либо возбудить [`GeneratorExit`](https://python-all.ru/2.7/library/exceptions.html#exceptions.GeneratorExit), либо [`StopIteration`](https://python-all.ru/2.7/library/exceptions.html#exceptions.StopIteration); перехватывать исключение и делать что-либо ещё незаконно и вызовет [`RuntimeError`](https://python-all.ru/2.7/library/exceptions.html#exceptions.RuntimeError). `close()` также будет вызван сборщиком мусора Python, когда генератор будет уничтожен сборкой мусора.

  Если нужно выполнить код очистки при возникновении [`GeneratorExit`](https://python-all.ru/2.7/library/exceptions.html#exceptions.GeneratorExit), рекомендуется использовать конструкцию `try: ... finally:` вместо перехвата [`GeneratorExit`](https://python-all.ru/2.7/library/exceptions.html#exceptions.GeneratorExit).

Совокупный эффект этих изменений – превращение генераторов из однонаправленных производителей информации одновременно и в производителей, и в потребителей.

Генераторы также становятся **корутинами** – более обобщённой формой подпрограмм. Подпрограммы имеют одну точку входа и одну точку выхода (начало функции и оператор `return`), тогда как корутины могут иметь много разных точек входа, выхода и возобновления (операторы `yield`).

## Встроенные функции

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

Две встроенные функции Python, [`map()`](https://python-all.ru/2.7/library/functions.html#map) и [`filter()`](https://python-all.ru/2.7/library/functions.html#filter), несколько устарели; они дублируют возможности списковых включений, но возвращают обычные списки вместо итераторов.

`map(f, iterA, iterB, ...)` возвращает список, содержащий `f(iterA[0], iterB[0]), f(iterA[1], iterB[1]), f(iterA[2], iterB[2]), ...`.

```python
>>> def upper(s):
...     return s.upper()
```

```python
>>> map(upper, ['sentence', 'fragment'])
['SENTENCE', 'FRAGMENT']
```

```python
>>> [upper(s) for s in ['sentence', 'fragment']]
['SENTENCE', 'FRAGMENT']
```

Как показано выше, того же эффекта можно достичь с помощью спискового включения. Функция [`itertools.imap()`](https://python-all.ru/2.7/library/itertools.html#itertools.imap) делает то же самое, но может работать с бесконечными итераторами; она будет рассмотрена позднее, в разделе о модуле [`itertools`](https://python-all.ru/2.7/library/itertools.html#module-itertools).

`filter(predicate, iter)` возвращает список, содержащий все элементы последовательности, удовлетворяющие определённому условию, и аналогично дублируется списковыми включениями. **Предикат** – это функция, возвращающая истинностное значение некоторого условия; для использования с [`filter()`](https://python-all.ru/2.7/library/functions.html#filter) предикат должен принимать одно значение.

```python
>>> def is_even(x):
...     return (x % 2) == 0
```

```python
>>> filter(is_even, range(10))
[0, 2, 4, 6, 8]
```

Это также можно записать в виде спискового включения:

```python
>>> [x for x in range(10) if is_even(x)]
[0, 2, 4, 6, 8]
```

У [`filter()`](https://python-all.ru/2.7/library/functions.html#filter) также есть аналог в модуле [`itertools`](https://python-all.ru/2.7/library/itertools.html#module-itertools) – [`itertools.ifilter()`](https://python-all.ru/2.7/library/itertools.html#itertools.ifilter), который возвращает итератор и поэтому может работать с бесконечными последовательностями, как и [`itertools.imap()`](https://python-all.ru/2.7/library/itertools.html#itertools.imap).

У `reduce(func, iter, [initial_value])` нет аналога в модуле [`itertools`](https://python-all.ru/2.7/library/itertools.html#module-itertools), поскольку он кумулятивно выполняет операцию над всеми элементами итерируемого объекта и поэтому не может применяться к бесконечным итераторам. `func` должна быть функцией, принимающей два элемента и возвращающей одно значение. [`reduce()`](https://python-all.ru/2.7/library/functions.html#reduce) берёт первые два элемента A и B, возвращённые итератором, и вычисляет `func(A, B)`. Затем он запрашивает третий элемент C, вычисляет `func(func(A, B), C)`, объединяет этот результат с четвёртым возвращённым элементом и продолжает, пока итерируемый объект не исчерпается. Если итерируемый объект не возвращает никаких значений, возбуждается исключение [`TypeError`](https://python-all.ru/2.7/library/exceptions.html#exceptions.TypeError). Если указано начальное значение, оно используется как отправная точка, и `func(initial_value, A)` становится первым вычислением.

```python
>>> import operator
>>> reduce(operator.concat, ['A', 'BB', 'C'])
'ABBC'
>>> reduce(operator.concat, [])
Traceback (most recent call last):
  ...
TypeError: reduce() of empty sequence with no initial value
>>> reduce(operator.mul, [1,2,3], 1)
6
>>> reduce(operator.mul, [], 1)
1
```

Если использовать [`operator.add()`](https://python-all.ru/2.7/library/operator.html#operator.add) с [`reduce()`](https://python-all.ru/2.7/library/functions.html#reduce), будут просуммированы все элементы итерируемого объекта. Этот случай настолько распространён, что для него существует специальная встроенная функция [`sum()`](https://python-all.ru/2.7/library/functions.html#sum):

```python
>>> reduce(operator.add, [1,2,3,4], 0)
10
>>> sum([1,2,3,4])
10
>>> sum([])
0
```

Однако для многих случаев использования [`reduce()`](https://python-all.ru/2.7/library/functions.html#reduce) может быть понятнее просто написать очевидный цикл [`for`](https://python-all.ru/2.7/reference/compound_stmts.html#for):

```python
# Вместо:
product = reduce(operator.mul, [1,2,3], 1)

# Можно написать:
product = 1
for i in [1,2,3]:
    product *= i
```

`enumerate(iter)` нумерует элементы в итерируемом объекте, возвращая кортежи из двух элементов, содержащие номер и каждый элемент.

```python
>>> for item in enumerate(['subject', 'verb', 'object']):
...     print item
(0, 'subject')
(1, 'verb')
(2, 'object')
```

[`enumerate()`](https://python-all.ru/2.7/library/functions.html#enumerate) часто используется при переборе списка и записи индексов, для которых выполняются определённые условия:

```python
f = open('data.txt', 'r')
for i, line in enumerate(f):
    if line.strip() == '':
        print 'Blank line at line #%i' % i
```

`sorted(iterable, [cmp=None], [key=None], [reverse=False])` собирает все элементы итерируемого объекта в список, сортирует его и возвращает отсортированный результат. Аргументы `cmp`, `key` и `reverse` передаются методу `.sort()` созданного списка.

```python
>>> import random
>>> # Сгенерировать 8 случайных чисел в диапазоне [0, 10000).
>>> rand_list = random.sample(range(10000), 8)
>>> rand_list
[769, 7953, 9828, 6431, 8442, 9878, 6213, 2207]
>>> sorted(rand_list)
[769, 2207, 6213, 6431, 7953, 8442, 9828, 9878]
>>> sorted(rand_list, reverse=True)
[9878, 9828, 8442, 7953, 6431, 6213, 2207, 769]
```

(Более подробное обсуждение сортировки см. в мини-руководстве по сортировке в вики Python по адресу [https://wiki.python.org/moin/HowTo/Sorting](https://python-all.ru/2.7/howto/functional.html).)

Встроенные функции `any(iter)` и `all(iter)` проверяют истинностные значения содержимого итерируемого объекта. [`any()`](https://python-all.ru/2.7/library/functions.html#any) возвращает `True`, если хотя бы один элемент в итерируемом объекте является истинным, а [`all()`](https://python-all.ru/2.7/library/functions.html#all) возвращает `True`, если все элементы являются истинными:

```python
>>> any([0,1,0])
True
>>> any([0,0,0])
False
>>> any([1,1,1])
True
>>> all([0,1,0])
False
>>> all([0,0,0])
False
>>> all([1,1,1])
True
```

## Небольшие функции и лямбда-выражение

При написании программ в функциональном стиле часто требуются небольшие функции, которые выступают в роли предикатов или каким-либо образом комбинируют элементы.

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

```python
stripped_lines = [line.strip() for line in lines]
existing_files = filter(os.path.exists, file_list)
```

Если нужной функции не существует, её необходимо написать. Один из способов написания небольших функций – использование оператора `lambda`. `lambda` принимает ряд параметров и выражение, комбинирующее эти параметры, и создаёт небольшую функцию, возвращающую значение выражения:

```python
lowercase = lambda x: x.lower()

print_assign = lambda name, value: name + '=' + str(value)

adder = lambda x, y: x+y
```

Альтернатива – просто использовать инструкцию `def` и определить функцию обычным способом:

```python
def lowercase(x):
    return x.lower()

def print_assign(name, value):
    return name + '=' + str(value)

def adder(x,y):
    return x + y
```

Какая альтернатива предпочтительнее? Это вопрос стиля; я обычно стараюсь не использовать `lambda`.

Одна из причин моего предпочтения в том, что `lambda` весьма ограничен в определении функций. Результат должен быть вычислим как одно выражение, а это значит, что нельзя использовать множественные сравнения `if... elif... else` или инструкции `try... except`. Если попытаться сделать слишком много в инструкции `lambda`, получится чрезмерно сложное выражение, которое трудно читать. Быстро, что делает следующий код?

```python
total = reduce(lambda a, b: (0, a[1] + b[1]), items)[1]
```

Можно разобраться, но требуется время, чтобы распутать выражение и понять, что происходит. Использование коротких вложенных инструкций `def` немного улучшает ситуацию:

```python
def combine (a, b):
    return 0, a[1] + b[1]

total = reduce(combine, items)[1]
```

Но лучше всего было бы просто использовать цикл `for`:

```python
total = 0
for a, b in items:
    total += b
```

Или встроенную функцию [`sum()`](https://python-all.ru/2.7/library/functions.html#sum) и выражение-генератор:

```python
total = sum(b for a,b in items)
```

Многие применения [`reduce()`](https://python-all.ru/2.7/library/functions.html#reduce) становятся понятнее, если записать их в виде циклов `for`.

Фредрик Лунд однажды предложил следующий набор правил для рефакторинга использования `lambda`:

1. Написать лямбда-функцию.
2. Написать комментарий, объясняющий, что, черт возьми, делает эта лямбда.
3. Некоторое время изучать комментарий и придумать имя, отражающее суть комментария.
4. Преобразовать лямбду в инструкцию def, используя это имя.
5. Удалить комментарий.

Мне очень нравятся эти правила, но вы вольны не соглашаться с тем, что этот стиль без лямбда лучше.

## Модуль itertools

Модуль [`itertools`](https://python-all.ru/2.7/library/itertools.html#module-itertools) содержит ряд часто используемых итераторов, а также функции для комбинирования нескольких итераторов. В данном разделе будут представлены возможности модуля на небольших примерах.

Функции модуля делятся на несколько широких категорий:

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

### Создание новых итераторов

`itertools.count(n)` возвращает бесконечный поток целых чисел, каждый раз увеличивающихся на 1. Можно дополнительно указать начальное число; по умолчанию оно равно 0:

```python
itertools.count() =>
  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ...
itertools.count(10) =>
  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, ...
```

`itertools.cycle(iter)` сохраняет копию содержимого переданного итерируемого объекта и возвращает новый итератор, который возвращает его элементы от первого до последнего. Этот новый итератор будет повторять эти элементы бесконечно.

```python
itertools.cycle([1,2,3,4,5]) =>
  1, 2, 3, 4, 5, 1, 2, 3, 4, 5, ...
```

`itertools.repeat(elem, [n])` возвращает переданный элемент `n` раз или возвращает его бесконечно, если `n` не указан.

```python
itertools.repeat('abc') =>
  abc, abc, abc, abc, abc, abc, abc, abc, abc, abc, ...
itertools.repeat('abc', 5) =>
  abc, abc, abc, abc, abc
```

`itertools.chain(iterA, iterB, ...)` принимает произвольное количество итерируемых объектов на вход и возвращает все элементы первого итератора, затем все элементы второго и так далее, пока все итерируемые объекты не будут исчерпаны.

```python
itertools.chain(['a', 'b', 'c'], (1, 2, 3)) =>
  a, b, c, 1, 2, 3
```

`itertools.izip(iterA, iterB, ...)` берёт по одному элементу из каждого итерируемого объекта и возвращает их в виде кортежа:

```python
itertools.izip(['a', 'b', 'c'], (1, 2, 3)) =>
  ('a', 1), ('b', 2), ('c', 3)
```

Эта функция похожа на встроенную [`zip()`](https://python-all.ru/2.7/library/functions.html#zip), но не создаёт список в памяти и не исчерпывает все входные итераторы перед возвратом; вместо этого кортежи создаются и возвращаются только по запросу. (Технический термин для такого поведения – [ленивые вычисления](https://python-all.ru/2.7/howto/functional.html).)

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

```python
itertools.izip(['a', 'b'], (1, 2, 3)) =>
  ('a', 1), ('b', 2)
```

Тем не менее, так делать не стоит, поскольку из более длинных итераторов может быть взят и отброшен элемент. Это означает, что использовать эти итераторы дальше нельзя – есть риск пропустить отброшенный элемент.

`itertools.islice(iter, [start], stop, [step])` возвращает поток данных, представляющий собой срез итератора. С одним аргументом `stop` она вернёт первые `stop` элементов. Если указать начальный индекс, будут возвращены `stop-start` элементов, а если задать значение для `step`, элементы будут пропускаться соответствующим образом. В отличие от срезов строк и списков Python, для `start`, `stop` и `step` нельзя использовать отрицательные значения.

```python
itertools.islice(range(10), 8) =>
  0, 1, 2, 3, 4, 5, 6, 7
itertools.islice(range(10), 2, 8) =>
  2, 3, 4, 5, 6, 7
itertools.islice(range(10), 2, 8, 2) =>
  2, 4, 6
```

`itertools.tee(iter, [n])` реплицирует итератор; возвращает `n` независимых итераторов, каждый из которых будет возвращать содержимое исходного итератора. Если не указать значение `n`, по умолчанию используется 2. Репликация итераторов требует сохранения части содержимого исходного итератора, поэтому при большом размере итератора, когда один из новых итераторов используется больше других, это может потребовать значительного объёма памяти.

```python
itertools.tee( itertools.count() ) =>
   iterA, iterB

where iterA ->
   0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ...

and   iterB ->
   0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ...
```

### Применение функций к элементам

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

`itertools.imap(f, iterA, iterB, ...)` возвращает поток данных, содержащий `f(iterA[0], iterB[0]), f(iterA[1], iterB[1]), f(iterA[2], iterB[2]), ...`:

```python
itertools.imap(operator.add, [5, 6, 5], [1, 2, 3]) =>
  6, 8, 8
```

Модуль `operator` содержит набор функций, соответствующих операторам Python. Некоторые примеры: `operator.add(a, b)` (складывает два значения), `operator.ne(a, b)` (то же, что `a!=b`) и `operator.attrgetter('id')` (возвращает вызываемый объект, который получает атрибут `"id"`).

`itertools.starmap(func, iter)` предполагает, что итерируемый объект возвращает поток кортежей, и вызывает `f()`, используя эти кортежи как аргументы:

```python
itertools.starmap(os.path.join,
                  [('/usr', 'bin', 'java'), ('/bin', 'python'),
                   ('/usr', 'bin', 'perl'),('/usr', 'bin', 'ruby')])
=>
  /usr/bin/java, /bin/python, /usr/bin/perl, /usr/bin/ruby
```

### Выбор элементов

Ещё одна группа функций выбирает подмножество элементов итератора на основе предиката.

`itertools.ifilter(predicate, iter)` возвращает все элементы, для которых предикат возвращает истину:

```python
def is_even(x):
    return (x % 2) == 0

itertools.ifilter(is_even, itertools.count()) =>
  0, 2, 4, 6, 8, 10, 12, 14, ...
```

`itertools.ifilterfalse(predicate, iter)` – противоположная функция, возвращает все элементы, для которых предикат возвращает ложь:

```python
itertools.ifilterfalse(is_even, itertools.count()) =>
  1, 3, 5, 7, 9, 11, 13, 15, ...
```

`itertools.takewhile(predicate, iter)` возвращает элементы, пока предикат возвращает истину. Как только предикат возвращает ложь, итератор сигнализирует о завершении результатов.

```python
def less_than_10(x):
    return (x < 10)

itertools.takewhile(less_than_10, itertools.count()) =>
  0, 1, 2, 3, 4, 5, 6, 7, 8, 9

itertools.takewhile(is_even, itertools.count()) =>
  0
```

`itertools.dropwhile(predicate, iter)` отбрасывает элементы, пока предикат возвращает истину, а затем возвращает оставшиеся результаты итерируемого объекта.

```python
itertools.dropwhile(less_than_10, itertools.count()) =>
  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, ...

itertools.dropwhile(is_even, itertools.count()) =>
  1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ...
```

### Группировка элементов

Последняя функция, которую я рассмотрю, `itertools.groupby(iter, key_func=None)`, является самой сложной. `key_func(elem)` – это функция, которая может вычислять ключевое значение для каждого элемента, возвращаемого итератором. Если не указать ключевую функцию, ключом является просто сам элемент.

`groupby()` собирает все последовательные элементы из базового итерируемого объекта с одинаковым ключевым значением и возвращает поток кортежей из двух элементов, содержащих ключевое значение и итератор для элементов с этим ключом.

```python
city_list = [('Decatur', 'AL'), ('Huntsville', 'AL'), ('Selma', 'AL'),
             ('Anchorage', 'AK'), ('Nome', 'AK'),
             ('Flagstaff', 'AZ'), ('Phoenix', 'AZ'), ('Tucson', 'AZ'),
             ...
            ]

def get_state ((city, state)):
    return state

itertools.groupby(city_list, get_state) =>
  ('AL', iterator-1),
  ('AK', iterator-2),
  ('AZ', iterator-3), ...

where
iterator-1 =>
  ('Decatur', 'AL'), ('Huntsville', 'AL'), ('Selma', 'AL')
iterator-2 =>
  ('Anchorage', 'AK'), ('Nome', 'AK')
iterator-3 =>
  ('Flagstaff', 'AZ'), ('Phoenix', 'AZ'), ('Tucson', 'AZ')
```

`groupby()` предполагает, что содержимое базового итерируемого объекта уже отсортировано по ключу. Обратите внимание, что возвращаемые итераторы также используют базовый итерируемый объект, поэтому необходимо потребить результаты итератора-1 перед запросом итератора-2 и соответствующего ему ключа.

## Модуль functools

Модуль [`functools`](https://python-all.ru/2.7/library/functools.html#module-functools) в Python 2.5 содержит несколько функций высшего порядка. **Функция высшего порядка** принимает одну или несколько функций на вход и возвращает новую функцию. Самым полезным инструментом в этом модуле является функция [`functools.partial()`](https://python-all.ru/2.7/library/functools.html#functools.partial).

Для программ в функциональном стиле иногда требуется создавать варианты существующих функций с частично заполненными параметрами. Рассмотрим функцию Python `f(a, b, c)`; возможно, вы захотите создать новую функцию `g(b, c)`, эквивалентную `f(1, b, c)`; вы заполняете значение для одного из параметров `f()`. Это называется «частичным применением функции».

Конструктор `partial` принимает аргументы `(function, arg1, arg2, ... kwarg1=value1, kwarg2=value2)`. Полученный объект является вызываемым, поэтому его можно просто вызвать, чтобы выполнить `function` с заданными аргументами.

Вот небольшой, но реалистичный пример:

```python
import functools

def log (message, subsystem):
    "Write the contents of 'message' to the specified subsystem."
    print '%s: %s' % (subsystem, message)
    ...

server_log = functools.partial(log, subsystem='server')
server_log('Unable to open socket')
```

### Модуль operator

Модуль [`operator`](https://python-all.ru/2.7/library/operator.html#module-operator) упоминался ранее. Он содержит набор функций, соответствующих операторам Python. Эти функции часто полезны в функциональном коде, поскольку избавляют от написания тривиальных функций, выполняющих одну операцию.

Некоторые функции этого модуля:

- Математические операции: `add()`, `sub()`, `mul()`, `div()`, `floordiv()`, `abs()`, …
- Логические операции: `not_()`, `truth()`.
- Побитовые операции: `and_()`, `or_()`, `invert()`.
- Сравнения: `eq()`, `ne()`, `lt()`, `le()`, `gt()` и `ge()`.
- Идентичность объектов: `is_()`, `is_not()`.

Полный список – в документации модуля operator.

## История изменений и благодарности

Автор хотел бы поблагодарить следующих людей за предложения, исправления и помощь с различными черновиками этой статьи: Ian Bicking, Nick Coghlan, Nick Efford, Raymond Hettinger, Jim Jewett, Mike Krell, Leandro Lameiro, Jussi Salmela, Collin Winter, Blake Winton.

Версия 0.1: опубликована 30 июня 2006 г.

Версия 0.11: опубликована 1 июля 2006 г. Исправлены опечатки.

Версия 0.2: опубликована 10 июля 2006 г. Разделы о выражениях-генераторах и списковых включениях объединены в один. Исправлены опечатки.

Версия 0.21: добавлены дополнительные ссылки, предложенные в списке рассылки tutor.

Версия 0.30: добавлен раздел о модуле `functional`, написанный Коллином Уинтером; добавлен короткий раздел о модуле operator; несколько других правок.

## Ссылки

### Общие

**Структура и интерпретация компьютерных программ**, автор Harold Abelson и Gerald Jay Sussman при участии Julie Sussman. Полный текст доступен по адресу [https://mitpress.mit.edu/sicp/](https://python-all.ru/2.7/howto/functional.html). В этом классическом учебнике по информатике, главы 2 и 3 рассматривают использование последовательностей и потоков для организации потока данных внутри программы. Книга использует Scheme для своих примеров, но многие из подходов к проектированию, описанных в этих главах, применимы к функциональному стилю кода Python.

[http://www.defmacro.org/ramblings/fp.html](https://python-all.ru/2.7/howto/functional.html): Общее введение в функциональное программирование на примерах Java, содержащее обширное историческое введение.

[https://en.wikipedia.org/wiki/Functional\_programming](https://python-all.ru/2.7/howto/functional.html): общая статья в Википедии, описывающая функциональное программирование.

[https://en.wikipedia.org/wiki/Coroutine](https://python-all.ru/2.7/howto/functional.html): статья о корутинах.

[https://en.wikipedia.org/wiki/Currying](https://python-all.ru/2.7/howto/functional.html): статья о концепции каррирования.

### Специфическое для Python

[http://gnosis.cx/TPiP/](https://python-all.ru/2.7/howto/functional.html): Первая глава книги Дэвида Мертца *Text Processing in Python* рассматривает функциональное программирование для обработки текста в разделе «Использование функций высшего порядка в обработке текста».

Мерц также написал серию статей из трёх частей по функциональному программированию для сайта IBM DeveloperWorks; см.

[часть 1](https://python-all.ru/2.7/howto/functional.html), [часть 2](https://python-all.ru/2.7/howto/functional.html) и [часть 3](https://python-all.ru/2.7/howto/functional.html),

### Документация Python

Документация по модулю [`itertools`](https://python-all.ru/2.7/library/itertools.html#module-itertools).

Документация по модулю [`operator`](https://python-all.ru/2.7/library/operator.html#module-operator).

[**PEP 289**](https://python-all.ru/2.7/howto/functional.html): “Генераторные выражения”

[**PEP 342**](https://python-all.ru/2.7/howto/functional.html): “Корутины через улучшенные генераторы” описывает новые возможности генераторов в Python 2.5.