Dlaczego Lambdy Pythona są przydatne? [zamknięte]

lambda to tylko wymyślny sposób na powiedzenie function. Poza jego nazwą nie ma w nim nic niejasnego, zastraszającego lub tajemniczego. Kiedy czytasz następujący wiersz, zastąp lambda przez function w umyśle:

>>> f = lambda x: x + 1
>>> f(3)
4

Definiuje tylko funkcję x. Niektóre inne języki, jak R, mówią wprost:

> f = function(x) { x + 1 }
> f(3)
4

Dwulinijkowe podsumowanie:

1. zamknięcia : bardzo przydatne. Ucz się ich, używaj ich, kochaj ich.
2. w Pythonie lambda słowo kluczowe: niepotrzebne, czasem przydatne. Jeśli zrobisz z nim coś skomplikowanego, odłóż to i zdefiniuj prawdziwą funkcję.

Lambda jest częścią bardzo ważnego mechanizmu abstrakcji, który zajmuje się funkcjami wyższego rzędu. Aby dobrze zrozumieć jego wartość, obejrzyj wysokiej jakości lekcje od Abelsona i Sussmana i przeczytaj książkę SICP

Są to zagadnienia istotne we współczesnym biznesie oprogramowania i coraz bardziej popularne.

Wątpię, żeby lambda odeszła. Zobacz post Guido o tym, że w końcu rezygnujesz z próby usunięcia go. Zobacz też zarys konfliktu .

Możesz sprawdzić ten post, aby uzyskać więcej informacji na temat transakcji stojącej za funkcjami Pythona: http://python-history.blogspot.com/2009/04/origins-of-pythons-functional-features.html

Co ciekawe, mapowanie, filtrowanie i redukowanie funkcji, które pierwotnie motywowały wprowadzenie lambda i innych funkcje funkcjonalne zostały w dużym stopniu zastąpione przez składanie list i wyrażenia generatora. W rzeczywistości funkcja reduce została usunięta z listy wbudowanych funkcji w Pythonie 3.0. (Nie ma jednak potrzeby wysyłania skarg na usunięcie lambda, mapy lub filtra: zostają. :-)

Moje dwa grosze: rzadko lambda jest tego warta, jeśli chodzi o jasność. Ogólnie rzecz biorąc, istnieje bardziej jasne rozwiązanie, które nie obejmuje lambda.

Lambda są niezwykle przydatne w programowaniu GUI. Na przykład, powiedzmy, że tworzysz grupę przycisków i chcesz użyć jednego sparamatyzowanego wywołania zwrotnego, a nie unikalnego wywołania zwrotnego na przycisk. Lambda pozwala to osiągnąć z łatwością:

for value in ["one","two","three"]:
    b = tk.Button(label=value, command=lambda arg=value: my_callback(arg))
    b.pack()

(Uwaga: chociaż to pytanie dotyczy konkretnie lambda, Możesz również użyć functools.częściowe , aby uzyskać ten sam typ wyniku)

Alternatywą jest utworzenie osobnego wywołania zwrotnego dla każdego przycisku, który może doprowadzić do zduplikowanego kodu.

W Pythonie, lambda jest tylko sposobem definiowania funkcji inline,

a = lambda x: x + 1
print a(1)

I..

def a(x): return x + 1
print a(1)

..są dokładne takie same.

>>> a = lambda x: x + 1
>>> type(a)
<type 'function'>

Szczerze myślę, że słowo kluczowe lambda jest zbędne w Pythonie-nigdy nie miałem potrzeby ich używać (lub widziałem takie używane, gdy zwykły funkcja, rozumienie listy lub jedna z wielu wbudowanych funkcji mogły być lepiej użyte) {]}

Na zupełnie przypadkowy przykład, z artykułu "Lambda Pythona jest zepsuta!":

Aby zobaczyć jak lambda jest zepsuta, spróbuj wygenerować listę funkcji fs=[f0,...,f9] gdzie fi(n)=i+n. Pierwsza próba:

>>> fs = [(lambda n: i + n) for i in range(10)]
>>> fs[3](4)
13

