Каковы преимущества использования лямбда-функции, а не median_fun? [Дубликат]

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

some_list = [2, 1, 3]
print sorted(some_list)
print sorted(some_list, lambda a, b: -cmp(a, b))

. В последнем случае создание отдельной полноценной функции только для возврата -cmp(a, b) создало бы больше недоразумений, чем лямбда.

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

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

Подумайте, как структурировать предложение. Каковы важные части (существительные и глаголы против объектов и методов и т. Д.) И как их нужно упорядочить для этой строки или блока кода, чтобы передать, что он делает интуитивно.

Синтаксис более ясен в некоторых ситуациях, в основном при работе с map и др.

map(lambda x: x * 2, [1,2,3,4])

мне кажется лучше:

def double(x):
    return x * 2

map(double, [1,2,3,4])

Я думаю лямбда - лучший выбор в этой ситуации, потому что def double кажется почти отключенным от map, который его использует. Кроме того, я полагаю, что это добавило преимущества, которые функция отбрасывает, когда вы закончите.

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

Плюс, всякий раз, когда я использую лямбда, я чувствую себя потрясающе.

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

from tkinter import *
from tkinter import ttk        
def callback(arg):
    print(arg)
    pass
root = Tk()
ttk.Button(root, text = 'Button1', command = lambda: callback('Button 1 clicked')).pack()
root.mainloop()

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

ttk.Button(root, text = 'Button1', command = callback('Button1 clicked')).pack()

Вот хороший пример:

def key(x):
    return x[1]

a = [(1, 2), (3, 1), (5, 10), (11, -3)]
a.sort(key=key)

по сравнению с

a = [(1, 2), (3, 1), (5, 10), (11, -3)]
a.sort(key=lambda x: x[1])

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

http://en.wikipedia.org/wiki/Lambda_calculus

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

map(lambda y: y * -1, range(0, 10))

, явно упоминает четыре анонимных количества: -1, 0, 10 и результат лямбда-оператора плюс подразумеваемый результат вызова map. можно создать значения анонимных типов на некоторых языках. поэтому игнорируйте поверхностную разницу между функциями и числами. вопрос о том, когда использовать анонимную функцию в отличие от именованного, аналогичен вопросу о том, когда нужно поставить в коде голый номер буква и когда заранее объявить TIMES_I_WISHED_I_HAD_A_PONY или BUFFER_SIZE. есть моменты, когда целесообразно использовать литерал (числовой, строковый или функциональный), и бывают случаи, когда более целесообразно называть такую ​​вещь и ссылаться на нее через ее имя.

см., например. Провокационная, задумчивая или раздражающая книга Аллена Голуба о шаблонах проектирования на Java; он использует анонимные классы совсем немного.

Lambdas позволяет вам создавать функции «на лету». Большинство примеров, которые я видел, не намного больше, чем создание функции с параметрами, переданными во время создания, а не с выполнением. Или они упрощают код, не требуя официального объявления функции перед использованием.

Более интересным будет использование динамической конструкции функции python для оценки математического выражения, которое неизвестно до времени выполнения (пользовательский ввод). После создания эту функцию можно вызывать несколько раз с разными аргументами для оценки выражения (например, вы хотели его построить). Это может быть даже плохим примером, данным eval (). Этот тип использования - вот где «реальная» мощность - динамически создавая более сложный код, а не простые примеры, которые вы часто видите, которые не намного больше, чем хорошие (исходные) сокращения размера кода.

Да, вы правы - это структурный выбор. Вероятно, это не делает ваши программы более правильными, просто используя лямбда-выражения. И это не делает их более надежными, и это не имеет ничего общего со скоростью.

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

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

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

Но это все еще структурный выбор. Вы можете сделать это иначе. Но то же самое касается объектно-ориентированного программирования;)

Lambdas - это объекты, а не методы, и они не могут быть вызваны таким же образом, как и методы. например,

succ = ->(x){ x+1 }

succ mow содержит объект Proc, который мы можем использовать, как и любой другой:

succ.call(2)

дает нам выход = 3

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

parameter=lambda x: x

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

Также часто полезно использовать при сортировке как ключ:

key=lambda x: x[field]

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

reverse=True

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

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

Прямо из PEP8

«Один из Основная информация Гвидо заключается в том, что код читается гораздо чаще, чем написано ».

Лямбда-функции наиболее полезны в таких вещах, как функции обратного вызова или места, в которых вам нужна функция throwaway. Пример JAB идеален - лучше было бы сопровождать аргумент ключевого слова key, но он по-прежнему содержит полезную информацию.

Когда

def key(x):
    return x[1]

появляется на расстоянии 300 строк от

[(1,2), (3,1), (5,10), (11,-3)].sort(key)

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

[(1,2), (3,1), (5,10), (11,-3)].sort(lambda x: x[1])

говорит вам намного больше.

1. Сортировка принимает функцию в качестве аргумента
2. Эта функция принимает 1 параметр (и " возвращает «результат»
3. Я пытаюсь отсортировать этот список по 2-ому значению каждого из элементов списка
4. (Если список был переменной, t см. значения), эта логика ожидает, что в списке будет по крайней мере 2 элемента.

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

Плюс это не загрязняет ваше пространство имен;)

Другое дело, что у python нет операторов switch. Объединение лямбда с диктонами может быть эффективной альтернативой. например ::

switch = {
 '1': lambda x: x+1, 
 '2': lambda x: x+2,
 '3': lambda x: x+3
}

x = starting_val
ans = expression
new_ans = switch[ans](x)