liste anlama ve lambda + filtre

Kendimi temel bir filtreleme ihtiyacına sahip buldum: Bir listem var ve öğelerin bir özelliğine göre filtrelemek zorundayım.

Kodum şöyle görünüyordu:

my_list = [x for x in my_list if x.attribute == value]

Ama sonra düşündüm, böyle yazmak daha iyi olmaz mıydı?

my_list = filter(lambda x: x.attribute == value, my_list)

Daha okunabilir ve performans için gerekirse bir şey kazanmak için lambda çıkarılabilir.

Soru: İkinci yolu kullanırken herhangi bir uyarı var mı? Performans farkı var mı? Pythonic Way ™ 'i tamamen mi kaçırıyorum ve başka bir şekilde yapmalıyım (lambda yerine itemgetter kullanmak gibi)?

Güzelliğin farklı insanlar için ne kadar değiştiği garip. Liste kavrayışını filter+ ' dan çok daha net buluyorum lambda, ancak hangisini daha kolay bulursanız kullanın.

Kullanımınızı yavaşlatabilecek iki şey vardır filter.

Birincisi, işlev çağrısı ek yüküdür: Bir Python işlevi ( defveya tarafından oluşturulmuş olsun lambda) kullandığınız anda, filtrenin liste kavrayışından daha yavaş olması muhtemeldir. Neredeyse kesinlikle önemli değildir ve kodunuzu zamanlayana ve bir darboğaz olarak bulana kadar performans hakkında fazla düşünmemelisiniz, ancak fark orada olacaktır.

Uygulanabilecek diğer ek yük, lambda'nın kapsamlı bir değişkene ( value) erişmeye zorlanmasıdır . Bu, yerel bir değişkene erişmekten daha yavaştır ve Python 2.x'te liste kavrama yalnızca yerel değişkenlere erişir. Python 3.x kullanıyorsanız, liste kavraması ayrı bir işlevde çalışır, böylece valuebir kapatma yoluyla da erişir ve bu fark geçerli olmaz.

Dikkate alınması gereken diğer seçenek, liste kavraması yerine bir jeneratör kullanmaktır:

def filterbyvalue(seq, value):
   for el in seq:
       if el.attribute==value: yield el

Daha sonra ana kodunuzda (okunabilirliğin gerçekten önemli olduğu yer) hem liste kavrayışını hem de filtreyi umarım anlamlı bir işlev adıyla değiştirdiniz.

Bu Python'da biraz dini bir konudur. Olsa Guido çıkarmadan kabul map, filterve reducePython 3'ten , sonunda sadece bir tepkisinden yeterince yoktu reduceinşa buralardan taşındı functools.reduce .

Şahsen liste kavrayışlarının okunmasını daha kolay buluyorum. [i for i in list if i.attribute == value]Tüm davranışlar filtre işlevinin içinde olmayan yüzeyde olduğundan , ifadeden neler olduğu daha açıktır .

Marjinal olduğu için iki yaklaşım arasındaki performans farkı konusunda fazla endişelenmem. Bunu sadece uygulamanızdaki darboğazın olası olmadığı kanıtlanırsa optimize ederim.

Ayrıca BDFL dilden gitmek istediğinden filter, o zaman kesinlikle liste kavrayışlarını otomatik olarak daha Pythonic ;-) yapar

Herhangi bir hız farkının minik olması gerektiğinden, filtre mi yoksa liste kavrayışı mı kullanmak bir zevk meselesi haline gelir. Genel olarak kavrayışları kullanmaya eğilimliyim (buradaki diğer cevapların çoğuna katılıyor gibi görünüyor), ancak tercih ettiğim bir durum var filter.

Çok sık kullanılan bir kullanım durumu, yüklem P (x) 'e tabi olarak tekrarlanabilir bazı X değerlerini çıkarır:

[x for x in X if P(x)]

ancak bazen önce değerlere bazı işlevler uygulamak istersiniz:

[f(x) for x in X if P(f(x))]

Belirli bir örnek olarak,

primes_cubed = [x*x*x for x in range(1000) if prime(x)]

Bence bu kullanmaktan biraz daha iyi görünüyor filter. Ama şimdi düşünün

prime_cubes = [x*x*x for x in range(1000) if prime(x*x*x)]

Bu durumda filterhesaplanan değere karşı çıkmak istiyoruz . Küpü iki kez hesaplama sorununun yanı sıra (daha pahalı bir hesaplama hayal edin), ifadeyi iki kez yazma, DRY estetiğini ihlal etme sorunu vardır . Bu durumda kullanmaya eğilimli olurum