Argumentowałbym, nawet gdyby to zadziałało, to jest strasznie i "niepytoniczne", ta sama funkcjonalność mogłaby być napisana na wiele innych sposobów, dla przykład:

>>> n = 4
>>> [i + n for i in range(10)]
[4, 5, 6, 7, 8, 9, 10, 11, 12, 13]

Tak, to nie to samo, ale ja nigdy nie widziałem przyczyny, w której generowanie grupy funkcji lambda na liście było wymagane. Może to mieć sens w innych językach, Ale Python nie jest Haskell (ani Lisp, ani ...)

Należy pamiętać, że możemy użyć lambda i nadal osiągnąć pożądane wyniki w ten sposób:

>>> fs = [(lambda n,i=i: i + n) for i in range(10)]
>>> fs[3](4)
7

Edit:

Jest kilka przypadków, w których lambda jest przydatna, na przykład jest często wygodna, gdy łączenie sygnałów w aplikacjach PyQt, jak to:

w = PyQt4.QtGui.QLineEdit()
w.textChanged.connect(lambda event: dothing())

Samo wykonanie w.textChanged.connect(dothing) wywołałoby metodę dothing z dodatkowym argumentem event i wywołałoby błąd. Użycie lambda oznacza, że możemy spokojnie upuścić argument bez konieczności definiowania funkcji owijania.

Uważam, że lambda jest użyteczna dla listy funkcji, które robią to samo, ale w różnych okolicznościach. Podobnie jak Mozilla plural rules .

plural_rules = [
    lambda n: 'all',
    lambda n: 'singular' if n == 1 else 'plural',
    lambda n: 'singular' if 0 <= n <= 1 else 'plural',
    ...
]
# Call plural rule #1 with argument 4 to find out which sentence form to use.
plural_rule[1](4) # returns 'plural'

Jeśli będziesz musiał zdefiniować funkcję dla wszystkich z nich, oszalejesz do końca. Również nie byłoby miło z nazwami funkcji, takimi jak plural_rule_1, plural_rule_2, itd. I musiałbyś eval() to, gdy jesteś zależny od zmiennej funkcji id.

Prawie wszystko, co możesz zrobić z lambda możesz zrobić lepiej z nazwanymi funkcjami lub wyrażeniami list i generatora.

W związku z tym w większości przypadków powinieneś być jednym z tych w praktycznie każdej sytuacji (może z wyjątkiem kodu zdrapkowego napisanego w interaktywnym interpreterze).

Używam Pythona od kilku lat i nigdy nie trafiłem do sprawy, w której potrzebowałem lambda. Tak naprawdę, jak mówi samouczek , to tylko dla cukru składniowego.

Nie mogę mówić o konkretnej implementacji lambda w Pythonie, ale ogólnie funkcje lambda są naprawdę przydatne. Są one podstawową techniką (może nawet techniką) programowania funkcyjnego, a także są bardzo przydatne w programach zorientowanych obiektowo. W przypadku niektórych rodzajów problemów są one najlepszym rozwiązaniem, więc na pewno nie należy o nich zapominać!

Proponuję poczytać o closures i map function (która łączy się z Pythonem docs, ale istnieje w prawie każdym język, który obsługuje konstrukty funkcjonalne), aby zobaczyć, dlaczego jest przydatny.

Funkcja Lambda jest to niebiurokratyczny sposób tworzenia funkcji.

Tradycyjny sposób:

def main():
...
...
y = square(some_number)
...
return something

def square(x):
    return x**2

Droga lambda:

def main():
...
square = lambda x: x**2
y = square(some_number)
return something

Funkcje Lambda bardzo dobrze współgrają z listami, takimi jak składanie list czy Mapa. W rzeczywistości rozumienie listy jest "pythonicznym" sposobem wyrażania używasz lambdy. Ex:

>>>a = [1,2,3,4]
>>>[x**2 for x in a]
[1,4,9,16]

Zobaczmy, co oznaczają poszczególne elementy składni:

[] : "Daj mi listę"

