Quelle est l'explication de base simple de ce qu'est l'instruction return, comment l'utiliser en Python?

Et quelle est la différence entre cela et la printdéclaration?

La print()fonction écrit, c'est-à-dire "imprime", une chaîne dans la console. L' returninstruction entraîne la fermeture de votre fonction et la restitution d'une valeur à son appelant. Le but des fonctions en général est de prendre des entrées et de retourner quelque chose. lereturn instruction est utilisée lorsqu'une fonction est prête à renvoyer une valeur à son appelant.

Par exemple, voici une fonction utilisant à la fois print()et return:

def foo():
    print("hello from inside of foo")
    return 1

Vous pouvez maintenant exécuter du code qui appelle foo, comme ceci:

if __name__ == '__main__':
    print("going to call foo")
    x = foo()
    print("called foo")
    print("foo returned " + str(x))

Si vous exécutez ceci en tant que script (par exemple, un .pyfichier) plutôt que dans l'interpréteur Python, vous obtiendrez la sortie suivante:

going to call foo
hello from inside foo
called foo   
foo returned 1

J'espère que cela rend les choses plus claires. L'interpréteur écrit les valeurs de retour sur la console afin que je puisse voir pourquoi quelqu'un pourrait être confus.

Voici un autre exemple de l'interpréteur qui démontre que:

>>> def foo():
...     print("hello from within foo")
...     return 1
...
>>> foo()
hello from within foo
1
>>> def bar():
...   return 10 * foo()
...
>>> bar()
hello from within foo
10

Vous pouvez voir que quand foo()est appelé depuis bar(), 1 n'est pas écrit dans la console. Au lieu de cela, il est utilisé pour calculer la valeur renvoyée par bar().

print()est une fonction qui provoque un effet secondaire (elle écrit une chaîne dans la console), mais l'exécution reprend avec l'instruction suivante. returnprovoque l'arrêt de l'exécution de la fonction et restitue une valeur à celui qui l'a appelée.

Je pense que le dictionnaire est votre meilleure référence ici

Retour et impression

En bref:

return renvoie quelque chose ou répond à l'appelant de la fonction tandis que print produit du texte

Considérez l'instruction d'impression comme causant un effet secondaire , elle oblige votre fonction à écrire du texte à l'utilisateur, mais cela ne peut pas être utilisée par une autre fonction.

Je vais essayer de mieux expliquer cela avec quelques exemples et quelques définitions de Wikipedia.

Voici la définition d'une fonction de Wikipedia

Une fonction, en mathématiques, associe une quantité, l'argument de la fonction, également appelée entrée, à une autre quantité, la valeur de la fonction, également appelée sortie.

Réfléchissez y un peu. Qu'est-ce que cela signifie lorsque vous dites que la fonction a une valeur?

Cela signifie que vous pouvez en fait remplacer la valeur d'une fonction par une valeur normale! (En supposant que les deux valeurs sont du même type de valeur)

Pourquoi voudriez-vous que vous demandiez?

Qu'en est-il des autres fonctions qui peuvent accepter le même type de valeur comme entrée ?

def square(n):
    return n * n

def add_one(n):
    return n + 1

print square(12)

# square(12) is the same as writing 144

print add_one(square(12))
print add_one(144)
#These both have the same output

Il existe un terme mathématique sophistiqué pour les fonctions qui ne dépendent que de leurs entrées pour produire leurs sorties: Transparence référentielle. Encore une fois, une définition de Wikipedia.

La transparence référentielle et l'opacité référentielle sont des propriétés de parties de programmes informatiques. Une expression est dite référentiellement transparente si elle peut être remplacée par sa valeur sans changer le comportement d'un programme

Il peut être un peu difficile de comprendre ce que cela signifie si vous êtes juste nouveau dans la programmation, mais je pense que vous l'obtiendrez après quelques expérimentations. En général cependant, vous pouvez faire des choses comme imprimer dans une fonction, et vous pouvez également avoir une instruction return à la fin.

N'oubliez pas que lorsque vous utilisez return, vous dites essentiellement "Un appel à cette fonction équivaut à écrire la valeur qui est renvoyée"

Python insérera en fait une valeur de retour pour vous si vous refusez de mettre la vôtre, elle s'appelle "None", et c'est un type spécial qui ne signifie simplement rien, ou null.

En python, nous commençons à définir une fonction avec "def" et généralement, mais pas nécessairement, terminons la fonction par "return".

Une fonction de la variable x est notée f (x). Que fait cette fonction? Supposons que cette fonction ajoute 2 à x. Donc, f (x) = x + 2

