Pythonic sadece yan etkiler için liste anlamalarını kullanmak mı?

Yan etkileri için çağırdığım bir işlevi düşünün, değerleri döndürmeyin (ekrana yazdırma, GUI'yi güncelleme, bir dosyaya yazdırma vb.).

def fun_with_side_effects(x):
    ...side effects...
    return y

Şimdi, bu işlevi çağırmak için liste anlamalarını kullanmak Pythonic mi?

[fun_with_side_effects(x) for x in y if (...conditions...)]

Listeyi hiçbir yere kaydetmediğimi unutmayın

Yoksa bu func şöyle mi demeliyim:

for x in y:
    if (...conditions...):
        fun_with_side_effects(x)

Hangisi daha iyi ve neden?

Bunu yapmak çok anti-Pythonic ve tecrübeli herhangi bir Pythonista sizi cehenneme çevirecektir. Ara liste, oluşturulduktan sonra atılır ve potansiyel olarak çok, çok büyük ve bu nedenle oluşturulması pahalı olabilir.

Bir liste anlama kullanmamalısınız , çünkü insanların söylediği gibi, ihtiyacınız olmayan büyük bir geçici liste oluşturacaktır. Aşağıdaki iki yöntem eşdeğerdir:

consume(side_effects(x) for x in xs)

for x in xs:
    side_effects(x)

tanımından consumegelen itertoolsadam sayfası:

def consume(iterator, n=None):
    "Advance the iterator n-steps ahead. If n is none, consume entirely."
    # Use functions that consume iterators at C speed.
    if n is None:
        # feed the entire iterator into a zero-length deque
        collections.deque(iterator, maxlen=0)
    else:
        # advance to the empty slice starting at position n
        next(islice(iterator, n, n), None)

Tabii ki, ikincisi daha net ve anlaşılması daha kolay.

Liste anlayışları, listeler oluşturmak içindir. Aslında bir listesini oluşturarak sürece, sen gerektiğini değil Liste comprehensions kullanın.

Bu yüzden ikinci seçeneği elde ettim, sadece listeyi yineleyerek ve ardından koşullar uygulandığında işlevi çağırırdım.

İkincisi daha iyi.

Kodunuzu anlaması gereken kişiyi düşünün. İlkinde kolayca kötü karmaya kavuşabilirsiniz :)

Filter () kullanarak ikisinin ortasına gidebilirsiniz. Örneği düşünün:

y=[1,2,3,4,5,6]
def func(x):
    print "call with %r"%x

for x in filter(lambda x: x>3, y):
    func(x)

Hedefinize bağlıdır.

Listedeki her nesne üzerinde bir işlem yapmaya çalışıyorsanız, ikinci yaklaşım benimsenmelidir.

Başka bir listeden bir liste oluşturmaya çalışıyorsanız, liste anlamayı kullanabilirsiniz.

Açık, örtük olmaktan daha iyidir. Basit, karmaşıktan daha iyidir. (Python Zen)

Yapabilirsin

for z in (fun_with_side_effects(x) for x in y if (...conditions...)): pass

ama çok hoş değil.

Yan etkileri için bir liste anlayışı kullanmak çirkin, Pythonic değildir, verimsizdir ve bunu yapmam. Bunun foryerine bir döngü kullanırdım, çünkü bir fordöngü yan etkilerin önemli olduğu prosedürel bir tarzı işaret eder.

Ancak, yan etkileri için bir liste anlamayı kullanmakta kesinlikle ısrar ediyorsanız, bunun yerine bir üreteç ifadesi kullanarak verimsizlikten kaçınmalısınız. Bu stilde kesinlikle ısrar ediyorsanız, şu ikisinden birini yapın:

any(fun_with_side_effects(x) and False for x in y if (...conditions...))

veya:

all(fun_with_side_effects(x) or True for x in y if (...conditions...))

Bunlar üretici ifadeleridir ve fırlatılıp atılan rastgele bir liste oluşturmazlar. Benceall form biraz daha net, ancak ikisinin de kafa karıştırıcı olduğunu ve kullanılmaması gerektiğini düşünüyorum.

Bunun çirkin olduğunu düşünüyorum ve bunu kodla yapmam. Ancak döngülerinizi bu şekilde uygulamakta ısrar ediyorsanız, ben böyle yapardım.

Liste anlayışlarının ve benzerlerinin, en azından hafif bir şekilde işlevsel bir stile benzeyen bir şeyi kullanma girişimine işaret etmesi gerektiğini hissediyorum. Bu varsayımı bozan yan etkileri olan şeyler koymak, insanların kodunuzu daha dikkatli okumasına neden olur ve bence bu kötü bir şey.