“İf x: return x” ifadelerinden kaçınmanın pitonik yolu

Belirli koşulları kontrol etmek için sırayla 4 diğer yöntemleri çağıran bir yöntem var ve bir Truthy bir şey döndüğünde hemen (aşağıdakileri kontrol değil) döner.

def check_all_conditions():
    x = check_size()
    if x:
        return x

    x = check_color()
    if x:
        return x

    x = check_tone()
    if x:
        return x

    x = check_flavor()
    if x:
        return x
    return None

Bu çok fazla bagaj kodu gibi görünüyor. Her 2 satırlık if ifadesi yerine, şöyle bir şey yapmayı tercih ederim:

x and return x

Ama bu geçersiz Python. Burada basit ve zarif bir çözümü özlüyor muyum? Bu arada, bu durumda, bu dört kontrol yöntemi pahalı olabilir, bu yüzden onları birden çok kez aramak istemiyorum.

Bir döngü kullanabilirsiniz:

conditions = (check_size, check_color, check_tone, check_flavor)
for condition in conditions:
    result = condition()
    if result:
        return result

Bu, artık koşul sayısını değişken yapabileceğiniz ek bir avantaja sahiptir.

Sen kullanabilirsiniz map()+ filter()(kullanın Python 3 sürümleri future_builtinssürümleri tür ilk eşleşen değeri elde etmek Python 2'de):

try:
    # Python 2
    from future_builtins import map, filter
except ImportError:
    # Python 3
    pass

conditions = (check_size, check_color, check_tone, check_flavor)
return next(filter(None, map(lambda f: f(), conditions)), None)

ancak bu daha okunaklıysa tartışmalıdır.

Başka bir seçenek de bir jeneratör ifadesi kullanmaktır:

conditions = (check_size, check_color, check_tone, check_flavor)
checks = (condition() for condition in conditions)
return next((check for check in checks if check), None)

Martijn'ın iyi cevabına alternatif olarak, zincirleyebilirsiniz or. Bu, ilk doğruluk değerini döndürür veya doğruluk değeri Noneyoksa:

def check_all_conditions():
    return check_size() or check_color() or check_tone() or check_flavor() or None

Demo:

>>> x = [] or 0 or {} or -1 or None
>>> x
-1
>>> x = [] or 0 or {} or '' or None
>>> x is None
True

Değiştirme

Diğer çeşitli cevapların gösterdiği gibi bunu yapmanın başka yolları da vardır. Hiçbiri orijinal kodunuz kadar net değil.

Timgeb ile aynı cevapta, ancak daha güzel biçimlendirme için parantez kullanabilirsiniz:

def check_all_the_things():
    return (
        one()
        or two()
        or five()
        or three()
        or None
    )

Göre Kıvırcık hukuk , sen bölünme iki endişeleri tarafından bu kod daha okunabilir yapabilirsiniz:

• Neleri kontrol ederim?
• Bir şey doğru mu döndü?

iki fonksiyona ayrılır:

def all_conditions():
    yield check_size()
    yield check_color()
    yield check_tone()
    yield check_flavor()

def check_all_conditions():
    for condition in all_conditions():
        if condition:
            return condition
    return None

Bu önler:

• karmaşık mantıksal yapılar
• gerçekten uzun çizgiler
• tekrarlama

... doğrusal, okunması kolay bir akışı korurken.

Ayrıca, özel durumunuza göre, daha da okunabilir hale getiren daha iyi işlev adları da bulabilirsiniz.

Bu, Martijns'in ilk örneğinin bir çeşididir. Ayrıca, kısa devreye izin vermek için "callables koleksiyonu" stilini kullanır.

Bir döngü yerine yerleşik'i kullanabilirsiniz any.

conditions = (check_size, check_color, check_tone, check_flavor)
return any(condition() for condition in conditions) 

anyBir boole döndürdüğünü unutmayın , bu nedenle çekin tam dönüş değerine ihtiyacınız varsa bu çözüm çalışmaz. anybirbirinden ayırt edemez 14, 'red', 'sharp', 'spicy'dönüş değeri olarak, hepsi olarak iade edilecektir True.

Sadece yazmayı düşündün mü if x: return xHepsini tek bir satıra ?

def check_all_conditions():
    x = check_size()
    if x: return x

    x = check_color()
    if x: return x

    x = check_tone()
    if x: return x

    x = check_flavor()
    if x: return x

    return None

Bu, sahip olduklarınızdan daha az tekrarlayıcı değil , ancak IMNSHO biraz daha düzgün okuyor.

Kimse anybu amaçla yapılmış yerleşikten bahsetmediğim için oldukça şaşırdım :

def check_all_conditions():
    return any([
        check_size(),
        check_color(),
        check_tone(),
        check_flavor()
    ])

Bu uygulama muhtemelen en açık olmasına rağmen, birincisi olsa bile tüm kontrolleri değerlendirdiğini unutmayın True.

İlk başarısız denetimde gerçekten durmanız gerekiyorsa, reducebir listeyi basit bir değere dönüştürmek için hangisinin kullanıldığını düşünün :

def check_all_conditions():
    checks = [check_size, check_color, check_tone, check_flavor]
    return reduce(lambda a, f: a or f(), checks, False)

reduce(function, iterable[, initializer]): Yinelenebilir öğeyi tek bir değere azaltmak için soldan sağa, yinelenebilir öğelere toplu olarak iki argümanın işlevini uygulayın. Sol argüman, x, biriken değer ve sağ argüman, y, yinelenebilir öğenin güncelleme değeridir. İsteğe bağlı başlatıcı varsa, hesaplamada yinelenebilir öğelerin önüne yerleştirilir

Senin durumunda:

• lambda a, f: a or f()kontrol akümülatör ya o fonksiyonu aveya geçerli kontrol f()olduğu True. Eğer unutmayın aolduğunu True, f()değerlendirmeye alınmayacaktır.
• checksçek fonksiyonları içerir ( flambdadan alınan öğe)
• False başlangıç ​​değeridir, aksi takdirde kontrol olmaz ve sonuç her zaman olur True

anyve reducefonksiyonel programlama için temel araçlardır. Bunların yanı sıra mapharika olanı da eğitmenizi şiddetle tavsiye ediyorum !

Aynı kod yapısını istiyorsanız üçlü ifadeler kullanabilirsiniz!

def check_all_conditions():
    x = check_size()
    x = x if x else check_color()
    x = x if x else check_tone()
    x = x if x else check_flavor()

    return x if x else None

Bence bu güzel ve net görünüyor.

Demo:

Benim için en iyi cevap @ phil-frost, ardından @ wayne-werner'dan geliyor.

İlginç bulduğum şey, hiç kimsenin bir işlevin birçok farklı veri türünü döndüreceği gerçeği hakkında bir şey söylemedi, bu da daha sonra başka bir iş yapmak için x'in kendisinin türünü kontrol etmeyi zorunlu hale getirecektir.

Bu yüzden @ PhilFrost'un yanıtını tek bir tür tutma fikriyle karıştırırdım:

def all_conditions(x):
    yield check_size(x)
    yield check_color(x)
    yield check_tone(x)
    yield check_flavor(x)

def assessed_x(x,func=all_conditions):
    for condition in func(x):
        if condition:
            return x
    return None

Bağımsız xdeğişken olarak iletildiğine dikkat edin , aynı zamanda all_conditionshepsinin bir denetleneceği kontrol işlevlerinin geçirilmiş bir jeneratörü olarak kullanılır xve Trueveya döndürür False. Kullanarak funcile all_conditionsvarsayılan değer olarak kullanabileceğinizassessed_x(x) veya üzeri bir başka kişiye jeneratör geçebilirfunc .

Bu şekilde, xbir kontrol geçer geçmez alırsınız , ancak her zaman aynı tür olacaktır.

İdeal olarak, ben yeniden yazmak istiyorum check_ getiri fonksiyonlarını Trueveya Falseyerine bir değerden. Çekleriniz daha sonra

if check_size(x):
    return x
#etc

xDeğişmez olduğunuzu varsayarsak , işleviniz yine de değiştirebilir (yeniden atayamasalar da) - ancak adı verilen bir işlev checkzaten gerçekten değiştirmemelidir.

Yukarıdaki Martijns ilk örneğinde, döngü içinde olup olmadığını önleyen küçük bir varyasyon:

Status = None
for c in [check_size, check_color, check_tone, check_flavor]:
  Status = Status or c();
return Status

@ Timgeb'in hoşuma gitti. Bu arada ben ifade olduğunu eklemek istiyorum Noneiçinde returnifadenin koleksiyonu olarak gerekli değildir orayrılmış ifadelerden değerlendirilir ve ilk hiçbiri sıfır, hiçbiri boş, hiçbiri-Yok döndürülür ve daha sonra hiç yok ise Nonedöndürülür olup olmadığıNone olmadığı!

Yani benim check_all_conditions()fonksiyonum şöyle görünüyor:

def check_all_conditions():
    return check_size() or check_color() or check_tone() or check_flavor()

Kullanımı timeitile number=10**7I önerileri bir dizi çalışma süresi baktı. Karşılaştırma uğruna sadece random.random()bir dize döndürmek veya Nonerastgele sayılara dayalı işlevi kullandım . İşte tüm kod:

import random
import timeit

def check_size():
    if random.random() < 0.25: return "BIG"

def check_color():
    if random.random() < 0.25: return "RED"

def check_tone():
    if random.random() < 0.25: return "SOFT"

def check_flavor():
    if random.random() < 0.25: return "SWEET"

def check_all_conditions_Bernard():
    x = check_size()
    if x:
        return x

    x = check_color()
    if x:
        return x

    x = check_tone()
    if x:
        return x

    x = check_flavor()
    if x:
        return x
    return None

def check_all_Martijn_Pieters():
    conditions = (check_size, check_color, check_tone, check_flavor)
    for condition in conditions:
        result = condition()
        if result:
            return result

def check_all_conditions_timgeb():
    return check_size() or check_color() or check_tone() or check_flavor() or None

def check_all_conditions_Reza():
    return check_size() or check_color() or check_tone() or check_flavor()

def check_all_conditions_Phinet():
    x = check_size()
    x = x if x else check_color()
    x = x if x else check_tone()
    x = x if x else check_flavor()

    return x if x else None

def all_conditions():
    yield check_size()
    yield check_color()
    yield check_tone()
    yield check_flavor()

def check_all_conditions_Phil_Frost():
    for condition in all_conditions():
        if condition:
            return condition

def main():
    num = 10000000
    random.seed(20)
    print("Bernard:", timeit.timeit('check_all_conditions_Bernard()', 'from __main__ import check_all_conditions_Bernard', number=num))
    random.seed(20)
    print("Martijn Pieters:", timeit.timeit('check_all_Martijn_Pieters()', 'from __main__ import check_all_Martijn_Pieters', number=num))
    random.seed(20)
    print("timgeb:", timeit.timeit('check_all_conditions_timgeb()', 'from __main__ import check_all_conditions_timgeb', number=num))
    random.seed(20)
    print("Reza:", timeit.timeit('check_all_conditions_Reza()', 'from __main__ import check_all_conditions_Reza', number=num))
    random.seed(20)
    print("Phinet:", timeit.timeit('check_all_conditions_Phinet()', 'from __main__ import check_all_conditions_Phinet', number=num))
    random.seed(20)
    print("Phil Frost:", timeit.timeit('check_all_conditions_Phil_Frost()', 'from __main__ import check_all_conditions_Phil_Frost', number=num))

if __name__ == '__main__':
    main()

İşte sonuçlar:

Bernard: 7.398444877040768
Martijn Pieters: 8.506569201346597
timgeb: 7.244275416364456
Reza: 6.982133448743038
Phinet: 7.925932800076634
Phil Frost: 11.924794811353031

Bu şekilde kutunun dışında biraz, ama sonuç basit, okunabilir ve güzel görünüyor düşünüyorum.

Temel fikir, raiseişlevlerden biri doğruluk olarak değerlendirildiğinde ve sonucu döndürdüğünde bir istisnadır. İşte böyle görünebilir:

def check_conditions():
    try:
        assertFalsey(
            check_size,
            check_color,
            check_tone,
            check_flavor)
    except TruthyException as e:
        return e.trigger
    else:
        return None

assertFalseyAranan işlev bağımsız değişkenlerinden biri doğruluk olarak değerlendirildiğinde bir özel durum oluşturan bir işleve ihtiyacınız olacaktır:

def assertFalsey(*funcs):
    for f in funcs:
        o = f()
        if o:
            raise TruthyException(o)

Yukarıdakiler, değerlendirilecek fonksiyonlar için argümanlar sağlayacak şekilde değiştirilebilir.

Ve tabii ki TruthyExceptionkendine ihtiyacınız olacak . Bu istisna object, istisnayı tetikleyen şeyi sağlar :

class TruthyException(Exception):
    def __init__(self, obj, *args):
        super().__init__(*args)
        self.trigger = obj

Orijinal işlevi daha genel bir şeye dönüştürebilirsiniz, elbette:

def get_truthy_condition(*conditions):
    try:
        assertFalsey(*conditions)
    except TruthyException as e:
        return e.trigger
    else:
        return None

result = get_truthy_condition(check_size, check_color, check_tone, check_flavor)

Bu biraz daha yavaş olabilir çünkü her ikisini de if ifade bir istisna . Ancak, istisna yalnızca en fazla bir kez ele alındığından, kontrolü çalıştırmayı ve Truebinlerce kez bir değer almayı beklemediğiniz sürece performans isabeti küçük olmalıdır .

Pitonik yol, azaltma (daha önce bahsedildiği gibi) veya itertools (aşağıda gösterildiği gibi) kullanmaktır, ancak bana göre, oroperatörün kısa devresini kullanmanın daha net kod ürettiği görülmektedir.

from itertools import imap, dropwhile

def check_all_conditions():
    conditions = (check_size,\
        check_color,\
        check_tone,\
        check_flavor)
    results_gen = dropwhile(lambda x:not x, imap(lambda check:check(), conditions))
    try:
        return results_gen.next()
    except StopIteration:
        return None

Buraya atlayacağım ve asla tek bir Python satırı yazmadım ama if x = check_something(): return x geçerli ?

Öyleyse:

def check_all_conditions():

    if (x := check_size()): return x
    if (x := check_color()): return x
    if (x := check_tone()): return x
    if (x := check_flavor()): return x

    return None

Veya şunu kullanın max:

def check_all_conditions():
    return max(check_size(), check_color(), check_tone(), check_flavor()) or None

Geçmişte beni bu cevaba götüren dikte ile anahtar / vaka ifadelerinin bazı ilginç uygulamalarını gördüm. Sağladığınız örneği kullanarak aşağıdakileri elde edersiniz. (Bu delilik using_complete_sentences_for_function_names, check_all_conditionsyeniden adlandırıldı status. Bkz. (1))

def status(k = 'a', s = {'a':'b','b':'c','c':'d','d':None}) :
  select = lambda next, test : test if test else next
  d = {'a': lambda : select(s['a'], check_size()  ),
       'b': lambda : select(s['b'], check_color() ),
       'c': lambda : select(s['c'], check_tone()  ),
       'd': lambda : select(s['d'], check_flavor())}
  while k in d : k = d[k]()
  return k

Seçim işlevi, her birini check_FUNCTIONiki kez arama gereğini ortadan kaldırır;check_FUNCTION() if check_FUNCTION() else next başka bir işlev katmanı ekleyerek . Bu, uzun süre çalışan işlevler için kullanışlıdır. Dikteki lambdas değerlerinin while döngüsüne kadar yürütülmesini geciktirir.

Bonus olarak, yürütme sırasını değiştirebilir ve hatta değiştirerek kve sörneğin bazı testleri atlayabilirsiniz.k='c',s={'c':'b','b':None} sayısını test sayısını azaltarak ve orijinal işleme sırasını tersine çevirerek .

timeitArkadaşlar bakmak ama daha kod Hoşluklar ilgilenen görünüyor fazladan bir katman veya yığınına ikisini ve dict için maliyet ekleyerek maliyetini üzerinde pazarlık olabilir.

Alternatif olarak, daha basit bir uygulama aşağıdakiler olabilir:

def status(k=check_size) :
  select = lambda next, test : test if test else next
  d = {check_size  : lambda : select(check_color,  check_size()  ),
       check_color : lambda : select(check_tone,   check_color() ),
       check_tone  : lambda : select(check_flavor, check_tone()  ),
       check_flavor: lambda : select(None,         check_flavor())}
  while k in d : k = d[k]()
  return k

1. Bu, pep8 açısından değil, bir cümle yerine açık bir tanımlayıcı kelime kullanma anlamındadır. OP'nin bazı kodlama kurallarını izlemesi, mevcut bir kod tabanından birini çalıştırması veya kod tabanlarındaki kısa terimleri önemsememesi olabilir.