Które z nich jest lepsze w użyciu: funkcje lambda czy funkcje zagnieżdżone („def”)?

Najczęściej używam funkcji lambda, ale czasami używam funkcji zagnieżdżonych, które wydają się zapewniać to samo zachowanie.

Oto kilka trywialnych przykładów, w których funkcjonalnie robią to samo, jeśli znaleziono jedną z nich w innej funkcji:

Funkcja lambda

>>> a = lambda x : 1 + x
>>> a(5)
6

Funkcja zagnieżdżona

>>> def b(x): return 1 + x

>>> b(5)
6

Czy są zalety używania jednego nad drugim? (Wydajność? Czytelność? Ograniczenia? Spójność? Itp.)

Czy to w ogóle ma znaczenie? Jeśli tak nie jest, narusza to zasadę Pythonic:

Powinien być jeden - a najlepiej tylko jeden - oczywisty sposób na zrobienie tego .

Jeśli chcesz przypisać nazwę lambdado nazwy, użyj defzamiast tego. defs są po prostu cukrem syntaktycznym dla zadania, więc wynik jest taki sam, są o wiele bardziej elastyczne i czytelne.

lambdas można użyć tylko raz, wyrzuć funkcje, które nie będą miały nazwy.

Jednak ten przypadek użycia jest bardzo rzadki. Rzadko trzeba omijać nienazwane obiekty funkcyjne.

Builtins map()i filter()potrzeby funkcji obiektów, ale listowych i wyrażenia generatorów są na ogół bardziej czytelny niż tych funkcji i może obejmować wszystkie przypadki użycia, bez konieczności lambda.

W przypadkach, gdy naprawdę potrzebujesz małego obiektu funkcyjnego, powinieneś użyć operatorfunkcji modułu, takich jak operator.addzamiastlambda x, y: x + y

Jeśli nadal potrzebujesz niektórych, które lambdanie zostały uwzględnione, możesz rozważyć napisanie def, aby być bardziej czytelnym. Jeśli funkcja jest bardziej złożona niż te w operatormodule, a defjest prawdopodobnie lepsza.

Zatem lambdaprzypadki użycia dobrych rzeczy w świecie rzeczywistym są bardzo rzadkie.

Praktycznie rzecz biorąc, są dla mnie dwie różnice:

Pierwsza dotyczy tego, co robią i co zwracają:

• def to słowo kluczowe, które nic nie zwraca i tworzy „nazwę” w lokalnej przestrzeni nazw.

• lambda to słowo kluczowe, które zwraca obiekt funkcji i nie tworzy „nazwy” w lokalnej przestrzeni nazw.

Dlatego jeśli chcesz wywołać funkcję, która przyjmuje obiekt funkcji, jedynym sposobem na zrobienie tego w jednym wierszu kodu w Pythonie jest użycie lambda. Nie ma odpowiednika z def.

W niektórych ramach jest to dość powszechne; na przykład często używam Twisted i robię coś takiego

d.addCallback(lambda result: setattr(self, _someVariable, result))

jest dość powszechny i ​​bardziej zwięzły w przypadku lambd.

Druga różnica dotyczy tego, co może robić rzeczywista funkcja.

• Funkcja zdefiniowana za pomocą „def” może zawierać dowolny kod Pythona
• Funkcja zdefiniowana za pomocą `` lambda '' musi obliczać do wyrażenia i dlatego nie może zawierać instrukcji, takich jak print, import, raise, ...

Na przykład,

def p(x): print x

działa zgodnie z oczekiwaniami, podczas gdy

lambda x: print x

jest SyntaxError.

Oczywiście istnieją obejścia - zastąp printje sys.stdout.writelub importz __import__. Ale zazwyczaj w takim przypadku lepiej jest wybrać funkcję.

W tym wywiadzie Guido van Rossum mówi, że żałował, że nie wpuścił „lambdy” do Pythona:

" Q. Co cechą Pythona jesteś najmniej zadowolony z?

Czasami byłem zbyt szybkie w przyjmowaniu wkładów, a później sobie sprawę, że to był błąd. Przykładem może być niektóre z cech funkcjonalnych programowania, takich jak funkcje lambda. Lambda jest słowem kluczowym, które umożliwia utworzenie małej anonimowej funkcji; wbudowane funkcje, takie jak mapowanie, filtrowanie i zmniejszanie, uruchamiają funkcję w typie sekwencji, takim jak lista.

