koddla

Yazılımcıları bilgi ile güçlendirir.

Lambda – Satır içi, Anonim İşlevler

lambda anahtar sözcüğü, tek bir ifade içeren bir satır içi işlev oluşturur. Bu ifadenin değeri, işlev çağrıldığında döndürdüğü değerdir.

Aşağıdaki işlevi göz önünde bulundurun:

def greeting():
    return "Hello"

bu fonksiyon, şu şekilde çağrıldığında:

print(greeting())

Çıktı:

Hello

Olacaktır. Bu fonksiyonu, lambda fonksiyonu olarak aşağıdaki gibi yazabilirdik:

greet_me = lambda: "Hello"

lambdaların değişkenlere atanmasıyla ilgili bu bölümün altındaki nota bakmayı unutmayın. Genel olarak lambda’yı değişkenlere atamayın.

Bu kod, greet_me adı ile satır içi bir işlev oluşturur ve Hello değerini döndürür. Lambda ile işlev oluştururken return yazmadığınızı unutmayın. :‘dan sonraki değer otomatik olarak döndürülür. 

Bir değişkene atandıktan sonra, normal bir işlev gibi kullanılabilir:

print(greet_me())

baskı:

Hello

lambda argümanlar da alabilir:

strip_and_upper_case = lambda s: s.strip().upper()

strip_and_upper_case("  Hello   ")

Çıktı:

HELLO

Ayrıca, normal işlevler gibi rasgele sayıda bağımsız değişken / anahtar kelime bağımsız değişkeni de alabilirler.

greeting = lambda x, *args, **kwargs: print(x, args, kwargs)
greeting('hello', 'world', world='world')

Çıktı:

hello ('world',) {'world': 'world'}

lambda, çağrıldıkları noktada tanımlanması uygun olan kısa işlevler için yaygın olarak kullanılır (tipik olarak sorted, filter ve map ile). 

Örneğin, aşağıdaki satır, büyük/küçük harf ve başlangıçtaki ve sondaki boşlukları önemsemeden listeyi sıralar:

sorted( [" foo ", "    bAR", "BaZ    "], key=lambda s: s.strip().upper())
# Çıktı:
# ['    bAR', 'BaZ    ', ' foo ']

Listeyi yalnızca boşlukları yoksayarak sıralayalım:

sorted( [" foo ", "    bAR", "BaZ    "], key=lambda s: s.strip())
# Çıktı:
# ['BaZ    ', '    bAR', ' foo ']

Örnekler : map

sorted( map( lambda s: s.strip().upper(), [" foo ", "    bAR", "BaZ    "]))
# Çıktı:
# ['BAR', 'BAZ', 'FOO']

sorted( map( lambda s: s.strip(), [" foo ", "    bAR", "BaZ    "]))
# Çıktı:
# ['BaZ', 'bAR', 'foo']

Sayı içeren listeler içeren örnekler:

my_list = [3, -4, -2, 5, 1, 7]
sorted( my_list, key=lambda x: abs(x))
# Çıktı:
# [1, -2, 3, -4, 5, 7]

list( filter( lambda x: x>0, my_list))
# Çıktı:
# [3, 5, 1, 7]

list( map( lambda x: abs(x), my_list))
# Çıktı:
[3, 4, 2, 5, 1, 7]

Bir lambda fonksiyonunun içinden diğer fonksiyonları (bağımsız değişkenli / bağımsız değişkensiz) çağırabilirsiniz.

def foo(msg):
    print(msg)

greet = lambda x = "hello world": foo(x)
greet()

çıktı:

hello world

Bu yöntem kullanışlı olabilir, çünkü yalnızca bir ifade ve bir yan işlev kullanarak birden çok deyim çalıştırılabilir. 

NOT

PEP-8’in (resmi Python stil kılavuzu) değişkenlere lambda atamayı önermediğini unutmayın (ilk iki örnekte yaptığımızın aksine):

Bir lambda ifadesini doğrudan bir tanımlayıcıya bağlayan atama deyimi yerine her zaman def deyimi kullanın.

Yani aşağıdakine evet:

def f(x): return 2*x

Aşağıdakine hayır:

f = lambda x: 2*x

Diyoruz.

Atanan değişken ile özyinelemeli lambda

Özyinelemeli lambda fonksiyonları oluşturmak için kullanılan bir yöntem, işlevin bir değişkene atanması ve daha sonra fonksiyonun içinden bu değişkenin çağırılmasıdır. Bunun yaygın bir örneği, aşağıdaki kodda gösterildiği gibi bir sayının faktörüyelinin yinelemeli bir şekilde hesaplaması olabilir:

lambda_factorial = lambda i:1 if i==0 else i*lambda_factorial(i-1)
print(lambda_factorial(4)) # 4 * 3 * 2 * 1 = 12 * 2 = 24

Kod açıklaması 

Lambda işlevi, değişken atama sayesinde, 4 değerini alır. Bu değer incelenir ve değer 0 ise 1 değeri döndürülür. Aksi durumda ise mevcut değer (i) * değerinin lambda fonksiyonu tarafından hesaplanan diğer değeri (i-1) döndürür. Bu işlem geçilen değer 0’a (return 1) denk olana kadar devam eder. Görselleştirilen bir süreci aşağıdan görebilirsiniz:

Bir yanıt yazın

E-posta adresiniz yayınlanmayacak. Gerekli alanlar * ile işaretlenmişlerdir

Back to top