Arkasındaki sözdizimi sıralanır (anahtar = lambda:…)

sorted()Argümanın ardındaki sözdizimini tam olarak anlamıyorum :

key=lambda variable: variable[0]

lambdaKeyfi değil mi? Neden variablea'ya benzeyen iki kez ifade edilir dict?

key, koleksiyon öğelerini karşılaştırılmadan önce dönüştürmek için çağrılacak bir işlevdir. Geçirilen parametre keyçağrılabilir bir şey olmalıdır.

Kullanımı lambda(çağrılabilir olan) anonim bir işlevi oluşturur. sortedÇağrılabilir durumda sadece bir parametre alır. Python's lambdaoldukça basit. Gerçekten sadece bir şeyi yapabilir ve geri verebilir.

Sözdizimi lambda, sözcüğün lambdaardından parametre adları listesinin ardından tek bir kod bloğudur. Parametre listesi ve kod bloğu iki nokta üst üste ile gösterilir. Bu aynı zamanda gibi piton diğer yapılara benzer while, for, ifvb. Hepsi tipik olarak bir kod bloğu olan ifadelerdir. Lambda, kod bloğu olan bir ifadenin başka bir örneğidir.

Bir fonksiyon oluşturmak için lambda kullanımını def ile karşılaştırabiliriz.

adder_lambda = lambda parameter1,parameter2: parameter1+parameter2
def adder_regular(parameter1, parameter2): return parameter1+parameter2

lambda bize bir isim vermeden bunu yapmanın bir yolunu sunuyor. Bu, bir işleve parametre olarak kullanılmasını harika kılar.

variable Burada iki kez kullanılır, çünkü kolonun sol tarafında bir parametrenin adı ve sağ tarafta kod bloğunda bir şey hesaplamak için kullanılır.

Buradaki tüm cevapların lambda fonksiyonunun sorted () bağlamında ne yaptığını çektiğini düşünüyorum, ancak yine de sezgisel bir anlayışa yol açmayan bir açıklama gibi hissediyorum, bu yüzden iki sentim.

Tamlık uğruna, ön tarafı açık olarak belirteceğim: sort (), sıralanmış öğelerin bir listesini döndürür ve belirli bir şekilde sıralamak istiyorsak veya karmaşık bir öğe listesini (örneğin iç içe listeler veya tuples listesi) anahtar argümanı çağırabiliriz.

Benim için, kilit argümanın sezgisel anlayışı, neden çağrılabilir olması gerektiği ve lambda'nın bunu gerçekleştirmek için (anonim) çağrılabilir fonksiyon olarak kullanılması iki bölümden oluşmaktadır.

1. Sonunda lamba kullanmak, bir sblom örneğinin sağladığı gibi tüm bir işlevi yazmak (tanımlamak) zorunda olmadığınız anlamına gelir . Lambda fonksiyonları yaratılır, kullanılır ve hemen imha edilir; böylece kodunuzu yalnızca bir kez kullanılacak daha fazla kodla donatmazlar. Bu, anladığım kadarıyla, lambda fonksiyonunun temel faydasıdır ve bu tür roller için uygulamaları geniştir. Sözdizimi tamamen, genel olarak programatik sözdiziminin doğası olan sözleşmedir. Sözdizimini öğrenin ve onunla bitirin.

Lambda sözdizimi aşağıdaki gibidir:

lambda input_variable (s) : lezzetli bir astar

Örneğin

In [1]: f00 = lambda x: x/2

In [2]: f00(10)
Out[2]: 5.0

In [3]: (lambda x: x/2)(10)
Out[3]: 5.0

In [4]: (lambda x, y: x / y)(10, 2)
Out[4]: 5.0

In [5]: (lambda: 'amazing lambda')() # func with no args!
Out[5]: 'amazing lambda'

2. keyArgümanın arkasındaki fikir , sıralamak için kullanılması gereken liste öğelerinde 'sort ()' işlevini gösterecek bir dizi talimat alması gerektiğidir. Dediğinde key=, gerçekten ne anlama geliyor: Listede her seferinde bir öğe yinelediğimde (yani listedeki e için), geçerli öğeyi anahtar argümanında sağladığım işleve geçireceğim ve bunu kullanacağım son sıralı listenin sırası hakkında beni bilgilendirecek dönüştürülmüş bir liste oluşturmak için.

Bunu kontrol et:

mylist = [3,6,3,2,4,8,23]
sorted(mylist, key=WhatToSortBy)

Temel örnek:

sorted(mylist)

[2, 3, 3, 4, 6, 8, 23] # Tüm sayılar küçükten büyüğe doğru sıradadır.

Örnek 1:

mylist = [3,6,3,2,4,8,23]
sorted(mylist, key=lambda x: x%2==0)

[3, 3, 23, 6, 2, 4, 8] # Bu sıralama sonucu size sezgisel bir anlam katıyor mu?

