Qual è la semplice spiegazione di base di cos'è l'istruzione return, come usarla in Python?
E qual è la differenza tra questo e l' printaffermazione?
Risposte:
La print()funzione scrive, cioè "stampa", una stringa nella console. L' returnistruzione fa uscire la funzione e restituisce un valore al chiamante. Lo scopo delle funzioni in generale è quello di accettare input e restituire qualcosa. L' returnistruzione viene utilizzata quando una funzione è pronta per restituire un valore al suo chiamante.
Ad esempio, ecco una funzione che utilizza sia print()e return:
def foo():
print("hello from inside of foo")
return 1
Ora puoi eseguire il codice che chiama foo, in questo modo:
if __name__ == '__main__':
print("going to call foo")
x = foo()
print("called foo")
print("foo returned " + str(x))
Se lo esegui come uno script (ad esempio un .pyfile) invece che nell'interprete Python, otterrai il seguente output:
going to call foo
hello from inside foo
called foo
foo returned 1
Spero che questo lo renda più chiaro. L'interprete scrive i valori di ritorno sulla console in modo da poter capire perché qualcuno potrebbe essere confuso.
Ecco un altro esempio dell'interprete che dimostra che:
>>> 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
Puoi vedere che quando foo()viene chiamato da bar(), 1 non viene scritto sulla console. Viene invece utilizzato per calcolare il valore restituito da bar().
print()è una funzione che causa un effetto collaterale (scrive una stringa nella console), ma l'esecuzione riprende con l'istruzione successiva. returnfa sì che la funzione interrompa l'esecuzione e restituisca un valore a qualunque cosa sia chiamata.
"foo returned " + str(x)o otterrai TypeError: cannot concatenate 'str' and 'int' objects.
Pensa all'istruzione print come a causare un effetto collaterale , fa sì che la tua funzione scriva del testo all'utente, ma non può essere utilizzata da un'altra funzione.
Cercherò di spiegarlo meglio con alcuni esempi e un paio di definizioni da Wikipedia.
Ecco la definizione di una funzione da Wikipedia
Una funzione, in matematica, associa una quantità, l'argomento della funzione, noto anche come input, con un'altra quantità, il valore della funzione, noto anche come output.
Pensaci per un secondo. Cosa significa quando dici che la funzione ha un valore?
Ciò significa che puoi effettivamente sostituire il valore di una funzione con un valore normale! (Supponendo che i due valori siano lo stesso tipo di valore)
Perché vorresti che lo chiedessi?
E le altre funzioni che possono accettare lo stesso tipo di valore come input ?
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
C'è un termine matematico di fantasia per le funzioni che dipendono solo dai loro input per produrre i loro output: Trasparenza referenziale. Di nuovo, una definizione da Wikipedia.
La trasparenza referenziale e l'opacità referenziale sono proprietà di parti dei programmi per computer. Si dice che un'espressione è referenzialmente trasparente se può essere sostituita con il suo valore senza modificare il comportamento di un programma
Potrebbe essere un po 'difficile capire cosa significhi se sei solo nuovo nella programmazione, ma penso che lo otterrai dopo un po' di sperimentazione. In generale, però, puoi fare cose come stampare in una funzione e puoi anche avere un'istruzione return alla fine.
Ricorda solo che quando usi return in pratica stai dicendo "Una chiamata a questa funzione è la stessa che scrivere il valore che viene restituito"
Python effettivamente inserirà un valore di ritorno per te se rifiuti di inserire il tuo, si chiama "Nessuno", ed è un tipo speciale che semplicemente non significa niente, o nullo.
In Python, iniziamo a definire una funzione con "def" e generalmente, ma non necessariamente, terminiamo la funzione con "return".
Una funzione della variabile x è indicata come f (x). Cosa fa questa funzione? Supponiamo che questa funzione aggiunga 2 a x. Quindi, f (x) = x + 2
Ora, il codice di questa funzione sarà:
def A_function (x):
return x + 2
Dopo aver definito la funzione, puoi usarla per qualsiasi variabile e ottenere il risultato. Ad esempio:
print A_function (2)
>>> 4
Potremmo semplicemente scrivere il codice in modo leggermente diverso, ad esempio:
def A_function (x):
y = x + 2
return y
print A_function (2)
Questo darebbe anche "4".
Ora possiamo anche usare questo codice:
def A_function (x):
x = x + 2
return x
print A_function (2)
Ciò darebbe anche 4. Vedi, che la "x" accanto a return in realtà significa (x + 2), non x di "A_function (x)".
Immagino che da questo semplice esempio capiresti il significato del comando return.
Questa risposta va oltre alcuni dei casi che non sono stati discussi sopra.
L' istruzione return ti consente di terminare l'esecuzione di una funzione prima che tu raggiunga la fine. Ciò fa sì che il flusso di esecuzione ritorni immediatamente al chiamante.
Nella riga numero 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)
Dopo che l'istruzione condizionale viene eseguita, la ret()funzione viene terminata a causa di return temp(riga 4). Quindi il print("return statement")non viene eseguito.
Produzione:
two digits
Questo codice che appare dopo le istruzioni condizionali, o il punto in cui il flusso di controllo non può raggiungere, è il codice morto .
Restituzione di valori
Nelle righe numero 4 e 8, l'istruzione return viene utilizzata per restituire il valore di una variabile temporanea dopo che la condizione è stata eseguita.
Per far risaltare la differenza tra stampa e reso :
def ret(n):
if n > 9:
print("two digits")
return "two digits"
else :
print("one digit")
return "one digit"
ret(25)
Produzione:
two digits
'two digits'
return significa "emette questo valore da questa funzione".
print significa "invia questo valore a (generalmente) stdout"
In Python REPL, una funzione return verrà visualizzata sullo schermo per impostazione predefinita (non è esattamente la stessa cosa di print).
Questo è un esempio di stampa:
>>> 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
>>>
Questo è un esempio di reso:
>>> 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
>>>
Solo per aggiungere all'eccellente risposta di @Nathan Hughes:
L' returnistruzione può essere utilizzata come una sorta di flusso di controllo. Inserendo una (o più) returnaffermazioni nel mezzo di una funzione, possiamo dire: "smetti di eseguire questa funzione. O abbiamo quello che volevamo o qualcosa è andato storto!"
Ecco un esempio:
>>> 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!
Vedere la sezione Stile del codice della Guida a Python per ulteriori consigli su questo modo di utilizzo return.
La differenza tra "ritorno" e "stampa" può essere trovata anche nel seguente esempio:
RITORNO:
def bigger(a, b):
if a > b:
return a
elif a <b:
return b
else:
return a
Il codice sopra darà risultati corretti per tutti gli input.
STAMPA:
def bigger(a, b):
if a > b:
print a
elif a <b:
print b
else:
print a
NOTA: questo fallirà per molti casi di test.
ERRORE:
----
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
Penso che una risposta molto semplice potrebbe essere utile qui:
returnrende il valore (una variabile, spesso) disponibile per l'uso da parte del chiamante (ad esempio, per essere memorizzato da una funzione all'interno della quale si trova la funzione che utilizza return). Senza return, il tuo valore o la tua variabile non sarebbero disponibili per il chiamante da memorizzare / riutilizzare.
print stampa sullo schermo, ma non rende il valore o la variabile disponibile per l'uso da parte del chiamante.
(Ammettendo pienamente che le risposte più complete sono più accurate.)
Ecco la mia comprensione. (spero che possa aiutare qualcuno ed è corretto).
def count_number_of(x):
count = 0
for item in x:
if item == "what_you_look_for":
count = count + 1
return count
Quindi questo semplice pezzo di codice conta il numero di occorrenze di qualcosa. Il posizionamento del rendimento è significativo. Indica al tuo programma dove hai bisogno del valore. Quindi, quando stampi, invii l'output allo schermo. Quando torni, dici al valore di andare da qualche parte. In questo caso puoi vedere che count = 0 è rientrato con return - vogliamo che il valore (count + 1) sostituisca 0. Se provi a seguire la logica del codice quando indenti ulteriormente il comando di ritorno l'output sarà sempre 1 , perché non diremmo mai di cambiare il conteggio iniziale. Spero di aver capito bene. Oh, e il ritorno è sempre all'interno di una funzione.
returnfa parte della definizione di una funzione, mentre printrestituisce il testo allo standard output (solitamente la console).
Una funzione è una procedura che accetta parametri e restituisce un valore. returnè per il secondo, mentre il primo è finito def.
Esempio:
def timestwo(x):
return x*2
La cosa migliore della returnfunzione è che puoi restituire un valore dalla funzione ma puoi fare lo stesso con printquindi qual è la differenza? Fondamentalmente returnnon si tratta solo di restituire l'output in forma di oggetto in modo che possiamo salvare il valore di ritorno dalla funzione a qualsiasi variabile, ma non possiamo farlo printperché è lo stesso come stdout/coutin C Programming.
Segui il codice sottostante per una migliore comprensione
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?"
Ora stiamo eseguendo le nostre funzioni matematiche per add, subtract, multiply,e divide. La cosa importante da notare è l'ultima riga in cui diciamo return a + b(in add). Ciò che fa è il seguente:
ae b.a + b. Potresti dire questo come "aggiungo ae bpoi restituisco".a + brisultato a una variabile.returndovrebbe essere utilizzato per funzioni / metodi ricorsivi o si desidera utilizzare il valore restituito per applicazioni successive nel proprio algoritmo.
print dovrebbe essere utilizzato quando si desidera visualizzare un output significativo e desiderato per l'utente e non si desidera ingombrare lo schermo con risultati intermedi a cui l'utente non è interessato, sebbene siano utili per il debug del codice.
Il codice seguente mostra come utilizzare returne printcorrettamente:
def fact(x):
if x < 2:
return 1
return x * fact(x - 1)
print(fact(5))
Questa spiegazione è vera per tutti i linguaggi di programmazione, non solo per Python .