Функция высшего порядка-это та, которая либо принимает функцию в качестве аргумента, либо возвращает функцию (или оба!). Эти функции помогают нам выполнять более сложные задачи в нашей бизнес-логике, которые были бы гораздо более утомительными с первоклассными функциями.
Python позволяет нам определить наши собственные пользовательские функции высшего порядка. На самом деле, я демонстрирую эту функцию в своей предыдущей статье о Lambda функции в Python. Я не буду освещать эту конкретную функцию в этой статье. Тем не менее, я буду покрывать 3 наиболее полезных функций высшего порядка, которые встроены в Python:
- карта
- Уменьшать
- Фильтр
Эти функции делают дело с итерационными объектами намного проще, чем использование первоклассных функций или обычных петлей. Для каждой функции я объясню, что выполняет функция, продемонстрирую, как она работает с примером кода, и предложу возможные приложения для функции.
карта
Функция карты в Python позволяет нам создавать новый иерный объект из исходного итерабируемого объекта. Это требует 2 аргумента: функция и итерабильный объект. Функция карты применяет функцию, передаваемую каждому элементу итерации, а затем создает объект карты. Этот объект может быть поднят на итерационный тип нашего выбора. Функция, передаваемая в объект карты, не должна возвращать значение (я продемонстрирую это позже).
Реализация
Для нашего примера давайте генерируем новый список (L2) из первоначального списка (L1), так что каждый элемент L2 является двойным от соответствующего элемента в L1. Вот как мы можем достичь этого с помощью функции карты:
def double(x):
return x * 2
L1 = [3, 1, 4, 22, 45, 1, 245, 6, 34, 4, 8, 14]
L2 = list(map(double, L1))
print("Doubled Numbers: {}".format(L2))
# [6, 2, 8, 44, 90, 2, 490, 12, 68, 8, 16, 28]
Приведенный выше код проходит двойную функцию (обратите внимание, что мы оставляем в скобках) и исходный список (L1). Объект карты возвращается, а затем бросает в список. Обратите внимание, что мы можем отменить этот объект карты в любой тип итерабильного, который мы хотим (список, кортеж, установлен, …).
Функция карты также работает с функциями Lambda. Чтобы сделать код выше более компактного, мы можем переписать его следующим образом:
L1 = [3, 1, 4, 22, 45, 1, 245, 6, 34, 4, 8, 14] L2 = list(map( (lambda x : x * 2) , L1)) print(L2)
Это было бы более желательным решением, если бы функция вашей карты довольно проста и не понадобится в другом месте программы. Однако, если вы выполняете сложную операцию на иерной и/или планировании повторного использования функции вне этого контекста, лучше всего придерживаться регулярных функций.
Помните, что я упомянул, что функция на самом деле не должна ничего возвращать. Если вы хотите отобразить определенные функциональности каждому члену итерабируемого, но не заботитесь о полученном объекте MAP, функция MAP просто не возвращает ни одного для каждого соответствующего члена исходного итерационного.
На самом деле, нам даже не нужно хранить возвращенный объект карты вообще. Если у нас есть список людей, и мы просто хотим распечатать приветствие для каждого человека в списке, мы можем использовать функцию карты:
def greet(person):
print("Hello, {}!".format(person['name']))
people = [
{ 'name' : 'John Doe', 'age' : 20},
{ 'name' : 'Mike Will', 'age' : 10},
{ 'name' : 'Jane Hill', 'age' : 18},
{ 'name' : 'Alan Smith', 'age' : 16},
{ 'name' : 'Chimuka Chinene', 'age' : 18},
]
list(map(greet, people ))
""" Prints :
Hello, John Doe!
...
Hello, Chimuka Chinene!
"""
Мы должны отбрасывать объект карты, возвращаемый, чтобы фактически выполнить функцию выполнять для всех участников. Созданный список – это всего лишь список объектов типа «нет», так как функция Mapper ничего не вернула. Если вы назначите этот список переменной и распечатайте его, вывод будет: [ Нет, нет, нет, нет, нет]
Использование
Наиболее очевидное использование функции карты заключается в создании хэш -таблицы. Хэш -таблица – это структура данных, которая связывает ключ с хэшем, который генерируется с использованием ключа. Функция карты может быть использована для применения функции хэш к списку ключей без необходимости итерации.
Функция карты также может быть использована для замены петель. Вместо того, чтобы зацикливаться на каждом члене итерабильной и выполняющей некоторую логику, мы могли бы сопоставить функцию с этой логикой с итерационной. Помните, что нам не нужно ничего возвращать из функции Mapper, и мы не должны заботиться о полученном объекте MAP.
Уменьшать
Функция уменьшения работает аналогично функции карты в том смысле, что она принимает итерабильную и функцию, которая применяется ко всем членам итерации. Тем не менее, он отличается от карты, поскольку возвращает одно значение вместо итерабируемого отображения на оригинал. Это уменьшает итерабильный до одного значения. Функция уменьшения также принимает третий аргумент, начальное значение, с которым она начинает итерацию. Если это значение не предоставлено, первый элемент итерабильного будет использоваться в качестве начального значения. С каждой итерацией функция принимает свое текущее значение, а следующий элемент в итерации и возвращает значение, которое будет использоваться для следующего элемента.
Реализация
Давайте рассчитаем сумму удвоения всех чисел в массиве целых чисел L1. Мы могли бы использовать петлю для этого. Тем не менее, более чистое решение будет заключаться в том, чтобы использовать функцию уменьшения следующим образом: Примечание в Python 3, DEMOL был перенесен в функции Functools, поэтому вам придется импортировать его.
from functools import reduce
def addDoubles(a, b):
return a + (b * 2)
L1 = [3, 1, 4, 22, 45, 1, 245, 6, 34, 4, 8, 14]
doubleSum = reduce(addDoubles, L1, 0)
print(doubleSum) # 774
В приведенном выше коде функция добавления принимает 2 параметра: текущая сумма (a) и текущий элемент в итерационном (b), который удвоится. Общая сумма двойной и текущей суммы возвращается и переносится в следующую итерацию до конца итерабильной. Функция уменьшения также принимает функции Lambda. Мы можем упростить код выше следующим образом:
from functools import reduce L1 = [3, 1, 4, 22, 45, 1, 245, 6, 34, 4, 8, 14] doubleSum = reduce( (lambda a,b : a + b * 2) , L1, 0) print(doubleSum) # 774
Это простой пример, мы можем определить гораздо более сложную функцию редуктора. Мы также можем выбрать еще одно начальное значение. Например, если бы я хотел, чтобы моя отправная точка была 1000, я бы написал код по -другому:
from functools import reduce L1 = [3, 1, 4, 22, 45, 1, 245, 6, 34, 4, 8, 14] sum = reduce( (lambda a,b : a + b * 2) , L1, 1000) # 1000 as initial value print(sum) # 1774
Использование
Функция уменьшения может быть использована везде, где необходимо агрегировать итерабильное до одного значения. Мы все равно можем определить функцию редуктора.
Фильтр
Функция фильтра также аналогична функции карты. Он принимает итерабильную и функцию выполнения всех членов итерации. Тем не менее, это происходит с некоторыми разными правилами:
- Фильтр не должен создавать отображение 1 до 1 между новым итерабильным и исходным, как функция карты.
- Фильтр создает новый список, основанный на элементах, которые возвращают true, когда функция фильтра выполняется на них
Реализация
Учитывая список из 5 человек, давайте Отфильтровать Все люди, которые моложе 18.
def legal(person):
return person['age'] >= 18
people = [
{ 'name' : 'John Doe', 'age' : 20},
{ 'name' : 'Mike Will', 'age' : 10},
{ 'name' : 'Jane Hill', 'age' : 18},
{ 'name' : 'Alan Smith', 'age' : 16},
{ 'name' : 'Chimuka Chinene', 'age' : 18},
]
legal_people = list(filter(legal, people))
print(legal_people)
""" Prints [{'name': 'John Doe', 'age': 20}, {'name': 'Jane Hill', 'age': 18}, #{'name': 'Chimuka Chinene', 'age': 18}] """
В приведенном выше Кодексе мы запускаем «законную» функцию на каждом человеке. Функция возвращает либо истинную, либо ложную, в зависимости от возраста человека. Только люди, чей возраст возвращается от юридической функции, попадают в новый список. Объект фильтра возвращается. Мы можем поднять это на любой итерационный тип, который мы желаем.
Функция фильтра также может воспринимать функцию лямбды в качестве аргумента. Мы можем написать код выше следующим образом:
people = [
{ 'name' : 'John Doe', 'age' : 20},
{ 'name' : 'Mike Will', 'age' : 10},
{ 'name' : 'Jane Hill', 'age' : 18},
{ 'name' : 'Alan Smith', 'age' : 16},
{ 'name' : 'Chimuka Chinene', 'age' : 18},
]
legal_people = list(filter( (lambda person : person['age'] >= 18) , people))
print(legal_people)
""" Prints [{'name': 'John Doe', 'age': 20}, {'name': 'Jane Hill', 'age': 18}, #{'name': 'Chimuka Chinene', 'age': 18}] """
Использование
Этот довольно просто. Мы используем функцию фильтра во всех случаях, когда мы хотим отфильтровать нежелательных членов исходного списка. Мы можем запустить это на очень сложных элементах в итерационных и определить сложные функции фильтра для достижения того желаемого результата, который мы хотим. Просто помните, что функция фильтра должна вернуть true или false.
Вывод
Функции высшего порядка являются бесценным инструментом при написании программ, особенно тех, которые работают над итерационными объектами. Они не нужны, так как их функциональность может быть достигнута регулярными для/во время петли. Тем не менее, они очень помогают поддерживать наш код аккуратным и кратким по сравнению с обычными циклами. Я надеюсь, что я предоставил достаточное объяснение вышеупомянутых функций, которое позволит вам реализовать их в ваших проектах. Счастливого кодирования!
Пост Функции высшего порядка Python появился первым на Кельвин Мвинука Анкет
Если вам понравилась эта статья, подумайте о моей Веб -сайт Для раннего доступа к моему контенту до того, как он будет опубликован здесь (не волнуйтесь, это все еще бесплатно без раздражающей всплывающей рекламы!). Кроме того, не стесняйтесь комментировать этот пост. Я хотел бы услышать ваши мысли!
Оригинал: “https://dev.to/kelvinvmwinuka/python-higher-order-functions-3co”