Lambda fonksiyonumun (e) 'nin sıralamadan önce çift mi yoksa tek mi olduğunu kontrol etmek için sıralandığını söylediğine dikkat edin.

FAKAT BEKLE! İki şeyi merak ediyor olabilirsiniz (ya da belki de düşünmelisiniz) - ilk olarak, oranlar neden evladımdan önce geliyor (çünkü anahtar değerim, mod operatörünü kullanarak evens'e öncelik vermesini sıraladığım fonksiyona söylüyor gibi görünüyor x%2==0). İkincisi, evladım neden düzensiz? 2 6'dan önce geliyor değil mi? Bu sonucu analiz ederek, özellikle anonim lambda işleviyle birlikte, sort () 'key' argümanının nasıl çalıştığı hakkında daha derin bir şey öğreneceğiz.

Birincisi, oranların eşitlerden önce gelmesine rağmen, eşitlerin kendilerinin sıralanmadığını fark edeceksiniz. Bu neden?? Dokümanları okuyalım :

Temel İşlevler Python 2.4 ile başlayarak, list.sort () ve sorted (), karşılaştırmalar yapmadan önce her liste öğesinde çağrılacak bir işlevi belirtmek için bir anahtar parametresi ekledi.

Buradaki satırlar arasında biraz okuma yapmak zorundayız, ancak bunun bize söylediği şey, sıralama işlevinin yalnızca bir kez çağrılmasıdır ve anahtar argümanını belirtirsek, anahtar işlevin bizi işaret ettiği değere göre sıralarız.

Peki, bir modulo kullanan örnek ne döndürüyor? Bir boole değeri: True == 1, False == 0. Peki sıralama bu anahtarla nasıl başa çıkıyor? Temel olarak orijinal listeyi 1s ve 0s dizisine dönüştürür.

[3,6,3,2,4,8,23] [0,1,0,1,1,1,0] olur

Şimdi bir yere gidiyoruz. Dönüştürülmüş listeyi sıraladığınızda ne elde edersiniz?

[0,0,0,1,1,1,1]

Tamam, şimdi oranların neden evlenmeden önce geldiğini biliyoruz. Ama bir sonraki soru şu: Niye hala son listemdeki 2'den önce geliyor? Bu kolay - çünkü sıralama sadece bir kez olur! yani bu 1'ler hala birbirlerine göre orijinal konumlarında olan orijinal liste değerlerini temsil eder. Sıralama yalnızca bir kez gerçekleştiğinden ve orijinal çift değerlerini düşükten yükseğe doğru sıralamak için herhangi bir sıralama işlevi çağırdığımızdan, bu değerler birbirine göre orijinal sıralarında kalır.

Son soru şudur: Nihai sıralı listeyi yazdırdığımda, boole değerlerimin sırasının nasıl orijinal değerlere geri dönüştüğü hakkında kavramsal olarak nasıl düşünürüm?

Sorted (), (eğlenceli gerçek) Timsort adlı karma sıralama algoritmasını kullanan yerleşik bir yöntemdirbirleştirme sıralaması ve ekleme sıralaması özelliklerini birleştirir. Bana öyle diyor ki, bu değerleri hafızada tutan ve onları lambda fonksiyonu tarafından belirlenen (...!) Boole kimlikleriyle (maske) bir araya getiren bir tamirci var. Sıra, lambda işlevinden hesaplanan boole kimliklerine göre belirlenir, ancak bu alt listelerin (birinin ve sıfırların) kendilerinin orijinal değerlerine göre sıralanmadığını unutmayın. Bu nedenle, son liste, Odds ve Evens tarafından organize edilirken, alt listeye göre sıralanmaz (bu durumda evenler sıra dışıdır). Oranların sıralı olması, orijinal listedeki tesadüfen zaten sırada olmalarıdır. Tüm bunlardan elde edilen paket, lambda bu dönüşümü gerçekleştirdiğinde, alt listelerin orijinal düzeninin korunmasıdır.

Öyleyse, bunların hepsi orijinal soru ile nasıl ilişkilidir ve daha da önemlisi, anahtar argümanı ve lambda ile sort () yöntemini nasıl uygulamamız gerektiği konusundaki sezgimiz?

Bu lambda işlevi, sıralamak zorunda olduğumuz değerlere işaret eden bir işaretçi, lambda işlevi tarafından dönüştürülen boole ile bir değeri eşleştiren bir işaretçi ya da iç içe bir listede belirli bir öğe olup olmadığını, dikte vb. yine lambda fonksiyonu tarafından belirlenir.

Denemek ve aşağıdaki kodu çalıştırdığınızda ne olacağını tahmin sağlar.

mylist = [(3, 5, 8), (6, 2, 8), ( 2, 9, 4), (6, 8, 5)]
sorted(mylist, key=lambda x: x[1])

Benim sortedçağrı besbelli "bu listeyi sıralamak Lütfen" diyor. Temel argüman yapar mylist her elemanın (x), dönüş göstergesi diyerek biraz daha belirgin 1 ile hesaplanan listenin sıralı emriyle sıralama tüm orijinal liste 'mylist' unsurlarının sonra, o elementin lambda işlevi. Bir tuples listemiz olduğundan, bu tupledan indekslenmiş bir eleman döndürebiliriz. Yani şunu elde ederiz:

[(6, 2, 8), (3, 5, 8), (6, 8, 5), (2, 9, 4)]

Bu kodu çalıştırın ve bunun sipariş olduğunu göreceksiniz. Bir tamsayı listesini dizine eklemeyi deneyin; kodun bozulduğunu göreceksiniz.

Bu uzun soluklu bir açıklama, ama umarım bu lambda fonksiyonlarının sıralı () ve ötesindeki temel argüman olarak kullanımı ile ilgili sezginizi 'sıralamanıza' yardımcı olur.

lambdaanonim işlevler oluşturmak için kullanılan bir Python anahtar kelimesidir .

>>> (lambda x: x+2)(3)
5

Öğesinin variablesolunda :bir parametre adı bulunur. Kullanımıvariable sağda parametrenin kullanımı yapıyor.

Neredeyse tamamen aynı anlama gelir:

def some_method(variable):
  return variable[0]

Key = lambda ile sıralanan () işlev kullanımına bir örnek daha . Bir grup listeniz olduğunu düşünelim. Her grupta bir marka, model ve ağırlık var ve bu grup listesini marka, model veya ağırlığa göre sıralamak istiyorsunuz. Bunu lambda ile yapabilirsiniz.

cars = [('citroen', 'xsara', 1100), ('lincoln', 'navigator', 2000), ('bmw', 'x5', 1700)]

print(sorted(cars, key=lambda car: car[0]))
print(sorted(cars, key=lambda car: car[1]))
print(sorted(cars, key=lambda car: car[2]))

Sonuçlar:

[('bmw', 'x5', '1700'), ('citroen', 'xsara', 1100), ('lincoln', 'navigator', 2000)]
[('lincoln', 'navigator', 2000), ('bmw', 'x5', '1700'), ('citroen', 'xsara', 1100)]
[('citroen', 'xsara', 1100), ('bmw', 'x5', 1700), ('lincoln', 'navigator', 2000)]

lambdaisimsiz bir işlevdir, rastgele bir işlev değildir. Kabul edilen parametre, üzerinde çalıştığınız değişken ve onu sıraladığınız sütun olacaktır.

Lambda kullanımı bağlamında istendiğinden, buna da sorted()bir göz atın https://wiki.python.org/moin/HowTo/Sorting/#Key_Functions

Sadece yeniden ifade etmek için, anahtar (İsteğe bağlı. Sıraya karar vermek için yürütülecek bir işlev. Varsayılan Hiçbiri'dir) sıralanmış işlevlerde bir işlev bekler ve lambda kullanırsınız.

Lambda'yı tanımlamak için, sıralamak istediğiniz nesne özelliğini belirtirsiniz ve python'un yerleşik sıralanmış işlevi otomatik olarak onunla ilgilenir.

Birden çok özelliğe göre sıralamak istiyorsanız, key = lambda x: (özellik1, özellik2) atayın.

Sıralamayı belirtmek için, üçüncü bağımsız değişken olarak reverse = true değerini iletin (İsteğe bağlı. Bir Boolean. False artan olarak sıralar, True azalan olarak sıralar. Varsayılan, False'dir) sıralama işlevi.

Sorulan soruyla ilgili bir örnekle basit ve zaman alıcı olmayan bir cevap Bu örneği izleyin:

 user = [{"name": "Dough", "age": 55}, 
            {"name": "Ben", "age": 44}, 
            {"name": "Citrus", "age": 33},
            {"name": "Abdullah", "age":22},
            ]
    print(sorted(user, key=lambda el: el["name"]))
    print(sorted(user, key= lambda y: y["age"]))

Listedeki isimlere bakın, D, B, C ve A ile başlıyorlar. Ve yaşları fark ederseniz, 55, 44, 33 ve 22'dir. İlk baskı kodu

print(sorted(user, key=lambda el: el["name"]))

Sonuçlar:

[{'name': 'Abdullah', 'age': 22}, 
{'name': 'Ben', 'age': 44}, 
{'name': 'Citrus', 'age': 33}, 
{'name': 'Dough', 'age': 55}]

ismi sıralar, çünkü key = lambda el: el ["name"] ile isimleri ve isimleri alfabetik sıraya göre sıralarız.

İkinci baskı kodu

print(sorted(user, key= lambda y: y["age"]))

Sonuç:

[{'name': 'Abdullah', 'age': 22},
 {'name': 'Citrus', 'age': 33},
 {'name': 'Ben', 'age': 44}, 
 {'name': 'Dough', 'age': 55}]

yaşa göre sıralar ve böylece liste artan yaş sırasına göre geri döner.

Daha iyi anlamak için bu kodu deneyin.