Сортировки и лямбда-функции
У стандартной сортировки (метода sort списка, функции sorted) есть более универсальный способ задания порядка сортировки при помощи параметра key. Значение этого параметра некоторая функция, которая вызывается для каждого элемента, перед сравнением этих элементов: элементы списка сортируются, но сравниваются не значения элементов, а результат вызова переданной функции от этого элемента.
Например, пусть дан список строк, содержащих цифры, нужно упорядочить элементы списка, сравнивая их, как числа, а не как строки. Это можно сделать так:
a = ["10", "20", "30", "1", "2", "3", "111", "112", "222"] a.sort(key=int)
В сложных случаях функцию нужно написать самостоятельно, например, пусть дан список чисел, который нужно упорядочить по последней цифре. Напишем функцию, которая возвращает последнюю цифру числа:
def last_digit(n): return n % 10 a.sort(key=last_digit)
Параметр key можно использовать вместе с параметром reverse .
Лямбда-функции
В предыдущем примере пришлось создавать отдельную функцию только для того, чтобы задать порядок сортировки, что захламляет программу ненужными функциями. В таких случаях нужно использовать лямбда-функции: “одноразовые фукцнии, которые можно объявлять без использовать слова def , прямо при вызове сортировки. Лямбда-функция — это функция, которая состоит только из одной строки с инструкцией return , то есть функция сразу возвращает значение по набору аргументов. Лямбда-функции объявляются таким образом:
lambda список переменных-аргументов: возвращаемое значение
Например, отсортировать список чисел по последней цифре можно при помощи следующей лямбда-функции:
a = [3, 15, 22, 13, 12, 32, 45, 43] a.sort(key=lambda n: n % 10)
Рассмотрим другой пример. Пусть дан список точек, каждая точка: кортеж из двух чисел. Например, [(3, -2), (7, 1), (0, 4)] . Этот список нужно отсортировать по возрастанию расстояния от начала координат до точки. Напишем лямбда-функцию:
a.sort(key=lamda point: point[0] ** 2 + point[1] ** 2)
Элементами списка являются кортежи из двух координат, можно обратиться к этим координатам по индексам [0] и [1].
Устойчивость сортировки
Вернёмся к примеру сортировки по последней цифре. В приведённом выше примере упорядоченный список будет таким:
[22, 12, 32, 3, 13, 43, 15, 45]
Этот пример иллюстрирует свойство устойчивости сортировки: функция сортировки не переставлят элементы, если они равны друг другу. В данном случае функция упорядочивает числа по последней цифре, а при равной последней цифре сохраняется порядок следования элементов в исходном списке: 22, 12, 32.
Что делать, если нужно сделать сложную сортировку, учитывающую несколько критериев? Например, при равной последней цифре нужно упорядочить элементы в порядке возрастания самих чисел.
Первый способ решения: напишем функцию, которая будет возвращать кортеж из двух чисел: последней цифры и самого числа. Кортежи сравниваются в лексикографическом порядке, поэтому при равенстве остатка от деления будут сравниваться сами числа.
a.sort(key=lambda n: (n % 10, n))
Второй способ: воспользуемся устойчивостью сортировки. Отстортируем список сначала по возрастанию чисел, а затем — по последней цифре. Тогда при равном значении последней цифры сохранится ранее полученный порядок.
a.sort() a.sort(key=lambda n: n % 10)
То есть сортировку по \(k\) параметрам (если по первому параметру элементы равны, то сравнить по второму, если равны два параметра, то сравнить по третьему и т.д.) можно заменить на \(k\) последовательных сортировок, выполняющихся в обратном порядке (от наименее значимого параметра к наиболее значимому).
Функция operator.itemgetter
При сортировке кортежей частой задачей является сортировка по какому-то одному элементу кортежа. Например, если нужно отсортировать кортежи по элементу с индексом 1, то можно написать такую лямбда-функцию:
a.sort(key=lambda elem: elem[1])
Для удобства в модуле operator есть функция itemgetter , которая позволяет создавать подобные функции, а именно, функция реализована примерно так:
def itemgetter(i): return lambda elem: elem[i]
То есть operator.itemgetter(i) — это функция, при вызове которой от числового параметра создаётся лямдба-функция, которую можно использовать в качестве параметра key . Если вызвать функцию itemgetter от нескольких параметров, то полученная функция будет возвращать кортеж из элементов с заданными индексами.
Что такое lambda в питоне
Лямбда-выражения в языке Python представляют небольшие анонимные функции, которые определяются с помощью оператора lambda . Формальное определение лямбда-выражения:
lambda [параметры] : инструкция
Определим простейшее лямбда-выражение:
message = lambda: print("hello") message() # hello
Здесь лямбда-выражение присваивается переменной message. Это лямбда-выражение не имеет параметров, ничего не возвращает и просто выводит строку «hello» на консоль. И через переменную message мы можем вызвать это лямбда-выражение как обычную функцию. Фактически оно аналогично следующей функции:
def message(): print("hello")
Если лямбда-выражение имеет параметры, то они определяются после ключевого слова lambda . Если лямбда-выражение возвращает какой-то результат, то он указывается после двоеточия. Например, определим лямбда-выражение, которое возвращает квадрат числа:
square = lambda n: n * n print(square(4)) # 16 print(square(5)) # 25
В данном случае лямбда-выражение принимает один параметр — n. Справа от двоеточия идет возвращаемое значение — n* n . Это лямбда-выражение аналогично следующей функции:
def square2(n): return n * n
Аналогичным образом можно создавать лямбда-выражения, которые принимают несколько параметров:
sum = lambda a, b: a + b print(sum(4, 5)) # 9 print(sum(5, 6)) # 11
Хотя лямбда-выражения позволяют немного сократить определения функций, тем не менее они ограничены тем, что они могут выполнять только одно выражение. Однако они могут быть довольно удобны в тех случаях, когда необходимо использовать функцию для передачи в качестве параметра или возвращения в другой функции. Например, передача лямбда-выражения в качестве параметра:
def do_operation(a, b, operation): result = operation(a, b) print(f"result = ") do_operation(5, 4, lambda a, b: a + b) # result = 9 do_operation(5, 4, lambda a, b: a * b) # result = 20
В данном случае нам нет необходимости определять функции, чтобы передать их в качестве параметра, как в прошлой статье.
То же самое касается и возвращение лямбда-выражений из функций:
def select_operation(choice): if choice == 1: return lambda a, b: a + b elif choice == 2: return lambda a, b: a - b else: return lambda a, b: a * b operation = select_operation(1) # operation = sum print(operation(10, 6)) # 16 operation = select_operation(2) # operation = subtract print(operation(10, 6)) # 4 operation = select_operation(3) # operation = multiply print(operation(10, 6)) # 60
Анонимные функции — Python: Функции
Представим, что нам нужно написать функцию для выполнения определенного действия, но создание отдельной функции кажется излишним. Чтобы решить эту проблему, можно использовать анонимные функции. Они позволяют определить функцию «на лету» внутри другой функции или выражения.
В этом уроке мы изучим, что такое анонимные функции, как их определять и использовать в Python. Также рассмотрим примеры, где использование анонимных функций может значительно упростить написание кода. Но для начала вспомним, что такое именованные функции.
Принцип работы именованных функций
Именованные функции в Python — это функции, которым назначено имя с помощью оператора def . Он позволяет создавать функции, которые можно вызывать по имени из любой точки программы.
Пример именованной функции:
def add_numbers(x, y): return x + y Здесь именованная функция — add_numbers . Она принимает два аргумента x и y и возвращает их сумму.
Еще бывают ситуации, когда нужна функция, чтобы ее передать, например, в функцию высшего порядка. Но больше эта функция нигде не понадобится.
Придумывание имен в программировании — одна из основных проблем. Но если функция нужна здесь и сейчас, и больше нигде ее вызывать не придется, то и имя ей не нужно. Такие одноразовые функции называются анонимными или лямбда-функциями.
Принцип работы анонимных функций
Анонимные функции — это функции, у которых нет имени. Они определяются с помощью ключевого слова lambda . Это ключевое слово названо в честь лямбда-абстракции — основы Лямбда Исчисления. Это математический аппарат, который часто применяется в разработке языков программирования. В Лямбда Исчислении все функции — анонимные. Поэтому анонимные функции во многих языках тоже иногда называют лямбдами или лямбда-функциями.
Такие функции обычно используются в качестве аргументов функций высшего порядка, таких как map() , filter() и reduce() . Также они позволяют описывать практически все языки, которые умеют работать с функциями как со значениями.
В Python определение подобной функции выглядит так:
lambda x: x + 1 # at 0x7f56e5798a60> Мы сконструировали функцию, но имя она не получила, поэтому REPL ее отобразил как function .
Рассмотрим пример, который использует анонимную функцию:
l = [1, 2, 5, 3, 4] l.sort(key=lambda x: -x) l # [5, 4, 3, 2, 1] Метод sort принимает в качестве аргумента key ссылку на функцию. В примере в качестве аргумента указана функция, которая меняет знак у аргумента. По этой причине список получается отсортирован от большего к меньшему.
Сортировка с указанием ключа встречается довольно часто, а вот ключи сортировки чаще всего будут разными. Поэтому выносить ключи в именованные функции смысла нет и анонимные функции здесь подходят.
Рассмотрим другой пример, который использует анонимную функцию вместе с функцией map() :
l = [1, 2, 3, 4, 5] result = list(map(lambda x: x * 2, l)) result # [2, 4, 6, 8, 10] В данном примере функция map() принимает анонимную функцию и список данных. Анонимная функция lambda x: x * 2 принимает один аргумент x и умножает его на два. Функция map() применяет эту анонимную функцию к каждому элементу списка l и возвращает новый список, в котором каждый элемент удвоен. Результат сохраняется в переменной result и выводится на экран.
Теперь рассмотрим пример работы с функцией filter :
l = [1, 2, 3, 4, 5] result = list(filter(lambda x: x % 2 == 0, l)) result # [2, 4] Этот код использует функцию filter . Она фильтрует элементы входной последовательности, согласно условию, которое задано в лямбда-функции. В нашем примере функция фильтрует элементы списка l .
Здесь лямбда-функция lambda x: x % 2 == 0 определяет, что элемент должен быть четным — его остаток при делении на два должен быть равен нулю.
Функция filter применяет лямбда-функцию к каждому элементу списка l и оставляет только те элементы, для которых лямбда-функция возвращает True . Затем эти элементы используются для создания нового списка с помощью функции list .
Посмотрим на еще один пример применения анонимной функции, но уже с функцией reduce :
from functools import reduce l = [1, 2, 3, 4, 5] result = reduce(lambda x, y: x * y, l) result # 120 В данном примере используется лямбда-функция, которая принимает два аргумента: x и y . В итоге она возвращает их произведение. Итерируемый объект l содержит числа [1, 2, 3, 4, 5] . Поэтому функция reduce последовательно умножает каждую пару чисел в списке: (1 * 2) * 3) * 4) * 5 . Это приводит к результату 120 .
Особенности анонимных функций
Рассмотрим главные особенности анонимных функций:
- Аргументы анонимных функций не заключены в скобки. К этому нужно будет привыкнуть. Остальные средства для описания аргументов доступны в полной мере — и именованные аргументы, и *args с **kwargs
- Тело лямбда-функции — это всегда одно выражение, результат вычисления которого и будет возвращаемым значением. В теле лямбда-функции не получится выполнить несколько действий и не получится использовать многострочные конструкции вроде for и while . Но зато анонимные функции обычно просто читать, чего было бы сложно добиться, разреши авторам «многострочные» лямбды
- Объявление функции является выражением. Функции можно конструировать и тут же вызывать, не заканчивая выражение:
1 + (lambda x: x * 5)(8) + 1 # 42 В таком виде лямбды встречаются редко. Зато часто можно встретить возврат лямбды из функции:
def caller(arg): return lambda f: f(arg) call_with_five = caller(5) call_with_five(str) # '5' call_with_five(lambda x: x + 1) # 6 Из этого примера можно понять, что лямбды являются замыканиями — возвращаемая лямбда запоминает значение переменной arg .
Открыть доступ
Курсы программирования для новичков и опытных разработчиков. Начните обучение бесплатно
- 130 курсов, 2000+ часов теории
- 1000 практических заданий в браузере
- 360 000 студентов
Наши выпускники работают в компаниях:
Все, что нужно знать о lambda-функциях в Python
В этой статье вы узнаете о том, что такое лямбда-функции в Python. На самом деле, если вы знаете, что такое функции и умеете с ними работать, то знаете и что такое лямбда.
Лямбда-функция в Python — это просто функция Python. Но это некий особенный тип с ограниченными возможностями. Если есть желание погрузиться глубже и узнать больше, то эта статья целиком посвящена lambda .
Что такое лямбда в Python?
Прежде чем переходить как разбору понятия лямбда в Python, попробуем понять, чем является обычная функция Python на более глубоком уровне.
Для этого потребуется немного поменять направление мышление. Как вы знаете, все в Python является объектом.
Например, когда мы запускаем эту простейшую строку кода
x = 5 Создается объект Python типа int , который сохраняет значение 5. x же является символом, который ссылается на объект.
Теперь проверим тип x и адрес, на которой он ссылается. Это можно сделать с помощью встроенных функций type и id .
>>> type(x) class 'int'> >>> id(x) 4308964832 В итоге x ссылается на объект типа int , а расположен он по адресу, который вернула функция id .
Просто и понятно.
А что происходит при определении вот такой функции:
>>> def f(x): ... return x * x ... Повторим упражнение и узнаем type и id объекта f .
>>> def f(x): ... return x * x ... >>> type(f) class 'function'> >>> id(f) 4316798080 Оказывается, в Python есть класс function , а только что определенная функция f — это его экземпляр. Так же как x был экземпляром класса integer . Другими словами, о функциях можно думать как о переменных. Разница лишь в том, что переменные хранят данные, а функции — код.
Это же значит, что функции можно передать в качестве аргументов другим функциям или даже использовать их как тип возвращаемого значения.
Рассмотрим простой пример, где функция f передается другой функции.
def f(x): return x * x def modify_list(L, fn): for idx, v in enumerate(L): L[idx] = fn(v) L = [1, 3, 2] modify_list(L, f) print(L) #вывод: [1, 9, 4] Попробуйте разобраться самостоятельно с тем, что делает этот код, прежде чем читать дальше.
Итак, modify_list — это функция, которая принимает список L и функцию fn в качестве аргументов. Затем она перебирает список элемент за элементом и применяет функцию к каждому из них.
Это общий способ изменения объектов списка, ведь он позволяет передать функцию, которая займется преобразованием. Так, если передать modify_list функцию f , то результатом станет список, где все значения будут возведены в квадрат.
Но можно передать и любую другую, которая изменит оригинальный список другим способом. Это очень мощный инструмент.
Теперь, когда с основами разобрались, стоит перейти к лямбда. Лямбда в Python — это просто еще один способ определения функции. Вот базовый синтаксис лямбда-функции в Python:
lambda arguments: expression Лямбда принимает любое количество аргументов (или ни одного), но состоит из одного выражения. Возвращаемое значение — значение, которому присвоена функция. Например, если нужно определить функцию f из примера выше, то это можно сделать вот так:
>>> f = lambda x: x * x >>> type(f) class 'function'> Но возникает вопрос: а зачем нужны лямбда-функции, если их можно объявлять традиционным образом? Но на самом деле, они полезны лишь в том случае, когда нужна одноразовая функция. Такие функции еще называют анонимными. И, как вы увидите дальше, есть масса ситуаций, где они оказываются нужны.
Лямбда с несколькими аргументами
Определить лямбда-функцию с одним аргументом не составляет труда.
>>> f = lambda x: x * x >>> f(5) 25 А если их должно быть несколько, то достаточно лишь разделить значения запятыми. Предположим, что нужна функция, которая берет два числовых аргумента и возвращает их произведение.
>>> f = lambda x, y: x * y >>> f(5, 2) 10 Отлично! А как насчет лямбда-функции без аргументов?
Лямбда-функция без аргументов
Допустим, нужно создать функцию без аргументов, которая бы возвращала True . Этого можно добиться с помощью следующего кода.
>>> f = lambda: True >>> f() True Несколько лямбда-функций
В определенный момент возникнет вопрос: а можно ли иметь лямбда-функцию из нескольких строк.
Ответ однозначен: нет.
Лямбда-функции в Python всегда принимают только одно выражение. Если же их несколько, то лучше создать обычную функцию.
Примеры лямбда-функций
Теперь рассмотрим самые распространенные примеры использования лямбда-функций.
Лямбда-функция и map
Распространенная операция со списками в Python — применение операции к каждому элементу.
map() — это встроенная функция Python, принимающая в качестве аргумента функцию и последовательность. Она работает так, что применяет переданную функцию к каждому элементу.
Предположим, есть список целых чисел, которые нужно возвести в квадрат с помощью map .
>>> L = [1, 2, 3, 4] >>> list(map(lambda x: x**2, L)) [1, 4, 9, 16] Обратите внимание на то, что в Python3 функция map возвращает объект Map , а в Python2 — список.
Так, вместо определения функции и передачи ее в map в качестве аргумента, можно просто использовать лямбда для быстрого определения ее прямо внутри. В этом есть смысл, если упомянутая функция больше не будет использоваться в коде.
Вот еще один пример.
Лямбда-функция и filter
filter() — это еще одна встроенная функция, которая фильтрует последовательность итерируемого объекта.
Другими словами, функция filter отфильтровывает некоторые элементы итерируемого объекта (например, списка) на основе какого-то критерия. Критерий определяется за счет передачи функции в качестве аргумента. Она же применяется к каждому элементу объекта.
Если возвращаемое значение — True , элемент остается. В противном случае — отклоняется. Определим, например, простую функцию, которая возвращает True для четных чисел и False — для нечетных:
def even_fn(x): if x % 2 == 0: return True return False print(list(filter(even_fn, [1, 3, 2, 5, 20, 21]))) #вывод: [2, 20] С лямбда-функциями это все можно сделать максимально сжато. Код выше можно преобразовать в такой, написанный в одну строку.
print(list(filter(lambda x: x % 2 == 0, [1, 3, 2, 5, 20, 21]))) И в этом сила лямбда-функций.
Лямбда-функция и сортировка списков
Сортировка списка — базовая операция в Python. Если речь идет о списке чисел или строк, то процесс максимально простой. Подойдут встроенные функции sort и sorted .
Но иногда имеется список кастомных объектов, сортировать которые нужно на основе значений одного из полей. В таком случае можно передать параметр key в sort или sorted . Он и будет являться функцией.
Функция применяется ко всем элементам объекта, а возвращаемое значение — то, на основе чего выполнится сортировка. Рассмотрим пример. Есть класс Employee .
class Employee: def __init__(self, name, age): self.name = name self.age = age Теперь создадим экземпляры этого класса и добавим их в список.
Alex = Employee('Alex', 20) Amanda = Employee('Amanda', 30) David = Employee('David', 15) L = [Alex, Amanda, David] Предположим, что мы хотим отсортировать его на основе поля age сотрудников. Вот что нужно сделать для этого:
L.sort(key=lambda x: x.age) print([item.name for item in L]) # вывод: ['David', 'Alex', 'Amanda'] Лямбда-выражение было использовано в качестве параметра key вместо отдельного ее определения и затем передачи в функцию sort .
Пара слов о выражениях и инструкциях
Как уже упоминалось, лямбда могут иметь только одно выражение (expression) в теле.
Обратите внимание, что речь идет не об инструкции (statement).
Выражение и инструкции — две разные вещи, в которых часто путаются. В программировании инструкцией является строка кода, выполняющая что-то, но не генерирующая значение.
Например, инструкция if или циклы for и while являются примерами инструкций. Заменить инструкцию на значение попросту невозможно.
А вот выражения — это значения. Запросто можно заменить все выражения в программе на значения, и программа продолжит работать корректно.
- 3 + 5 — выражение со значением 8
- 10 > 5 — выражение со значением True
- True and (5 < 3) — выражение со значением False
Тело лямбда-функции должно являться выражением, поскольку его значение будет тем, что она вернет. Обязательно запомните это для работы с лямбда-функциями в будущем.