Comment est de retour la sortie d'une fonction différente de l'imprimer?

Question

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

  

En plus de tous les autres trucs et astuces, je pense que vous manque quelque chose de crucial: vos fonctions réellement besoin de retourner quelque chose.   Lorsque vous créez autoparts() ou splittext(), l'idée est que ce sera une fonction que vous pouvez appeler, et il peut (et devrait) donner quelque chose en retour.   Une fois que vous figurez sur la sortie que vous voulez que votre fonction d'avoir, vous devez le mettre dans une déclaration de 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 il ne retourne pas quelque chose. Cependant, depuis que j'ajouté le print, la sortie de la fonction est affichée quand je lance la fonction. Quelle est la différence entre returning quelque chose et il printing?

Answer 1

Imprimer imprime simplement la structure à votre périphérique de sortie (normalement la console). Rien de plus. Pour retourner à partir 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? Eh bien, si vous ne le faites pas, ce dictionnaire meurt (se ramasse-miettes) et est plus accessible dès que cet appel de fonction se termine. Si vous retournez la valeur, vous pouvez faire d'autres choses avec elle. Tels que:

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

Voir ce qui est arrivé? Autoparts () a été appelé et renvoyé le parts_dict et nous stockés dans la variable my_auto_parts. Maintenant, nous pouvons utiliser cette variable pour accéder à l'objet le dictionnaire et il continue à vivre même si l'appel de fonction est terminée. Nous avons ensuite imprimé le objet dans le dictionnaire avec le « moteur » clé.

Pour un bon tutoriel, consultez en python . Il est gratuit et très facile à suivre.

Answer 2

La sortie de l'instruction volonté d'impression d'un objet à l'utilisateur. Une déclaration de retour permettra l'attribution du dictionnaire à une variable une fois que la fonction est 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 de retour 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 déclarations où rien ne s'imprime après une ligne est exécutée signifie que la dernière instruction renvoyée Aucune)

Answer 3

Je pense que vous êtes confus parce que vous êtes en cours d'exécution de la REMP, qui imprime automatiquement la valeur retournée lorsque vous appelez une fonction. Dans ce cas, vous ne recevez pas une sortie identique si vous avez une fonction qui crée une valeur, elle imprime, et le jette, ou si vous avez une fonction qui crée une valeur et le renvoie, en laissant le REPL imprimer.

Cependant, ceux-ci sont très pas la même chose, que vous vous rendrez compte lorsque vous appelez Autoparts avec une autre fonction qui veut faire quelque chose avec la valeur que Autoparts crée.

Answer 4

vous suffit d'ajouter 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
  return parts_dict

imprimer seulement imprime sur la sortie standard (écran) de l'application. Vous pouvez également revenir plusieurs choses en les séparant par des virgules:

return parts_dict, list_of_parts

pour l'utiliser:

test_dict = {}
test_dict = autoparts()

Answer 5

De plus, aussi ceci:

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

jetteront erreur, mais:

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

t résultat souhaité.

Pour expliquer:

Si vous type(print()) retourne la sortie, il n'y en a pas, si le type est NoneType, donc NoneType ne pas attribuer lower(), OTOH return est une chaîne ici, donc pas d'erreur, fonctionne parfaitement

Answer 6

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

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

sum = add(3, 5)

print(sum)

Mais si le serait alors « ajouter » fonction imprimer la sortie « somme » Aucun être que l'action aurait déjà eu lieu après avoir été attribué.