[18:29] <leoquant> commandoline, hier staat alles goed
[18:29] <commandoline> ok, prima. StefandeVries klaar?
[18:30] <leoquant> nog even wachten...
[18:30] <StefandeVries> klaar
[18:30] <commandoline> leoquant?
[18:30] <leoquant> ok
[18:30] <leoquant> ツ
[18:31] <commandoline> Goed, welkom allemaal bij de 5e les Python.
[18:32] <commandoline> Ten eerste wil ik nu iedereen die de cursus volgt aanwezig is, even zeggen dat vanaf deze les StefandeVries officieel mede-workshop leider is.
[18:32] <commandoline> tijdens de lessen doet hij de vragen, buiten de lessen zijn we beide bereikbaar daarvoor.
[18:32] <leoquant> welkom StefandeVries !
[18:33] <StefandeVries> dank jullie ;)
[18:33] <commandoline> Goed, ik had 2 huiswerkopdrachten gegeven i.v.m. de 2x uitval, dus laten we die eerst maar eens bekijken.
[18:33] <commandoline> de eerste opdracht is:
[18:34] <commandoline> http://paste.ubuntu.com/563139/
[18:35] <StefandeVries> bekijk dat voorbeeld, en kijk of het in grote lijnen hetzelfde werkt als jouw uitwerking. als je vragen hebt, kan je ze stellen
[18:35] <commandoline> ohnee, deze klopt niet zie ik nu
[18:35] <commandoline> ik heb het huiswerk van les 3 voor me :P
[18:36] <commandoline> http://paste.ubuntu.com/566649/
[18:36] <StefandeVries> Is op deze laatste opdracht nog een toelichting nodig, of lijkt hij duidelijk?
[18:37] <commandoline> de bijbehorende opdracht was:
[18:37] <commandoline> [19:28] <commandoline> wel heb ik nog een opdracht voor jullie bedacht
[18:37] <commandoline> [19:28] <commandoline> probeer dit programma zo om te schrijven, dat het een woordenboek wordt.
[18:37] <commandoline> [19:28] <commandoline> met als opties:
[18:37] <commandoline> [19:28] <commandoline> - een woord met betekenis toevoegen
[18:37] <commandoline> [19:29] <commandoline> - alle woorden & betekenissen tonen
[18:37] <commandoline> [19:29] <commandoline> - een woord verwijderen
[18:37] <commandoline> [19:29] <commandoline> - evt. een woord aanpassen
[18:37] <commandoline> bekijk het programma rustig, en voer het eens uit
 Hoe kan je gegevens sorteren in een dictionary?
[18:39] <StefandeVries> hannie: dit kan niet direct; daar zijn dictionaries niet voor bedoeld. er is een methode om de keys via een list te sorteren, en door die list te lopen. daar komen we na de les even op terug, als je dat zou willen
[18:40] <leoquant> ok gesnapt
[18:40] <StefandeVries> klopt, hannie
 Het woordenboek is eigenlijk exact hetzelfde als naam/e-mail (key/value)
[18:41] <commandoline> goed, als er geen vragen meer zijn gaan we door naar opdr. 2
[18:41] <commandoline> die staat hier: http://paste.ubuntu.com/575952/
[18:41] <commandoline> de bijbehorende opdracht was:
[18:41] <commandoline> [19:29] <commandoline> en voor degene die nog meer wil oefenen:
[18:41] <commandoline> [19:30] <commandoline> - probeer een winkelinventarisprogramma te schrijven, dat bijhoud wat een winkel allemaal in voorraad heeft.
[18:42] <commandoline> eigenlijk lijkt dit programma erg op het volgende
[18:43] <commandoline> het enige wat je even door moet hebben, is wat de bedoelde key/value combinatie is
[18:43] <commandoline> nl.:
[18:43] <commandoline> key = naam v/h product
[18:43] <commandoline> value = de hoeveelheid producten die de winkel op voorraad heeft.
[18:44] <commandoline> nogmaals, draai dit programma eens, en kijk of je het begrijpt
[18:44] <commandoline> hannie> We hebben toch al appels=10, peren=20 enz. gehad. Is dat wat je bedoelt?
[18:45] <commandoline> eigenlijk is dat inderdaad precies hetzelfde voorbeeld
[18:45] <commandoline> hier wordt het alleen toegepast in een programma, en die stap wilde ik jullie even laten maken.
[18:46] <commandoline> ok, als er toch nog vragen zijn mag dat ook na de les, ik kan me voorstellen dat het wat tijd kost om dit goed door te nemen
[18:46] <commandoline> vandaag gaan we namelijk met iets anders verder: functies.
[18:46] <commandoline> Ten eerste: wat is een functie?
[18:47] <commandoline> een functie kun je zien als een klein programma
[18:47] <commandoline> dat programma krijgt invoer, doet daar iets mee, en geeft het resultaat terug
[18:48] <commandoline> we hebben al een aantal functies gezien de afgelopen lessen, functies die standaard in python zitten.
[18:48] <commandoline> nl:
[18:48] <commandoline> len()
[18:48] <commandoline> raw_input()
[18:48] <commandoline> input()
[18:48] <commandoline> str()
[18:48] <commandoline> float() ook nog dacht ik?
[18:49] <commandoline> ok, float ook :)
 hmm wat deed float ook alweer?