prime_cubes = filter(prime, [x*x*x for x in range(1000)])

filter"Daha hızlı yol" olsa da, "Pythonic yolu" performans kesinlikle kritik olmadıkça (bu durumda Python kullanmazsınız!) Bu tür şeyleri umursamayacaktır.

Ben sadece python 3, filtre () aslında bir yineleyici nesne eklemek olacağını düşündüm, bu yüzden filtre yöntemi listesini oluşturmak için listeye () filtre yöntemi çağrısı geçmek zorunda kalacak. Python 2'de:

lst_a = range(25) #arbitrary list
lst_b = [num for num in lst_a if num % 2 == 0]
lst_c = filter(lambda num: num % 2 == 0, lst_a)

b ve c listeleri aynı değerlere sahiptir ve filter () ile yaklaşık aynı sürede tamamlanmıştır [z, eğer x in y için x]. Bununla birlikte, 3'te aynı kod, filtrelenmiş bir liste değil, bir filtre nesnesi içeren c listesini bırakacaktır. 3'te aynı değerleri üretmek için:

lst_a = range(25) #arbitrary list
lst_b = [num for num in lst_a if num % 2 == 0]
lst_c = list(filter(lambda num: num %2 == 0, lst_a))

Sorun şu ki, list () argümanı olarak yinelenebilir ve bu argümandan yeni bir liste oluşturur. Sonuç olarak, bu şekilde python 3'te filtre kullanılması, orijinal listenin yanı sıra filter () 'den gelen çıktıyı yinelemeniz gerektiğinden [x için x in y in x] yönteminin iki katına kadar sürebilir.

Önemli bir fark Liste kavraması dönecektir olmasıdır listfiltre getiri bir süre filterşöyle bir şey manipüle edemez list(: çağrı yani lendönüşü ile çalışmıyor üzerinde, filter).

Kendi kendi öğrenimim beni benzer bir konuya getirdi.

Bu varlık Elde var bir yolu varsa, söz konusu listbir mesafede filter, bunu yaptığında .NET yapacağını gibi biraz lst.Where(i => i.something()).ToList(), bunu bilmek merak ediyorum.

DÜZENLEME: Bu Python 3 için geçerlidir, 2 değil (yorumlardaki tartışmaya bakın).

İkinci yolu daha okunaklı buluyorum. Niyetin tam olarak ne olduğunu söyler: listeye filtre uygulayın.
Not: 'list' değişken adı olarak kullanılmaz

filteryerleşik bir işlev kullanılıyorsa genellikle biraz daha hızlıdır.

Dava listenizde anlaşmanın biraz daha hızlı olmasını beklerdim

Filtre sadece budur. Bir listenin öğelerini filtreler. Tanımda aynı ifadeleri görebilirsiniz (daha önce bahsettiğim resmi dokümanlar bağlantısında). Oysa liste kavrama, önceki listedeki bir şey üzerinde işlem yaptıktan sonra yeni bir liste üreten bir şeydir . (Hem filtre hem de liste kavrama, yeni liste oluşturur ve eski liste yerine işlem gerçekleştirmez. Buradaki yeni liste, , örneğin, tamamen yeni bir veri türü. Tam sayıları dizeye dönüştürmek gibi.)

Örneğinizde, tanıma göre filtre kavramasını liste kavramasından daha iyidir. Ancak, örneğin, liste öğelerinden other_attribute diyelim, örneğinizde yeni bir liste olarak alınacaksa, liste kavrama özelliğini kullanabilirsiniz.

return [item.other_attribute for item in my_list if item.attribute==value]

Aslında filtre ve liste kavrayışı hatırlıyorum. Bir listedeki birkaç şeyi kaldırın ve diğer öğeleri olduğu gibi koruyun, filtre kullanın. Öğelerde kendi başınıza bir mantık kullanın ve bir amaca uygun sulandırılmış bir liste oluşturun, liste kavrayışı kullanın.

İşte liste kavrayışından sonra bir şeye filtre uygulamak gerektiğinde kullandığım kısa bir parça . Sadece filtre, lambda ve listelerin bir kombinasyonu (bir kedinin sadakati ve bir köpeğin temizliği olarak bilinir).

Bu durumda bir dosyayı okuyorum, boş satırları çıkarıyorum, satırları yorumladım ve bir satıra yorum yaptıktan sonra herhangi bir şey:

# Throw out blank lines and comments
with open('file.txt', 'r') as lines:        
    # From the inside out:
    #    [s.partition('#')[0].strip() for s in lines]... Throws out comments
    #   filter(lambda x: x!= '', [s.part... Filters out blank lines
    #  y for y in filter... Converts filter object to list
    file_contents = [y for y in filter(lambda x: x != '', [s.partition('#')[0].strip() for s in lines])]

Kabul edilen cevaba ek olarak, liste kavramak yerine filtre kullanmanız gereken bir köşe vakası vardır. Liste paylaşılamıyorsa, doğrudan liste kavrayışı ile işleyemezsiniz. Gerçek bir dünya örneği, pyodbcbir veritabanındaki sonuçları okumak için kullanmanızdır . fetchAll()Elde edilen sonuçlar cursorbir unhashable listesidir. Bu durumda, döndürülen sonuçlara doğrudan müdahale etmek için filtre kullanılmalıdır:

cursor.execute("SELECT * FROM TABLE1;")
data_from_db = cursor.fetchall()
processed_data = filter(lambda s: 'abc' in s.field1 or s.StartTime >= start_date_time, data_from_db) 

Burada liste kavrama kullanırsanız hatayı alırsınız:

TypeError: shahableble type: 'list'

Bana alışmak için biraz zaman aldı higher order functions filterve map. Bu yüzden onlara alıştım ve gerçekten filterdoğru olanı koruyarak filtrelediği açıktı ve bazı functional programmingterimleri bildiğimi hissettim .

Sonra bu pasajı (Akıcı Python Kitabı) okudum:

Harita ve filtre işlevleri hala Python 3'te yerleşiktir, ancak liste kavrayışları ve jeneratör açıklamaları sunulduğundan bu kadar önemli değildir. Listcomp veya genexp, harita ve filtre işlerini bir araya getirir, ancak daha okunabilirdir.

Ve şimdi düşünüyorum, neden filter/ kavram mapanlama gibi zaten yayılmış deyimlerle başarabilirseniz / kavramı ile uğraşabilirsiniz. Ayrıca mapsve filterstür fonksiyonları vardır. Bu durumda Anonymous functionslambda kullanmayı tercih ederim .

Son olarak, sadece test etmek uğruna, her iki yöntemi de ( mapve listComp) zamanladım ve bununla ilgili tartışmalar yapmayı haklı çıkaracak herhangi bir ilgili hız farkı görmedim.

from timeit import Timer

timeMap = Timer(lambda: list(map(lambda x: x*x, range(10**7))))
print(timeMap.timeit(number=100))

timeListComp = Timer(lambda:[(lambda x: x*x) for x in range(10**7)])
print(timeListComp.timeit(number=100))

#Map:                 166.95695265199174
#List Comprehension   177.97208347299602

Merakla Python 3'te, filtrenin liste kavrayışlarından daha hızlı performans gösterdiğini görüyorum.

Her zaman liste kavrayışının daha verimli olacağını düşündüm. Şuna benzer bir şey: [ad None değilse brand_names_db dosyasındaki ad] Oluşturulan bayt kodu biraz daha iyi.

>>> def f1(seq):
...     return list(filter(None, seq))
>>> def f2(seq):
...     return [i for i in seq if i is not None]
>>> disassemble(f1.__code__)
2         0 LOAD_GLOBAL              0 (list)
          2 LOAD_GLOBAL              1 (filter)
          4 LOAD_CONST               0 (None)
          6 LOAD_FAST                0 (seq)
          8 CALL_FUNCTION            2
         10 CALL_FUNCTION            1
         12 RETURN_VALUE
>>> disassemble(f2.__code__)
2           0 LOAD_CONST               1 (<code object <listcomp> at 0x10cfcaa50, file "<stdin>", line 2>)
          2 LOAD_CONST               2 ('f2.<locals>.<listcomp>')
          4 MAKE_FUNCTION            0
          6 LOAD_FAST                0 (seq)
          8 GET_ITER
         10 CALL_FUNCTION            1
         12 RETURN_VALUE

Ama aslında daha yavaşlar:

   >>> timeit(stmt="f1(range(1000))", setup="from __main__ import f1,f2")
   21.177661532000116
   >>> timeit(stmt="f2(range(1000))", setup="from __main__ import f1,f2")
   42.233950221000214

Benim almam

def filter_list(list, key, value, limit=None):
    return [i for i in list if i[key] == value][:limit]