web-dev-qa-db-fra.com

Est-ce que je peux sauter "retourner aucun"?

Je me demande si c'est une mauvaise manière de sauter return None, quand ce n'est pas nécessaire.

Exemple:

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)

Dans les deux cas, lorsque la condition est fausse, la fonction retournera avec None.

pythonfunctionreturn-value
37
Tomasz Wysocki

Comme vous l'avez dit, return None n'est (presque) jamais nécessaire.

Mais vous devriez considérer que la intention de votre code est beaucoup plus claire avec un return None explicite. Rappelez-vous: un morceau de code doit aussi être lisible par un être humain, et être explicite est généralement utile.

56
rsenna

Pour expliquer ce que d'autres ont dit, j'utilise un return None si la fonction est supposée renvoyer une valeur. En Python, toutes les fonctions renvoient une valeur, mais nous écrivons souvent des fonctions qui ne renvoient jamais que de type None, car leur valeur de retour est ignorée. Dans certaines langues, cela s'appellerait des procédures.

Donc, si une fonction est supposée renvoyer une valeur, je m'assure que tous les chemins de code ont un retour et que le retour a une valeur, même s'il s'agit de None.

Si une fonction "ne" renvoie pas de valeur, c'est-à-dire si elle n'est jamais appelée par quelqu'un utilisant sa valeur de retour, il est correct de terminer sans retour et si j'ai besoin de retourner plus tôt, j'utilise le formulaire nu return.

23
Ned Batchelder

Oui et non.

Dans le cas le plus simple, il est correct de sauter "return None" car il renvoie None dans une seule condition négative. 

Mais s'il existe une évaluation de condition imbriquée et plusieurs scénarios dans lesquels une fonction pourrait renvoyer Aucun. J'ai tendance à les inclure en tant que documentation visuelle des scénarios .

[Édition: Basé sur le commentaire ci-dessous]

retour ou retour Aucun 

Je préfère "return None" à bare "return" , comme c'est explicite et plus tard, personne ne sera en doute si le retour signifiait renvoyer None ou si c'était une erreur car quelque chose manquait.

5
pyfunc

Oui, si vous ne renvoyez aucune valeur d'une fonction Python, elle renvoie None. Ainsi, le fait de renvoyer explicitement Aucun est une décision stylistique.

Personnellement, je préfère toujours renvoyer une valeur pour plus de clarté.

3
JAL

Plus j'y pense, moins je pense que le cas que vous décrivez montre de bonnes pratiques. Cela oblige le client à discriminer, ainsi le code client ressemblerait presque toujours à:

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

Vous ne pouviez même pas écrire:

if b:
    ...

puisque, si Baz.__nonzero__ est écrasé, b pourrait s’évaluer à False, même si ce n’est pas None. Il serait préférable d’avoir une instance Null-Baz (AKA Null Object ), par exemple:

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

Le but est: aidez le client (qui pourrait être vous-même!) À garder Complexité cyclomatique faible. Moins il y a de branches, mieux c'est. 

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

ou 

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

Je ne crois pas à la fonction à moitié définie, mais ce faux peut être utile dans la taille d'échec de type de recherche.

0
Tony Veijalainen

Je suis en désaccord avec beaucoup de réponses ici.
Explicite vaut mieux qu'implicite, mais parfois moins c'est plus quand il s'agit de lisibilité. 

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

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

Dans cet exemple particulier, vous avez 2 lignes supplémentaires qui ne fournissent aucune information utile car toutes les fonctions renvoient Aucune par défaut.

De plus, le caractère explicite de return None disparaît encore plus avec l'utilisation des indicateurs de type:

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

Y compris return None, il y a une double redondance: aucun n'est renvoyé par défaut et il est indiqué explicitement dans le balisage indicateur de type. 

À mon humble avis, évitez de traîner avec return None, ils sont absolument inutiles et laids.

0
Granitosaurus