Was ist die einfache grundlegende Erklärung für die return-Anweisung, wie wird sie in Python verwendet?

Und was ist der Unterschied zwischen ihm und dem print Aussage?

Die print()Funktion schreibt, dh "druckt", eine Zeichenfolge in die Konsole. Die returnAnweisung bewirkt, dass Ihre Funktion beendet wird und einen Wert an den Aufrufer zurückgibt. Der Sinn von Funktionen im Allgemeinen besteht darin, Eingaben aufzunehmen und etwas zurückzugeben. Die returnAnweisung wird verwendet, wenn eine Funktion bereit ist, einen Wert an ihren Aufrufer zurückzugeben.

Zum Beispiel, hier ist eine Funktion sowohl Verwendung print()und return:

def foo():
    print("hello from inside of foo")
    return 1

Jetzt können Sie Code ausführen, der foo aufruft, wie folgt:

if __name__ == '__main__':
    print("going to call foo")
    x = foo()
    print("called foo")
    print("foo returned " + str(x))

Wenn Sie dies als Skript (z. B. eine .pyDatei) im Gegensatz zum Python-Interpreter ausführen , erhalten Sie die folgende Ausgabe:

going to call foo
hello from inside foo
called foo   
foo returned 1

Ich hoffe das macht es klarer. Der Interpreter schreibt Rückgabewerte in die Konsole, damit ich sehen kann, warum jemand verwirrt sein könnte.

Hier ist ein weiteres Beispiel des Dolmetschers, das dies demonstriert:

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

Sie können sehen, dass beim foo()Aufruf von bar()1 nicht in die Konsole geschrieben wird. Stattdessen wird es verwendet, um den zurückgegebenen Wert zu berechnen bar().

print()ist eine Funktion, die einen Nebeneffekt verursacht (sie schreibt eine Zeichenfolge in die Konsole), die Ausführung wird jedoch mit der nächsten Anweisung fortgesetzt. returnbewirkt, dass die Funktion die Ausführung beendet und einen Wert an einen beliebigen Namen zurückgibt.

Ich denke, das Wörterbuch ist Ihre beste Referenz hier

Zurück und drucken

Zusamenfassend:

return gibt etwas zurück oder antwortet dem Aufrufer der Funktion, während print Text erzeugt

Stellen Sie sich die print-Anweisung als Nebeneffekt vor . Dadurch schreibt Ihre Funktion Text an den Benutzer, kann dies jedoch nicht sein von einer anderen Funktion verwendet werden.

Ich werde versuchen, dies anhand einiger Beispiele und einiger Definitionen aus Wikipedia besser zu erklären.

Hier ist die Definition einer Funktion aus Wikipedia

Eine Funktion assoziiert in der Mathematik eine Größe, das Argument der Funktion, auch als Eingabe bekannt, mit einer anderen Größe, den Wert der Funktion, auch als Ausgabe bekannt.

Denken Sie eine Sekunde darüber nach. Was bedeutet es, wenn Sie sagen, dass die Funktion einen Wert hat?

Das bedeutet, dass Sie den Wert einer Funktion tatsächlich durch einen normalen Wert ersetzen können! (Angenommen, die beiden Werte sind vom gleichen Werttyp)

Warum willst du, dass du fragst?

Was ist mit anderen Funktionen, die möglicherweise denselben Werttyp als Eingabe akzeptieren ?

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

Es gibt einen ausgefallenen mathematischen Begriff für Funktionen, die nur von ihren Eingaben abhängen, um ihre Ausgaben zu erzeugen: Referenzielle Transparenz. Wieder eine Definition aus Wikipedia.

Referenzielle Transparenz und referenzielle Undurchsichtigkeit sind Eigenschaften von Teilen von Computerprogrammen. Ein Ausdruck wird als referenziell transparent bezeichnet, wenn er durch seinen Wert ersetzt werden kann, ohne das Verhalten eines Programms zu ändern

Es mag ein bisschen schwierig sein zu verstehen, was dies bedeutet, wenn Sie noch nicht mit dem Programmieren vertraut sind, aber ich denke, Sie werden es nach einigen Experimenten bekommen. Im Allgemeinen können Sie beispielsweise in einer Funktion drucken und am Ende eine return-Anweisung haben.