X * * 2 : "używanie tej nowo narodzonej funkcji"

Dla x W a: "do każdego elementu w a"

>>> square = lambda x: x**2
>>> [square(s) for x in a]
[1,4,9,16]

Teraz użyjmy mapy, która jest tym samym, ale bardziej neutralnym językowo. Mapy przyjmują 2 argumenty:

(i) jeden function

(ii) iterowalny

I daje listę, gdzie każdy element jest funkcją zastosowaną do każdego elementu iterable.

Więc używając mapy mamy:

>>> a = [1,2,3,4]
>>> squared_list = map(lambda x: x**2, a)

Jedną z fajnych rzeczy w lambda, która moim zdaniem jest zaniżona, jest to, że jest to sposób na odroczenie oceny dla prostych form, aż do potrzebnej wartości. Pozwól mi wyjaśnić.

Wiele procedur bibliotecznych jest zaimplementowanych tak, że pozwalają one na wywołanie pewnych parametrów (z których lambda jest jednym). Chodzi o to, że rzeczywista wartość będzie obliczana tylko w momencie, gdy będzie używana (a raczej wtedy, gdy zostanie wywołana). (Wymyślony) przykład może pomóc zilustrować punkt. Załóżmy, że masz rutynę, która miała zrobić dziennik danego znacznika czasu. Chcesz, aby rutyna używała bieżącego czasu minus 30 minut. You ' d call it like so

log_timestamp(datetime.datetime.now() - datetime.timedelta(minutes = 30))

Teraz Załóżmy, że rzeczywista funkcja zostanie wywołana tylko wtedy, gdy wystąpi pewne zdarzenie i chcesz, aby znacznik czasu był obliczany tylko w tym czasie. Możesz to zrobić tak

log_timestamp(lambda : datetime.datetime.now() - datetime.timedelta(minutes = 30))

Zakładając, że log_timestamp poradzi sobie z takimi wywołaniami, oceni to, kiedy będzie tego potrzebował i otrzymasz znacznik czasu czas.

Są oczywiście alternatywne sposoby, aby to zrobić (na przykład za pomocą modułu operator), ale mam nadzieję, że przekazałem punkt.

Aktualizacja: tutaj jest nieco bardziej konkretny przykład z prawdziwego świata.

Update 2: myślę, że jest to przykład tego, co nazywa się thunk .

Jak wspomniano powyżej, operator lambda w Pythonie definiuje funkcję anonimową, a w Pythonie funkcje są zamknięciami. Ważne jest, aby nie mylić pojęcia zamknięć z operatorem lambda, który jest dla nich jedynie metadonem składniowym.

Kiedy zaczynałem kilka lat temu w Pythonie, często używałem lambda, uważając, że są fajne, wraz z list comprehensions. Jednak napisałem i muszę utrzymywać dużą stronę internetową napisaną w Pythonie, z rzędu kilku tysięcy punkty funkcyjne. Z doświadczenia dowiedziałem się, że lambdy mogą być w porządku do prototypowania rzeczy z, ale nie oferują nic nad funkcjami inline (nazwane zamknięcia) z wyjątkiem zapisania kilku klawiszy, a czasami nie.

Zasadniczo sprowadza się to do kilku punktów:

• łatwiej jest odczytać oprogramowanie, które jest wyraźnie napisane przy użyciu znaczących nazw. Anonimowe zamknięcia z definicji nie mogą mieć wymownej nazwy, ponieważ nie mają nazwy. Ta zwięzłość wydaje się z jakiegoś powodu również zarażać parametry lambda, stąd często widzimy przykłady takie jak lambda X: x + 1
[7]}łatwiej jest ponownie użyć nazw zamknięć, ponieważ można je nazwać po imieniu więcej niż raz, gdy istnieje nazwa, aby się do nich odnieść.
• łatwiej jest debugować kod, który używa nazwanych zamknięć zamiast lambda, ponieważ nazwa pojawi się w traceback i wokół błędu.

