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

Введение

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

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

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

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

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

Некоторые языки очень строго относятся к чистоте и даже не имеют операторов присваивания, таких как a=3 или c = a + b, но трудно избежать всех побочных эффектов, таких как вывод на экран или запись в файл. Другой пример — вызов функции print() или time.sleep(), ни одна из которых не возвращает полезного значения. Обе вызываются только для своих побочных эффектов — отправки текста на экран или приостановки выполнения на секунду.

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

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

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

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

Итераторы

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

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

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

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

>>> L = [1, 2, 3]
>>> it = iter(L)
>>> it  
<...iterator object at ...>
>>> it.__next__()  # same as 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])
Jan 1
Feb 2
Mar 3
Apr 4
May 5
Jun 6
Jul 7
Aug 8
Sep 9
Oct 10
Nov 11
Dec 12

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

for line in file:
    # do something for each line
    ...

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

Выражения-генераторы и списковые включения

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

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

>>> line_list = ['  line 1\n', 'line 2  \n', ' \n', '']

>>> # Generator expression -- returns iterator
>>> stripped_iter = (line.strip() for line in line_list)

>>> # List comprehension -- returns 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 равно true.

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

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   # Skip this element
    for expr2 in sequence2:
        if not (condition2):
            continue   # Skip this element
        ...
        for exprN in sequenceN:
            if not (conditionN):
                continue   # Skip this element

            # Output the value of
            # the expression.

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

>>> 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 создаёт кортеж, он должен быть заключён в скобки. Первое списковое включение ниже является синтаксической ошибкой, тогда как второе — правильное:

# Syntax error
[x, y for x in seq1 for y in seq2]
# Correct
[(x, y) for x in seq1 for y in seq2]

Генераторы

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

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

# A recursive generator that generates Tree leaves in 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)
        # If value provided, change counter
        if val is not None:
            i = val
        else:
            i += 1

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

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

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

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

map(f, iterA, iterB, ...) returns an iterator over the sequence

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) нумерует элементы в итерируемом объекте, возвращая кортежи длиной 2, содержащие счётчик (от start) и каждый элемент.

>>> 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
>>> # Generate 8 random numbers between [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

Модуль 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

Модуль functools содержит некоторые высшего порядка функции. Функция высшего порядка принимает на вход одну или несколько функций и возвращает новую функцию. Наиболее полезным инструментом в этом модуле является функция 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):
    """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')

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
# Instead of:
product = functools.reduce(operator.mul, [1, 2, 3], 1)

# You can write:
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

Небольшие функции и выражение lambda

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

Если есть встроенная функция 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. Напишите функцию lambda.
2. Напишите комментарий, объясняющий, что делает эта функция lambda.
3. Поизучайте комментарий некоторое время и придумайте имя, которое отражает суть комментария.
4. Преобразуйте lambda в инструкцию def, используя это имя.
5. Удалите комментарий.

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

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

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

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

Версия 0.30: Добавлена секция о модуле functional, написанный Collin Winter; добавлена короткая секция о модуле operator; несколько других исправлений.

Ссылки