¿En qué se diferencia la devolución de la salida de una función de la de imprimirla?

36

En mi pregunta anterior , Andrew Jaffe escribe:

In addition to all of the other hints and tips, I think you're missing something crucial: your functions actually need to return something. When you create autoparts() or splittext(), the idea is that this will be a function that you can call, and it can (and should) give something back. Once you figure out the output that you want your function to have, you need to put it in a return statement.

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, ...}

Esta función crea un diccionario, pero no devuelve nada. Sin embargo, desde que agregué print, la salida de la función se muestra cuando ejecuto la función. ¿Cuál es la diferencia entre ver returnalgo y printhacerlo?

0
68

printsimplemente imprime la estructura en su dispositivo de salida (normalmente la consola). Nada mas. Para devolverlo de su función, haría:

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

¿Por qué volver? Bueno, si no lo hace, ese diccionario muere (se recolecta la basura) y ya no es accesible tan pronto como finaliza esta llamada a la función. Si devuelve el valor, puede hacer otras cosas con él. Tal como:

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

¿Ves lo que pasó? autoparts()fue llamado y devolvió el parts_dicty lo almacenamos en la my_auto_partsvariable. Ahora podemos usar esta variable para acceder al objeto de diccionario y continúa vivo aunque la llamada a la función haya terminado. Luego imprimimos el objeto en el diccionario con la clave 'engine'.

Para obtener un buen tutorial, echa un vistazo a sumergirse en python . Es gratis y muy fácil de seguir.

0
10

La declaración de impresión generará un objeto para el usuario. Una declaración de retorno permitirá asignar el diccionario a una variable una vez finalizada la función .

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

O en el contexto de devolver un diccionario:

>>> 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}

(Las declaraciones en las que no se imprime nada después de que se ejecuta una línea significan que la última declaración devolvió Ninguno)

4

Creo que está confundido porque está ejecutando desde REPL, que imprime automáticamente el valor devuelto cuando llama a una función. En ese caso, obtiene una salida idéntica si tiene una función que crea un valor, lo imprime y lo desecha, o tiene una función que crea un valor y lo devuelve, dejando que el REPL lo imprima.

Sin embargo, estos no son lo mismo, como se dará cuenta cuando llame a autopartes con otra función que quiera hacer algo con el valor que crea autoparts.

3

solo agrega una declaración de devolución ...

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

la impresión solo se imprime en la salida estándar (pantalla) de la aplicación. También puede devolver varias cosas separándolas con comas:

return parts_dict, list_of_parts

para usarlo:

test_dict = {}
test_dict = autoparts()
2

Diferencia importante:

Llamar a imprimir hará que su programa escriba inmediatamente un texto para que lo vea. Utilice la letra impresa cuando desee mostrar un valor a un humano.

return es una palabra clave. Cuando se alcanza una declaración de retorno , Python detendrá la ejecución de la función actual, enviando un valor al lugar donde se llamó a la función. Use return cuando desee enviar un valor de un punto a otro en su código.

El uso de retorno cambia el flujo del programa. El uso de la impresión no lo hace.

1
  • Esa es una buena explicación. Podría abreviarse para "imprimir algo para mostrárselo a un humano. Devolver algo para mostrarlo al código". 8 de mayo a las 18:22
2

Una función es, en un nivel básico, un bloque de código que se puede ejecutar, no cuando se escribe, sino cuando se llama. Entonces, digamos que tengo el siguiente fragmento de código, que es una función de multiplicación simple:

def multiply(x,y):
    return x * y

Entonces, si llamé a la función con multiply(2,3), devolvería el valor 6. Si modifiqué la función para que se vea así:

def multiply(x,y):
    print(x*y)
    return x*y

... entonces la salida es la que cabría esperar, el número 6 impreso. Sin embargo, la diferencia entre estas dos declaraciones es que printsimplemente muestra algo en la consola, pero return"devuelve algo" a lo que sea que se llame, que a menudo es una variable. Luego, a la variable se le asigna el valor de la declaración de retorno en la función que llamó. Aquí hay un ejemplo en el shell de Python:

>>> def multiply(x,y):
        return x*y

>>> multiply(2,3) #no variable assignment
6
>>> answer = multiply(2,3) #answer = whatever the function returns
>>> answer
6

Entonces, ahora la función ha devuelto el resultado de llamar a la función al lugar desde donde fue llamada, que es una variable llamada 'respuesta' en este caso.

Esto hace mucho más que simplemente imprimir el resultado, porque luego puede acceder a él nuevamente. Aquí hay un ejemplo de la función que usa declaraciones de retorno:

>>> x = int(input("Enter a number: "))
Enter a number: 5
>>> y = int(input("Enter another number: "))
Enter another number: 6
>>> answer = multiply(x,y)
>>> print("Your answer is {}".format(answer)
Your answer is 30

Básicamente, almacena el resultado de llamar a una función en una variable.

0

Desafortunadamente, hay un límite de caracteres, por lo que será en muchas partes. Lo primero que hay que tener en cuenta es que return e print son declaraciones, no funciones, pero eso es solo semántica.

Comenzaré con una explicación básica. print solo muestra al usuario humano una cadena que representa lo que está sucediendo dentro de la computadora. La computadora no puede hacer uso de esa impresión. return es cómo una función devuelve un valor. Este valor a menudo no es visto por el usuario humano, pero la computadora puede usarlo en otras funciones.

En una nota más amplia, la impresión no afectará de ninguna manera a una función. Simplemente está ahí para beneficio del usuario humano. Es muy útil para comprender cómo funciona un programa y puede usarse en la depuración para verificar varios valores en un programa sin interrumpir el programa.

return es la forma principal en que una función devuelve un valor. Todas las funciones devolverán un valor, y si no hay una declaración de retorno (o rendimiento, pero no se preocupe por eso todavía), devolverá Ninguno. El valor devuelto por una función se puede utilizar posteriormente como un argumento que se pasa a otra función, se almacena como una variable o simplemente se imprime para el beneficio del usuario humano. Considere estos dos programas:

def function_that_prints():
    print "I printed"

def function_that_returns():
    return "I returned"

f1 = function_that_prints()
f2 = function_that_returns()

print "Ahora veamos cuáles son los valores de f1 y f2"

imprimir f1 ---> Ninguno

print f2 ----> "Regresé"

Cuando se ejecutó function_that_prints, se imprimió automáticamente en la consola "I Printed". Sin embargo, el valor almacenado en f1 es Ninguno porque esa función no tenía declaración de retorno.

Cuando se ejecutó function_that_returns, no imprimió nada en la consola. Sin embargo, devolvió un valor y ese valor se almacenó en f2. Cuando imprimimos f2 al final del código, vimos "Regresé"

2
  • 1
    Para los futuros lectores, tenga en cuenta que la parte de esta respuesta que dice que imprimir es una declaración y no una función solo es cierta para Python 2.x. En Python 3.x, printes una función y ya no una declaración. 21 de julio a las 15:27
  • Gracias por esta explicación adicional
    Salio
    21 de julio a las 17:31
0

Los siguientes ejemplos pueden ayudar a comprender:

def add_nums1(x,y):
    print(x+y)

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

#----Function output is usable for further processing
add_nums2(10,20)/2
15.0

#----Function output can't be used further (gives TypeError)
add_nums1(10,20)/2

30
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-124-e11302d7195e> in <module>
----> 1 add_nums1(10,20)/2

TypeError: unsupported operand type(s) for /: 'NoneType' and 'int'
-1
def add(x, y):
    return x+y

De esa forma, puede convertirse en una variable.

sum = add(3, 5)

print(sum)

Pero si la función 'agregar' imprime la 'suma' de salida, entonces sería Ninguno, ya que la acción ya se habría llevado a cabo después de haber sido asignada.