Maintenant, le code de cette fonction sera:

def A_function (x):
    return x + 2

Après avoir défini la fonction, vous pouvez l'utiliser pour n'importe quelle variable et obtenir le résultat. Tel que:

print A_function (2)
>>> 4

Nous pourrions simplement écrire le code légèrement différemment, comme:

def A_function (x):
    y = x + 2
    return y
print A_function (2)

Cela donnerait également "4".

Maintenant, nous pouvons même utiliser ce code:

def A_function (x):
    x = x + 2
    return x
print A_function (2)

Cela donnerait également 4. Voyez que le "x" à côté de return signifie en fait (x + 2), pas x de "A_function (x)".

Je suppose qu'à partir de cet exemple simple, vous comprendrez la signification de la commande return.

return signifie, "sortie cette valeur de cette fonction".

print signifie "envoyer cette valeur à (généralement) stdout"

Dans le Python REPL, un retour de fonction sera affiché à l'écran par défaut (ce n'est pas tout à fait la même chose que print).

Voici un exemple d'impression:

>>> n = "foo\nbar" #just assigning a variable. No output
>>> n #the value is output, but it is in a "raw form"
'foo\nbar'
>>> print n #the \n is now a newline
foo
bar
>>>

Voici un exemple de retour:

>>> def getN():
...    return "foo\nbar"
...
>>> getN() #When this isn't assigned to something, it is just output
'foo\nbar'
>>> n = getN() # assigning a variable to the return value. No output
>>> n #the value is output, but it is in a "raw form"
'foo\nbar'
>>> print n #the \n is now a newline
foo
bar
>>>

Cette réponse passe en revue certains des cas qui n'ont pas été discutés ci-dessus.
L' instruction return vous permet de terminer l'exécution d'une fonction avant d'atteindre la fin. Cela provoque le retour immédiat du flux d'exécution vers l'appelant.

Dans la ligne numéro 4:

def ret(n):
    if n > 9:
         temp = "two digits"
         return temp     #Line 4        
    else:
         temp = "one digit"
         return temp     #Line 8
    print("return statement")
ret(10)

Une fois l'instruction conditionnelle exécutée, la ret()fonction se termine en raison de return temp(ligne 4). Ainsi, leprint("return statement") n'est pas exécuté.

Production:

two digits   

Ce code qui apparaît après les instructions conditionnelles, ou l'endroit où le flux de contrôle ne peut pas atteindre, est le code mort .

Valeurs renvoyées
Dans les lignes 4 et 8, l'instruction return est utilisée pour renvoyer la valeur d'une variable temporaire une fois la condition exécutée.

Pour faire la différence entre l' impression et le retour :

def ret(n):
    if n > 9:
        print("two digits")
        return "two digits"           
    else :
        print("one digit")
        return "one digit"        
ret(25)

Production:

two digits
'two digits'

Juste pour ajouter à l'excellente réponse de @Nathan Hughes:

L' returninstruction peut être utilisée comme une sorte de flux de contrôle. En mettant une (ou plusieurs) returninstructions au milieu d'une fonction, nous pouvons dire: "arrêtez d'exécuter cette fonction. Soit nous avons ce que nous voulions, soit quelque chose ne va pas!"

Voici un exemple:

>>> def make_3_characters_long(some_string):
...     if len(some_string) == 3:
...         return False
...     if str(some_string) != some_string:
...         return "Not a string!"
...     if len(some_string) < 3:
...         return ''.join(some_string,'x')[:,3]
...     return some_string[:,3]
... 
>>> threechars = make_3_characters_long('xyz')    
>>> if threechars:
...     print threechars
... else:
...     print "threechars is already 3 characters long!"
... 
threechars is already 3 characters long!

Consultez la section Style de code du Guide Python pour plus de conseils sur cette façon d'utiliser return.

La différence entre «retour» et «impression» peut également être trouvée dans l'exemple suivant:

REVENIR:

def bigger(a, b):
    if a > b:
        return a
    elif a <b:
        return b
    else:
        return a

Le code ci-dessus donnera des résultats corrects pour toutes les entrées.

IMPRESSION:

def bigger(a, b):
    if a > b:
        print a
    elif a <b:
        print b
    else:
        print a

REMARQUE: cela échouera dans de nombreux cas de test.

ERREUR:

----  

FAILURE: Test case input: 3, 8.

            Expected result: 8  

FAILURE: Test case input: 4, 3.

            Expected result: 4  

FAILURE: Test case input: 3, 3.

            Expected result: 3  

You passed 0 out of 3 test cases