To wystarczający powód, aby je zaokrąglić i przekształcić w nazwane zamknięcia. Jednak mam dwie inne urazy do anonimowe zamknięcia.

Pierwsza uraza polega na tym, że są one po prostu kolejnym niepotrzebnym słowem kluczowym zaśmiecającym język.

Druga uraza jest głębsza i na poziomie paradygmatu, tzn. nie podoba mi się, że promują styl programowania funkcyjnego, ponieważ styl ten jest mniej elastyczny niż style przekazywania wiadomości, zorientowane obiektowo lub proceduralne, ponieważ rachunek lambda nie jest Turing-complete (na szczęście w Pythonie możemy jeszcze wyrwać się z tego ograniczenia nawet wewnątrz lambda). Powody, dla których uważam, że lambdy promują ten styl to:

• Istnieje niejawny zwrot, tzn. wydaje się, że "powinny" być funkcjami.

• Są one alternatywnym mechanizmem ukrywania stanu dla innego, bardziej wyraźnego, bardziej czytelnego, bardziej wielokrotnego użytku i bardziej ogólnego mechanizmu: metod.

Staram się pisać lambda-Free Python i usuwać lambda na widoku. Myślę, że Python byłby nieco lepszym językiem bez lambda, ale to tylko mój opinia.

Lambda są w rzeczywistości bardzo potężnymi konstrukcjami, które wynikają z pomysłów w programowaniu funkcyjnym, i jest to coś, co w żadnym wypadku nie będzie łatwo poprawione, zdefiniowane lub usunięte w niedalekiej przyszłości Pythona. Pomagają w pisaniu kodu, który jest bardziej wydajny, ponieważ pozwala przekazywać funkcje jako parametry, a tym samym ideę funkcji jako obywateli pierwszej klasy.

Lambdy bywają mylące, ale po uzyskaniu solidnego zrozumienia można napisać czysty, elegancki Kod, jak to:

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

Powyższy wiersz kodu zwraca listę kwadratów liczb z listy. Oczywiście, można też zrobić to tak:

def square(x):
    return x*x

squared = map(square, [1, 2, 3, 4, 5])

Jest oczywiste, że poprzedni kod jest krótszy, a jest to szczególnie ważne, jeśli zamierzasz używać funkcji map (lub jakiejkolwiek podobnej funkcji, która przyjmuje funkcję jako parametr) tylko w jednym miejscu. Dzięki temu kod jest bardziej intuicyjny i elegancki.

Również, jak wspomniał @ David Zaslavsky w swojej odpowiedzi, listy nie są zawsze sposób, aby przejść, zwłaszcza jeśli lista ma uzyskać wartości z jakiegoś niejasnego matematycznego sposobu.

Z bardziej praktycznego punktu widzenia, jedną z największych zalet lambda jest dla mnie ostatnio GUI i programowanie oparte na zdarzeniach. Jeśli spojrzysz na wywołania zwrotne w Tkinter, wszystko, co biorą jako argumenty, to zdarzenie, które je wywołało. Np.

def define_bindings(widget):
    widget.bind("<Button-1>", do-something-cool)

def do-something-cool(event):
    #Your code to execute on the event trigger

def main():
    # define widgets and other imp stuff
    x, y = None, None
    widget.bind("<Button-1>", lambda event: do-something-cool(x, y))

def do-something-cool(event, x, y):
    x = event.x
    y = event.y
    #Do other cool stuff

Teraz możesz argumentować, że można to zrobić za pomocą zmiennych globalnych, ale czy naprawdę chcesz uderzyć się w głowę martwiąc się o zarządzanie pamięcią i wycieki, zwłaszcza jeśli zmienna globalna będzie używana tylko w jednym konkretnym miejscu? To byłby po prostu kiepski styl programowania.

Lambdy są głęboko związane ze stylem programowania funkcyjnego w ogóle. Idea, że można rozwiązać problemy poprzez zastosowanie funkcji do niektórych danych i łączenie wyników, jest tym, co google wykorzystuje do implementacji większości swoich algorytmów.

