Pythonischer Weg, um "if x: return x" -Anweisungen zu vermeiden

Ich habe eine Methode, die 4 andere Methoden nacheinander aufruft, um nach bestimmten Bedingungen zu suchen, und sofort zurückkehrt (ohne die folgenden zu prüfen), wenn man etwas Wahres zurückgibt.

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

Dies scheint eine Menge Gepäckcode. Anstelle jeder zweizeiligen if-Anweisung würde ich lieber Folgendes tun:

x and return x

Aber das ist ungültiges Python. Vermisse ich hier eine einfache, elegante Lösung? In dieser Situation können diese vier Prüfmethoden übrigens teuer sein, daher möchte ich sie nicht mehrmals aufrufen.

Sie könnten eine Schleife verwenden:

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

Dies hat den zusätzlichen Vorteil, dass Sie jetzt die Anzahl der Bedingungen variabel machen können.

Sie können map()+ verwenden filter()(die Python 3-Versionen, verwenden Sie die future_builtinsVersionen in Python 2), um den ersten solchen übereinstimmenden Wert zu erhalten:

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)

aber ob dies besser lesbar ist, ist umstritten.

Eine andere Option ist die Verwendung eines Generatorausdrucks:

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)

Alternativ zu Martijns feiner Antwort könnten Sie verketten or. Dies gibt den ersten Wahrheitswert zurück, oder Nonewenn es keinen Wahrheitswert gibt:

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

Ändere es nicht

Es gibt andere Möglichkeiten, dies zu tun, wie die verschiedenen anderen Antworten zeigen. Keiner ist so klar wie Ihr Originalcode.

In praktisch der gleichen Antwort wie Timgeb, aber Sie könnten Klammern für eine schönere Formatierung verwenden:

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

Nach dem Gesetz von Curly können Sie diesen Code lesbarer machen, indem Sie zwei Probleme aufteilen:

• Welche Dinge überprüfe ich?
• Hat sich eines als wahr erwiesen?

in zwei Funktionen:

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

Dies vermeidet:

• komplizierte logische Strukturen
• wirklich lange Schlangen
• Wiederholung

... unter Beibehaltung eines linearen, leicht lesbaren Flusses.

Abhängig von Ihren besonderen Umständen können Sie wahrscheinlich auch noch bessere Funktionsnamen finden, die die Lesbarkeit verbessern.

Dies ist eine Variante von Martijns erstem Beispiel. Es wird auch der Stil "Sammlung von Callables" verwendet, um Kurzschlüsse zu ermöglichen.

Anstelle einer Schleife können Sie die eingebaute verwenden any.

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

Beachten Sie, dass anyein Boolescher Wert zurückgegeben wird. Wenn Sie also den genauen Rückgabewert der Prüfung benötigen, funktioniert diese Lösung nicht. anynicht unterscheiden zwischen 14, 'red', 'sharp', 'spicy'wird als Rückgabewerte, sie alle als zurückgeschickt werden True.

Haben Sie darüber nachgedacht, if x: return xalles in eine Zeile zu schreiben ?

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

Dies ist nicht weniger repetitiv als das, was Sie hatten, aber IMNSHO liest es sich ziemlich flüssiger.

Ich bin ziemlich überrascht, dass niemand das eingebaute Gerät erwähnt hat, das anyfür diesen Zweck hergestellt wurde:

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

Beachten Sie, dass diese Implementierung zwar wahrscheinlich die klarste ist, jedoch alle Überprüfungen auswertet, auch wenn es sich um die erste handelt True.

Wenn Sie bei der ersten fehlgeschlagenen Prüfung wirklich anhalten müssen, sollten Sie überlegen, mit reducewelcher Methode eine Liste in einen einfachen Wert konvertiert werden soll:

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]): Wenden Sie die Funktion von zwei Argumenten kumulativ von links nach rechts auf die Elemente von iterable an, um das iterable auf einen einzelnen Wert zu reduzieren. Das linke Argument x ist der akkumulierte Wert und das rechte Argument y ist der Aktualisierungswert aus dem iterierbaren Wert. Wenn der optionale Initialisierer vorhanden ist, wird er in der Berechnung vor den Elementen der Iterable platziert

In deinem Fall:

• lambda a, f: a or f()ist die Funktion, die prüft, ob entweder der Akku aoder die aktuelle Prüfung vorhanden f()ist True. Beachten Sie, dass , wenn aist True, f()werden nicht bewertet.
• checksenthält Prüffunktionen (der fArtikel aus dem Lambda)
• False ist der Anfangswert, sonst würde keine Prüfung stattfinden und das Ergebnis wäre immer True

anyund reducesind grundlegende Werkzeuge für die funktionale Programmierung. Ich empfehle Ihnen dringend, diese zu trainieren, und mapdas ist auch großartig!

Wenn Sie dieselbe Codestruktur wünschen, können Sie ternäre Anweisungen verwenden!

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

Ich denke, das sieht gut und klar aus, wenn man es sich ansieht.

Demo:

Für mich ist die beste Antwort die von @ phil-frost, gefolgt von @ wayne-werner's.

Was ich interessant finde, ist, dass niemand etwas darüber gesagt hat, dass eine Funktion viele verschiedene Datentypen zurückgibt, was es dann zwingend erforderlich macht, den Typ von x selbst zu überprüfen, um weitere Arbeiten durchzuführen.

Also würde ich die Antwort von @ PhilFrost mit der Idee mischen, einen einzigen Typ beizubehalten:

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

