[18:28] <leoquant> alles gereed hier
[18:28] <commandoline> ok, bedankt
[18:29] <StefandeVries> dank je, leoquant
[18:30] <commandoline> Het is 19:30, dus laten we beginnen met de 8e pythonles!
[18:31] <commandoline> welkom allemaal, we gaan vandaag verder met waar we vorige week ook al mee bezig waren: OOP
[18:31] <commandoline> (Object Oriented Programming)
[18:31] <commandoline> laten we beginnen met het huiswerk van de vorige keer bespreken
[18:31] <commandoline> http://typewith.me/ep/pad/view/ro.KilZOISYC3j/latest
[18:32] <commandoline> het leek me goed om de uitwerking daarvan tijdens deze les te maken, omdat het toch een vrij ingewikkeld onderwerp is zoals jullie vorige les hebben gemerkt
[18:33] <commandoline> de opdracht was om de door ons geschreven class te gaan gebruiken.
[18:34] <commandoline> om dat te doen, hebben we eerst objecten nodig
[18:34] <commandoline> want met een class alleen kunnen we niks
[18:34] <commandoline> We gaan dus de class 'instantieren'; we krijgen dan een 'instantie' zoals jullie vorige week hebben gezien.
[18:35] <commandoline> vaak wordt in plaats van de term 'instantie' ook de term 'object' gebruikt.
[18:35] <commandoline> ok, zoals jullie zien heb ik nu een nieuw adresboek aangemaakt
[18:35] <commandoline> nu gaan we daar een mailadres aan toevoegen
[18:36] <commandoline> en nog een adres
[18:37] <commandoline> goed, we moesten het adresboek zoveel mogelijk gebruiken, en een adresboek heeft nog 3 methods (handelingen):
[18:37] <commandoline> - verwijder
[18:37] <commandoline> - sla_op
[18:37] <commandoline> - laad
[18:37] <commandoline> dus laten we die ook maar gebruiken, ten eerste verwijder
[18:38] <commandoline> zo, ik ben geschrapt uit mijn eigen adresboek.
[18:38] <commandoline> tijd om het adresboek op te slaan
[18:39] <commandoline> goed, om de laatste method te gebruiken, namelijk laad(), gaan we een tweede adresboek aanmaken.
[18:39] <StefandeVries> hannie: dat zit er prima uit :)
[18:39] <commandoline> (19:39:20) hannie: elif keuze == 3:
[18:39] <commandoline> (19:39:20) hannie: 		naamweg = raw_input("Welke naam moet weg?")
[18:39] <commandoline> (19:39:20) hannie: 		mijnAB.verwijder(naamweg)
[18:39] <commandoline> (19:39:26) hannie: Ik had dit
[18:39] <commandoline> (19:39:46) hannie: mijnAB zelfde als Adresboek1
[18:40] <commandoline> klopt, de naam adresboek1 is gewoon gekozen, net zoals je hierbij een naam kan kiezen:
[18:40] <commandoline> getal = input("Geef een getal")
[18:40] <commandoline> getal had net zo goed nummer kunnen zijn
[18:40] <commandoline> hier is dat ook zo
[18:40] <commandoline> ok, we gingen dus een tweede adresboek aanmaken
[18:41] <commandoline> wat ik daarna heb gedaan, is het laden van het adresboek dat net was opgeslagen in het nieuwe adresboek
[18:41] <commandoline> op dit moment is adresboek1 dus gelijk aan adresboek2
[18:42] <commandoline> oh, ik had een foutje gemaakt
[18:42] <commandoline> ik wilde hetzelfde bestand laden
[18:42] <commandoline> (bedankt, StefandeVries!)
[18:42] <commandoline> en dat gebeurt nu ook
[18:42] <leoquant> hannie> Ik zie alleen adresboek1=adresboek(). Heb ik adresboek2 gemist?
[18:42] <commandoline> ik heb hier toch wat meer staan, momentje...
[18:43] <StefandeVries> hannie: foutje van commandoline; we gebruiken voor adresboek2 het opgeslagen adresboek van adresboek1
[18:43] <commandoline> http://typewith.me/ep/pad/view/ro.KilZOISYC3j/latest
[18:43] <commandoline> klopt bij mij gewoon
[18:44] <commandoline> ik ga wel verder, want ik hoor verder geen mensen die het bestand niet kunnen volgen.
[18:45] <commandoline> goed, ik wil aan het tweede adresboek een nieuw mailadres toevoegen.
[18:45] <commandoline> en dat heb ik gedaan.
[18:46] <commandoline> laten we om er een werkend programma van te maken ook nog even laten zien welke adressen nu precies in het adresboek zitten.
[18:47] <commandoline> goed, we hebben nu een werkend programma, dat een adresboek aanmaakt en daar verschillende handelingen op uitvoert
[18:47] <commandoline> het voordeel is dat we niet meer zelf hoeven na te denken over hoe we een bestand laden en opslaan, of over hoe je een naam verwijdert uit een dictionary
[18:48] <commandoline> begrijpt iedereen nu wat dit programma doet?
[18:48] <commandoline> (19:48:39) MedUsaXIII56: Ik snap het wel, maar hoe gebruik je dit programma nu precies ?
[18:49] <commandoline> dit programma geeft altijd hetzelfde resultaat.
[18:49] <commandoline> het laat puur zien hoe de class Adresboek functioneert.
[18:50] <commandoline> (19:49:56) MedUsaXIII56: Ok, je moet dus zelf de raw inputs er in doen ? 2e vraag, we hebben geen functie aan gemaakt die alle adrssen laad zien of wel ?
[18:50] <StefandeVries> Klopt allebei
[18:50] <commandoline> maar, dat laatste is op zich niet nodig
[18:50] <commandoline> want we hebben de property 'adressen'
[18:50] <commandoline> en de vragen van MedUsaXIII56 sluiten prachtig aan op de link die ik jullie wilde geven:
[18:51] <commandoline> http://paste.ubuntu.com/588654/
[18:51] <commandoline> hier wordt precies dezelfde class gebruikt
[18:51] <commandoline> maar er is een programma omheen geschreven.
[18:52] <commandoline> Ik ga dat programma nu niet uitgebreid uitleggen, maar ik raad jullie aan om het door te lezen en te draaien, en de volgende keer vragen te stellen als jullie (een deel ervan) niet begrijpen.
[18:53] <commandoline> ik wil nu namelijk samen met jullie een programma schrijven, zodat je doorkrijgt hoe dat nou eigenlijk werkt, zo'n class schrijven.
[18:53] <commandoline> hoewel, eigenlijk schrijven we samen de class die het gebruikt, jullie mogen het daaromheenliggende programma gebruiken.
[18:54] <commandoline> het programma dat we gaan maken heet 'galgje.py'
[18:54] <commandoline> en kan worden gebruikt om een spel te spelen wat jullie allemaal wel kennen :)
[18:54] <commandoline> http://typewith.me/ep/pad/view/ro.KSz8svqakm4/latest
[18:56] <commandoline> goed, we willen vandaag de logica achter het spel galgje gaan programmeren.
[18:56] <commandoline> de interface die die logica gebruikt, gaan jullie later maken.
[18:56] <commandoline> om dat wat toe te lichten
[18:57] <commandoline> de class Adresboek bevatte de logica van het adresboekprogramma
[18:57] <commandoline> de rest was de gebruikersinterface
[18:57] <commandoline> centraal in galgje is het woord dat geraden moet worden.
[18:58] <commandoline> dus we gaan een class maken die 'Woord' heet.
[18:58] <commandoline> duidelijk tot zover?
[18:58] <commandoline> OK, blijkbaar is het duidelijk.
[18:59] <commandoline> dan wordt het nu eerst tijd om de eigenschappen (properties) en handelingen (methods) te bedenken.
[19:00] <commandoline> in dit geval hebben we een aantal properties:
[19:00] <StefandeVries> hannie: dat is aan te raden, zeker bij grote projecten
[19:00] <commandoline> - aantal_fouten; op basis hiervan kunnen jullie in je interface de galg tekenen.
[19:00] <commandoline> (20:00:19) hannie: Je zou dus eigenlijk eerst een ontwerp op papier moeten zetten?
[19:00] <StefandeVries> (08:00:34 PM) StefandeVries: hannie: dat is aan te raden, zeker bij grote projecten
[19:01] <commandoline> en ook bij kleine projecten kan het zeker in het begin, handig zijn :)
[19:02] <commandoline> daarnaast is het voor de interface handig om te weten uit hoeveel letters het woord bestaat
[19:02] <commandoline> dan kan die het juiste aantal 'streepjes' neerzetten.
[19:02] <commandoline> dus een property 'lengte'
[19:02] <commandoline> goed, dan de handelingen:
[19:02] <commandoline> 'gok_letter'
[19:03] <commandoline> misschien is raad_letter trouwens mooier.
[19:03] <commandoline> en daarnaast:
[19:03] <commandoline> raad_woord
[19:04] <commandoline> goed, daarnaast moet het nog mogelijk zijn om een woord te geven aan de Woord-class
[19:04] <commandoline> het woord dat geraden moet wordne
[19:04] <commandoline> *worden
[19:04] <commandoline> ik geef dat door via de handeling __init__, die automatisch wordt aangeroepen door python bij het maken van een instantie/object
[19:04] <commandoline> zoals jullie later zullen zien.
[19:05] <commandoline> (20:05:18) hannie: Moet je categorie?n maken, b.v. 5-letter woorden enz.?
[19:06] <StefandeVries> nee, hannie, Python kan automatisch berekenen uit hoeveel letters het woord dat je gebruikt bestaat
[19:06] <commandoline> en
[19:06] <StefandeVries> en daar de interface op aanpassen
[19:06] <commandoline> goed, ik heb alle handelingen/methods toegevoegd
[19:07] <commandoline> nou nog de properties, ik doe dat meestal in __init__ want dan zijn ze direct vanaf het aanmaken van het object beschikbaar
[19:08] <commandoline> ok, en daarmee is de eerste handeling/method gelijk klaar :)
[19:08] <commandoline> laten we eerst eens de raad_woord handeling/method invullen
[19:08] <commandoline> de gebruiker geeft daarbij een woord
[19:09] <commandoline> de handeling/method kijkt of dat woord klopt
[19:09] <commandoline> en als dat zo is, wordt 'True' teruggegeven.
[19:09] <commandoline> als dat niet zo is, wordt het aantal fouten met 2 verhoogt
[19:09] <commandoline> en wordt False teruggegeven.
[19:11] <commandoline> en dat is alweer omgezet in code :)
[19:11] <commandoline> goed, dan blijft er nog één handeling/method over
[19:11] <commandoline> en die is het ingewikkeldst
[19:11] <commandoline> de aanroeper ervan geeft een letter waarvan hij/zij denkt dat die in het woord zit.
[19:12] <commandoline> als dat zo is, dan moeten *alle* posities waarop dat zo is doorgegeven worden.
[19:12] <StefandeVries> hannie: waarom komen er tegelijk 2 fouten bij en niet 1?
[19:12] <commandoline> en voor het gemak, geef ik dan ook meteen de bijbehorende letter mee terug
[19:12] <StefandeVries> Raad je een letter fout dan heb je één fout. Raad je het woord fout, heb je twee fout
[19:13] <commandoline> en anders wordt er één fout toegevoegd.
[19:16] <commandoline> ok, en daarmee is de class af.
[19:17] <commandoline> begrijp iedereen wat ik gedaan heb, en ook hoe deze class te gebruiken is?
[19:17]  * commandoline verwacht vragen :)
[19:17] <StefandeVries> hannie: een beetje, heeft nog bestudering nodig
[19:17] <StefandeVries> We zijn er bijna altijd ;)
[19:18] <commandoline> goed, ik zal jullie dan een beetje op weg helpen met de interface
[19:19] <commandoline> zodat jullie daar als jullie die deze week proberen te maken niet op vastlopen.
[19:19] <commandoline> zoals jullie zien heb ik een stukje code toegevoegd
[19:20] <commandoline> dat wil ik nog even regel voor regel behandelen.
[19:20] <commandoline> wat het doet is de class gebruiken.
[19:20] <commandoline> zo, even gok weer in raad verandert :)
[19:21] <commandoline> ok, zo werkt het programma weer...
[19:21] <commandoline> (even getest)
[19:21] <commandoline> regel 35
[19:21] <leoquant> hannie> wat houdt main in?
[19:21] <commandoline> ben ik net mee bezig :)
[19:22] <commandoline> die regel betekend zoiets als:
[19:22] <commandoline> 'Als dit bestand uitgevoerd wordt (niet bijv. geimporteerd via import), dan...'
[19:22] <commandoline> __name__ wordt door python op '__main__' gezet als dat het geval is
[19:22] <commandoline> ok, volgende regel, 36:
[19:23] <commandoline> hierin wordt een nieuw woord aangemaakt
[19:23] <commandoline> het woord 'test' moet geraden worden
[19:23] <commandoline> vervolgens raden we een letter, de 't'. Die zit er twee keer in. We krijgen dan ook terug:
[19:23] <commandoline> [[0, 't'], [3, 't']]
[19:24] <commandoline> m.a.w., de letter t komt voor op positie 0 en positie 3
[19:24] <commandoline> dit is handig als jullie jullie interface gaan maken (hint)
[19:24] <commandoline> oja, ik had nog een regel overgeslagen
[19:24] <commandoline> regel 38, waarop de lengte van het woord wordt opgevraagd
[19:25] <commandoline> dat geeft 4 terug
[19:25] <commandoline> (die property hadden we eerder aangemaakt)
[19:25] <commandoline> goed, daarna raden we nog een letter:
[19:25] <commandoline> de 's'
[19:25] <commandoline> die zit er ook in, we krijgen dus:
[19:25] <commandoline> [[2, 's']] terug
[19:26] <commandoline> pas hier verandert wat:
[19:26] <commandoline>     print woord.raad_letter("x")
[19:26] <commandoline> we vragen de x, en die zit er niet in. we krijgen dus een lege list [] terug
[19:26] <commandoline> en als we nu het aantal fouten opvragen:
[19:26] <commandoline>     print woord.aantal_fouten
[19:26] <commandoline> is dat 1
[19:26] <commandoline> daarna raden we het woord 'tesst' (dom, teveel letters :()
[19:27] <commandoline> dat levert achter de schermen twee punten aftrek op, trouwens
[19:27] <commandoline> en we krijgen daarom False terug
[19:27] <commandoline> daarna raden we 'test'
[19:27] <commandoline> en dat klopt :)
[19:27] <commandoline> daarna willen we nog even het aantal fouten weten
[19:27] <commandoline> print woord.aantal_fouten.
[19:28] <commandoline> dat is 3
[19:28] <commandoline> jullie kunnen precies diezelfde methods en properties gebruiken om het spel te laten spelen door de gebruiker
[19:28] <commandoline> (20:28:28) hannie: en dan moet Barbertje nog getekend worden
[19:29] <commandoline> als dat te ingewikkeld is, kan je gewoon de score laten zien in de interface
[19:29] <commandoline> maar leuker is om met ascii-art e.d. te gaan werken
[19:29] <commandoline> (zie wikipedia)
[19:29] <commandoline> oja, nog een hint:
[19:30] <commandoline> maak eerst een list aan met allemaal '_' erin
[19:30] <commandoline> met de lengte van het woord
[19:30] <commandoline> en vervang zodra je een letter terugkrijgt die klopt, het streepje op die index door de mee teruggegeven letter.
[19:31] <commandoline> ok, ik ben benieuwd wat jullie maken van de twee opdrachten:
[19:31] <commandoline> - probeer het adresboekprogramma zoals halverwege gegeven te begrijpen, en stel vragen als dat niet zo is:
[19:31] <commandoline> http://paste.ubuntu.com/588654/
[19:32] <commandoline> - maak een mooie interface voor galgje, als je ergens op vastloopt, vraag dan in #ubuntu-nl-mwanzo, dan helpen we je een stukje op weg :)
[19:32] <commandoline> goed, dat was het voor vandaag
[19:32] <commandoline> bedankt voor jullie komst allemaal :)
[19:32] <commandoline> en tot volgende week!
[19:38] <StefandeVries> dank je, leoquant :)
[19:38] <leoquant> mooi les
[19:38] <leoquant> e
[19:38] <StefandeVries> dank je