retour, retour Aucun, et pas de retour du tout?

Considérez trois fonctions:

def my_func1():
  print "Hello World"
  return None

def my_func2():
  print "Hello World"
  return

def my_func3():
  print "Hello World"

Ils semblent tous retourner Aucun. Existe-t-il des différences entre le comportement de la valeur renvoyée de ces fonctions? Y a-t-il des raisons de préférer l'un à l'autre?

Sur le comportement réel, il n'y a pas de différence. Ils reviennent tous Noneet c'est tout. Cependant, il y a un temps et un lieu pour tout cela. Les instructions suivantes indiquent essentiellement comment les différentes méthodes doivent être utilisées (ou du moins comment on m'a appris qu'elles devraient être utilisées), mais ce ne sont pas des règles absolues, vous pouvez donc les mélanger si vous le jugez nécessaire.

En utilisant return None

Cela indique que la fonction est en effet destinée à renvoyer une valeur pour une utilisation ultérieure, et dans ce cas, elle retourne None. Cette valeur Nonepeut ensuite être utilisée ailleurs. return Nonen'est jamais utilisé s'il n'y a pas d'autres valeurs de retour possibles de la fonction.

Dans l'exemple suivant, nous retournons personle s mothersi le persondonné est un humain. Si ce n'est pas un humain, nous revenons Nonecar le personn'a pas mother(supposons que ce n'est pas un animal ou quelque chose).

def get_mother(person):
    if is_human(person):
        return person.mother
    else:
        return None

En utilisant return

Ceci est utilisé pour la même raison que breakdans les boucles. La valeur de retour n'a pas d'importance et vous souhaitez uniquement quitter la fonction entière. Il est extrêmement utile à certains endroits, même si vous n'en avez pas besoin souvent.

Nous en avons 15 prisonerset nous savons que l'un d'eux a un couteau. Nous passons en revue chacun prisonerd'eux pour vérifier s'ils ont un couteau. Si nous frappons la personne avec un couteau, nous pouvons simplement quitter la fonction parce que nous savons qu'il n'y a qu'un seul couteau et aucune raison de vérifier le reste du prisoners. Si nous ne trouvons pas le prisonercouteau, nous lançons une alerte. Cela peut être fait de différentes manières et l'utilisation returnn'est probablement même pas la meilleure façon, mais ce n'est qu'un exemple pour montrer comment l'utiliser returnpour quitter une fonction.

def find_prisoner_with_knife(prisoners):
    for prisoner in prisoners:
        if "knife" in prisoner.items:
            prisoner.move_to_inquisition()
            return # no need to check rest of the prisoners nor raise an alert
    raise_alert()

Remarque: vous ne devriez jamais le faire var = find_prisoner_with_knife(), car la valeur de retour n'est pas destinée à être interceptée.

Ne pas utiliser returndu tout

Cela reviendra également None, mais cette valeur n'est pas destinée à être utilisée ou capturée. Cela signifie simplement que la fonction s'est terminée avec succès. C'est fondamentalement la même chose que returndans les voidfonctions de langages tels que C ++ ou Java.

Dans l'exemple suivant, nous définissons le nom de la mère de la personne, puis la fonction se termine après avoir terminé avec succès.

def set_mother(person, mother):
    if is_human(person):
        person.mother = mother

Remarque: vous ne devriez jamais le faire var = set_mother(my_person, my_mother), car la valeur de retour n'est pas destinée à être interceptée.

Oui, ils sont tous pareils.

Nous pouvons examiner le code machine interprété pour confirmer qu'ils font tous exactement la même chose.

import dis

def f1():
  print "Hello World"
  return None

def f2():
  print "Hello World"
  return

def f3():
  print "Hello World"

dis.dis(f1)
    4   0 LOAD_CONST    1 ('Hello World')
        3 PRINT_ITEM
        4 PRINT_NEWLINE

    5   5 LOAD_CONST    0 (None)
        8 RETURN_VALUE

