Что такое map в питоне

Встроенные функции map, filter и reduce в Python

Python предоставляет множество встроенных (built-in) функций, которые предопределены и могут использоваться конечным пользователем, просто вызывая их. Эти функции не только облегчают работу программистов, но и создают стандартную среду программирования. В этой статье вы узнаете о трех таких впечатляющих функциях, как map(), filter() и reduce() в Python.

Что такое функции map(), filter() и reduce() в Python?

Как упоминалось ранее, map(), filter() и reduce() являются встроенными функциями Python. Эти функции обеспечивают функциональный программный аспект Python. В функциональном программировании передаваемые аргументы являются единственными факторами, которые определяют результат. Эти функции могут принимать любую другую функцию в качестве параметра и могут быть переданы другим функциям в качестве параметров.

Функция map():

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

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

Совместное использование с функциями, определяемыми пользователем и Lambda-функциями:

Пользовательские функции совместно с map():

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

Вы также можете передать несколько списков в качестве параметров.

Теперь давайте посмотрим, как вы можете использовать lambda-функции внутри map().

Lambda-функции совместно с map():

Lambda-функции — это функции, которые являются анонимными и им не нужно указывать какое-то собственное имя, как это происходит с пользовательскими функциями. Эти функции часто передаются в качестве параметров другим функциям.
Теперь давайте попробуем применить lambda-функции совместно с функцией map(). Рассмотрим следующий пример:

Приведенный выше вывод является результатом применения lambda-выражения (x + 3) к каждому элементу, присутствующему в кортеже.

Функция filter():

Функция filter() используется для создания списка, состоящего из значений, для которых функция возвращает true. Синтаксис этого следующий:

Так же, как и map(), эта функция может использовать в качестве параметра пользовательские функции, а также lambda-функции.

Как видите, y — это объект типа функции filter, а выходной список — это список значений, которые являются истинными для условия (x>=3).

Использование lambda-функций совместно с filter():

Lambda-функция, которая используется в качестве параметра, фактически определяет условие, которое необходимо проверить.

Приведенный выше код выдает тот же результат, что и предыдущая функция.

Функция reduce():

Функция reduce(), как можно понять из названия, применяет переданную функцию к итерируемому объекту и возвращает одно значение.

Здесь функция определяет, какое выражение необходимо применить к итерируемому объекту. Эту функцию необходимо импортировать из модуля functools.

В приведенном выше примере функция reduce последовательно суммирует каждый элемент из списка и возвращает одно выходное значение.

Функции map(), filter() и reduce() в Python могут использоваться вместе друг с другом.

Совместное использование функций map(), filter() и reduce() functions:

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

Если вы отфильтруете целые числа, большие или равные 3, из данного кортежа, вы получите [3,4] в результате. Затем, если вы примените функцию map к результату вывода предыдущей функции с использованием условия (x + x), то вы получите [6,8] список, который является выходным.

Использование map() внутри filter():

Когда вы используете функцию map() внутри функции filter(), итерации сначала обрабатываются функцией map, а затем к ним применяется условие filter().

Использование map() и filter() внутри reduce():

Вывод внутренних функций обрабатывается в соответствии с условием, заданным для функции reduce().

Результатом и выходными данными внутренних функций map() и reduce() является [6,8].

Итак, можно подводить итоги статьи по функциям map(), filter() и reduce() в Python. Я надеюсь, что вы все ясно поняли. Постарайтесь как можно больше практиковаться и применять полученные знания на практике.

Остались какие-то вопросы по теме? Пожалуйста, напишите их в разделе комментариев этой статьи, и мы дадим вам ответ как можно скорее.

Источник

map() в Python

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

map() — один из инструментов, поддерживающих стиль функционального программирования в Python.

Из этой статьи вы узнаете:

Обладая этими знаниями, вы сможете эффективно использовать map() в своих программах или, в качестве альтернативы, использовать списковое включение (list comprehensions) или выражения-генераторы (generator expressions), чтобы сделать ваш код более питоническим и читабельным.

Для лучшего понимания работы map() вам были бы полезны некоторые знания о том, как работать с итерациями (iterables), циклами, функциями (functions) и лямбда-функций (lambda functions).

Функциональный стиль в Python

В функциональном программировании вычисления выполняются путем объединения функций, которые принимают аргументы и возвращают конкретное значение (или значения). Эти функции не изменяют свои входные аргументы и не изменяют состояние программы. Они просто предоставляют результат данного вычисления. Такие функции обычно называются чистыми функциями (pure functions).

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

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

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

