Pythoniczny sposób na uniknięcie instrukcji „if x: return x”

Mam metodę, która wywołuje 4 kolejne metody w celu sprawdzenia określonych warunków i zwraca natychmiast (nie sprawdzając kolejnych), ilekroć ktoś zwróci coś Prawdy.

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

To wygląda na dużo kodu bagażu. Zamiast każdej 2-liniowej instrukcji if wolę zrobić coś takiego:

x and return x

Ale to jest nieprawidłowy Python. Czy brakuje mi tutaj prostego, eleganckiego rozwiązania? Nawiasem mówiąc, w tej sytuacji te cztery metody sprawdzania mogą być drogie, więc nie chcę dzwonić do nich wiele razy.

Możesz użyć pętli:

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

Ma to tę dodatkową zaletę, że można teraz zmienić liczbę warunków.

Możesz użyć map()+ filter()(wersje Python 3, użyj future_builtinswersji Python 2), aby uzyskać pierwszą taką pasującą wartość:

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)

ale jeśli jest to bardziej czytelne, jest dyskusyjne.

Inną opcją jest użycie wyrażenia generatora:

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)

Alternatywnie do dobrej odpowiedzi Martijna, możesz połączyć or. Zwróci pierwszą prawdziwą wartość lub Nonejeśli nie ma prawdziwej wartości:

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

Próbny:

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

Nie zmieniaj tego

Istnieją inne sposoby osiągnięcia tego, jak pokazują różne inne odpowiedzi. Żadne nie są tak jasne, jak oryginalny kod.

W rzeczywistości taka sama odpowiedź jak timgeb, ale można użyć nawiasu do lepszego formatowania:

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

Zgodnie z prawem Curly'ego możesz zwiększyć czytelność tego kodu, dzieląc dwie kwestie:

• Jakie rzeczy sprawdzam?
• Czy jedna rzecz zwróciła się prawda?

na dwie funkcje:

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

Pozwala to uniknąć:

• skomplikowane struktury logiczne
• naprawdę długie linie
• powtórzenie

... zachowując liniowy, łatwy do odczytania przepływ.

Prawdopodobnie możesz również wymyślić jeszcze lepsze nazwy funkcji, w zależności od konkretnej sytuacji, co czyni ją jeszcze bardziej czytelną.

Jest to wariant pierwszego przykładu Martijns. Wykorzystuje również styl „zbieranie kalabrów”, aby umożliwić zwarcie.

Zamiast pętli możesz użyć wbudowanego any.

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

Zwróć uwagę, że anyzwraca wartość logiczną, więc jeśli potrzebujesz dokładnej wartości zwrotu czeku, to rozwiązanie nie będzie działać. anynie rozróżnia 14, 'red', 'sharp', 'spicy'jako wartości zwracane, wszystkie będą zwracane jako True.

Czy zastanawiałeś się nad pisaniem if x: return xwszystkiego w jednym wierszu?

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

To nie jest mniej powtarzalne niż to, co miałeś, ale IMNSHO czyta dość płynniej.

Jestem dość zaskoczony, że nikt nie wspomniał o wbudowanym, anyktóry został stworzony w tym celu:

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

Zauważ, że chociaż ta implementacja jest prawdopodobnie najczystsza, ocenia wszystkie kontrole, nawet jeśli pierwsza jest True.

Jeśli naprawdę musisz zatrzymać się przy pierwszym nieudanym sprawdzeniu, zastanów się nad użyciem tego, reduceco jest zrobione, aby przekonwertować listę do prostej wartości:

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]): Zastosuj funkcję dwóch argumentów łącznie do elementów iterowalnych, od lewej do prawej, aby zmniejszyć iterowalną wartość do pojedynczej wartości. Lewy argument x to skumulowana wartość, a prawy argument y to wartość aktualizacji z iterowalnego. Jeśli obecny jest opcjonalny inicjator, jest on umieszczany przed elementami iterowalnymi w obliczeniach

W Twoim przypadku:

• lambda a, f: a or f()Jest to funkcja, która sprawdza, czy akumulator alub sprawdzić aktualny f()jest True. Pamiętaj, że jeśli atak True, f()to nie będzie oceniane.
• checkszawiera funkcje sprawdzania ( fpozycja od lambda)
• False jest wartością początkową, w przeciwnym razie nie nastąpiłoby sprawdzenie i wynik byłby zawsze True

anyi reducesą podstawowymi narzędziami do programowania funkcjonalnego. Gorąco zachęcam do ich trenowania, co również mapjest niesamowite!

Jeśli chcesz mieć taką samą strukturę kodu, możesz użyć instrukcji potrójnych!

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

Myślę, że wygląda to ładnie i wyraźnie, jeśli na to spojrzysz.

Próbny:

Dla mnie najlepsza odpowiedź to: @ phil-frost, a następnie @ wayne-werner.

Interesujące jest dla mnie to, że nikt nie powiedział nic o tym, że funkcja zwróci wiele różnych typów danych, co spowoduje, że wówczas będzie obowiązkowe sprawdzanie samego typu x, aby wykonać jakąkolwiek dalszą pracę.