Denken Sie daran, dass Sie bei Verwendung von return im Grunde sagen: "Ein Aufruf dieser Funktion entspricht dem Schreiben des zurückgegebenen Werts."

Python fügt tatsächlich einen Rückgabewert für Sie ein, wenn Sie sich weigern, Ihren eigenen Wert einzugeben. Er heißt "None" und ist ein spezieller Typ, der einfach nichts oder null bedeutet.

In Python beginnen wir mit der Definition einer Funktion mit "def" und beenden die Funktion im Allgemeinen, aber nicht unbedingt, mit "return".

Eine Funktion der Variablen x wird als f (x) bezeichnet. Was macht diese Funktion? Angenommen, diese Funktion addiert 2 zu x. Also ist f (x) = x + 2

Der Code dieser Funktion lautet nun:

def A_function (x):
    return x + 2

Nachdem Sie die Funktion definiert haben, können Sie diese für jede Variable verwenden und das Ergebnis abrufen. Sowie:

print A_function (2)
>>> 4

Wir könnten den Code nur etwas anders schreiben, wie zum Beispiel:

def A_function (x):
    y = x + 2
    return y
print A_function (2)

Das würde auch "4" geben.

Jetzt können wir sogar diesen Code verwenden:

def A_function (x):
    x = x + 2
    return x
print A_function (2)

Das würde auch 4 ergeben. Sehen Sie, dass das "x" neben return tatsächlich (x + 2) bedeutet, nicht x von "A_function (x)".

Ich denke, anhand dieses einfachen Beispiels würden Sie die Bedeutung des Rückgabebefehls verstehen.

Diese Antwort geht auf einige der Fälle ein, die oben nicht erörtert wurden.
Mit der return- Anweisung können Sie beenden die Ausführung einer Funktion bevor Sie das Ende erreichen. Dadurch kehrt der Ausführungsfluss sofort zum Aufrufer zurück.

In Zeile 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)

Nachdem die bedingte Anweisung ausgeführt wurde, wird die ret()Funktion aufgrund von return temp(Zeile 4) beendet. Somit wird das print("return statement")nicht ausgeführt.

Ausgabe:

two digits   

Dieser Code, der nach den bedingten Anweisungen oder dem Ort erscheint, den der Kontrollfluss nicht erreichen kann, ist der tote Code .

Rückgabewerte
In den Zeilen 4 und 8 wird die return-Anweisung verwendet, um den Wert einer temporären Variablen zurückzugeben, nachdem die Bedingung ausgeführt wurde.

Um den Unterschied zwischen Druck und Rücksendung herauszustellen :

def ret(n):
    if n > 9:
        print("two digits")
        return "two digits"           
    else :
        print("one digit")
        return "one digit"        
ret(25)

Ausgabe:

two digits
'two digits'

return bedeutet "diesen Wert von dieser Funktion ausgeben".

print bedeutet "diesen Wert an (allgemein) stdout senden"

In Python REPL wird standardmäßig eine Funktionsrückgabe auf dem Bildschirm ausgegeben (dies entspricht nicht ganz dem Drucken).

Dies ist ein Beispiel für Druck:

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

Dies ist ein Beispiel für die Rückgabe:

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

Nur um die hervorragende Antwort von @Nathan Hughes zu ergänzen:

Die returnAnweisung kann als eine Art Kontrollfluss verwendet werden. Indem returnwir eine (oder mehrere) Anweisungen in die Mitte einer Funktion stellen, können wir sagen: "Stoppen Sie die Ausführung dieser Funktion. Wir haben entweder das, was wir wollten, oder etwas ist schief gelaufen!"

Hier ist ein Beispiel:

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

Sehen Sie sich den Code - Stil Abschnitt des Python - Handbuch für mehr Beratung auf diese Weise zu verwenden return.

Der Unterschied zwischen "return" und "print" ist auch im folgenden Beispiel zu finden:

RÜCKKEHR:

def bigger(a, b):
    if a > b:
        return a
    elif a <b:
        return b
    else:
        return a

Der obige Code liefert korrekte Ergebnisse für alle Eingaben.

DRUCKEN:

def bigger(a, b):
    if a > b:
        print a
    elif a <b:
        print b
    else:
        print a

HINWEIS: Dies schlägt in vielen Testfällen fehl.

ERROR:

----  

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