Я никогда не считал, что Python находится под сильным влиянием функциональных языков, независимо от того, что люди говорят или думают. Я был более знаком с императивными языками, такими как C и Algol 68, и хотя я сделал функции первоклассными объектами (first-class objects), я не рассматривал Python как язык функционального программирования. (Источник)

Однако еще в 1993 году сообщество Python требовало некоторых функций функционального программирования. Они просили:

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

Начало работы с map() в Python

Иногда вы можете столкнуться с ситуациями, когда вам нужно выполнить одну и ту же операцию со всеми элементами массива, чтобы создать новый массив. Самый быстрый и распространенный подход к этой проблеме — использовать цикл for в Python. Однако вы также можете решить эту проблему без явного использования циклов, используя map().

В следующих трех разделах вы узнаете, как работает map() и как вы можете использовать егр для обработки и преобразования итераций без циклов.

Что такое map()

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

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

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

Примечание. Первый аргумент map() — это объект функция, что означает, что вам нужно передать функцию, не вызывая ее. То есть без пары скобок.

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

Операция, выполняемая map(), обычно известна как сопоставление, потому что она сопоставляет каждый элемент во входном итерируемом элементе с новым элементом в итоговом итерируемом. Для этого map() применяет функцию преобразования ко всем элементам во входной итерации.

Чтобы лучше понять map(), предположим, что вам нужно взять список числовых значений и преобразовать его в список, содержащий квадратное значение каждого числа в исходном списке. В этом случае вы можете использовать цикл for и написать что-то вроде этого:

Когда вы запускаете этот цикл для чисел, вы получаете список квадратных значений. Цикл for перебирает числа и применяет к каждому значению операцию возведения в квадрат. Наконец, он сохраняет полученные значения в squared.

Вы можете добиться того же результата без использования явного цикла for, используя map(). Взгляните на следующую реализацию приведенного выше примера:

square() — это функция преобразования, которая преобразует число в его квадратное значение. Вызов map() применяет square() ко всем значениям и возвращает итератор, который возвращает квадратные значения. Затем вызывается list() для map(), чтобы создать объект списка, содержащий квадратные значения.

Поскольку map() написан на C и сильно оптимизирован, его внутренний подразумеваемый цикл может быть более эффективным, чем обычный цикл for в Python. Это одно из преимуществ использования map().

Второе преимущество использования map() связано с потреблением памяти. С помощью цикла for вам нужно сохранить весь список в памяти вашей системы. С помощью map() вы получаете элементы по запросу, и только один элемент находится в памяти вашей системы в данный момент.

Примечание. В Python 2.x map() возвращает список. Это поведение изменилось в Python 3.x. Теперь map() возвращает объект map, который является итератором, выдающим элементы по запросу. Вот почему вам нужно вызвать list(), чтобы создать желаемый объект списка.

В качестве другого примера предположим, что вам нужно преобразовать все элементы в списке из строки в целое число. Для этого вы можете использовать map() вместе с int() следующим образом:

map() применяет int() к каждому значению в str_nums. Поскольку map() возвращает итератор (объект map), вам понадобится вызов list(), чтобы вы могли превратить его в объект списка. Обратите внимание, что исходная последовательность не изменяется в процессе

Использование map() с различными видами функций

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

Есть несколько встроенных функций, которые вы можете использовать с map(). Рассмотрим следующие примеры:

Вы можете использовать любую встроенную функцию с map() при условии, что функция принимает аргумент и возвращает значение.

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

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

Обработка множественных итераций с помощью map()

Если вы предоставляете несколько итераций для map(), тогда функция преобразования должна принимать столько аргументов, сколько итераций, которые вы передаете. Каждая итерация map() будет передавать одно значение из каждой итерации в качестве аргумента функции. Итерация останавливается в конце самой короткой итерации.

Рассмотрим следующий пример, в котором используется pow():

pow() принимает два аргумента, x и y, и возвращает x в степени y. На первой итерации x будет 1, y будет 4, а результат будет 1. Во второй итерации x будет 2, y будет 5, а результат будет 32, и так далее. Последняя итерация равна длине самой короткой итерации, которой в данном случае является first_it.

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

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

Источник

Использование функции map в Python

Published on September 11, 2020

Введение

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

Функция map() имеет следующий синтаксис:

Вместо использования цикла for функция map() дает возможность применить функцию к каждому элементу итерируемого объекта. Это повышает производительность, поскольку функция применяется только к одному элементу за раз без создания копий элементов в другом итерируемом объекте. Это особенно полезно при обработке больших наборов данных. Также map() может принимать несколько итерируемых объектов в качестве аргументов функции, отправляя в функцию по одному элементу каждого итерируемого объекта за раз.

Использование функции Lambda

Синтаксис map() с функцией lambda выглядит следующим образом:

С таким списком мы можем реализовать функцию lambda с выражением, которое хотим применить к каждому элементу в нашем списке:

Чтобы применить выражение к каждому из наших чисел, мы можем использовать map() и lambda :

Для немедленного получения результатов мы распечатаем список объекта map :

Реализация определяемой пользователем функции

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

Например, в следующем итерируемом объекте каждый элемент является словарем, содержащим различные детали о каждом из существ в нашем аквариуме:

Мы вызовем assign_to_tank() с нашим списком словарей и новый номер резервуара, который нам нужно заменить для каждого существа:

Вывод программы будет выглядеть следующим образом:

Мы присвоили новый номер резервуара нашему списку словарей. Используя функцию, которую мы определяем, мы включаем map() для эффективного применения функции к каждому элементу списка.

Использование встроенной функции с несколькими итерируемыми объектами

Здесь у нас списки целых чисел, которые мы хотим использовать с pow() :

Затем мы передадим pow() в качестве функции в map() и укажем два списка в качестве итерируемых объектов:

Если мы передадим map() итерируемый объект, который будет длиннее другого итерируемого объекта, map() остановит расчеты после достижения конца наиболее короткого объекта. В следующей программе мы дополним base_numbers тремя дополнительными числами:

В расчетах программы ничего не изменится, и результат будет точно таким же:

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

Заключение

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

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

Источник

Основы функционального программирования на Python

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

Принципы функционального программирования

Включение в последовательность

Рекомендации по ФП на языке Python

Принципы функционального программирования

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

В последние годы почти все известные процедурные и объектно-ориентированные языки программирования стали поддерживать средства функционального программирования (ФП). И язык Python не исключение.

Когда говорят о ФП, прежде всего имеют в виду следующее:

Функции – это «граждане более высокого сорта», т.е., все, что можно делать с «данными», можно делать и с функциями (в том числе передача функции другой функции в качестве аргумента).

Использование рекурсии в качестве основной структуры контроля потока управления. В некоторых языках не существует иной конструкции цикла, кроме рекурсии.

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

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

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

ФП акцентируется на том, что должно быть вычислено, а не как.

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

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

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

Оператор lambda, функции map, filter, reduce и другие

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

Оператор lambda

lambda список_аргументов: выражение

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

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

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

Здесь в строке 1 определяется лямбда-функция и присваивается переменной, которая теперь ссылается на лямбда-функцию. В строке 2 она применяется с двумя аргументами. В строке 4 ссылка на эту функцию присваивается еще одной переменной, и затем пользуясь этой переменной данная функция вызывается еще раз. В строке 7 создается словарь, в котором в качестве значения задана ссылка на эту функцию, и затем, обратившись к этому значению по ключу, эта функция применяется в третий раз.

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

Функция map

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

Встроенная в Python функция map – это функция более высокого порядка, которая предназначена для выполнения именно такой задачи. Она позволяет обрабатывать одну или несколько последовательностей с использованием заданной функции. Вот общий формат функции map :

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

В приведенном выше интерактивном сеансе в строках 1 и 2 двум переменным, seq и seq2, присваиваются две итерируемые последовательности. В строке 3 переменной result присваивается результат применения функции map, в которую в качестве аргументов были переданы ранее определенная лямбда-функция и две последовательности. Обратите внимание, что функция map возвращает объект-последовательность map, о чем говорит строка 5. Особенность объекта-последовательности map состоит в том он может предоставлять свои элементы, только когда они требуются, используя ленивые вычисления. Ленивые вычисления – это стратегия вычисления, согласно которой вычисления следует откладывать до тех пор, пока не понадобится их результат. Программистам часто приходится обрабатывать последовательности, состоящие из десятков тысяч и даже миллионов элементов. Хранить их в оперативной памяти, когда в определенный момент нужен всего один элемент, не имеет никакого смысла. Ленивые вычисления позволяют генерировать ленивые последовательности, которые при обращении к ним предоставляют следующий элемент последовательности. Чтобы показать ленивую последовательность, в данном случае результат работы примера, необходимо эту последовательность «вычислить». В строке 6 объект map вычисляется во время преобразования в список.