dis.dis(f2)
    9   0 LOAD_CONST    1 ('Hello World')
        3 PRINT_ITEM
        4 PRINT_NEWLINE

    10  5 LOAD_CONST    0 (None)
        8 RETURN_VALUE

dis.dis(f3)
    14  0 LOAD_CONST    1 ('Hello World')
        3 PRINT_ITEM
        4 PRINT_NEWLINE            
        5 LOAD_CONST    0 (None)
        8 RETURN_VALUE      

Ils retournent chacun le même singleton None- Il n'y a pas de différence fonctionnelle.

Je pense qu'il est raisonnablement idiomatique de laisser la returndéclaration à moins que vous n'en ayez besoin pour sortir de la fonction plus tôt (auquel cas une mise à nu returnest plus courante), ou renvoyer autre chose que None. Il est également logique et semble idiomatique d'écrire return Nonequand il se trouve dans une fonction qui a un autre chemin qui renvoie autre chose queNone . L'écriture return Noneexplicite est une indication visuelle pour le lecteur qu'il existe une autre branche qui renvoie quelque chose de plus intéressant (et que le code appelant devra probablement gérer les deux types de valeurs de retour).

Souvent en Python, les fonctions qui retournent Nonesont utilisées comme des voidfonctions en C - Leur but est généralement d'opérer sur les arguments d'entrée en place (sauf si vous utilisez des données globales ( frissons )). Le retour Nonerend généralement plus explicite la mutation des arguments. Cela rend un peu plus clair pourquoi il est logique de laisser l' returnénoncé du point de vue des «conventions linguistiques».

Cela dit, si vous travaillez dans une base de code qui a déjà des conventions prédéfinies autour de ces choses, je ferais certainement de même pour aider la base de code à rester uniforme ...

Comme d'autres l'ont répondu, le résultat est exactement le même, Noneest retourné dans tous les cas.

La différence est stylistique, mais veuillez noter que PEP8 nécessite une utilisation cohérente:

Soyez cohérent dans les déclarations de retour. Soit toutes les instructions de retour d'une fonction doivent renvoyer une expression, soit aucune ne doit le faire. Si une instruction return renvoie une expression, toute instruction return où aucune valeur n'est renvoyée doit l'indiquer explicitement comme return None, et une instruction return explicite doit être présente à la fin de la fonction (si elle est accessible).

Oui:

def foo(x):
    if x >= 0:
        return math.sqrt(x)
    else:
        return None

def bar(x):
    if x < 0:
        return None
    return math.sqrt(x)

Non:

def foo(x):
    if x >= 0:
        return math.sqrt(x)

def bar(x):
    if x < 0:
        return
    return math.sqrt(x)

https://www.python.org/dev/peps/pep-0008/#programming-recommendations

Fondamentalement, si vous retournez une Nonevaleur nulle dans une fonction, cela signifie que la valeur de retour a un sens et est destinée à être interceptée par les appelants. Donc, quand vous revenez None, il doit aussi être explicite, pour transmettreNone dans ce cas a du sens, c'est une des valeurs de retour possibles.

Si vous n'avez pas besoin du tout de retour, votre fonction fonctionne essentiellement comme une procédure au lieu d'une fonction, donc n'incluez pas l' returninstruction.

Si vous écrivez une fonction de type procédure et qu'il est possible de revenir plus tôt (c'est-à-dire que vous avez déjà terminé à ce stade et n'avez pas besoin d'exécuter le reste de la fonction), vous pouvez utiliser un returns vide pour signaler au lecteur c'est juste une fin précoce de l'exécution et la Nonevaleur retournée implicitement n'a aucune signification et n'est pas destinée à être interceptée (la fonction de type procédure retourne toujours de Nonetoute façon).

En termes de fonctionnalité, ce sont tous les mêmes, la différence entre eux réside dans la lisibilité et le style du code (ce qui est important à considérer)