Welkom terug.
In deze video wil ik het hebben over een belangrijk concept, namelijk terugkeer.
Het is een sleutelwoord in Python dat we veel gaan zien bij het werken met functies.
Dus laten we eens kijken.
Als ik zeg dat ik een functie met de naam sum wil maken, die trouwens al in Python bestaat, maar we
gaan onze eigen maken en ik ga nummer één voor nummer één zeggen.
En nummer twee, nou, onze somfunctie gaat negen één plus nummer twee toevoegen, een mooie en eenvoudige functie.
Nu, als ik wat met nummer vier en vijf run, raad eens wat er gaat gebeuren?
Ik ga rennen.
En er gebeurt niets, wat ik bedoel, misschien niet verrassend voor u, omdat we niets afdrukken, toch.
Maar wat als ik hier print?
Zal dit veranderen?
Laten we eens kijken.
Hmm, ik snap er geen.
Is dat wat je verwachtte en we hebben er nog geen gezien.
Juist, ik bedoel, weet je nog dat we een lijst hadden, laten we zeggen één tot drie, en toen deden we er zoiets
als duidelijk op?
In onze Ed gaf het ons deze kleine pijl en zei geen, en we hadden het over dit idee van op
lijsten, zoiets als wissen verandert de eigenlijke lijst en wist alles en maakt de lijst leeg.
Maar er wordt geen nieuwe lijst geretourneerd.
Het wijzigt alleen de bestaande lijst, maar retourneert er niets aan ons.
Nou, functies zijn precies zo.
Ze moeten altijd iets teruggeven.
En als ze niets teruggeven alsof er hier geen return-sleutelwoord is, wordt er automatisch niets geretourneerd.
Dus als we niet zoiets hebben als hier terugkeren, zal het altijd niets opleveren.
Maar als we return toevoegen, zal het zeggen zodra we bij, zoals, hey komen.
Ik wil dat je deze functie verlaat, en als je deze functie afsluit, wil ik dat je teruggeeft wat deze uitdrukking
ons ook geeft, als ik klik, run.
Ik krijg negen.
Als we dit veranderen in 10.
Plus vijf, krijgen we 15.
En dit is een goede algemene regel met functies, omdat functies twee dingen kunnen doen, toch?
Ten eerste kan het iets teruggeven.
Dus aan het einde van de functie, wat dan ook, nadat de functie is uitgevoerd, retourneren
we iets ofwel Nunn of een soort van waarde, een soort gegevenstype, of we kunnen een functie hebben die
niets teruggeeft, maar misschien wijzigt iets.
Dus ik zou bijvoorbeeld kunnen printen.
Hoi.
En als ik hierheen was gelopen.
Ik retourneer geen omdat ik die return-instructie niet heb, maar mijn functie doet iets dat het wijzigt.
Nou, het uiterlijk van deze belasting, juist, een prins hoog voor ons.
Dus een functie wijzigt iets in ons programma of retourneert iets.
En dit is een vrij geavanceerd onderwerp waar we later op
in zullen gaan als we het hebben over functioneel programmeren, maar een goede vuistregel met functies is dat een functie één ding heel goed moet doen.
En meestal moet een functie iets teruggeven.
Dit betekent niet dat een functie die misschien meerdere dingen doet of een functie die niets teruggeeft, slecht is,
maar het is over het algemeen een goede gewoonte om je code eenvoudig en leesbaar te maken, om deze twee
regels te hebben.
Hier, bijvoorbeeld, als ik print en optellen heb, doet deze functie meerdere dingen.
Het maakt zich zorgen over het afdrukken en het maakt zich ook ergens zorgen over.
En de definitie van deze functie wordt wat genoemd.
Ik bedoel, als ik het niet wist of dit niet zag en het enige wat ik deed was wat rennen, dan denk ik dat
een hoge afdruksnelheid verrassend zou zijn, omdat de naam niet echt beschrijft wat het doet.
Ik bedoel, ik verwacht dat dit nog wel even gaat duren.
Waarom zegt mijn programma hallo?
Dus we willen er zeker van zijn dat onze functie maar één ding echt doet?
Welnu, zoals we later zullen zien, kunnen we verschillende functies combineren en samen uitvoeren.
En dan willen we er ook zeker van zijn dat we iets teruggeven, want wat we op deze manier kunnen
doen, is dat we deze retourwaarde daadwerkelijk aan een variabele kunnen toewijzen.
Ik kan bijvoorbeeld zeggen dat het totaal ongeveer 10 is.
Vijf.
En omdat deze functie iets teruggeeft en als het klaar is, zal hardlopen 15 als waarde hebben, dat is
hetzelfde als wat we hier doen.
En hier is het coole deel, nu kan ik misschien een stuk of 10 rennen.
Plus totaal.
Laten we dit nu één voor één doornemen.
Ik definieer mijn functie, de Python-interpreter zal zeggen, oké, ik weet wat sommige zijn nu je het
hebt gedefinieerd.
Ik ga het in het geheugen bewaren.
Het gaat door, blijf doorgaan tot regel zeven.
En het gaat zeggen, hé, ik wil een variabel totaal en ik wil dat die totale variabele gelijk is aan ongeveer 10
vijf.
En voordat we zelfs maar iets toewijzen aan totale python, zal de tolk iets zeggen?
Weer wat.
Oh, ik herinner het me hier nog.
Het zit in het geheugen, oké, bij sommigen ga ik het argumenten 10 en vijf geven.
Dus het gaat die functie uitvoeren.
Zodra we deze sluithaak beëindigen, gaat hij de zon in.
Het gaat zeggen, hey, niemand zal gelijk zijn aan tien.
Hé, nummer twee wordt gelijk aan vijf.
Nu gaan we naar regel twee en het zal zeggen, hey, ik wil dat je tien plus vijf toevoegt omdat ik weet wat deze
variabelen zijn.
En als je daarmee klaar bent en dit verandert in 15, wil ik dat je terugkomt.
Dus de Python-interpreter, eindelijk, als hij klaar is met het aanroepen van sommigen, zal zeggen, hey, wijs de waarde
van 15 toe aan het variabele totaal en dan gaat het naar de volgende regel.
Hé, ik wil iets afdrukken.
Wat wil je printen?
Nou, ik wil dit afdrukken.
Het gaat zeggen, hey, wat ik weet wat hier op staat.
Ik heb het in het geheugen.
En dan weer, het gaat om tien te zeggen.
En dan wordt het volgende argument totaal.
Hé, wat is het totaal?
Laat me het geheugen gaan en het uitzoeken.
O, het is 15.
Dus het is alsof je 50 zegt.
En dit is de kracht van functies, juist, ik ben in staat om dingen terug te geven en ze toe te wijzen aan variabelen en ze zo aan
te roepen en ik kan ze blijven uitvoeren als ik dat wil.
Als ik dit nog eenvoudiger wil maken, kan ik gaan.
Sommige in plaats van totaal zullen hier zijn.
En kijk daar nu eens naar.
Ik heb het allemaal op één regel en als ik op uitvoeren klik.
Nogmaals, het werkt nog steeds.
Oké, maar wat als we zoiets doen?
Wat als ik zeg wat definieer en dan zeg ik definieer hier een andere functie en deze functie heeft
nummer één en nummer twee.
En hier komen we eindelijk terug op nummer één en nummer twee.
Hmm, laten we dit eens testen.
Wat denk je dat er gaat gebeuren?
Laten we eerst zeggen dat het totaal ongeveer 10 plus 20 is.
En dan ga ik het totaal afdrukken.
Als ik klik, ren dan weg.
Ik krijg er geen.
Nu, waarom is dat en dit zou voor jou duidelijk moeten zijn, want hier zeg ik, hey, ik wil dat je
iets definieert en wat gaan we doen met de functie?
Nou, hierbinnen, ik ga een andere functie definiëren.
Maar deze return-instructie wordt eigenlijk niet uitgevoerd.
Juist, want alles wat we doen in dit blok, dit codeblok.
Is dit deel dat we de functie definiëren, maar we roepen nooit een andere functie aan.
Dit levert dus geen op.
En we hebben het vermogen verloren om deze functie te noemen.
Dus hoe kunnen we dit oplossen?
Een manier is om terug te keren, toch?
Dus aan het einde hier, moeten we ervoor zorgen dat de inspringing goed is en we gaan nog een func
teruggeven.
Dus laten we return toevoegen en kijken wat hier gebeurt.
Als ik klik, ren dan weg.
Oké, ik krijg deze functie nu, dus het totaal zal gelijk zijn aan deze functie die we teruggaven en het staat in
het geheugen.
Oké, maar ik krijg niet het resultaat dat ik wil, toch?
En waarom is dat?
Want hoewel we deze functie niet aanroepen, zijn er een paar manieren waarop we dit kunnen doen.
We kunnen het hier de parameters of de argumenten geven.
Dus laten we zeggen 10, 20.
En als ik klik, ren dan weg.
Ik krijg 30 of als we willen houden wat we het hier geven, kan ik gewoon nog een funk zeggen.
Dus als we het nummer één en nummer twee geven en ik klik op uitvoeren.
Hé, kijk eens aan, ik krijg 30.
Nu, deze video moet je misschien steeds opnieuw bekijken, omdat het je geest een beetje verruimt, en
om eerlijk te zijn, deze functie is niet erg goed, want het is goed, het is erg verwarrend.
Uw functie moet gemakkelijk te begrijpen zijn.
Dus misschien willen we dit een beetje veranderen, misschien in plaats van hier dezelfde parameternamen te hebben om het
te verduidelijken.
Misschien kunnen we zeggen en één en twee.
En dan doen we dat hier.
En één plus en twee om te verduidelijken dat wanneer we deze andere functie teruggeven, ik de parameters nummer één en nummer twee
gebruik die we hier hebben genoemd.
Omdat deze definitie van een functie er niet echt om geeft wat deze dingen zijn.
Het maakt alleen uit wanneer een andere functie wordt aangeroepen.
Als je de video moet pauzeren en hiernaar moet kijken en dit misschien een beetje moet oefenen, dan
is dat volkomen begrijpelijk.
Maar ik wilde je de kracht van terugkeer laten zien.
Je kunt geneste functies hebben, net zoals je zou kunnen met conditionals, maar je moet
oppassen dat je functie ofwel iets retourneert, anders retourneert het niets.
En meestal wil je iets van een functie teruggeven, zodat we zoiets kunnen doen, waarbij we
het aan een variabele toewijzen, zodat we het later in onze programma's kunnen gebruiken.
Ik zie je bij de volgende.
Een laatste ding, een return-sleutelwoord verlaat automatisch de functie, zodat hier, als ik nog een stukje code
heb toegevoegd, zoals print, hallo?
Of misschien heb je hier zelfs vijf terug, je ziet dat het nog steeds geldig is, maar als ik dit doe.
Ik krijg nog steeds 30 omdat de tolk nooit op regel vijf en zes komt, want zodra we
iets van een functie retourneren, verlaat hij die functie.
En de reden dat dit deel de functie niet verlaat, is omdat, onthoud, binnen deze functie,
we definiëren.
Dus we voeren dit deel niet echt uit.
We zeggen alleen maar, hé, als we een andere functie in onze code zien verschijnen, weten we wat het is, maar
we gaan het niet uitvoeren.
Het gaat er dus zo uitzien.
En zodra het de return-statement ziet, als het koud wordt, zal het zeggen,
oké, ik verlaat deze functie met deze waarde.
Even een heads-up.