Hier ist mein Verständnis. (hoffe es wird jemandem helfen und es ist richtig).

def count_number_of(x):
    count = 0
    for item in x:
        if item == "what_you_look_for":
        count = count + 1
    return count

Dieser einfache Code zählt also die Anzahl der Vorkommen von etwas. Die Platzierung der Rendite ist von Bedeutung. Es teilt Ihrem Programm mit, wo Sie den Wert benötigen. Wenn Sie also drucken, senden Sie die Ausgabe an den Bildschirm. Wenn Sie zurückkehren, teilen Sie dem Wert mit, dass er irgendwohin gehen soll. In diesem Fall können Sie sehen, dass count = 0 mit return eingerückt wird. Wir möchten, dass der Wert (count + 1) 0 ersetzt. Wenn Sie versuchen, der Logik des Codes zu folgen, wenn Sie den return-Befehl weiter einrücken, ist die Ausgabe immer 1 , weil wir niemals die anfängliche Zählung anweisen würden, sich zu ändern. Ich hoffe ich habe es richtig gemacht. Oh, und die Rückkehr ist immer in einer Funktion.

return ist Teil einer Funktionsdefinition, während print Text an die Standardausgabe (normalerweise die Konsole) ausgegeben wird.

Eine Funktion ist eine Prozedur, die Parameter akzeptiert und einen Wert zurückgibt. returnist für Letzteres, während Ersteres erledigt ist def.

Beispiel:

def timestwo(x):
    return x*2

Ich denke, eine wirklich einfache Antwort könnte hier nützlich sein:

returnstellt den Wert (häufig eine Variable) zur Verwendung durch den Aufrufer zur Verfügung (z. B. um von einer Funktion gespeichert zu werden, in der sich die verwendete Funktion returnbefindet). Ohne wäre returnIhr Wert oder Ihre Variable für den Aufrufer nicht zum Speichern / Wiederverwenden verfügbar.

print Druckt auf dem Bildschirm, stellt den Wert oder die Variable jedoch nicht für den Anrufer zur Verfügung.

(Ich gebe voll und ganz zu, dass die gründlicheren Antworten genauer sind.)

Das Beste an der returnFunktion ist, dass Sie einen Wert von der Funktion zurückgeben können, aber dasselbe können Sie tun. printWas ist der Unterschied? Grundsätzlich geht es returnnicht nur um die Rückgabe, sondern um die Ausgabe in Objektform, damit wir diesen Rückgabewert von der Funktion in einer beliebigen Variablen speichern können, aber wir können nicht damit umgehen, printweil es dasselbe ist wie stdout/coutin C Programming.

Befolgen Sie zum besseren Verständnis den folgenden Code

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?"

Wir machen jetzt unsere eigenen mathematischen Funktionen für add, subtract, multiply,und divide. Das Wichtigste ist die letzte Zeile, in der wir return a + b(in add) sagen . Dies bewirkt Folgendes:

1. Unsere Funktion wird mit zwei Argumenten aufgerufen: aund b.
2. Wir drucken aus, was unsere Funktion tut, in diesem Fall "HINZUFÜGEN".
3. Dann fordern wir Python auf, etwas rückwärts zu tun: Wir geben die Hinzufügung von zurück a + b. Sie könnten dies sagen als: "Ich füge sie hinzu aund bgebe sie dann zurück."
4. Python fügt die beiden Zahlen hinzu. Wenn die Funktion endet, kann jede Zeile, die ausgeführt wird, dieses a + bErgebnis einer Variablen zuweisen .

returnsollte für rekursive Funktionen / Methoden verwendet werden oder Sie möchten den zurückgegebenen Wert für spätere Anwendungen in Ihrem Algorithmus verwenden.

print sollte verwendet werden, wenn Sie dem Benutzer eine aussagekräftige und gewünschte Ausgabe anzeigen möchten und den Bildschirm nicht mit Zwischenergebnissen überladen möchten, an denen der Benutzer nicht interessiert ist, obwohl diese für das Debuggen Ihres Codes hilfreich sind.

Der folgende Code zeigt die Verwendung returnund printordnungsgemäße Verwendung:

def fact(x):
    if x < 2:
        return 1
    return x * fact(x - 1)

print(fact(5))

Diese Erklärung gilt für alle Programmiersprachen, nicht nur für Python .