[18:49] <StefandeVries> het maakte van een geheel getal een komma getal, Tjibba
 maar je kunt i.p.v. float ook een getal met ,00 opgeven bij input
[18:50] <commandoline> i.p.v. een komma moet het een punt zijn
[18:50] <StefandeVries> dat kan inderdaad ook, met een punt
[18:50] <commandoline> maar het achterliggende idee klopt :)
[18:50] <StefandeVries> commandoline was me voor
[18:51] <commandoline> ok, len() vind ik wel een mooi voorbeeld
[18:51] <commandoline> het krijgt invoer (bijv. een lijst), en geeft als resultaat de lengte van die lijst terug.
[18:51] <commandoline> dat is iets wat we ook zelf zouden kunnen doen, bijv. zo:
[18:51] <commandoline> lengte = 0
[18:52] <commandoline> for item in lijst:
[18:52] <commandoline>     lengte = lengte +1
[18:52] <commandoline> (in het echt is de implementatie anders, maar even ter illustratie)
[18:53] <commandoline> voordelen van de functie boven deze code is:
[18:53] <commandoline> *zijn
[18:54] <commandoline> - het is abstracter, je hoeft niet meer te bedenken dat bovenstaande code de lengte berekend.
[18:54] <commandoline> - hergebruik: het is mogelijk om de functie meerdere keren aan te roepen, terwijl we dan de code elke keer zouden moeten kopiëren, en dat is lastig in het onderhoud.
 Bedoel je met de lengte van de lijst het AANTAL items?
[18:56] <StefandeVries> Ja, hannie :)
 Kun je zelf ook functies maken ? En gaat dat dan richting object georienteerd programmeren ?
[18:56] <StefandeVries> MedUsaXIII74: Ja, dat gaan we deze les uitleggen en inderdaad, we gaan later in de cursus door op OOP. maar maak je voor nu geen zorgen. ;)
[18:57] <leoquant> ok
[18:57] <commandoline> goed, ik zal jullie nog een paar termen vertellen, voordat we verdergaan met een voorbeeld:
[18:58] <commandoline> het aanroepen (Eng: callen) van een functie = een functie gebruiken, bijv. len(list)
[18:58] <commandoline> argumenten (Eng: parameters of arguments) = invoer van een functie, in het voorbeeld is dat 'list'.
[18:59] <commandoline> maar bij bijv. de functie pow(x, y) (power, x tot de macht y), zijn dat x en y
[19:00] <commandoline> ten slotte is het handig om de engelse term te kennen voor 'waarde teruggeven aan het de aanroeper (caller)': return
 QUESTION: Over die tweede opdracht van vorige week, kan je python ook de values op laten slaan in een document?