Chciałbym więc połączyć odpowiedź @ PhilFrost z pomysłem zachowania jednego typu:

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

Zauważ, że xjest przekazywany jako argument, ale all_conditionsjest także używany jako przekazywany generator funkcji sprawdzających, w którym wszystkie z nich xsą sprawdzane i zwracają Truelub False. Używając funcz all_conditionsjako wartością domyślną, możesz użyć assessed_x(x)lub przekazać kolejny spersonalizowany generator za pośrednictwem func.

W ten sposób otrzymasz, xjak tylko jeden czek przejdzie, ale zawsze będzie tego samego typu.

Idealnie, chciałbym ponownie napisać check_ funkcje, aby powrócić Truelub Falsezamiast wartości. Twoje czeki stają się

if check_size(x):
    return x
#etc

Zakładając, że twoja xnie jest niezmienna, twoja funkcja może nadal ją modyfikować (chociaż nie mogą jej ponownie przypisać) - ale funkcja wywoływana i checktak nie powinna tak naprawdę modyfikować.

Niewielka odmiana pierwszego przykładu Martijns powyżej, która pozwala uniknąć wewnątrz pętli:

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

Lubię @ timgeb's. W międzyczasie chciałbym dodać, że wyrażanie Nonew returninstrukcji nie jest potrzebne, ponieważ zbiór oroddzielnych instrukcji jest oceniany, a pierwsze zero-zero, nic-puste, żadne-Brak jest zwracane, a jeśli nie, to Nonejest zwracane czy istnieje Noneczy nie!

Więc moja check_all_conditions()funkcja wygląda następująco:

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

Używając timeitz number=10**7, spojrzałem na czas działania wielu sugestii. Dla porównania użyłem tej random.random()funkcji do zwrócenia ciągu znaków lub Nonena podstawie liczb losowych. Oto cały 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()

A oto wyniki:

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

Ten sposób jest nieco poza pudełkiem, ale myślę, że wynik końcowy jest prosty, czytelny i ładnie wygląda.

Podstawową ideą jest raisewyjątek, gdy jedna z funkcji jest oceniana jako prawdziwa i zwraca wynik. Oto jak może to wyglądać:

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

Potrzebujesz assertFalseyfunkcji, która podnosi wyjątek, gdy jeden z wywoływanych argumentów funkcji jest oceniany jako prawdziwy:

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

Powyższe można zmodyfikować, aby dostarczyć argumentów do oceny funkcji.

I oczywiście będziesz potrzebować TruthyExceptionsamego siebie. Ten wyjątek zapewnia wyjątek, objectktóry wywołał wyjątek:

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

Oczywiście możesz zmienić oryginalną funkcję w coś bardziej ogólnego:

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)

Może to być nieco wolniejsze, ponieważ używasz zarówno ifinstrukcji, jak i obsługi wyjątku. Jednak wyjątek jest obsługiwany maksymalnie jeden raz, więc wpływ na wydajność powinien być niewielki, chyba że spodziewasz się uruchomienia testu i uzyskania Truewartości wiele tysięcy razy.

Pythoniczny sposób albo wykorzystuje redukcję (jak ktoś już wspomniał) lub itertools (jak pokazano poniżej), ale wydaje mi się, że po prostu użycie zwarcia oroperatora daje wyraźniejszy kod

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

Wskoczę tutaj i nigdy nie napisałem ani jednej linii Pythona, ale zakładam, że if x = check_something(): return xjest poprawna?

w takim razie:

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

Lub użyj max:

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

W przeszłości widziałem ciekawe implementacje instrukcji switch / case z dyktami, które doprowadziły mnie do tej odpowiedzi. Korzystając z podanego przez Ciebie przykładu, uzyskasz następujące informacje. (To szaleństwo using_complete_sentences_for_function_names, więc check_all_conditionsprzemianowano je na status. Zobacz (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

Funkcja wyboru eliminuje potrzebę check_FUNCTIONdwukrotnego wywoływania, tzn. Unikasz check_FUNCTION() if check_FUNCTION() else next, dodając kolejną warstwę funkcji. Jest to przydatne w przypadku długo działających funkcji. Lambdas w nagraniu opóźnia wykonanie jego wartości aż do pętli while.

Jako bonus można modyfikować kolejność wykonywania, a nawet pominąć niektóre badania przez przerabiania ki snpk='c',s={'c':'b','b':None} zmniejsza liczbę testów i odwraca pierwotną kolejność przetwarzania.

Ludzie timeitmogą się targować o koszt dodania dodatkowej warstwy lub dwóch do stosu i koszt dyktowania, ale wydajesz się bardziej zaniepokojony ładnością kodu.

Alternatywnie prostsza implementacja może wyglądać następująco:

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. Mam na myśli to nie w kategoriach pep8, ale w kategoriach użycia jednego zwięzłego słowa opisowego zamiast zdania. To prawda, że ​​OP może postępować zgodnie z jakąś konwencją kodowania, działając w oparciu o istniejącą bazę kodu lub nie dbając o krótkie terminy w swojej bazie kodu.