[08:25] <leoquant> sst
[17:54] <leoquant> zo
[17:54] <leoquant> de negende cursus
[18:32] <commandoline> goed, we gaan wel beginnen.
[18:33] <commandoline> welkom bij de -volgens mijn administratie- negende pythonles!
[18:33] <commandoline> goed, laten we beginnen met het huiswerk
[18:33] <commandoline> ten eerste had ik gevraagd of iedereen http://paste.ubuntu.com/588654/ begreep
[18:34] <commandoline> het belangrijkste verschil met eerdere programma's is dat hier het 'hoofdprogramma' in een class is verpakt
[18:34] <commandoline> het programma wordt uitgevoerd door de voer_uit()-method aan te roepen
[18:35] <commandoline> en dat gebeurt onderin:
[18:35] <commandoline> if __name__ == "__main__":
[18:35] <commandoline> 	adresboekProgramma = AdresboekProgramma()
[18:35] <commandoline> 	adresboekProgramma.voer_uit()
[18:35] <commandoline> de rest is wel besproken van dat voorbeeld eerder, dus ik neem aan dat jullie daar allemaal wel uitkomen.
[18:36] <commandoline> ok, dan gaan we over naar de tweede opdracht: galgje!
[18:36] <commandoline> ten eerste: heeft iemand daar vragen over?
[18:37] <commandoline> ok, ik zal jullie eerst even een relatief simpele uitwerking laten zien
[18:37] <commandoline> en daarna een waar kunstwerk gemaakt door CasW :)
[18:37] <commandoline> http://paste.ubuntu.com/591810/
[18:38] <commandoline> jullie zien bij die link eerst de Word-class van vorige week
[18:38] <commandoline> daarna wordt een woord gekozen om te raden
[18:39] <commandoline> dat in de code zetten ('hardcoden') is natuurlijk niet zo slim
[18:39] <commandoline> maar het is wel simpel
[18:39] <commandoline> het alternatief zou zijn om de gebruiker te vragen een woord in te vullen.
[18:40] <commandoline> goed, we gebruiken hier in het programma een list met daarin allemaal strings van 1 teken
[18:40] <commandoline> standaard zijn die tekens '_'
[18:40] <commandoline> maar gaandeweg veranderen ze in letters die geraden zijn
[18:41] <commandoline> het aanmaken van die list gebeurt op de regels 39-41
[18:41] <commandoline> daarna start het spel
[18:41] <commandoline> (de while loop)
[18:41] <commandoline> er wordt altijd eerst de uitvoer opgebouwd:
[18:41] <commandoline> eerst worden alle letters weergeven
[18:42] <commandoline> en daarna wordt de galg getekend, als er een bepaald aantal fouten is gemaakt
[18:42] <commandoline> text += " _________     \n" if woord.aantal_fouten > 0 else "\n"
[18:42] <commandoline> daar staat hetzelfde als:
[18:42] <commandoline> if woord.aantal_fouten > 0:
[18:42] <commandoline>     += " _________     \n"
[18:42] <commandoline> else:
[18:42] <commandoline>     text += "\n"
[18:43] <commandoline> en ik ben het woord 'text' voor die eerste keer vergeten
[18:43] <commandoline> (19:42:39) FOAD: Je bouwt dus elke keer "text" opnieuw op, ok.
[18:44] <CasW> Ja
[18:44] <CasW> (Sorry voor de late reactie)
[18:44] <commandoline> ok, als dat gebeurd is, wordt gekeken of er al teveel fouten zijn gemaakt.
[18:45] <commandoline> (19:44:42) hannie: Ik begrijp de 3 streepjes in het midden niet. Dat zijn toch 3 fouten
[18:45] <CasW> Welke 3 streepjes bedoel je precies?
[18:45] <CasW> (19:45:21) hannie: armpje, buikje, armpje
[18:46] <CasW> Ja, het galgje wordt per 'lijn' getekend
[18:46] <CasW> *nee dus
[18:46] <CasW> Dat is dus een fout
[18:46] <commandoline> de galg wordt hier van boven naar onder getekend, draai het programma maar eens, dan zie je het vanzelf
[18:47] <commandoline> ok, er wordt daarna dus nagegaan of er al teveel fouten (>6) zijn gemaakt
[18:47] <commandoline> zoja, dan heb je verloren en stopt de while loop
[18:47] <commandoline> daarna wordt een menu weergeven
[18:48] <commandoline> dat afhankelijk van de keuze v/d gebruiker een letter laat raden, een woord, of het spel stopt
[18:48] <commandoline> (ja, je kan stoppen als je dik aan het verliezen bent :P)
[18:49] <commandoline> maar goed, die opties worden gewoon afgehandeld met behulp van de class
[18:49] <commandoline> 		locaties = woord.raad_letter(letter)
[18:49] <commandoline>  		for locatie in locaties:
[18:49] <commandoline>  			geraden[locatie[0]] = locatie[1]
[18:49] <commandoline> is nog wel interessant
[18:50] <commandoline> daar gebruiken we de eigenschap dat raad_letter het volgende teruggaf:
[18:50] <commandoline> [positie, letter]
[18:50] <commandoline> ok, is dit voorbeeld dan duidelijk?
[18:51] <commandoline> mooi, zoals zolangzamerhand wel duidelijk is heeft CasW aan een andere uitwerking gewerkt.
[18:51] <commandoline> http://www.technotaal.nl/qhangman/qhangman.tar.gz
[18:51] <commandoline> let wel: je hebt het pakket 'python-qt4' nodig
[18:52] <CasW> Omdat ik hem nog niet heb verwerkt tot een .deb, moet je die dus zelf installeren
[18:52] <CasW> (.deb komt er wel nog aan)
[18:52] <commandoline> maar dat is niet zo moeilijk:
[18:52] <commandoline> gewoon het bestand uitpakken en hangman.py starten
[18:53] <CasW> Dat is dus het spel starten
[18:53] <CasW> Niet PyQT installeren, dat is gewoon sudo apt-get install python-qt4
[18:54] <commandoline> ok, jullie kunnen het rustig bekijken, in de tussentijd ga ik verder
[18:54] <commandoline> verdere uitleg over QHangman volgt in -mwanzo
[18:55] <commandoline> ok, ik wil jullie vandaag nog wat nieuws uitleggen.
[18:55] <commandoline> het gaat om een onderdeel van OOP:
[18:56] <commandoline> inheritance (overerving)
[18:56] <commandoline> je kan het gebruiken om classes uit te breiden.
[18:56] <commandoline> bijvoorbeeld:
[18:57] <commandoline> je hebt een class die bijna alles doet wat je wilt
[18:57] <commandoline> maar één method ontbreekt
[18:58] <commandoline> bijv. bij een list, je zou kunnen denken aan 'randomItem()'
[18:58] <commandoline> je kan dan de complete list-class herschrijven
[18:58] <commandoline> maar dat is veel te veel werk
[18:59] <commandoline> in plaats daarvan kan je ervoor kiezen om een nieuwe class te maken die overerft van 'list'
[19:00] <commandoline> goed, ander voorbeeld:
[19:00] <commandoline> je hebt een voertuig
[19:00] <commandoline> ieder voertuig kan bijv. bewegen
[19:00] <commandoline> als je nou zowel een fiets als een auto zou willen programmeren
[19:01] <commandoline> dan kan je ervoor kiezen om de functionaliteit die het bewegen regelt in een class Voertuig te stoppen
[19:01] <commandoline> waarvan zowel Auto als Fiets overerven, zodat je geen dubbele code schrijft.
[19:01] <commandoline> duidelijk tot zover?
[19:02] <commandoline> http://typewith.me/ep/pad/view/ro.W-w-q$ggIak/latest
[19:03] <commandoline> goed, laten we dat voorbeeld eens in code omzetten
[19:03] <commandoline> ten eerste maken we een class aan
[19:04] <commandoline> aangezien een voertuig kan bewegen, wil ik dat het ergens staat zodra het geïnitialiseerd is.
[19:05] <commandoline> daarom heb ik de mogelijkheid gegeven om een x en y coördinaat te geven.
[19:06] <commandoline> goed, zoals ik al eerder zei, ieder voertuig kan bewegen.
[19:07] <commandoline> dus we kunnen hem een 'vooruit'-method geven.
[19:07] <commandoline> ok, ik houd het even simpel en laat eigenschappen als 'richting' even weg.
[19:08] <commandoline> vooruit doet niks anders dan een bepaalde afstand afleggen, opgeteld bij laten we zeggen x.
[19:09] <CasW> (20:09:10) FOAD: Wat doet aantal_vakjes nu?
[19:09] <CasW> Dat zegt hoeveel vakjes hij in de x-richting moet gaan
[19:09] <commandoline> scherp, FOAD
[19:09] <CasW> *hoeveel eenheden
[19:09] <commandoline> ik maak een foutje :(
[19:09] <CasW> Correctie, nú zegt die dat
[19:10] <commandoline> goed, genoeg over een voertuig
[19:10] <commandoline> laten we nu een fiets gaan maken.
[19:12] <commandoline> ok, het idee is hier dat je een versnelling kan opgeven aan een fiets
[19:12] <commandoline> en dat de viets afhankelijk van die versnelling een verschillend aantal hokjes opschuift bij 1x trappen.
[19:12] <commandoline> begrijpt iedereen ongeveer wat hier gebeurd?
[19:12] <commandoline> *gebeurt
[19:12] <CasW> *fiets
[19:13] <commandoline> hmm, ik ben niet helemaal wakker geloof ik :P
[19:13] <leoquant> gaat goed hor!
[19:13] <leoquant> o
[19:14] <commandoline> ok, volgende voertuig, idd
[19:14] <commandoline> (reactie op: (20:13:46) FOAD: En nu komt er een ander voertuig?)
[19:14] <commandoline> goed, een auto moet zich aan een snelheidslimiet houden.
[19:16] <commandoline> dat betekent dat als vooruit() wordt aangeroepen op een auto, dat die niet sneller dan de maximumsnelheid gaat, ondanks het aantal_vakjes dat is opgegeven.
[19:16] <commandoline> (20:16:02) FOAD: Zou fiets.versnelling niet een default waarde moeten hebben?
[19:16] <CasW> Je kunt inderdaad zeggen dat 'ie een default waarde heeft, dan doe je:
[19:16] <CasW> def __init__(self, versnelling = 1)
[19:17] <CasW> Bijvoorbeeld
[19:17] <commandoline> FOAD: duidelijk?
[19:17] <commandoline> ok, verder met de auto
[19:17] <commandoline> hoewel, ik ben nog wat bij de Fiets vergeten
[19:18] <commandoline> de __init__ daarvan moet de __init__ van Voertuig aanroepen
[19:18] <commandoline> anders wordt self.x niet op een bepaalde waarde geset.
[19:18] <commandoline> (20:18:41) exalt: moet het gewicht / bouw / materiaal keuze van de fiets niet ook iets invloed hebben over de snelheden?
[19:19] <commandoline> (20:18:59) CasW: Dan moet je nog weer meer toevoegen aan die fiets
[19:19] <CasW> Maar dan heb je alweer een ander soort fiets
[19:19] <CasW> Dus dan doe je bijvoorbeeld class Mountainbike(Fiets)
[19:19] <commandoline> dat is inderdaad een mogelijkheid
[19:20] <commandoline> daarnaast kun je eigenlijk nooit alle eigenschappen van een object overnemen
[19:20] <commandoline> sommige zijn ook niet relevant
[19:20] <commandoline> je implementeert alleen wat je nodig hebt.
[19:20] <commandoline> duidelijk, exalt?
[19:22] <commandoline> in de tussentijd: ik heb zoals jullie hebben gezien op regel 22 gezorgd dat de __init__ van Voertuig aangeroepen.
[19:22] <commandoline> waardoor de code weer werkt.
[19:22] <commandoline> ok, nu de auto implementeren
[19:25] <commandoline> ok, duidelijk wat ik tot nu toe allemaal heb getypt?
[19:25] <CasW> self.vooruit
[19:25] <commandoline> en ook hoe je het moet gebruiken?
[19:25] <CasW> Niet Voertuig.vooruit
[19:25] <commandoline> CasW: nee, want dan roept hij zichzelf aan
[19:26] <commandoline> (20:25:42) FOAD: Ja.  Ik moet het nog in detail bestuderen, maar dat inheritance concept is leuk hoor.
[19:26] <commandoline> het is een leuk concept, maar zorg wel dat je het alleen toepast als het echt nuttig is
[19:26] <CasW> En bij Fiets dan? ;)
[19:26] <commandoline> CasW: daar roept de method 'trap' de method 'vooruit' aan
[19:27] <commandoline> in dat geval wordt de method niet opnieuw geimplementeerd
[19:27] <CasW> Och ja, nu zie ik het pas, excuses
[19:27] <commandoline> inheritance gebruiken om hele abstracte objecten te maken die amper wat doen op zichzelf heeft niet altijd evenveel nut.
[19:28] <commandoline> ok, verder nog vragen?
[19:28] <commandoline> goed, tijd voor het huiswerk voor de volgende keer dan
[19:29] <commandoline> -- installeer: pyqt4 (python library) en laby (programmeerspelletje)
[19:29] <commandoline> --- sudo apt-get install sudo apt-get install python-qt4 laby
[19:29] <commandoline> -- schrijf de class die beschreven wordt bij deze link, op de plek van het commentaar:
[19:29] <commandoline> --- http://paste.ubuntu.com/591811/
[19:30] <commandoline> -- kijk hoe ver je kan komen bij het spel 'laby' (selecteer als programmeertaal Python). (Toepassingen > Spelletjes > Logica > Laby)
[19:30] <commandoline> (20:30:24) CasW: Eenmaal sudo apt-get install
[19:30] <commandoline> (20:30:28) CasW: Niet tweemaal
[19:30] <commandoline> sudo apt-get install python-qt4 laby
[19:30] <commandoline> wordt het dan
[19:30] <commandoline> goed, succes allemaal
[19:31] <commandoline> CasW, StefandeVries (neem ik aan) en ik zijn vaak in -mwanzo of een ander ubuntukanaal om vragen te beantwoorden
[19:31] <commandoline> en ik blijf nu ook bereikbaar voor vragen
[19:32] <commandoline> oja, je mag proberen om de classes die we hebben gemaakt te gebruiken
[19:32] <commandoline> mocht je dat willen (en dan zie je direct of er nog fouten in zitten, ik heb dit nl. uit het hoofd getypt)
[19:32] <commandoline> tot volgende week!
[19:32] <commandoline> (dan trouwens waarschijnlijk vanaf de Ubuntu Jam in Burgum!)
[19:32] <leoquant> commandoline, en CasW bedankt weer!
[19:33] <commandoline> graag gedaan leoquant, jij ook bedankt weer :)