web-dev-qa-db-fra.com

En quoi le retour d'une sortie d'une fonction est-il différent de son impression?

Dans ma précédente question , Andrew Jaffe écrit: 

En plus de tous les autres trucs et astuces, je pense qu'il vous manque un élément crucial: vos fonctions doivent en réalité renvoyer quelque chose . Lorsque vous créez autoparts() ou splittext(), l’idée est qu’il s’agit d’une fonction que vous pouvez appeler et qui peut (et devrait) rendre quelque chose en retour . Une fois que vous avez déterminé le résultat souhaité pour votre fonction, vous devez l'insérer dans une instruction return.

def autoparts():
    parts_dict = {}
    list_of_parts = open('list_of_parts.txt', 'r')

    for line in list_of_parts:
        k, v = line.split()
        parts_dict[k] = v

    print(parts_dict)

>>> autoparts()
{'part A': 1, 'part B': 2, ...}

Cette fonction crée un dictionnaire, mais ne renvoie rien. Cependant, depuis que j'ai ajouté la variable print, le résultat de la fonction est affiché lorsque je l'exécute. Quelle est la différence entre returning quelque chose et printing?

pythonreturn
27
Thanx

Imprimer imprime simplement la structure sur votre périphérique de sortie (normalement la console). Rien de plus. Pour le retourner de votre fonction, vous feriez:

def autoparts():
  parts_dict = {}
  list_of_parts = open('list_of_parts.txt', 'r')
  for line in list_of_parts:
        k, v = line.split()
        parts_dict[k] = v
  return parts_dict

Pourquoi revenir? Bien, si vous ne le faites pas, ce dictionnaire meurt (il ramasse les ordures) et n'est plus accessible dès que cet appel de fonction prend fin. Si vous renvoyez la valeur, vous pouvez faire d'autres choses avec. Tel que:

my_auto_parts = autoparts() 
print my_auto_parts['engine']

Vous voyez ce qui s'est passé? autoparts () a été appelé et a renvoyé le parts_dict et nous l'avons stocké dans la variable my_auto_parts. Nous pouvons maintenant utiliser cette variable pour accéder à l'objet dictionnaire et celui-ci continue à vivre même si l'appel de la fonction est terminé. Nous avons ensuite imprimé l'objet dans le dictionnaire avec la clé 'engine'.

Pour un bon tutoriel, consultez plongez dans python . C'est gratuit et très facile à suivre.

59
ryeguy

L'instruction print produira un objet pour l'utilisateur. Une instruction return permettra d’affecter le dictionnaire à une variable une fois la fonction terminée .

>>> def foo():
...     print "Hello, world!"
... 
>>> a = foo()
Hello, world!
>>> a
>>> def foo():
...     return "Hello, world!"
... 
>>> a = foo()
>>> a
'Hello, world!'

Ou dans le contexte du renvoi d'un dictionnaire:

>>> def foo():
...     print {'a' : 1, 'b' : 2}
... 
>>> a = foo()
{'a': 1, 'b': 2}
>>> a
>>> def foo():
...     return {'a' : 1, 'b' : 2}
... 
>>> a = foo()
>>> a
{'a': 1, 'b': 2}

(Les instructions dans lesquelles rien n'est imprimé après l'exécution d'une ligne signifient la dernière instruction renvoyée Aucune)

8
Jason Baker

vous venez d'ajouter une déclaration de retour ...

def autoparts():
  parts_dict={}
  list_of_parts = open('list_of_parts.txt', 'r')
  for line in list_of_parts:
        k, v = line.split()
        parts_dict[k] = v
  return parts_dict

l’impression n’imprime que sur la sortie standard (écran) de l’application. Vous pouvez également renvoyer plusieurs éléments en les séparant par des virgules:

return parts_dict, list_of_parts

pour l'utiliser:

test_dict = {}
test_dict = autoparts()
3
jle

Je pense que vous êtes confus parce que vous utilisez le REPL, qui affiche automatiquement la valeur renvoyée lorsque vous appelez une fonction. Dans ce cas, vous obtenez une sortie identique, que vous ayez une fonction qui crée une valeur, l’imprime et la jette, ou une fonction qui crée une valeur et la restitue, permettant à la REPL de l’imprimer. 

Cependant, ce ne sont pas du tout la même chose, comme vous le constaterez lorsque vous appelez autoparts avec une autre fonction qui veut faire quelque chose avec la valeur créée par autoparts.

3
RossFabricant
def add(x, y):
    return x+y

De cette façon, il peut devenir une variable.

sum = add(3, 5)

print(sum)

Mais si la fonction 'add' imprime la sortie, la 'somme' sera alors None car l'action aurait déjà eu lieu après son affectation.

0
Wool

De plus, ceci aussi:

def f():
    print("A")
a=f()
print(a.lower())

Va jeter une erreur, mais:

def f():
    return "A"
a=f()
print(a.lower())

fait le résultat désiré.

Expliquer:

Si vous type(print()) renvoie la sortie, il s'agit de None, le type est donc NoneType, donc NoneType n'est pas attribut lower(), OTOH return est une chaîne ici, aucune erreur ne fonctionne parfaitement 

0
U9-Forward