Функциональное программирование HOWTO

Введение

Этот раздел объясняет основные понятия функционального программирования; если вас интересуют только языковые особенности 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 истинно.

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

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 в 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):
    """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; несколько других исправлений.

Ссылки