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

Введение¶Introduction

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

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

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

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

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

Итераторы¶Iterators

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

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

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

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

>>> L = [1,2,3]
>>> it = iter(L)
>>> it  #doctest: +ELLIPSIS
<...iterator object at ...>
>>> it.__next__()  # то же, что и next(it)
1
>>> next(it)
2
>>> next(it)
3
>>> next(it)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
>>>

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

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

for i in obj:
    print(i)

Итераторы можно материализовать в списки или кортежи с помощью функций-конструкторов list() или tuple():

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

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

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

Встроенные функции, такие как max() и min(), могут принимать один аргумент-итератор и возвращать наибольший или наименьший элемент. Операторы "in" и "not in" также поддерживают итераторы: X in iterator истинно, если X найден в потоке, возвращаемом итератором. С бесконечным итератором возникнут очевидные проблемы: max() и min() никогда не завершатся, а если элемент X никогда не появится в потоке, операторы "in" и "not in" тоже не вернут результат.

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

>>> 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

>>> L = [('Italy', 'Rome'), ('France', 'Paris'), ('US', 'Washington DC')]
>>> dict(iter(L))  #doctest: +SKIP
{'Italy': 'Rome', 'US': 'Washington DC', 'France': 'Paris'}

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

S = {2, 3, 5, 7, 11, 13}
for i in S:
    print(i)

Генераторные выражения и списковые включения¶Generator expressions and list comprehensions

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

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

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":

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

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

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

( 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 истинно.

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

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

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

Другими словами, списковое включение или генераторное выражение эквивалентно следующему коду 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 элементов:

>>> seq1 = 'abc'
>>> seq2 = (1,2,3)
>>> [(x, y) for x in seq1 for y in seq2]  #doctest: +NORMALIZE_WHITESPACE
[('a', 1), ('a', 2), ('a', 3),
 ('b', 1), ('b', 2), ('b', 3),
 ('c', 1), ('c', 2), ('c', 3)]

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

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

Генераторы¶Generators

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

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

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

>>> def generate_ints(N):
...    for i in range(N):
...        yield i

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

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

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

>>> gen = generate_ints(3)
>>> gen  #doctest: +ELLIPSIS
<generator object generate_ints at ...>
>>> next(gen)
0
>>> next(gen)
1
>>> next(gen)
2
>>> next(gen)
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 value вызывает возбуждение StopIteration(value) из метода __next__(). Как только это происходит или достигается конец функции, поток значений завершается, и генератор больше не может выдавать значения.

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

Тестовый набор, входящий в библиотеку Python, Lib/test/test_generators.py, содержит ряд более интересных примеров. Вот один генератор, который реализует обход дерева в порядке (in-order) с использованием генераторов рекурсивно.

# Рекурсивный генератор, порождающий листья дерева в порядке 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, не посещая ни одну клетку дважды).

val = (yield i)

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

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

Встроенные функции¶Built-in functions

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

Две встроенные функции Python, map() и filter(), дублируют возможности генераторных выражений:

map(f, iterA, iterB, ...) возвращает итератор по последовательности

f(iterA[0], iterB[0]), f(iterA[1], iterB[1]), f(iterA[2], iterB[2]), ....

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

>>> list(map(upper, ['sentence', 'fragment']))
['SENTENCE', 'FRAGMENT']
>>> [upper(s) for s in ['sentence', 'fragment']]
['SENTENCE', 'FRAGMENT']

Конечно, того же эффекта можно достичь с помощью спискового включения.

filter(predicate, iter) возвращает итератор по всем элементам последовательности, удовлетворяющим определённому условию, и также дублируется списковыми включениями. Предикат – это функция, возвращающая истинностное значение некоторого условия; для использования с filter() предикат должен принимать одно значение.

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

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

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

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

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

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

enumerate() часто используется при переборе списка и записи индексов, для которых выполняются определённые условия:

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

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

>>> 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]

(Для более подробного обсуждения сортировки см. Руководство по сортировке.)

Встроенные функции any(iter) и all(iter) проверяют истинность элементов итерируемого объекта. any() возвращает True, если хотя бы один элемент является истинным, а all() возвращает True, если все элементы истинны:

>>> 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

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

zip(['a', 'b', 'c'], (1, 2, 3)) =>
  ('a', 1), ('b', 2), ('c', 3)

Он не создаёт список в памяти и не исчерпывает все входные итераторы до возврата; вместо этого кортежи создаются и возвращаются только по запросу. (Технический термин для такого поведения – ленивые вычисления.)

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

zip(['a', 'b'], (1, 2, 3)) =>
  ('a', 1), ('b', 2)

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

Модуль itertools¶The itertools module