Функция filter

В данном формате предикативная_функция – это ссылка на стандартную функцию либо лямбда-функция, которая возвращает истину либо ложь, и последовательность – это итерируемая последовательность, т.е. список, кортеж, диапазон или строковые данные.

Например, ниже приведена однострочная функция is_even для определения четности числа:

Чтобы отфильтровать все числа последовательности и оставить только четные, применим функцию filter :

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

Функция reduce

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

Вот общий формат функции reduce :

reduce(функция, последовательность, инициализатор)

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

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

Вот еще один пример. Если sentences – это список предложений, и требуется подсчитать общее количество слов в этих предложениях, то можно написать, как показано в приведенном ниже интерактивном сеансе:

В чем преимущества функций более высокого порядка?

Они нередко состоят из одной строки.

Все важные компоненты итерации – объект-последовательность, операция и возвращаемое значение – находятся в одном месте.

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

Приведем еще пару полезных функций.

Функция zip

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

В данном формате последовательность – это итерируемая последовательность, т.е. список, кортеж, диапазон или строковые данные. Функция zip возвращает ленивый объект-последовательность, который нужно вычислить, чтобы увидеть результат. Приведенный ниже интерактивный сеанс это демонстрирует:

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

Функция enumerate

Встроенная функция enumerate возвращает индекс элемента и сам элемент последовательности в качестве кортежа. Вот общий формат функции enumerate:

В данном формате последовательность – это итерируемая последовательность, т.е. список, кортеж, диапазон или строковые данные. Функция enumerate возвращает ленивый объект-последовательность, который нужно вычислить, чтобы увидеть результат.

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

Функция convert в строке 1 переводит строковое значение второго элемента кортежа в верхний регистр и присоединяет к нему преобразованное в строковый тип значение первого элемента. Здесь tup – это кортеж, в котором tup[0] – это индекс элемента, и tup[1] – строковое значение элемента.

Включение в последовательность

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

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

[выражение for переменная in список if выражение2]

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

Приведенное выше включение в список эквивалентно следующему ниже фрагменту программного кода:

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

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

Таблица 1. Формы описания интенсионала

Выражение

Описание

[x*x for x in numbers]

set(x*x for x in numbers)

(x*x for x in numbers)

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

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

Таким образом, примеры из разделов о функциях map и filter легко можно переписать с использованием включения в последовательность. Например, в строке 3 приведенного ниже интерактивного сеанса вместо функции map применена операция включения в список:

Включение в список применено и в приведенном ниже примере вместо функции filter :

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

Замыкание

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

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

Чтобы сделать ее каррированной, она должна быть переписана следующим образом:

Это же самое можно выразить при помощи лямбда-функций:

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

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

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

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

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

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

Рекомендации по ФП на языке Python

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

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

Что делает функции нечистыми?

Глобальные мутации, т.е. внесение изменений в глобальное состояние,

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

Пример глобальной мутации:

Пример операции ввода-вывода:

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

Ссылочная прозрачность (1) улучшает тестопригодность программ, т.е. поведение подпрограмм не зависит от контекста, повторный запуск приложения дает одинаковый результаты как следствие отсутствия мутаций, (2) обеспечивается модульность, т.е. поведение функций не зависит от контекста, и чистые функции можно легко составлять в композиции, строя новые формы поведений, (3) упрощает обеспечение конкурентности из-за отсутствия необходимости в синхронизации, т.к. отсутствие совместных мутируемых данных делает синхронизацию ненужной.

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

Эффективное функциональное программирование на Python вполне возможно.

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

Указанные выше два простых правила делают ненужными архитектурные шаблоны и принципы ООП, заменяя их функциями! А что, спросите вы, и классы тоже? В Python использование классов не противоречит ФП, если в них отсутствует мутирующие интерфейсы.

Пример класса с мутирующим интерфейсом:

Пример класса без мутирующего интерфейса:

Но лучше использовать замороженные dataclasses и копирование, где необходимо. Иными словами, все классы должны быть замороженными dataclasses.

При всем при этом dataclasses могут быть вполне себе умными!

Также следует использовать сторонние функциональные библиотеки (например, toolz), которые обеспечивают более оптимальную композиционность функций.

Выводы

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

Данный пост служит дополнением к моему предыдущему посту о конвейере данных. Приведенный выше материал был опубликован в качестве авторского в переводе книги Starting Out with Python и дополнен материалами Энтони Хвона.

Источник