W praktyce nie wyszło to najlepiej. Python ma tylko dwa zakresy: lokalny i globalny. To sprawia, że ​​pisanie funkcji lambda jest bolesne, ponieważ często chcesz uzyskać dostęp do zmiennych w zakresie, w którym została zdefiniowana lambda, ale nie możesz tego zrobić z powodu dwóch zakresów. Jest sposób na obejście tego, ale to coś w rodzaju bałaganu. Często wydaje się znacznie łatwiejsze w Pythonie, aby po prostu użyć pętli for zamiast bawić się funkcjami lambda. mapa i przyjaciele działają dobrze tylko wtedy, gdy jest już wbudowana funkcja, która robi to, co chcesz.

IMHO, Iambdas mogą być czasami wygodne, ale zwykle są wygodne kosztem czytelności. Czy możesz mi powiedzieć, co to robi:

str(reduce(lambda x,y:x+y,map(lambda x:x**x,range(1,1001))))[-10:]

Napisałem to i zajęło mi minutę, zanim to rozgryzłem. To jest z Project Euler - nie powiem, który problem, bo nie znoszę spoilerów, ale działa w 0,124 sekundy :)

Dla n = 1000 mamy trochę czasu na wywołanie funkcji a lambda:

In [11]: def f(a, b):
             return a * b

In [12]: g = lambda x, y: x * y

In [13]: %%timeit -n 100
for a in xrange(n):
  for b in xrange(n):
    f(a, b)
   ....:
100 loops, best of 3: 285 ms per loop

In [14]: %%timeit -n 100
for a in xrange(n):
  for b in xrange(n):
    g(a, b)
   ....:
100 loops, best of 3: 298 ms per loop

In [15]: %%timeit -n 100
for a in xrange(n):
  for b in xrange(n):
    (lambda x, y: x * y)(a, b)
   ....:
100 loops, best of 3: 462 ms per loop

Występ:

Tworzenie funkcji za pomocą lambdajest nieco szybsze niż tworzenie jej za pomocą def. Różnica wynika z defutworzenia wpisu nazwy w tabeli ustawień lokalnych. Wynikowa funkcja ma taką samą szybkość wykonywania.

Czytelność:

Funkcje lambda są nieco mniej czytelne dla większości użytkowników Pythona, ale w niektórych okolicznościach są też znacznie bardziej zwięzłe. Rozważ przejście z rutyny niefunkcjonalnej na funkcjonalną:

# Using non-functional version.

heading(math.sqrt(v.x * v.x + v.y * v.y), math.atan(v.y / v.x))

# Using lambda with functional version.

fheading(v, lambda v: math.sqrt(v.x * v.x + v.y * v.y), lambda v: math.atan(v.y / v.x))

# Using def with functional version.

def size(v):
    return math.sqrt(v.x * v.x + v.y * v.y)

def direction(v):
    return math.atan(v.y / v.x)

deal_with_headings(v, size, direction)

Jak widać, lambdawersja jest krótsza i „łatwiejsza” w tym sensie, że wystarczy dodać lambda v:ją do oryginalnej, niefunkcjonalnej wersji, aby przejść do wersji funkcjonalnej. Jest też dużo bardziej zwięzły. Pamiętaj jednak, że wielu użytkowników Pythona będzie zdezorientowanych składnią lambda, więc to, co stracisz na długości i prawdziwej złożoności, może zostać odzyskane przez innych programistów.

Ograniczenia:

• lambda funkcje mogą być użyte tylko raz, chyba że są przypisane do nazwy zmiennej.
• lambdafunkcje przypisane do nazw zmiennych nie mają żadnej przewagi nad deffunkcjami.
• lambda funkcje mogą być trudne lub niemożliwe do wytrawienia.
• def nazwy funkcji muszą być starannie dobrane, aby były rozsądnie opisowe i unikalne lub przynajmniej w inny sposób nieużywane w zakresie.

Konsystencja:

Python w większości unika konwencji programowania funkcjonalnego na rzecz proceduralnej i prostszej semantyki obiektywnej. lambdaOperator stoi w sprzeczności z tym stronniczości. Ponadto, jako alternatywa dla już rozpowszechnionej def, lambdafunkcja dodaje różnorodności do składni. Niektórzy uznaliby to za mniej spójne.

Wcześniej istniejące funkcje:

Jak zauważyli inni, wiele zastosowań lambdaw tej dziedzinie można zastąpić członkami operatormodułów lub innych modułów. Na przykład:

do_something(x, y, lambda x, y: x + y)
do_something(x, y, operator.add)

Użycie istniejącej funkcji może w wielu przypadkach zwiększyć czytelność kodu.