Beachten Sie, dass dies xals Argument übergeben wird, aber auch all_conditionsals übergebener Generator für Überprüfungsfunktionen verwendet wird, bei denen alle eine xzu überprüfende Funktion erhalten und Trueoder zurückgeben False. Durch die Verwendung von funcmit all_conditionsals Standardwert, können Sie verwenden assessed_x(x), oder Sie können über einen weiteren personalisierten Generator übergeben func.

Auf diese Weise erhalten Sie, xsobald ein Scheck bestanden wurde, aber es wird immer der gleiche Typ sein.

Im Idealfall würde ich die check_ Funktionen neu schreiben , um sie zurückzugeben, Trueoder Falsenicht einen Wert. Ihre Schecks werden dann

if check_size(x):
    return x
#etc

Vorausgesetzt x, Ihre Funktion ist nicht unveränderlich, kann Ihre Funktion sie dennoch ändern (obwohl sie sie nicht neu zuweisen kann) - aber eine aufgerufene Funktion checksollte sie ohnehin nicht wirklich ändern .

Eine kleine Variation von Martijns erstem Beispiel oben, die das if innerhalb der Schleife vermeidet:

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

Ich mag @ timgeb's. In der Zwischenzeit möchte ich hinzufügen, dass das Ausdrücken Nonein der returnAnweisung nicht erforderlich ist, da die Sammlung orgetrennter Anweisungen ausgewertet wird und die ersten nicht null, nicht leer, keine keine zurückgegeben werden und wenn keine vorhanden Nonesind, zurückgegeben wird ob es eine gibt Noneoder nicht!

Meine check_all_conditions()Funktion sieht also so aus:

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

Mit timeitmit habe number=10**7ich mir die Laufzeit einiger Vorschläge angesehen. Zum Vergleich habe ich die random.random()Funktion nur verwendet , um eine Zeichenfolge zurückzugeben oder Nonebasierend auf Zufallszahlen. Hier ist der gesamte Code:

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()

Und hier sind die Ergebnisse:

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

Dieser Weg ist etwas außerhalb des Rahmens, aber ich denke, das Endergebnis ist einfach, lesbar und sieht gut aus.

Die Grundidee ist raiseeine Ausnahme, wenn eine der Funktionen als wahr bewertet wird und das Ergebnis zurückgibt. So könnte es aussehen:

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

Sie benötigen eine assertFalseyFunktion, die eine Ausnahme auslöst, wenn eines der aufgerufenen Funktionsargumente als wahr bewertet wird:

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

Das Obige könnte geändert werden, um auch Argumente für die zu bewertenden Funktionen bereitzustellen.

Und natürlich brauchst du das TruthyExceptionselbst. Diese Ausnahme liefert die object, die die Ausnahme ausgelöst hat:

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

Sie können die ursprüngliche Funktion natürlich in etwas Allgemeineres verwandeln:

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)

Dies kann etwas langsamer sein, da Sie sowohl eine ifAnweisung verwenden als auch eine Ausnahme behandeln. Die Ausnahme wird jedoch nur maximal einmal behandelt, sodass der Leistungseinbruch gering sein sollte, es sei denn, Sie erwarten, dass Sie die Prüfung ausführen und Trueviele, viele tausend Male einen Wert erhalten.

Die pythonische Methode ist entweder die Verwendung von reduct (wie bereits erwähnt) oder itertools (wie unten gezeigt), aber es scheint mir, dass die einfache Verwendung des Kurzschlusses des orOperators einen klareren Code erzeugt

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

Ich werde hier reinspringen und habe noch nie eine einzige Zeile Python geschrieben, aber ich gehe davon aus, dass sie if x = check_something(): return xgültig ist?

wenn ja:

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

Oder verwenden Sie max:

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

Ich habe in der Vergangenheit einige interessante Implementierungen von Switch / Case-Anweisungen mit Diktaten gesehen, die mich zu dieser Antwort geführt haben. Anhand des von Ihnen angegebenen Beispiels erhalten Sie Folgendes. (Es ist Wahnsinn using_complete_sentences_for_function_names, also check_all_conditionswird umbenannt instatus . Siehe (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

Die Auswahlfunktion macht das Aufrufen jedes einzelnen überflüssig check_FUNCTION zweimalige überflüssig, dh Sie vermeiden dies, check_FUNCTION() if check_FUNCTION() else nextindem Sie eine weitere Funktionsebene hinzufügen. Dies ist nützlich für lang laufende Funktionen. Die Lambdas im Diktat verzögern die Ausführung ihrer Werte bis zur while-Schleife.

Als Bonus können Sie die Ausführungsreihenfolge ändern und sogar einige der Tests durch Ändern überspringen k undsk='c',s={'c':'b','b':None} die Anzahl der Tests z. B. reduzieren und die ursprüngliche Verarbeitungsreihenfolge umkehren.

Das timeit Kollegen feilschen möglicherweise über die Kosten für das Hinzufügen einer oder zweier zusätzlicher Ebenen zum Stapel und die Kosten für das Nachschlagen des Diktats, aber Sie scheinen sich mehr um die Schönheit des Codes zu kümmern.

Alternativ könnte eine einfachere Implementierung die folgende sein:

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. Ich meine dies nicht mit pep8, sondern mit der Verwendung eines kurzen beschreibenden Wortes anstelle eines Satzes. Zugegeben, das OP folgt möglicherweise einer Codierungskonvention, arbeitet mit einer vorhandenen Codebasis oder kümmert sich nicht um knappe Begriffe in ihrer Codebasis.