wake-up-neo.com

Ist es in Ordnung, "return None" zu überspringen?

Ich frage mich, ob es schlecht ist, return None zu überspringen, wenn es nicht benötigt wird.

Beispiel:

def foo1(x):
    if [some condition]:
        return Baz(x)
    else:
        return None

def foo2(x):
    if [some condition]:
        return Baz(x)

bar1 = foo1(x)
bar2 = foo2(x)

In beiden Fällen kehrt die Funktion mit None zurück, wenn die Bedingung falsch ist.

pythonfunctionreturn-value
37
Tomasz Wysocki

Wie Sie schon sagten, wird return None (fast) nie gebraucht.

Sie sollten jedoch bedenken, dass die Intention Ihres Codes mit einem expliziten return None viel klarer ist. Denken Sie daran: Ein Stück Code muss auch für Menschen lesbar sein, und es hilft normalerweise, explizit zu sein.

56
rsenna

Um zu erläutern, was andere gesagt haben, verwende ich einen return None, wenn die Funktion einen Wert zurückgeben soll. In Python geben alle Funktionen einen Wert zurück. Oft schreiben wir jedoch Funktionen, die immer nur None zurückgeben, da ihr Rückgabewert ignoriert wird. In einigen Sprachen werden diese als Prozeduren bezeichnet.

Wenn also eine Funktion einen Wert zurückgeben soll, stelle ich sicher, dass alle Codepfade einen Rückgabewert haben und dass der Rückgabewert einen Wert hat, auch wenn es sich um None handelt.

Wenn eine Funktion "keinen" Wert zurückgibt, das heißt, wenn sie niemals von jemandem mit ihrem Rückgabewert aufgerufen wird, dann ist es in Ordnung, ohne Rückgabe zu beenden. Wenn ich früher zurückkehren muss, verwende ich die blanke Form. return.

23
Ned Batchelder

Ja und nein.

Im einfachsten Fall ist es in Ordnung, "return none" zu überspringen, da in einem einzigen negativen Zustand None angezeigt wird. 

Wenn es jedoch eine verschachtelte Zustandsbewertung und mehrere Szenarien gibt, bei denen eine Funktion Keine zurückgeben könnte. Ich neige dazu, sie als visuelle Dokumentation der Szenarien aufzunehmen.

[Bearbeitung: Basierend auf Kommentar unten]

rückgabe oder Rückgabe Keine 

Ich bevorzuge "return None" lieber als "return" da Es explizit ist und später wird niemand bezweifelt sein, ob die Rückkehr das Zurückgeben von None bedeutete oder war es ein Fehler, da etwas fehlte.

5
pyfunc

Ja, wenn Sie keinen Wert aus einer Python-Funktion zurückgeben, wird None zurückgegeben. Ob also None explizit zurückgegeben wird, ist eine stilistische Entscheidung.

Ich persönlich ziehe es vor, zur Klarheit immer einen Wert zurückzugeben.

3
JAL

Je mehr ich darüber nachdenke, desto weniger denke ich, dass der von Ihnen beschriebene Fall eine gute Praxis darstellt. Es zwingt den Client zur Diskriminierung, so dass der Clientcode fast immer so aussieht:

b = foo1(123)
if b is not None:
    ...

Sie konnten nicht einmal schreiben:

if b:
    ...

wenn Baz.__nonzero__ überschrieben wird, kann b zu False ausgewertet werden, auch wenn es nicht None ist. Es wäre besser, eine Null-Baz-Instanz (AKA Null Object ) zu haben, z.

class Baz(object):
    def some_method(self):
        """some action:"""
        ...
    ...

class BazNull(Baz):
    def some_method(self):
        """nothing happens here"""
    ...

Baz.Null = BazNull()

...

def foo1(x):
    if some_condition:
        return Baz(x)
    else:
        return Baz.Null

...

b = foo1(123)
b.some_method()

Der Punkt ist: Helfen Sie dem Kunden (der Sie möglicherweise selbst sind), um Cyclomatic Complexity niedrig zu halten. Je weniger Äste desto besser. 

0
pillmuncher
def foo1(x):
    try:
        return Baz(x)
    except:
        raise ValueError('Incorrect value fo Bac')

oder 

def foo3(x):
    return Baz(x) if <condition> else False

Ich glaube nicht an eine halb definierte Funktion, aber dieses False kann bei der Fehlerbehebung beim Suchtyp nützlich sein.

0
Tony Veijalainen

Ich stimme vielen Antworten hier nicht zu.
Explizite sind besser als implizit, aber manchmal ist weniger mehr, wenn es um Lesbarkeit geht. 

def get_cat():
    if cat_is_alive():
        return Cat()
# vs     

def get_cat():
    if cat_is_alive():
        return Cat()
    return None

In diesem speziellen Beispiel haben Sie zwei zusätzliche Zeilen, die wirklich keine vorteilhaften Informationen liefern, da alle Funktionen standardmäßig None zurückgeben.

Zusätzlich verschwindet die Erklärung von return None durch die Verwendung von Typhinweisen noch mehr:

def get_cat() -> Union[Cat, None]:
    if cat_is_alive():
        return Cat()

Einschließlich return None ist hier eine doppelte Redundanz: None wird standardmäßig zurückgegeben und explizit in der Typhinweismarkierung angegeben. 

Imho vermeiden, hinter dem return None nachzulaufen, sie sind absolut sinnlos und hässlich.

0
Granitosaurus