Zasada Pythona: „Powinien istnieć jeden - a najlepiej tylko jeden - oczywisty sposób na zrobienie tego”

To jest podobne do pojedynczego źródła doktryny prawdy . Niestety, zasada jednego oczywistego sposobu na zrobienie tego zawsze była bardziej tęsknym dążeniem do Pythona niż prawdziwą zasadą przewodnią. Weź pod uwagę bardzo potężne funkcje tablicowe w Pythonie. Są one funkcjonalnym odpowiednikiem funkcji mapi filter:

[e for e in some_array if some_condition(e)]
filter(some_array, some_condition)

lambdai defsą takie same.

To kwestia opinii, ale powiedziałbym, że wszystko w języku Python przeznaczone do ogólnego użytku, które w oczywisty sposób niczego nie psuje, jest wystarczające.

Bardziej preferowane: funkcje lambda czy funkcje zagnieżdżone ( def)?

Stosowanie lambdy w stosunku do funkcji regularnej ma jedną zaletę: są tworzone w wyrażeniu.

Istnieje kilka wad:

• bez imienia (tylko '<lambda>')
• bez dokumentów
• brak adnotacji
• brak skomplikowanych instrukcji

Oba są również tego samego rodzaju obiektami. Z tych powodów generalnie wolę tworzyć funkcje ze defsłowem kluczowym zamiast z lambdami.

Punkt pierwszy - są to obiekty tego samego typu

Lambda daje ten sam typ obiektu, co zwykła funkcja

>>> l = lambda: 0
>>> type(l)
<class 'function'>
>>> def foo(): return 0
... 
>>> type(foo)
<class 'function'>
>>> type(foo) is type(l)
True

Ponieważ lambdy są funkcjami, są obiektami pierwszej klasy.

Zarówno lambdy, jak i funkcje:

• może być przekazywany jako argument (tak samo jak zwykła funkcja)
• gdy są tworzone w ramach funkcji zewnętrznej, stają się zamknięciem dla lokalności tej funkcji zewnętrznej

Jednak w wyrażeniach lambdowych domyślnie brakuje niektórych rzeczy, które funkcje uzyskują za pośrednictwem pełnej składni definicji funkcji.

A Lamba za __name__znaczy'<lambda>'

Lambdy to w końcu funkcje anonimowe, więc nie znają swojego imienia.

>>> l.__name__
'<lambda>'
>>> foo.__name__
'foo'

Zatem lambda nie mogą być wyszukiwane programowo w ich przestrzeni nazw.

To ogranicza pewne rzeczy. Na przykład foomożna wyszukać za pomocą serializowanego kodu, podczas gdy lnie można:

>>> import pickle
>>> pickle.loads(pickle.dumps(l))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
_pickle.PicklingError: Can't pickle <function <lambda> at 0x7fbbc0464e18>: 
attribute lookup <lambda> on __main__ failed

Możemy dobrze wyszukać foo- ponieważ zna swoją nazwę:

>>> pickle.loads(pickle.dumps(foo))
<function foo at 0x7fbbbee79268>

Lambdy nie mają adnotacji ani napisów

Zasadniczo lambdy nie są udokumentowane. Przepiszmy, fooaby być lepiej udokumentowanym:

def foo() -> int:
    """a nullary function, returns 0 every time"""
    return 0

Teraz foo ma dokumentację:

>>> foo.__annotations__
{'return': <class 'int'>}
>>> help(foo)
Help on function foo in module __main__:

foo() -> int
    a nullary function, returns 0 every time

Zważywszy, że nie mamy tego samego mechanizmu przekazywania tych samych informacji lambdom:

>>> help(l)
Help on function <lambda> in module __main__:

<lambda> lambda (...)

Ale możemy je zhakować na:

>>> l.__doc__ = 'nullary -> 0'
>>> l.__annotations__ = {'return': int}
>>> help(l)
Help on function <lambda> in module __main__:

<lambda> lambda ) -> in
    nullary -> 0

Ale prawdopodobnie jest jakiś błąd, który zakłóca wynik pomocy.

Lambdy mogą zwracać tylko wyrażenie

Lambdy nie mogą zwracać złożonych instrukcji, tylko wyrażenia.

>>> lambda: if True: 0
  File "<stdin>", line 1
    lambda: if True: 0
             ^
SyntaxError: invalid syntax

Wyrażenia mogą być wprawdzie dość złożone, a jeśli bardzo się postarasz, prawdopodobnie możesz osiągnąć to samo za pomocą lambdy, ale dodatkowa złożoność bardziej szkodzi pisaniu czystego kodu.

