Ist es ok, Sie zu überspringen "return None"?

Frage ich mich, ob es schlecht ist Art und Weise zu überspringen return None, 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, wenn die Bedingung false ist, wird die Funktion zurück, mit None.

InformationsquelleAutor Tomasz Wysocki | 2010-10-26

57

Wie Sie sagte: return None ist (fast) nie gebraucht.

Aber Sie sollten Bedenken, dass die Absicht der code ist viel klarer, mit einem deutlichen return None. Denken Sie daran: ein Stück code muss auch gelesen werden von Menschen, und explizite hilft in der Regel.

Hilft auch beim "halten" mit import this 😛
"Explizit ist besser als implizit."
Von Den Zen of Python python.org/dev/peps/pep-0020
Menschen Nachplappern, das "Zen of Python" machen, mich ständig mit für einen Kommentar downvotes. Implizit ist besser als eine explizite, wenn es klarer und vermeidet unnötige Redundanz.
Nicht return None es sei denn, die None return value selbst sinnvoll ist. Der Rückgabewert von __init__ ist nicht sinnvoll, also nicht explizit Rückkehr Keine. Wenn Sie brauchen, um wieder aus der Mitte der __init__ nur sagen return, und nicht setzen eine unnötige return am Ende der Funktion.

InformationsquelleAutor rsenna
24

Zu erläutern, was andere gesagt haben, ich benutze ein return None wenn die Funktion sollte einen Wert zurückgeben. In Python werden alle Funktionen geben einen Wert zurück, aber oft haben wir Funktionen schreiben, die immer nur zurück Keine, weil Ihr Rückgabewert wird ignoriert. In einigen Sprachen, diese werden als Prozeduren bezeichnet.

Also, wenn eine Funktion soll einen Wert zurückgeben, dann I stellen Sie sicher, dass alle code-Pfade haben eine Rückkehr, und die Rücksendung hat einen Wert, auch wenn es Keiner ist.

Wenn die Funktion "nicht" einen Wert zurück, dass ist, wenn es nie genannt wird, indem jemand mit seinen Rückgabewert, dann ist es ok zu beenden, ohne ein zurück, und wenn ich brauchen, um wieder zu früh, ich die Reine form, return.

InformationsquelleAutor Ned Batchelder
5

Ja und Nein.

Im einfachsten Fall ist es ok, Sie zu überspringen "return None" denn es gibt Keine in nur eine einzige negative Bedingung.

Aber wenn es geschachtelte Bedingung evaluation und mehrere Szenarien, in denen eine Funktion zurückgeben konnte Keine. Ich Neige dazu, Sie als visuelle Dokumentation der Szenarien.

[Bearbeitung: Basierend auf Kommentar unten]

zurückgeben oder Keine

Ich lieber "return None" nackten "return", wie Es explizite und später, wird niemand in Zweifel gezogen werden, wenn die Rückkehr bedeutete Keine Rückkehr oder war es ein Fehler, da fehlte etwas.

Auch mit Schachteln Sie konnte einfach return statt return None. Manchmal kann es sein, klarer zu machen, die None explizit, aber oft Menschen nutzen None zu zeigen, dass es eine Art von außergewöhnlichen Fall, in welchem Falle das heben einer gut benannten Ausnahme wäre besser.
Ich Stimme mit Ihnen überein. Einige von diesen sind Stil Gewohnheiten. Ich verabscheue einfach mit "return", als ob ich verpasst hatte, die Rückkehr etwas. Ich bevorzuge "return None" in solchen Fällen, wie ich bin ausdrücklich darauf hingewiesen, dass dies ist, was ich wollte.
Ich persönlich glaube nicht, verwenden Sie None für außergewöhnlichen Wert, aber in der Regel verwenden Sie es als Platzhalter, um anzuzeigen, legen Sie für den Wert. [] oder () geben dann an, unbestimmte Anzahl von Ergebnissen, und für manche Art von Funktionen sind Sie besser im False-ähnlichen Wert als return None (None ist nicht durchsuchbar)

InformationsquelleAutor pyfunc
3

Ja, wenn Sie nicht wieder einen beliebigen Wert aus einer Python-Funktion, es gibt Keine. Also, ob ausdrücklich return Keiner ist eine stilistische Entscheidung.

Persönlich bevorzuge ich immer einen Wert zurück, der für Klarheit.

InformationsquelleAutor JAL

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, dass in der Hälfte der angegebenen Funktion, aber das Falsche kann nützlich sein in suchen, geben Sie Fehler beschneiden.

InformationsquelleAutor Tony Veijalainen

0

Je mehr ich darüber nachdenke, desto weniger denke ich, dass der Fall den Sie beschreiben, zeigt eine gute Praxis. Es zwingt den client, um zu unterscheiden, so dass der client-code würde fast immer wie folgt Aussehen:
```
b = foo1(123)
if b is not None:
    ...
```
Konnte man nicht sogar schreiben:
```
if b:
    ...
```
da, wenn Baz.__nonzero__ überschrieben wird, könnte b zu False ausgewertet, auch wenn es nicht Keine. Es wäre besser, eine Null-Baz Instanz (AKA Null-Objekt), z.B.:
```
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: dem Klienten helfen (wer könnte Sie selbst sein!) halten Zyklomatische Komplexität gering. Je weniger äste, desto besser.

Guter Punkt. Aber in einigen Fällen bin ich gezwungen, zurück Keine. Dh. in Django-Middleware Sie wieder Keiner in die meisten Ihrer Methoden.
Ich downvoted das, weil selbst wenn der Vorschlag gültig ist, in einigen Fällen ist es außerhalb der Frage.

InformationsquelleAutor pillmuncher
0

Ich bin nicht einverstanden mit viel von den Antworten hier.

Explizit ist besser als implizit, aber manchmal ist weniger mehr, wenn es um die Lesbarkeit zu verbessern.
```
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 2 zusätzliche Zeilen, die wirklich bieten keine nützlichen Informationen, da alle Funktionen werden standardmäßig Keine.

Zusätzlich Evidenz des return None verschwindet noch mehr mit der Verwendung von Typ-Hinweise:
```
def get_cat() -> Union[Cat, None]:
    if cat_is_alive():
        return Cat()
```
Einschließlich return None hier ist eine Doppel-Redundanz: Keine standardmäßig zurückgegeben wird und es wird explizit in der type-hint-markup.

Imho vermeiden trailing return None Sie sind absolut sinnlos und hässlich.

InformationsquelleAutor Granitosaurus

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.