Voici ma compréhension. (j'espère que cela aidera quelqu'un et c'est correct).

def count_number_of(x):
    count = 0
    for item in x:
        if item == "what_you_look_for":
        count = count + 1
    return count

Donc, ce simple morceau de code compte le nombre d'occurrences de quelque chose. Le placement du retour est significatif. Il indique à votre programme où vous avez besoin de la valeur. Ainsi, lorsque vous imprimez, vous envoyez la sortie à l'écran. Lorsque vous revenez, vous dites à la valeur d'aller quelque part. Dans ce cas, vous pouvez voir que count = 0 est indenté avec return - nous voulons que la valeur (count + 1) remplace 0. Si vous essayez de suivre la logique du code lorsque vous indentez davantage la commande de retour, la sortie sera toujours 1 , car nous ne dirions jamais au décompte initial de changer. J'espère que j'ai bien compris. Oh, et le retour est toujours à l'intérieur d'une fonction.

returnfait partie d'une définition de fonction, tandis que printrenvoie le texte vers la sortie standard (généralement la console).

Une fonction est une procédure acceptant des paramètres et renvoyant une valeur. returnest pour le second, tandis que le premier est terminé def.

Exemple:

def timestwo(x):
    return x*2

Je pense qu'une réponse très simple pourrait être utile ici:

returnrend la valeur (une variable, souvent) disponible pour une utilisation par l'appelant (par exemple, pour être stockée par une fonction dans laquelle la fonction utilisant returnse trouve). Sans return, votre valeur ou variable ne serait pas disponible pour l'appelant pour stocker / réutiliser.

print imprime à l'écran, mais ne rend pas la valeur ou la variable disponible pour une utilisation par l'appelant.

(En admettant pleinement que les réponses les plus complètes sont plus précises.)

La meilleure chose à propos de la returnfonction est que vous pouvez renvoyer une valeur à partir de la fonction, mais vous pouvez faire de même avec, printalors quelle est la différence? Fondamentalement, il returnne s'agit pas simplement de renvoyer, il donne une sortie sous forme d'objet afin que nous puissions enregistrer cette valeur de retour de la fonction dans n'importe quelle variable, mais nous ne pouvons pas le faire printcar c'est la même chose stdout/coutdans C Programming.

Suivez le code ci-dessous pour une meilleure compréhension

CODE

def add(a, b):
    print "ADDING %d + %d" % (a, b)
    return a + b

def subtract(a, b):
    print "SUBTRACTING %d - %d" % (a, b)
    return a - b

def multiply(a, b):
    print "MULTIPLYING %d * %d" % (a, b)
    return a * b

def divide(a, b):
    print "DIVIDING %d / %d" % (a, b)
    return a / b


print "Let's do some math with just functions!"

age = add(30, 5)
height = subtract(78, 4)
weight = multiply(90, 2)
iq = divide(100, 2)

print "Age: %d, Height: %d, Weight: %d, IQ: %d" % (age, height, weight, iq)


# A puzzle for the extra credit, type it in anyway.
print "Here is a puzzle."

what = add(age, subtract(height, multiply(weight, divide(iq, 2))))

print "That becomes: ", what, "Can you do it by hand?"

Nous faisons maintenant nos propres fonctions mathématiques pour add, subtract, multiply,et divide. La chose importante à noter est la dernière ligne où nous disons return a + b(in add). Voici ce que cela fait:

1. Notre fonction est appelée avec deux arguments: aet b.
2. Nous imprimons ce que fait notre fonction, dans ce cas "AJOUT".
3. Ensuite, nous disons à Python de faire quelque chose de rétrograde: nous retournons l'ajout de a + b. Vous pourriez dire ceci: «Je les ajoute aet je les brenvoie».
4. Python ajoute les deux nombres. Ensuite, lorsque la fonction se termine, toute ligne qui l'exécute pourra affecter ce a + brésultat à une variable.

returndoit être utilisé pour les fonctions / méthodes récursives ou vous souhaitez utiliser la valeur renvoyée pour les applications ultérieures de votre algorithme.

print doit être utilisé lorsque vous souhaitez afficher une sortie significative et souhaitée à l'utilisateur et que vous ne voulez pas encombrer l'écran avec des résultats intermédiaires qui ne intéressent pas l'utilisateur, bien qu'ils soient utiles pour déboguer votre code.

Le code suivant montre comment utiliser returnet printcorrectement:

def fact(x):
    if x < 2:
        return 1
    return x * fact(x - 1)

print(fact(5))

Cette explication est vraie pour tous les langages de programmation et pas seulement pour python .