Programy napisane w stylu programowania funkcjonalnego, są łatwo równoległe i dlatego stają się coraz ważniejsze w nowoczesnych maszynach wielordzeniowych. Krótko mówiąc, Nie, Nie należy o nich zapominać.

Pierwsze gratulacje, które zdołały rozgryźć lambdę. Moim zdaniem jest to naprawdę potężna konstrukcja do działania. Trend w dzisiejszych czasach w kierunku funkcjonalnych języków programowania jest z pewnością wskaźnikiem, że nie należy go unikać i nie zostanie ponownie zdefiniowany w najbliższej przyszłości.

Musisz myśleć trochę inaczej. Jestem pewien, że wkrótce to pokochasz. Ale uważaj, jeśli masz do czynienia tylko z Pythonem. Ponieważ lambda nie jest prawdziwym zamknięciem, jest jakoś "złamana": lambda jest zepsuta

[1]}właśnie zaczynam Pythona i wbiegłem prosto w Lambdę - co zajęło mi trochę czasu, zanim się zorientowałem.

Czy lambda jest jedną z tych "ciekawych" pozycji językowych, o których w prawdziwym życiu należy zapomnieć?

Jestem pewien, że są pewne skrajne przypadki, w których może być to potrzebne, ale biorąc pod uwagę ciemność it,

Potencjał tego przedefiniowania w przyszłych wydaniach (moje założenie oparte na różnych jego definicjach)

Nie widziałem żadnych poważnych propozycji ponownego zdefiniowania go w Pythonie, poza ustaleniem semantyki zamknięcia kilka lat temu.

I zmniejszona klarowność kodowania-czy należy tego unikać?

Jest nie mniej jasne, jeśli używasz dobrze. Wręcz przeciwnie, posiadanie większej liczby dostępnych konstrukcji językowych zwiększa klarowność .

To przypomina mi przepełnienie (przepełnienie bufora) typów C - wskazanie górnej zmiennej i przeciążenie, aby ustawić inne wartości pola...coś w rodzaju pokazu technicznego, ale koszmar programisty..

Zacząłem czytać dzisiejszą książkę Davida Mertza " Przetwarzanie tekstu w Pythonie."Chociaż ma dość zwięzły opis Lambdy, przykłady w pierwszym rozdziale połączone z wyjaśnieniem w Dodatku A sprawiły, że skoczyły mi ze strony (w końcu) i nagle zrozumiałem ich wartość. To nie znaczy, że jego wyjaśnienie zadziała dla Ciebie i nadal jestem na etapie odkrycia, więc nie będę próbował dodawać do tych odpowiedzi innych niż następujące: Jestem nowy w Pythonie Jestem nowy w OOP Lambdy były dla mnie walką Teraz, gdy czytam Mertza, myślę, że je Rozumiem i widzę je tak bardzo przydatne, jak myślę, że pozwalają na czystsze podejście do programowania.

Odtwarza Zen Pythona, którego jedna linijka jest prosta jest lepsza niż złożona. jako programista nie-OOP czytający kod z lambda (i do zeszłego tygodnia składanie list) myślałem-to jest proste?. W końcu zdałem sobie dziś sprawę, że w rzeczywistości te funkcje sprawiają, że kod jest znacznie bardziej czytelny, a zrozumiałe niż alternatywa-która niezmiennie jest jakąś pętlą. Zdałem sobie również sprawę, że podobnie jak sprawozdania finansowe-Python nie został zaprojektowany dla początkujących użytkowników, a jest przeznaczony dla użytkownika, który chce się wykształcić. Nie mogę uwierzyć, jak potężny jest ten język. Kiedy mnie (w końcu) uświadomiło cel i wartość lambda chciałem zgrać około 30 programów i zacząć od nowa umieszczać lambda tam, gdzie to stosowne.

Użytecznym przypadkiem użycia lambda jest poprawienie czytelności długich zestawień list . W tym przykładzie {[2] } jest skrótem od jasności, ale wyobraź sobie, że loop_dic jest bardzo długi. Jeśli użyjesz zwykłej wartości zawierającej i zamiast wersji lambda tej wartości, otrzymasz NameError.

