Quel est le but de la déclaration de retour?
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 déclaration print?
La fonction print() écrit, c’est-à-dire "imprime", une chaîne dans la console. L'instruction return entraîne la fermeture de votre fonction et le renvoi d'une valeur à l'appelant. Le but des fonctions en général est de prendre des entrées et de retourner quelque chose. L'instruction return 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
Maintenant, vous pouvez exécuter du code qui appelle foo, comme ceci:
if __== '__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 fichier .py], par opposition à l'interpréteur Python, vous obtiendrez le résultat suivant:
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ète écrit les valeurs de retour sur la console afin que je puisse voir pourquoi quelqu'un pourrait être dérouté.
Voici un autre exemple de l'interprète 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 lorsque foo() est appelé à partir de bar(), 1 n'est pas écrit sur 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 (écrit une chaîne dans la console), mais l'exécution reprend avec l'instruction suivante. return arrête l'exécution de la fonction et renvoie une valeur à celui qui l'a appelée.
Pensez à l’instruction print comme causant un effet secondaire , votre fonction écrit du texte pour l’utilisateur, mais ça ne peut pas être tilisé par une autre fonction.
Je vais essayer de mieux l'expliquer 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é 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 quand vous dites que la fonction a une valeur?
Cela signifie que vous pouvez réellement substituer la valeur d'une fonction à 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 pouvant accepter le même type de valeur qu'une 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 dépendent uniquement 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 est peut-être un peu difficile de comprendre ce que cela signifie si vous êtes novice en programmation, mais je pense que vous l'obtiendrez après quelques expériences. En général cependant, vous pouvez faire des choses comme imprimer dans une fonction et vous pouvez aussi avoir une déclaration de retour à la fin.
Rappelez-vous simplement que lorsque vous utilisez return, vous dites en gros "Un appel à cette fonction revient à écrire la valeur renvoyée"
Python insérera en fait une valeur de retour pour vous si vous refusez de la mettre dans la vôtre, elle s'appelle "Aucune" et c'est un type spécial qui ne veut tout simplement rien dire, ou null.
En python, nous commençons à définir une fonction avec "def" et généralement, mais pas nécessairement, nous terminons la fonction avec "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 un résultat. Tel que:
print A_function (2)
>>> 4
Nous pourrions simplement écrire le code légèrement différemment, par exemple:
def A_function (x):
y = x + 2
return y
print A_function (2)
Cela donnerait aussi "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. Voir que le "x" à côté de return signifie réellement (x + 2), pas x de "A_function (x)".
Je suppose qu'à partir de cet exemple simple, vous comprendriez le sens de la commande de retour.
Cette réponse couvre 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 que vous n'atteigniez la fin. Cela entraîne le retour immédiat du flux d’exécution à l’appelant.
En 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 que l'instruction conditionnelle est exécutée, la fonction ret() est interrompue en raison de return temp (ligne 4). Ainsi, la print("return statement") ne sera pas exécutée.
Sortie:
two digits
Ce code qui apparaît après les instructions conditionnelles ou à l'endroit que le flux de contrôle ne peut pas atteindre est le code mort.
valeurs de retour
Aux lignes 4 et 8, l'instruction return est utilisée pour renvoyer la valeur d'une variable temporaire après l'exécution de la condition.
Faire ressortir la différence entre print et return:
def ret(n):
if n > 9:
print("two digits")
return "two digits"
else :
print("one digit")
return "one digit"
ret(25)
Sortie:
two digits
'two digits'
return signifie "sortir cette valeur de cette fonction".
print signifie "envoie 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 comme imprimer).
Ceci est 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
>>>
Ceci est 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
>>>
Juste pour ajouter à l'excellente réponse de @Nathan Hughes:
L'instruction return peut être utilisée comme une sorte de flux de contrôle. En plaçant une (ou plusieurs) return déclaration au milieu d'une fonction, nous pouvons dire: "arrêtez d'exécuter cette fonction. Nous avons ce que nous voulions ou 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!
Reportez-vous à la section Section Style du Python Guide pour plus de conseils sur cette méthode d'utilisation de return.
La différence entre "return" et "print" 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 pour 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. (espérons que cela va aider quelqu'un et que 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 de retour est significatif. Il indique à votre programme où vous avez besoin de la valeur. Ainsi, lorsque vous imprimez, vous envoyez une sortie à l'écran. Lorsque vous revenez, vous indiquez la valeur d'aller quelque part. Dans ce cas, vous pouvez voir que count = 0 est en retrait avec return - nous voulons que la valeur (count + 1) remplace 0. Si vous essayez de suivre la logique du code lorsque vous indenter la commande de retour, la sortie sera toujours 1 , parce que nous ne dirions jamais que le nombre initial change. J'espère que j'ai bien compris. Oh, et le retour est toujours dans une fonction.
return fait partie d'une définition de fonction, tandis que print affiche du texte sur la sortie standard (généralement la console).
Une fonction est une procédure acceptant des paramètres et renvoyant une valeur. return est pour le dernier, tandis que le premier est fait avec def.
Exemple:
def timestwo(x):
return x*2
return devrait être utilisé pour récursif fonctions/méthodes ou vous voulez utiliser la valeur renvoyée pour des applications ultérieures dans votre algorithme.
print doit être utilisé lorsque vous souhaitez afficher une sortie significative et souhaitée pour l'utilisateur et que vous ne souhaitez pas encombrer l'écran de résultats intermédiaires qui ne intéressent pas l'utilisateur, bien qu'ils soient utiles pour le débogage de votre code. .
Le code suivant montre comment utiliser return et print correctement:
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 python.
La meilleure chose à propos de la fonction return est que vous pouvez renvoyer une valeur de fonction mais que vous pouvez faire la même chose avec print alors quelle est la différence? Fondamentalement, return ne pas se contenter de la renvoyer donne une sortie sous forme d'objet afin que nous puissions enregistrer cette valeur de retour d'une fonction à une variable, mais nous ne pouvons pas le faire avec print parce que c'est la même chose que stdout/cout dans 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). Ce que cela fait est la suivante:
- Notre fonction est appelée avec deux arguments:
aetb. - Nous imprimons ce que notre fonction est en train de faire, dans ce cas, "ADDING".
- Ensuite, nous disons à Python de faire quelque chose de très en arrière: nous retournons l'addition de
a + b. Vous pourriez dire ceci comme suit: "J'ajouteaetb, puis je les retourne." - Python ajoute les deux nombres. Ensuite, lorsque la fonction se terminera, toute ligne l’exécutant pourra affecter ce résultat
a + bà une variable.