[19:01] <StefandeVries> DooitzedeJong: ja, dat kan. in een later stadium van de cursus gaan we dit ook doen.
[19:01] <StefandeVries> maar voorlopig niet
[19:01] <commandoline> goed, alles duidelijk tot zover?
[19:02] <commandoline> /vragen?
[19:02] <commandoline> goed, dan gaan we het adresboekprogramma (huiswerkopdracht 1) omschrijven om functies te gebruiken.
[19:02] <commandoline> http://typewith.me/ep/pad/view/ro.LGhT4417wF8/latest
[19:03] <commandoline> hoewel, dat is hier al gebeurd :P Nou ja, ook goed, dan gaan we dat uitleggen :)
[19:05] <commandoline> goed, we gaan even kijken wat er allemaal gebeurd, en beginnen net als python zelf, bovenaan.
[19:05] <commandoline> daar zien we dat de lijst (list) menu_opties wordt aangemaakt
[19:05] <commandoline> dat hebben we eerder gedaan, niks bijzonders.
[19:06] <commandoline> daaronder wordt het interessant:
[19:06] <commandoline> we zien een nieuw statement, nl. 'def' .
[19:06] <commandoline> def definieert een nieuwe functie
[19:06] <commandoline> een eigen functie dus, waarvan we zelf duidelijk maken wat die doet.
[19:07] <commandoline> deze functie heeft menu, en onder die naam kunnen we hem straks dus bereiken
[19:07] <commandoline> tot slot geeft de eerste regel aan dat de functie menu een argument heeft, nl. 'opties'
 Wordt de functie door de programmeur gedefinieerd?
[19:09] <StefandeVries> Ja, je kunt een functie zelf definiëren, echter functies zoals len() niet; dit belcihten we later bij object geörienteerd programmeren
[19:10] <commandoline> en dat is ook precies wat gebeurd op regel 11 van het document
[19:10] <commandoline> de functie wordt hier dus gedefineerd, voor later gebruik.
[19:10] <commandoline> de functie menu doet het volgende:
[19:10] <commandoline> - het laat iedere optie zien in opties d.m.v. de for-loop
[19:11] <commandoline> - het vraagt de gebruiker om een keuze te maken m.b.v. input()
[19:11] <commandoline> - het geeft die keuze terug aan het hoofdprogramma (r. 18, return keuze)
[19:12] <commandoline> met deze functie kunnen we later zo aanroepen:
[19:12] <commandoline> keuze = menu(menu_opties)
[19:12] <commandoline> je ziet hier de twee voordelen terug:
[19:13] <commandoline> - we kunnen menu later nog een keer gebruiken, zelfs om een compleet ander menu te laten zien door i.p.v. menu_opties een andere lijst mee te geven.
[19:14] <commandoline> - de programmeur hoeft niet alle bovenstaande stappen te bedenken
[19:14] <commandoline> (abstractie), het enige waar de programmeur aan moet denken is om een lijst met menu opties door te geven aan menu(), en het resultaat op te slaan.
 Kan je de gedefinieerde functies opslaan en in andere programma's gebruiken?
[19:15] <StefandeVries> Ja, hannie, je kunt functies maken opslaan. deze bestanden kun je dan in programma's importeren en de functies dan aanroepen. volgende les wordt dit behandeld(modules)
 programma doet het nog niet klopt dit?
[19:16] <commandoline> hannie: je kunt momenteel ook nog gewoon regel 11 tot en met 20 kopieren naar een ander programma.
[19:17] <commandoline> bakeds: het werkt gewoon, zowel bij StefandeVries als bij mij.
[19:17] <commandoline> wel is het zo dat het nog niks doet als je het tot waar we nu zijn overneemt, bedoel je dat?
[19:19] <commandoline> vervolgens worden er nog een groot aantal functies gedefinieerd, ik loop ze wat sneller bij langs
[19:19] <commandoline> def toon_mailadressen(adresboek):
[19:20] <commandoline> deze functie toont alle mailadressen in 'adresboek' aan de gebruiker, we kunnen na deze declaratie dus zoiets doen:
[19:20] <commandoline> toon_mailadressen(adresboek_van_commandoline)
[19:20] <commandoline> deze functie geeft niks terug, het 'return'-statement staat nergens.
[19:21] <commandoline> de volgende functie heeft dezelfde argumenten en geeft opnieuw niets terug.
[19:21] <commandoline> def voeg_mailadres_toe(adresboek):
[19:21] <commandoline> het verschil is wat de functie zelf doet, namelijk een entry toevoegen aan het adresboek
[19:22] <commandoline> datzelfde geld voor verwijder_adresboek (r. 29)
[19:22] <commandoline> eh, regel 37
[19:22] <commandoline> goed, als je alles tot regel 41 in een bestand zet en dat uitvoerd, gebeurd er niks
[19:23] <commandoline> dat is zo, omdat we alleen een aantal functies hebben gedefinieerd, we doen er verder niks mee.
[19:23] <commandoline> ze worden niet aangeroepen, en daarom doen ze niks.
[19:23] <commandoline> dat komt nu, we beginnen met de welkomsboodschap:
[19:23] <commandoline> print "Welkom bij het adresboekprogramma"
[19:24] <commandoline> gevolgd door het aanmaken van het adresboek, en het starten van de while loop om het programma meerdere keren te laten draaien, zoals we vaker hebben gedaan.
[19:24] <commandoline> daarna roepen we onze eigen gedefinieerde functie aan:
[19:24] <commandoline> keuze = menu(menu_opties)
[19:24] <commandoline> keuze is nu gelijk aan wat de functie menu teruggeeft.
[19:25] <commandoline> dan kijken we wat de gebruiker heeft gekozen met if/elif/else
[19:25] <commandoline> iedere menuoptie heeft eerder een eigen functie gekregen, en die roepen we nu aan.
[19:26] <commandoline> (bijv. toon_mailadressen(adresboek))
[19:26] <commandoline> goed, dat is eigenlijk het hele programma.
[19:26] <commandoline> heeft iemand nog vragen tot zover?
[19:27] <commandoline> en is alles duidelijk?
 Maar ik zou het nog niet zelfstandig kunnen maken ):