Модуль itertools содержит ряд часто используемых итераторов, а также функции для комбинирования нескольких итераторов. В данном разделе будут представлены возможности модуля на небольших примерах.

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

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

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.count(10, 5) =>
  10, 15, 20, 25, 30, 35, 40, 45, 50, 55, ...

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

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

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

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( 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.starmap(os.path.join,
                  [('/bin', 'python'), ('/usr', 'bin', 'java'),
                   ('/usr', 'bin', 'perl'), ('/usr', 'bin', 'ruby')])
=>
  /bin/python, /usr/bin/java, /usr/bin/perl, /usr/bin/ruby

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

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(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.compress([1,2,3,4,5], [True, True, False, False, True]) =>
   1, 2, 5

itertools.combinations([1, 2, 3, 4, 5], 2) =>
  (1, 2), (1, 3), (1, 4), (1, 5),
  (2, 3), (2, 4), (2, 5),
  (3, 4), (3, 5),
  (4, 5)

itertools.combinations([1, 2, 3, 4, 5], 3) =>
  (1, 2, 3), (1, 2, 4), (1, 2, 5), (1, 3, 4), (1, 3, 5), (1, 4, 5),
  (2, 3, 4), (2, 3, 5), (2, 4, 5),
  (3, 4, 5)

itertools.permutations([1, 2, 3, 4, 5], 2) =>
  (1, 2), (1, 3), (1, 4), (1, 5),
  (2, 1), (2, 3), (2, 4), (2, 5),
  (3, 1), (3, 2), (3, 4), (3, 5),
  (4, 1), (4, 2), (4, 3), (4, 5),
  (5, 1), (5, 2), (5, 3), (5, 4)

itertools.permutations([1, 2, 3, 4, 5]) =>
  (1, 2, 3, 4, 5), (1, 2, 3, 5, 4), (1, 2, 4, 3, 5),
  ...
  (5, 4, 3, 2, 1)

itertools.permutations('aba', 3) =>
  ('a', 'b', 'a'), ('a', 'a', 'b'), ('b', 'a', 'a'),
  ('b', 'a', 'a'), ('a', 'a', 'b'), ('a', 'b', 'a')

itertools.combinations_with_replacement([1, 2, 3, 4, 5], 2) =>
  (1, 1), (1, 2), (1, 3), (1, 4), (1, 5),
  (2, 2), (2, 3), (2, 4), (2, 5),
  (3, 3), (3, 4), (3, 5),
  (4, 4), (4, 5),
  (5, 5)

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

def get_state(city_state):
    return city_state[1]

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')

Модуль functools¶The functools module

Модуль functools в Python 2.5 содержит несколько функций высшего порядка. Функция высшего порядка принимает одну или несколько функций на вход и возвращает новую функцию. Самым полезным инструментом в этом модуле является функция functools.partial().

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

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

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

import functools

def log(message, subsystem):
    """Записать содержимое 'message' в указанную подсистему."""
    print('%s: %s' % (subsystem, message))
    ...

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

functools.reduce(func, iter, [initial_value]) кумулятивно выполняет операцию над всеми элементами итерируемого объекта и, следовательно, не может применяться к бесконечным итерируемым объектам. func должна быть функцией, принимающей два элемента и возвращающей одно значение. functools.reduce() берёт первые два элемента A и B, возвращённые итератором, и вычисляет func(A, B). Затем запрашивает третий элемент C, вычисляет func(func(A, B), C), объединяет этот результат с четвёртым элементом и продолжает до исчерпания итерируемого объекта. Если итерируемый объект не возвращает ни одного значения, возбуждается исключение TypeError. Если указано начальное значение, оно используется как отправная точка и func(initial_value, A) становится первым вычислением.

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

Если использовать operator.add() с functools.reduce(), будут просуммированы все элементы итерируемого объекта. Этот случай настолько распространён, что для него существует специальная встроенная функция sum():

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

Однако для многих применений functools.reduce() может быть понятнее просто написать очевидный цикл for:

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

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

Родственная функция – itertools.accumulate(iterable, func=operator.add). Она выполняет то же вычисление, но вместо того, чтобы возвращать только конечный результат, accumulate() возвращает итератор, который также выдаёт каждый частичный результат:

itertools.accumulate([1,2,3,4,5]) =>
  1, 3, 6, 10, 15

itertools.accumulate([1,2,3,4,5], operator.mul) =>
  1, 2, 6, 24, 120

Небольшие функции и лямбда-выражение¶Small functions and the lambda expression

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

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

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

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

adder = lambda x, y: x+y

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

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

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

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

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

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

import functools
total = functools.reduce(lambda a, b: (0, a[1] + b[1]), items)[1]

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

import functools
def combine(a, b):
    return 0, a[1] + b[1]

total = functools.reduce(combine, items)[1]

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

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

Или встроенную функцию sum() и выражение-генератор:

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

Многие применения functools.reduce() становятся понятнее, если записать их в виде циклов for.

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

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

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

История изменений и благодарности¶Revision History and Acknowledgements

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

Ссылки¶References