Używamy Pythona dla przejrzystości i łatwości konserwacji. Nadużywanie lambd może temu przeciwdziałać.

Tylko góry za lambdas: mogą być tworzone w jednym wyrażeniu

To jedyna możliwa korzyść. Ponieważ możesz utworzyć lambdę za pomocą wyrażenia, możesz utworzyć ją wewnątrz wywołania funkcji.

Utworzenie funkcji wewnątrz wywołania funkcji pozwala uniknąć (niedrogiego) wyszukiwania nazwy w porównaniu z wyszukiwaniem utworzonym gdzie indziej.

Jednak ponieważ Python jest ściśle oceniany, nie ma innego zwiększenia wydajności poza unikaniem wyszukiwania nazwy.

Dla bardzo prostego wyrażenia mógłbym wybrać lambdę.

Zwykle używam również lambd podczas interaktywnego Pythona, aby uniknąć wielu wierszy, gdy to zrobi. Używam następującego formatu kodu, gdy chcę przekazać argument do konstruktora podczas wywoływania timeit.repeat:

import timeit

def return_nullary_lambda(return_value=0):
    return lambda: return_value

def return_nullary_function(return_value=0):
    def nullary_fn():
        return return_value
    return nullary_fn

I teraz:

>>> min(timeit.repeat(lambda: return_nullary_lambda(1)))
0.24312214995734394
>>> min(timeit.repeat(lambda: return_nullary_function(1)))
0.24894469301216304

Uważam, że powyższą niewielką różnicę czasu można przypisać wyszukiwaniu nazw w return_nullary_function- zwróć uwagę, że jest to bardzo pomijalne.

Wniosek

Lambdy są dobre w nieformalnych sytuacjach, w których chcesz zminimalizować liczbę wierszy kodu na rzecz tworzenia osobnych punktów.

Lambdy są złe w bardziej formalnych sytuacjach, w których potrzebujesz jasności dla redaktorów kodu, którzy przyjdą później, zwłaszcza w przypadkach, gdy są one nietrywialne.

Wiemy, że mamy nadawać naszym przedmiotom dobre nazwy. Jak możemy to zrobić, gdy obiekt nie ma nazwy?

Z tych wszystkich powodów generalnie wolę tworzyć funkcje za pomocą defzamiast with lambda.

Zgadzam się z radą nosklo: jeśli chcesz nadać funkcji nazwę, użyj def. Rezerwuję lambdafunkcje dla przypadków, w których właśnie przekazuję krótki fragment kodu do innej funkcji, np .:

a = [ (1,2), (3,4), (5,6) ]
b = map( lambda x: x[0]+x[1], a )

Zgadzając się z innymi odpowiedziami, czasami jest bardziej czytelny. Oto przykład, w którym się lambdaprzydaje, w przypadku użycia, w którym ciągle napotykam N-wymiar defaultdict.
Oto przykład:

from collections import defaultdict
d = defaultdict(lambda: defaultdict(list))
d['Foo']['Bar'].append(something)

Uważam, że jest to bardziej czytelne niż tworzenie defdla drugiego wymiaru. Ma to jeszcze większe znaczenie w przypadku wyższych wymiarów.

Podstawowym zastosowaniem lambdy zawsze były proste funkcje zwrotne oraz mapowanie, zmniejszanie i filtrowanie, które wymagają funkcji jako argumentu. Ze składanymi listami stają się normą, a dodawane dozwolone, jeśli jak w:

x = [f for f in range(1, 40) if f % 2]

trudno sobie wyobrazić prawdziwy przypadek użycia lambdy w codziennym użytkowaniu. W rezultacie powiedziałbym, że unikaj lambdy i twórz funkcje zagnieżdżone.

Ważnym ograniczeniem wyrażeń lambd jest to, że nie mogą one zawierać niczego poza wyrażeniem. Jest prawie niemożliwe, aby wyrażenie lambda wytworzyło cokolwiek poza trywialnymi skutkami ubocznymi, ponieważ nie może mieć nawet tak bogatej treści jak deffunkcja ed.

Biorąc to pod uwagę, Lua wpłynęła na mój styl programowania w kierunku szerokiego stosowania anonimowych funkcji i zaśmiecam nimi swój kod. Co więcej, myślę o mapowaniu / redukuj jako operatorach abstrakcyjnych w sposób, którego nie uważam za wyrażenia listowe lub generatory, prawie tak, jak w przypadku jawnego odraczania decyzji o implementacji za pomocą tych operatorów.

Edycja: To dość stare pytanie, a moje opinie na ten temat nieco się zmieniły.