>>> lis = [{"name": "Peter"}, {"name": "Josef"}]

>>> loop_dic = lambda i: {"name": i["name"] + " Wallace" }
>>> new_lis = [loop_dic(i) for i in lis]

>>> new_lis
[{'name': 'Peter Wallace'}, {'name': 'Josef Wallace'}]

Zamiast

>>> lis = [{"name": "Peter"}, {"name": "Josef"}]

>>> new_lis = [{"name": i["name"] + " Wallace"} for i in lis]

>>> new_lis
[{'name': 'Peter Wallace'}, {'name': 'Josef Wallace'}]

Używam lambda, aby uniknąć powielania kodu. To sprawi, że funkcja będzie łatwo zrozumiała Eg:

def a_func()
  ...
  if some_conditon:
     ...
     call_some_big_func(arg1, arg2, arg3, arg4...)
  else
     ...
     call_some_big_func(arg1, arg2, arg3, arg4...)

Zamieniam to na temp lambda

def a_func()
  ...
  call_big_f = lambda args_that_change: call_some_big_func(arg1, arg2, arg3, args_that_change)
  if some_conditon:
     ...
     call_big_f(argX)
  else
     ...
     call_big_f(argY)

Jestem początkującym Pythonem, więc aby uzyskać jasne pojęcie lambda porównałem go z pętlą' for'; pod względem wydajności. Oto kod (python 2.7) -

import time
start = time.time() # Measure the time taken for execution

def first():
    squares = map(lambda x: x**2, range(10))
    # ^ Lambda
    end = time.time()
    elapsed = end - start
    print elapsed + ' seconds'
    return elapsed # gives 0.0 seconds

def second():
    lst = []
    for i in range(10):
        lst.append(i**2)
    # ^ a 'for' loop
    end = time.time()
    elapsed = end - start
    print elapsed + ' seconds'
    return elapsed # gives 0.0019998550415 seconds.

print abs(second() - first()) # Gives 0.0019998550415 seconds!(duh)

Mogę podać przykład, gdzie naprawdę potrzebowałem lambdy poważnie. Tworzę program graficzny, w którym za pomocą prawego przycisku klikamy na plik i przypisujemy mu jedną z trzech opcji. Okazuje się, że w Tkinter (w interfejsie graficznym, w którym to piszę), gdy ktoś naciśnie przycisk, nie można go przypisać do polecenia, które przyjmuje argumenty. Więc jeśli wybrałem jedną z opcji i chciałem, aby wynik mojego wyboru był:

print 'hi there'

Używam go dość często, głównie jako obiekt null lub do częściowego powiązania parametrów z funkcją.

Oto przykłady:

Aby zaimplementować wzorzec obiektu null:

{
    DATA_PACKET: self.handle_data_packets
    NET_PACKET: self.handle_hardware_packets
}.get(packet_type, lambda x : None)(payload)

Dla wiązania parametrów:

Powiedzmy, że mam następujące API

def dump_hex(file, var)
    # some code
    pass

class X(object):
    #...
    def packet_received(data):
        # some kind of preprocessing
        self.callback(data)
    #...

Następnie, gdy nie chcę szybko zrzucić otrzymanych danych do pliku, robię to:

dump_file = file('hex_dump.txt','w')
X.callback = lambda (x): dump_hex(dump_file, x)
...
dump_file.close()

Używam lambda do tworzenia wywołań zwrotnych zawierających parametry. Czystsze jest pisanie lambda w jednej linijce niż pisanie metody do wykonywania tej samej funkcjonalności.

Na przykład:

import imported.module

def func():
    return lambda: imported.module.method("foo", "bar")

W przeciwieństwie do:

import imported.module

def func():
    def cb():
        return imported.module.method("foo", "bar")
    return cb

Lambda jest konstruktorem procedur. Można syntetyzować programy w czasie wykonywania, chociaż Lambda Pythona nie jest zbyt potężny. Zauważ, że niewiele osób rozumie tego rodzaju programowanie.