Willkommen zurück.
In diesem Video möchte ich über ein wichtiges Konzept sprechen, nämlich die Rückkehr.
Es ist ein Schlüsselwort in Python, das wir bei der Arbeit mit Funktionen häufig sehen werden.
Schauen wir also mal rein.
Angenommen, ich möchte eine Funktion namens Summe erstellen, die übrigens bereits in Python existiert, aber wir werden
unsere eigene erstellen, und ich sage Nummer eins für Nummer eins.
Und Nummer zwei, nun, unsere Summenfunktion wird neun eins plus zwei addieren, eine schöne und einfache Funktion.
Wenn ich jetzt einige mit Nummer vier und fünf starte, ratet mal, was passieren wird?
Ich gehe auf Laufen.
Und nichts passiert, was Sie vielleicht nicht überraschen wird, denn wir drucken ja nichts.
Aber was ist, wenn ich hier Print ausführe?
Wird sich das ändern?
Mal sehen.
Hm, ich bekomme keine.
Haben Sie das erwartet und wir haben noch nie zuvor gesehen.
Richtig, ich meine, erinnerst du dich, als wir eine Liste hatten, sagen wir eins bis drei, und dann haben wir so etwas
wie klar gemacht?
In unserer Ed gab es diesen kleinen Pfeil und sagte keiner, und wir sprachen über diese Idee von on-Listen, so
etwas wie clear ändert die aktuelle Liste und löscht alles und leert die Liste.
Aber es gibt keine neue Liste zurück.
Es ändert nur die vorhandene Liste, gibt jedoch keine an uns zurück.
Nun, Funktionen sind einfach so.
Sie müssen immer etwas zurückgeben.
Und wenn sie nichts zurückgeben, als gäbe es hier kein Schlüsselwort zurück, wird automatisch keines zurückgegeben.
Wenn wir hier also nicht so etwas wie Rückkehr haben, wird es immer nichts zurückgeben.
Aber wenn wir Return hinzufügen, heißt es, sobald wir zum Hey kommen.
Ich möchte, dass Sie diese Funktion beenden, und wenn Sie diese Funktion beenden, möchte ich, dass Sie alles zurückgeben, was uns dieser
Ausdruck gibt, wenn ich auf Ausführen klicke.
Ich bekomme neun.
Wenn wir dies auf 10 ändern.
Plus fünf bekommen wir 15.
Und das ist eine gute allgemeine Regel bei Funktionen, denn Funktionen können zwei Dinge richtig machen?
Erstens kann es etwas zurückgeben.
Am Ende der Funktion, was auch immer, nachdem die Funktion ausgeführt wurde, geben wir etwas
zurück, entweder Nunn oder eine Art Wert, eine Art Datentyp, oder wir können eine Funktion haben, die nichts
zurückgibt, sich aber möglicherweise ändert etwas.
So könnte ich zum Beispiel drucken.
Hi.
Und wenn ich hierher gelaufen wäre.
Ich gebe keine zurück, weil ich diese return-Anweisung nicht habe, meine Funktion führt jedoch etwas aus, das sie ändert.
Nun, das Aussehen dieser Steuer, richtig, ein Prinz hoch für uns.
Eine Funktion modifiziert also entweder etwas in unserem Programm oder gibt etwas zurück.
Und dies ist ein ziemlich fortgeschrittenes Thema, auf das wir später
eingehen werden, wenn wir über funktionale Programmierung sprechen, aber eine gute Faustregel für Funktionen ist, dass eine Funktion eine Sache wirklich gut machen sollte.
Und normalerweise sollte eine Funktion etwas zurückgeben.
Dies bedeutet nicht, dass eine Funktion, die möglicherweise mehrere Dinge tut, oder eine Funktion, die nichts zurückgibt, schlecht
ist, aber es ist im Allgemeinen eine gute Praxis, Ihren Code einfach und lesbar zu machen, um diese beiden
Regeln zu haben.
Wenn ich beispielsweise Drucken und Hinzufügen habe, macht diese Funktion mehrere Dinge.
Es macht sich Sorgen um das Drucken und es macht sich auch Sorgen um etwas.
Und die Definition dieser Funktion wird einige genannt.
Ich meine, wenn ich es nicht wüsste oder das nicht gesehen hätte und alles, was ich tat, war, einige zu drucken, würde ich es
überraschen, hoch drucken zu können, weil der Name nicht wirklich beschreibt, was er tut.
Ich meine, ich gehe davon aus, dass dies einige Zeit dauern wird.
Warum sagt mein Programm hallo?
Wir wollen also sicherstellen, dass unsere Funktion wirklich nur eines tut und nur eines?
Denn wie wir später sehen werden, können wir verschiedene Funktionen miteinander kombinieren und ausführen.
Und dann wollen wir auch sicherstellen, dass wir etwas zurückgeben, denn auf diese Weise
können wir diesen Rückgabewert tatsächlich einer Variablen zuweisen.
Zum Beispiel kann ich sagen, dass die Summe etwa 10 beträgt.
Fünf.
Und weil diese Funktion etwas zurückgibt und wenn sie fertig ist, wird running 15 als Wert haben,
das ist dasselbe wie hier.
Und hier ist der coole Teil, jetzt kann ich vielleicht 10 laufen.
Plus gesamt.
Lassen Sie uns dies nun nacheinander durchgehen.
Ich definiere meine Funktion, der Python-Interpreter wird sagen, in Ordnung, ich weiß, was einiges ist, jetzt haben Sie
es definiert.
Ich werde es in Erinnerung behalten.
Es wird weitergehen, weitermachen bis Zeile sieben.
Und es wird sagen, hey, ich möchte eine variable Gesamtsumme und ich möchte, dass diese Gesamtvariable etwa 10 fünf
beträgt.
Und bevor wir dem totalen Python überhaupt etwas zuordnen, wird der Dolmetscher etwas sagen, was?
Einige wieder.
Oh, ich erinnere mich hier.
Es ist im Gedächtnis, OK, bei einigen werde ich ihm Argumente 10 und 5 geben.
Es wird also diese Funktion ausführen.
Sobald wir diese schließende Klammer beenden, geht sie in die Sonne.
Es wird sagen, hey, niemand wird gleich zehn.
Hey, Nummer zwei wird gleich fünf.
Jetzt gehen wir zu Zeile zwei und sie wird sagen, hey, ich möchte, dass Sie zehn plus fünf addieren, weil ich weiß, was diese
Variablen sind.
Und wenn Sie damit fertig sind und daraus 15 werden, möchte ich, dass Sie zurückkommen.
Der Python-Interpreter wird also, wenn er mit dem Aufrufen von einigen fertig ist, sagen, hey, weisen Sie der
Variablen total den Wert 15 zu und dann geht es in die nächste Zeile.
Hey, ich möchte etwas drucken.
Was möchten Sie drucken?
Nun, ich möchte das drucken.
Es wird sagen, hey, was einige ich weiß, was da los ist.
Ich habe es in Erinnerung.
Und dann heißt es wieder zehn.
Und dann wird das nächste Argument total sein.
Hey, was ist insgesamt?
Lass mich die Erinnerung los und finde es heraus.
Ach, es ist 15.
Es ist also, als würde man 50 sagen.
Und das ist die Macht der Funktionen, richtig, ich kann Dinge zurückgeben und sie Variablen zuweisen und sie so aufrufen,
und ich kann sie weiter ausführen, wenn ich möchte.
Wenn ich es noch einfacher machen möchte, kann ich gehen.
Einige statt insgesamt werden hier richtig sein.
Und sieh dir das jetzt an.
Ich habe alles in einer Zeile und wenn ich auf Ausführen klicke.
Wieder funktioniert es immer noch.
OK, aber was ist, wenn wir so etwas tun?
Was ist, wenn ich sage einige definieren und dann sage ich hier eine andere Funktion definieren und diese Funktion nimmt die Nummer eins
und die Nummer zwei an.
Und hier drin geben wir endlich Nummer eins und Nummer zwei zurück.
Hmm, testen wir das mal.
Was denkst du wird passieren?
Nehmen wir zunächst einmal an, dass die Summe 10 plus 20 beträgt.
Und dann werde ich insgesamt drucken.
Wenn ich klicke, laufe.
Ich bekomme keine.
Nun, warum ist das so und das sollte Ihnen klar sein, denn hier sage ich, hey, ich möchte, dass Sie
etwas definieren und was werden wir mit der Funktion machen?
Nun gut, hier werde ich eine andere Funktion definieren.
Aber diese return-Anweisung wird eigentlich nicht ausgeführt.
Richtig, denn alles, was wir tun, ist in diesem Block, diesem Codeblock.
In diesem Teil definieren wir die Funktion, aber wir rufen nie eine andere Funktion auf.
Dies gibt also keine zurück.
Und wir haben die Fähigkeit verloren, diese Funktion gut aufzurufen.
Wie können wir das also lösen?
Eine Möglichkeit ist zurückzukehren, oder?
Am Ende müssen wir hier also sicherstellen, dass die Einrückung richtig ist und wir werden eine weitere Funktion zurückgeben.
Lassen Sie uns also Return hinzufügen und sehen, was hier passiert.
Wenn ich klicke, laufe.
In Ordnung, ich bekomme diese Funktion jetzt, also entspricht total der Funktion, die wir zurückgegeben haben und die sich im Speicher
befindet.
OK, aber ich erhalte nicht das gewünschte Ergebnis, oder?
Und warum ist das?
Denn obwohl wir diese Funktion nicht aufrufen, gibt es einige Möglichkeiten, dies zu tun.
Wir können ihm hier entweder die Parameter oder die Argumente übergeben.
Sagen wir also 10, 20.
Und wenn ich klicke, laufe.
Ich bekomme 30 oder wenn wir alles behalten wollen, was wir hier geben, kann ich einfach noch einen Funk sagen.
Wenn wir ihm also Nummer eins und Nummer zwei geben und ich auf Ausführen klicke.
Hey, sieh dir das an, ich bekomme 30.
Nun, dieses Video musst du dir vielleicht immer wieder ansehen, weil es deinen Verstand ein wenig strapaziert,
und um ehrlich zu sein, diese Funktion ist nicht sehr gut, weil sie gut ist, sie ist sehr verwirrend.
Ihre Funktion sollte leicht verständlich sein.
Wir möchten dies vielleicht ein wenig ändern, anstatt hier die gleichen Parameternamen zu verwenden, nur um es
zu verdeutlichen.
Vielleicht können wir sagen und eins und und zwei.
Und dann tun wir das hier.
Und eins plus zwei, um klarzustellen, dass ich bei der Rückgabe dieser anderen Funktion die Parameter Nummer eins und Nummer zwei verwende,
die wir hier aufgerufen haben.
Denn dieser Definition einer Funktion ist es egal, was diese Dinge sind.
Es interessiert nur, wenn eine andere Funktion aufgerufen wird.
Wenn Sie nun das Video anhalten und sich das ansehen und vielleicht ein wenig üben müssen, ist
das völlig verständlich.
Aber ich wollte dir die Macht der Rückkehr zeigen.
Sie können verschachtelte Funktionen haben, genau wie bei Bedingungen, aber Sie müssen darauf achten, dass
Ihre Funktion entweder etwas zurückgibt, andernfalls wird sie keine zurückgeben.
Und die meiste Zeit werden Sie etwas von einer Funktion zurückgeben wollen, damit wir so etwas tun können,
indem wir es einer Variablen zuweisen, damit wir es später in unseren Programmen verwenden können.
Wir sehen uns in der nächsten von.
Eine letzte Sache, ein Return-Schlüsselwort beendet automatisch die Funktion, so dass hier, wenn ich einen weiteren Code
wie print hinzugefügt habe, hallo?
Oder vielleicht sogar fünf hier drin zurückgeben, sehen Sie, dass es immer noch gültig ist, aber wenn ich das starte.
Ich bekomme immer noch 30, weil der Interpreter nie zu Zeile fünf und sechs kommt, denn sobald wir
etwas von einer Funktion zurückgeben, verlässt er diese Funktion.
Und der Grund, warum dieser Teil die Funktion nicht verlässt, liegt darin, dass wir innerhalb dieser
Funktion definieren.
Wir führen diesen Teil also nicht wirklich durch.
Wir sagen nur, hey, wenn wir eine andere Funktion in unserem Code sehen, wissen wir, was es ist, aber
wir werden sie nicht ausführen.
Es wird also so aussehen.
Und sobald es die return-Anweisung sieht, wenn es kalt wird, wird es sagen,
in Ordnung, ich verlasse diese Funktion mit diesem Wert.
Nur ein bisschen Kopf hoch.