Po pierwsze, jestem silnie stronniczy przed przypisywaniem lambdawyrażenia do zmiennej; ponieważ python ma specjalną składnię tylko do tego (wskazówka, def). Oprócz tego wiele zastosowań lambdy, nawet jeśli nie ma nazwy, ma predefiniowane (i bardziej wydajne) implementacje. Na przykład przykład, o którym mowa, można skrócić do just (1).__add__, bez konieczności zawijania go w lambdalub def. Wiele innych typowych zastosowań mogą być spełnione z jakiejś kombinacji operator, itertoolsi functoolsmodułów.

• Czas obliczeń.
• Funkcja bez nazwy.
• Aby osiągnąć jedną funkcję i wiele funkcji użyj.

Biorąc pod uwagę prosty przykład,

# CREATE ONE FUNCTION AND USE IT TO PERFORM MANY OPERATIONS ON SAME TYPE OF DATA STRUCTURE.
def variousUse(a,b=lambda x:x[0]):
    return [b(i) for i in a]

dummyList = [(0,1,2,3),(4,5,6,7),(78,45,23,43)]
variousUse(dummyList)                           # extract first element
variousUse(dummyList,lambda x:[x[0],x[2],x[3]]) # extract specific indexed element
variousUse(dummyList,lambda x:x[0]+x[2])        # add specific elements
variousUse(dummyList,lambda x:x[0]*x[2])        # multiply specific elements

Jeśli zamierzasz tylko przypisać lambdę do zmiennej w zakresie lokalnym, równie dobrze możesz użyć def, ponieważ jest bardziej czytelny i można go łatwiej rozwinąć w przyszłości:

fun = lambda a, b: a ** b # a pointless use of lambda
map(fun, someList)

lub

def fun(a, b): return a ** b # more readable
map(fun, someList)

Jednym z zastosowań lambd, które znalazłem ... są komunikaty debugowania.

Ponieważ lambdy można oceniać leniwie, możesz mieć taki kod:

log.debug(lambda: "this is my message: %r" % (some_data,))

zamiast prawdopodobnie drogiego:

log.debug("this is my message: %r" % (some_data,))

który przetwarza ciąg formatu, nawet jeśli wywołanie debugowania nie generuje danych wyjściowych z powodu bieżącego poziomu rejestrowania.

Oczywiście, aby działało zgodnie z opisem, używany moduł logowania musi obsługiwać lambdy jako „parametry leniwości” (tak jak robi to mój moduł logowania).

Ten sam pomysł można zastosować w każdym innym przypadku leniwej oceny w celu tworzenia wartości na żądanie.

Na przykład ten niestandardowy operator trójskładnikowy:

def mif(condition, when_true, when_false):
    if condition:
         return when_true()
    else:
         return when_false()

mif(a < b, lambda: a + a, lambda: b + b)

zamiast:

def mif(condition, when_true, when_false):
    if condition:
         return when_true
    else:
         return when_false

mif(a < b, a + a, b + b)

z lambdami oceniane będą tylko wyrażenia wybrane przez warunek, bez lambd oba będą oceniane.

Oczywiście możesz po prostu użyć funkcji zamiast lambd, ale w przypadku krótkich wyrażeń lambdy są (c) odchudzone.

Zgadzam się z nosklo. Nawiasem mówiąc, nawet przy jednorazowym użyciu funkcji wyrzuć , przez większość czasu chcesz po prostu użyć czegoś z modułu operatora.

EG:

Masz funkcję z tym podpisem: myFunction (dane, funkcja zwrotna).

Chcesz przekazać funkcję, która dodaje 2 elementy.

Korzystanie z lambda:

myFunction(data, (lambda x, y : x + y))

Sposób pytoniczny:

import operator
myFunction(data, operator.add)

Oczywiście jest to prosty przykład, ale moduł operatora dostarcza wiele rzeczy, w tym ustawiające / pobierające elementy dla list i dict. Bardzo fajny.

Główną różnicą jest to, że nie można używać deffunkcji inline, co jest moim zdaniem najwygodniejszym przypadkiem użycia lambdafunkcji. Na przykład podczas sortowania listy obiektów:

my_list.sort(key=lambda o: o.x)

Dlatego sugerowałbym pozostawienie stosowania lambd do tego rodzaju trywialnych operacji, które również nie korzystają z automatycznej dokumentacji dostarczanej przez nazwanie funkcji.

lambda jest przydatna do generowania nowych funkcji:

>>> def somefunc(x): return lambda y: x+y
>>> f = somefunc(10)
>>> f(2)
12
>>> f(4)
14