[19:28] <commandoline> dat is oefenen
[19:28] <commandoline> en dat is dan ook het huiswerk voor de volgende keer:
[19:28] <commandoline> mijn eerste opdracht is, schrijf je eigen len()-functie
[19:28] <commandoline> ik stel voor dat we 'm num() noemen zoals hannie voorstelde :)
 Als je def voor een stukje code zet wordt het ook uitgevoerd, is dit te voorkomen ?
[19:29] <StefandeVries> MedUsaXIII74: hoe bedoel je dat precies? de code die je als functie definieert wordt als het goed is niet uitgevoerd als het niet aangeroepen wordt
[19:29] <commandoline> terwijl StefandeVries de vraag beantwoord, voor mensen die nog meer willen oefenen: herschrijf het rekenmachineprogramma om functies te gebruiken
[19:30] <commandoline> vaak is de menuopties in een functie zetten overzichtelijk
[19:30] <commandoline> goed, het is 20:30, tot volgende week allemaal! Wij gaan nog even door met vragen beantwoorden, en dat doen StefandeVries en ik doen dat ook graag door de week
[19:31] <commandoline> (en anderen ook, dus gewoon vragen in #ubuntu-nl-mwanzo)
[19:31] <StefandeVries> schaam je niet, ook wij zijn ergens en ooit begonnen :)
[19:32] <StefandeVries> Graag gedaan, hannie
 Stel dat je bijvoorbeeld van het menu een def wilt maken MAAR nog niet wilt uitvoeren op dat punt. Dat bedoel ik.
[19:33] <commandoline> MedUsaXIII74, code binnen functies wordt nooit uitgevoerd als ze gedefinieerd worden, dat gebeurd pas als ze aangeroepen worden
[19:33] <StefandeVries> precies
[19:33] <commandoline> en def maakt duidelijk dat we een functie definiëren. duidelijk?
[19:33] <StefandeVries> ik begreep je niet helemaal, MedUsaXIII74, mijn excuses
[19:34] <commandoline> <MedUsaXIII74> Zodat je die def later als menu kan gebruiken, maar je wilt hem al van te voren defineren ipv pas als je hem nodig hebt.
[19:34] <commandoline> dat gebeurt dus altijd, het is zeg maar het idee achter een functie, je definieert 'm voordat je 'm nodig hebt.
 Ik wil nog iets vragen over regel 18:
 Waar gaat return keuze naartoe?
[19:35] <commandoline> 'return' stuurt een waarde terug naar dat stuk code dat de functie aanroept
[19:35] <commandoline> dat is in ons programma:
[19:36] <commandoline> keuze = menu(menu_opties)
[19:36] <commandoline> keuze is dus gelijk aan wat de menu-functie terugstuurt.
 en je defineert hem door bijv aan te geven: menu = menu(menu1) of menu = menu(menu2)
[19:36] <commandoline> nee
[19:36] <commandoline> de definitie is alles wat achter 'def' staat.
[19:37] <commandoline> in het voorbeeldprogramma:
[19:37] <commandoline> def menu(opties):
[19:37] <commandoline> is de definitie
[19:37] <commandoline>         keuze = menu(menu_opties)
[19:37] <commandoline> is de aanroep