#ubuntu-nl-mwanzo-klas 2011-04-02
<leoquant> alles gereed hier
<commandoline> ok, bedankt
<StefandeVries> dank je, leoquant
<commandoline> Het is 19:30, dus laten we beginnen met de 8e pythonles!
<commandoline> welkom allemaal, we gaan vandaag verder met waar we vorige week ook al mee bezig waren: OOP
<commandoline> (Object Oriented Programming)
<commandoline> laten we beginnen met het huiswerk van de vorige keer bespreken
<commandoline> http://typewith.me/ep/pad/view/ro.KilZOISYC3j/latest
<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
<commandoline> de opdracht was om de door ons geschreven class te gaan gebruiken.
<commandoline> om dat te doen, hebben we eerst objecten nodig
<commandoline> want met een class alleen kunnen we niks
<commandoline> We gaan dus de class 'instantieren'; we krijgen dan een 'instantie' zoals jullie vorige week hebben gezien.
<commandoline> vaak wordt in plaats van de term 'instantie' ook de term 'object' gebruikt.
<commandoline> ok, zoals jullie zien heb ik nu een nieuw adresboek aangemaakt
<commandoline> nu gaan we daar een mailadres aan toevoegen
<commandoline> en nog een adres
<commandoline> goed, we moesten het adresboek zoveel mogelijk gebruiken, en een adresboek heeft nog 3 methods (handelingen):
<commandoline> - verwijder
<commandoline> - sla_op
<commandoline> - laad
<commandoline> dus laten we die ook maar gebruiken, ten eerste verwijder
<commandoline> zo, ik ben geschrapt uit mijn eigen adresboek.
<commandoline> tijd om het adresboek op te slaan
<commandoline> goed, om de laatste method te gebruiken, namelijk laad(), gaan we een tweede adresboek aanmaken.
<StefandeVries> hannie: dat zit er prima uit :)
<commandoline> (19:39:20) hannie: elif keuze == 3:
<commandoline> (19:39:20) hannie: 		naamweg = raw_input("Welke naam moet weg?")
<commandoline> (19:39:20) hannie: 		mijnAB.verwijder(naamweg)
<commandoline> (19:39:26) hannie: Ik had dit
<commandoline> (19:39:46) hannie: mijnAB zelfde als Adresboek1
<commandoline> klopt, de naam adresboek1 is gewoon gekozen, net zoals je hierbij een naam kan kiezen:
<commandoline> getal = input("Geef een getal")
<commandoline> getal had net zo goed nummer kunnen zijn
<commandoline> hier is dat ook zo
<commandoline> ok, we gingen dus een tweede adresboek aanmaken
<commandoline> wat ik daarna heb gedaan, is het laden van het adresboek dat net was opgeslagen in het nieuwe adresboek
<commandoline> op dit moment is adresboek1 dus gelijk aan adresboek2
<commandoline> oh, ik had een foutje gemaakt
<commandoline> ik wilde hetzelfde bestand laden
<commandoline> (bedankt, StefandeVries!)
<commandoline> en dat gebeurt nu ook
<leoquant> hannie> Ik zie alleen adresboek1=adresboek(). Heb ik adresboek2 gemist?
<commandoline> ik heb hier toch wat meer staan, momentje...
<StefandeVries> hannie: foutje van commandoline; we gebruiken voor adresboek2 het opgeslagen adresboek van adresboek1
<commandoline> http://typewith.me/ep/pad/view/ro.KilZOISYC3j/latest
<commandoline> klopt bij mij gewoon
<commandoline> ik ga wel verder, want ik hoor verder geen mensen die het bestand niet kunnen volgen.
<commandoline> goed, ik wil aan het tweede adresboek een nieuw mailadres toevoegen.
<commandoline> en dat heb ik gedaan.
<commandoline> laten we om er een werkend programma van te maken ook nog even laten zien welke adressen nu precies in het adresboek zitten.
<commandoline> goed, we hebben nu een werkend programma, dat een adresboek aanmaakt en daar verschillende handelingen op uitvoert
<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
<commandoline> begrijpt iedereen nu wat dit programma doet?
<commandoline> (19:48:39) MedUsaXIII56: Ik snap het wel, maar hoe gebruik je dit programma nu precies ?
<commandoline> dit programma geeft altijd hetzelfde resultaat.
<commandoline> het laat puur zien hoe de class Adresboek functioneert.
<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 ?
<StefandeVries> Klopt allebei
<commandoline> maar, dat laatste is op zich niet nodig
<commandoline> want we hebben de property 'adressen'
<commandoline> en de vragen van MedUsaXIII56 sluiten prachtig aan op de link die ik jullie wilde geven:
<commandoline> http://paste.ubuntu.com/588654/
<commandoline> hier wordt precies dezelfde class gebruikt
<commandoline> maar er is een programma omheen geschreven.
<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.
<commandoline> ik wil nu namelijk samen met jullie een programma schrijven, zodat je doorkrijgt hoe dat nou eigenlijk werkt, zo'n class schrijven.
<commandoline> hoewel, eigenlijk schrijven we samen de class die het gebruikt, jullie mogen het daaromheenliggende programma gebruiken.
<commandoline> het programma dat we gaan maken heet 'galgje.py'
<commandoline> en kan worden gebruikt om een spel te spelen wat jullie allemaal wel kennen :)
<commandoline> http://typewith.me/ep/pad/view/ro.KSz8svqakm4/latest
<commandoline> goed, we willen vandaag de logica achter het spel galgje gaan programmeren.
<commandoline> de interface die die logica gebruikt, gaan jullie later maken.
<commandoline> om dat wat toe te lichten
<commandoline> de class Adresboek bevatte de logica van het adresboekprogramma
<commandoline> de rest was de gebruikersinterface
<commandoline> centraal in galgje is het woord dat geraden moet worden.
<commandoline> dus we gaan een class maken die 'Woord' heet.
<commandoline> duidelijk tot zover?
<commandoline> OK, blijkbaar is het duidelijk.
<commandoline> dan wordt het nu eerst tijd om de eigenschappen (properties) en handelingen (methods) te bedenken.
<commandoline> in dit geval hebben we een aantal properties:
<StefandeVries> hannie: dat is aan te raden, zeker bij grote projecten
<commandoline> - aantal_fouten; op basis hiervan kunnen jullie in je interface de galg tekenen.
<commandoline> (20:00:19) hannie: Je zou dus eigenlijk eerst een ontwerp op papier moeten zetten?
<StefandeVries> (08:00:34 PM) StefandeVries: hannie: dat is aan te raden, zeker bij grote projecten
<commandoline> en ook bij kleine projecten kan het zeker in het begin, handig zijn :)
<commandoline> daarnaast is het voor de interface handig om te weten uit hoeveel letters het woord bestaat
<commandoline> dan kan die het juiste aantal 'streepjes' neerzetten.
<commandoline> dus een property 'lengte'
<commandoline> goed, dan de handelingen:
<commandoline> 'gok_letter'
<commandoline> misschien is raad_letter trouwens mooier.
<commandoline> en daarnaast:
<commandoline> raad_woord
<commandoline> goed, daarnaast moet het nog mogelijk zijn om een woord te geven aan de Woord-class
<commandoline> het woord dat geraden moet wordne
<commandoline> *worden
<commandoline> ik geef dat door via de handeling __init__, die automatisch wordt aangeroepen door python bij het maken van een instantie/object
<commandoline> zoals jullie later zullen zien.
<commandoline> (20:05:18) hannie: Moet je categorie?n maken, b.v. 5-letter woorden enz.?
<StefandeVries> nee, hannie, Python kan automatisch berekenen uit hoeveel letters het woord dat je gebruikt bestaat
<commandoline> en
<StefandeVries> en daar de interface op aanpassen
<commandoline> goed, ik heb alle handelingen/methods toegevoegd
<commandoline> nou nog de properties, ik doe dat meestal in __init__ want dan zijn ze direct vanaf het aanmaken van het object beschikbaar
<commandoline> ok, en daarmee is de eerste handeling/method gelijk klaar :)
<commandoline> laten we eerst eens de raad_woord handeling/method invullen
<commandoline> de gebruiker geeft daarbij een woord
<commandoline> de handeling/method kijkt of dat woord klopt
<commandoline> en als dat zo is, wordt 'True' teruggegeven.
<commandoline> als dat niet zo is, wordt het aantal fouten met 2 verhoogt
<commandoline> en wordt False teruggegeven.
<commandoline> en dat is alweer omgezet in code :)
<commandoline> goed, dan blijft er nog Ã©Ã©n handeling/method over
<commandoline> en die is het ingewikkeldst
<commandoline> de aanroeper ervan geeft een letter waarvan hij/zij denkt dat die in het woord zit.
<commandoline> als dat zo is, dan moeten *alle* posities waarop dat zo is doorgegeven worden.
<StefandeVries> hannie: waarom komen er tegelijk 2 fouten bij en niet 1?
<commandoline> en voor het gemak, geef ik dan ook meteen de bijbehorende letter mee terug
<StefandeVries> Raad je een letter fout dan heb je Ã©Ã©n fout. Raad je het woord fout, heb je twee fout
<commandoline> en anders wordt er Ã©Ã©n fout toegevoegd.
<commandoline> ok, en daarmee is de class af.
<commandoline> begrijp iedereen wat ik gedaan heb, en ook hoe deze class te gebruiken is?
 * commandoline verwacht vragen :)
<StefandeVries> hannie: een beetje, heeft nog bestudering nodig
<StefandeVries> We zijn er bijna altijd ;)
<commandoline> goed, ik zal jullie dan een beetje op weg helpen met de interface
<commandoline> zodat jullie daar als jullie die deze week proberen te maken niet op vastlopen.
<commandoline> zoals jullie zien heb ik een stukje code toegevoegd
<commandoline> dat wil ik nog even regel voor regel behandelen.
<commandoline> wat het doet is de class gebruiken.
<commandoline> zo, even gok weer in raad verandert :)
<commandoline> ok, zo werkt het programma weer...
<commandoline> (even getest)
<commandoline> regel 35
<leoquant> hannie> wat houdt main in?
<commandoline> ben ik net mee bezig :)
<commandoline> die regel betekend zoiets als:
<commandoline> 'Als dit bestand uitgevoerd wordt (niet bijv. geimporteerd via import), dan...'
<commandoline> __name__ wordt door python op '__main__' gezet als dat het geval is
<commandoline> ok, volgende regel, 36:
<commandoline> hierin wordt een nieuw woord aangemaakt
<commandoline> het woord 'test' moet geraden worden
<commandoline> vervolgens raden we een letter, de 't'. Die zit er twee keer in. We krijgen dan ook terug:
<commandoline> [[0, 't'], [3, 't']]
<commandoline> m.a.w., de letter t komt voor op positie 0 en positie 3
<commandoline> dit is handig als jullie jullie interface gaan maken (hint)
<commandoline> oja, ik had nog een regel overgeslagen
<commandoline> regel 38, waarop de lengte van het woord wordt opgevraagd
<commandoline> dat geeft 4 terug
<commandoline> (die property hadden we eerder aangemaakt)
<commandoline> goed, daarna raden we nog een letter:
<commandoline> de 's'
<commandoline> die zit er ook in, we krijgen dus:
<commandoline> [[2, 's']] terug
<commandoline> pas hier verandert wat:
<commandoline>     print woord.raad_letter("x")
<commandoline> we vragen de x, en die zit er niet in. we krijgen dus een lege list [] terug
<commandoline> en als we nu het aantal fouten opvragen:
<commandoline>     print woord.aantal_fouten
<commandoline> is dat 1
<commandoline> daarna raden we het woord 'tesst' (dom, teveel letters :()
<commandoline> dat levert achter de schermen twee punten aftrek op, trouwens
<commandoline> en we krijgen daarom False terug
<commandoline> daarna raden we 'test'
<commandoline> en dat klopt :)
<commandoline> daarna willen we nog even het aantal fouten weten
<commandoline> print woord.aantal_fouten.
<commandoline> dat is 3
<commandoline> jullie kunnen precies diezelfde methods en properties gebruiken om het spel te laten spelen door de gebruiker
<commandoline> (20:28:28) hannie: en dan moet Barbertje nog getekend worden
<commandoline> als dat te ingewikkeld is, kan je gewoon de score laten zien in de interface
<commandoline> maar leuker is om met ascii-art e.d. te gaan werken
<commandoline> (zie wikipedia)
<commandoline> oja, nog een hint:
<commandoline> maak eerst een list aan met allemaal '_' erin
<commandoline> met de lengte van het woord
<commandoline> en vervang zodra je een letter terugkrijgt die klopt, het streepje op die index door de mee teruggegeven letter.
<commandoline> ok, ik ben benieuwd wat jullie maken van de twee opdrachten:
<commandoline> - probeer het adresboekprogramma zoals halverwege gegeven te begrijpen, en stel vragen als dat niet zo is:
<commandoline> http://paste.ubuntu.com/588654/
<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 :)
<commandoline> goed, dat was het voor vandaag
<commandoline> bedankt voor jullie komst allemaal :)
<commandoline> en tot volgende week!
<StefandeVries> dank je, leoquant :)
<leoquant> mooi les
<leoquant> e
<StefandeVries> dank je
#ubuntu-nl-mwanzo-klas 2011-04-07
<leoquant> hi  niekie
<leoquant> ik heb me eens  ingelezen in ca cert, maar ik begrijp niet welk voordeel ik zou kunnen hebben om erin te participeren, het is een soort web of trust systeem?
<niekie> leoquant: het is een certificerende authoriteit gebaseerd op web-of-trust inderdaad.
<exalt> je mag hier niet praten niekie
<exalt> van leoquant
<niekie> exalt: waarom stelt hij mij hier dan een vraag? :)
<leoquant> niekie bedankt
<leoquant> exalt
<exalt> ja leoquant :p
<leoquant> tuurlijk wel ã
<leoquant> en web of trust was ooit een idee van thawte sec.?
<niekie> Het web-of-trust idee bestaat volgens mij al een hele tijd, maar ik heb daar mij niet zo in verdiept.
<niekie> Zie ook PGP/GnuPG. :)
<leoquant> maar wanneer jij iemand certificeert is die partij te vertrouwen
<leoquant> want jij bent een assurer en bent door een aantal processen gegaan
<leoquant> ik neem aan in het zakelijkle circuit? op juist opensource?
#ubuntu-nl-mwanzo-klas 2011-04-09
<leoquant> sst
<leoquant> zo
<leoquant> de negende cursus
<commandoline> goed, we gaan wel beginnen.
<commandoline> welkom bij de -volgens mijn administratie- negende pythonles!
<commandoline> goed, laten we beginnen met het huiswerk
<commandoline> ten eerste had ik gevraagd of iedereen http://paste.ubuntu.com/588654/ begreep
<commandoline> het belangrijkste verschil met eerdere programma's is dat hier het 'hoofdprogramma' in een class is verpakt
<commandoline> het programma wordt uitgevoerd door de voer_uit()-method aan te roepen
<commandoline> en dat gebeurt onderin:
<commandoline> if __name__ == "__main__":
<commandoline> 	adresboekProgramma = AdresboekProgramma()
<commandoline> 	adresboekProgramma.voer_uit()
<commandoline> de rest is wel besproken van dat voorbeeld eerder, dus ik neem aan dat jullie daar allemaal wel uitkomen.
<commandoline> ok, dan gaan we over naar de tweede opdracht: galgje!
<commandoline> ten eerste: heeft iemand daar vragen over?
<commandoline> ok, ik zal jullie eerst even een relatief simpele uitwerking laten zien
<commandoline> en daarna een waar kunstwerk gemaakt door CasW :)
<commandoline> http://paste.ubuntu.com/591810/
<commandoline> jullie zien bij die link eerst de Word-class van vorige week
<commandoline> daarna wordt een woord gekozen om te raden
<commandoline> dat in de code zetten ('hardcoden') is natuurlijk niet zo slim
<commandoline> maar het is wel simpel
<commandoline> het alternatief zou zijn om de gebruiker te vragen een woord in te vullen.
<commandoline> goed, we gebruiken hier in het programma een list met daarin allemaal strings van 1 teken
<commandoline> standaard zijn die tekens '_'
<commandoline> maar gaandeweg veranderen ze in letters die geraden zijn
<commandoline> het aanmaken van die list gebeurt op de regels 39-41
<commandoline> daarna start het spel
<commandoline> (de while loop)
<commandoline> er wordt altijd eerst de uitvoer opgebouwd:
<commandoline> eerst worden alle letters weergeven
<commandoline> en daarna wordt de galg getekend, als er een bepaald aantal fouten is gemaakt
<commandoline> text += " _________     \n" if woord.aantal_fouten > 0 else "\n"
<commandoline> daar staat hetzelfde als:
<commandoline> if woord.aantal_fouten > 0:
<commandoline>     += " _________     \n"
<commandoline> else:
<commandoline>     text += "\n"
<commandoline> en ik ben het woord 'text' voor die eerste keer vergeten
<commandoline> (19:42:39) FOAD: Je bouwt dus elke keer "text" opnieuw op, ok.
<CasW> Ja
<CasW> (Sorry voor de late reactie)
<commandoline> ok, als dat gebeurd is, wordt gekeken of er al teveel fouten zijn gemaakt.
<commandoline> (19:44:42) hannie: Ik begrijp de 3 streepjes in het midden niet. Dat zijn toch 3 fouten
<CasW> Welke 3 streepjes bedoel je precies?
<CasW> (19:45:21) hannie: armpje, buikje, armpje
<CasW> Ja, het galgje wordt per 'lijn' getekend
<CasW> *nee dus
<CasW> Dat is dus een fout
<commandoline> de galg wordt hier van boven naar onder getekend, draai het programma maar eens, dan zie je het vanzelf
<commandoline> ok, er wordt daarna dus nagegaan of er al teveel fouten (>6) zijn gemaakt
<commandoline> zoja, dan heb je verloren en stopt de while loop
<commandoline> daarna wordt een menu weergeven
<commandoline> dat afhankelijk van de keuze v/d gebruiker een letter laat raden, een woord, of het spel stopt
<commandoline> (ja, je kan stoppen als je dik aan het verliezen bent :P)
<commandoline> maar goed, die opties worden gewoon afgehandeld met behulp van de class
<commandoline> 		locaties = woord.raad_letter(letter)
<commandoline>  		for locatie in locaties:
<commandoline>  			geraden[locatie[0]] = locatie[1]
<commandoline> is nog wel interessant
<commandoline> daar gebruiken we de eigenschap dat raad_letter het volgende teruggaf:
<commandoline> [positie, letter]
<commandoline> ok, is dit voorbeeld dan duidelijk?
<commandoline> mooi, zoals zolangzamerhand wel duidelijk is heeft CasW aan een andere uitwerking gewerkt.
<commandoline> http://www.technotaal.nl/qhangman/qhangman.tar.gz
<commandoline> let wel: je hebt het pakket 'python-qt4' nodig
<CasW> Omdat ik hem nog niet heb verwerkt tot een .deb, moet je die dus zelf installeren
<CasW> (.deb komt er wel nog aan)
<commandoline> maar dat is niet zo moeilijk:
<commandoline> gewoon het bestand uitpakken en hangman.py starten
<CasW> Dat is dus het spel starten
<CasW> Niet PyQT installeren, dat is gewoon sudo apt-get install python-qt4
<commandoline> ok, jullie kunnen het rustig bekijken, in de tussentijd ga ik verder
<commandoline> verdere uitleg over QHangman volgt in -mwanzo
<commandoline> ok, ik wil jullie vandaag nog wat nieuws uitleggen.
<commandoline> het gaat om een onderdeel van OOP:
<commandoline> inheritance (overerving)
<commandoline> je kan het gebruiken om classes uit te breiden.
<commandoline> bijvoorbeeld:
<commandoline> je hebt een class die bijna alles doet wat je wilt
<commandoline> maar Ã©Ã©n method ontbreekt
<commandoline> bijv. bij een list, je zou kunnen denken aan 'randomItem()'
<commandoline> je kan dan de complete list-class herschrijven
<commandoline> maar dat is veel te veel werk
<commandoline> in plaats daarvan kan je ervoor kiezen om een nieuwe class te maken die overerft van 'list'
<commandoline> goed, ander voorbeeld:
<commandoline> je hebt een voertuig
<commandoline> ieder voertuig kan bijv. bewegen
<commandoline> als je nou zowel een fiets als een auto zou willen programmeren
<commandoline> dan kan je ervoor kiezen om de functionaliteit die het bewegen regelt in een class Voertuig te stoppen
<commandoline> waarvan zowel Auto als Fiets overerven, zodat je geen dubbele code schrijft.
<commandoline> duidelijk tot zover?
<commandoline> http://typewith.me/ep/pad/view/ro.W-w-q$ggIak/latest
<commandoline> goed, laten we dat voorbeeld eens in code omzetten
<commandoline> ten eerste maken we een class aan
<commandoline> aangezien een voertuig kan bewegen, wil ik dat het ergens staat zodra het geÃ¯nitialiseerd is.
<commandoline> daarom heb ik de mogelijkheid gegeven om een x en y coÃ¶rdinaat te geven.
<commandoline> goed, zoals ik al eerder zei, ieder voertuig kan bewegen.
<commandoline> dus we kunnen hem een 'vooruit'-method geven.
<commandoline> ok, ik houd het even simpel en laat eigenschappen als 'richting' even weg.
<commandoline> vooruit doet niks anders dan een bepaalde afstand afleggen, opgeteld bij laten we zeggen x.
<CasW> (20:09:10) FOAD: Wat doet aantal_vakjes nu?
<CasW> Dat zegt hoeveel vakjes hij in de x-richting moet gaan
<commandoline> scherp, FOAD
<CasW> *hoeveel eenheden
<commandoline> ik maak een foutje :(
<CasW> Correctie, nÃº zegt die dat
<commandoline> goed, genoeg over een voertuig
<commandoline> laten we nu een fiets gaan maken.
<commandoline> ok, het idee is hier dat je een versnelling kan opgeven aan een fiets
<commandoline> en dat de viets afhankelijk van die versnelling een verschillend aantal hokjes opschuift bij 1x trappen.
<commandoline> begrijpt iedereen ongeveer wat hier gebeurd?
<commandoline> *gebeurt
<CasW> *fiets
<commandoline> hmm, ik ben niet helemaal wakker geloof ik :P
<leoquant> gaat goed hor!
<leoquant> o
<commandoline> ok, volgende voertuig, idd
<commandoline> (reactie op: (20:13:46) FOAD: En nu komt er een ander voertuig?)
<commandoline> goed, een auto moet zich aan een snelheidslimiet houden.
<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.
<commandoline> (20:16:02) FOAD: Zou fiets.versnelling niet een default waarde moeten hebben?
<CasW> Je kunt inderdaad zeggen dat 'ie een default waarde heeft, dan doe je:
<CasW> def __init__(self, versnelling = 1)
<CasW> Bijvoorbeeld
<commandoline> FOAD: duidelijk?
<commandoline> ok, verder met de auto
<commandoline> hoewel, ik ben nog wat bij de Fiets vergeten
<commandoline> de __init__ daarvan moet de __init__ van Voertuig aanroepen
<commandoline> anders wordt self.x niet op een bepaalde waarde geset.
<commandoline> (20:18:41) exalt: moet het gewicht / bouw / materiaal keuze van de fiets niet ook iets invloed hebben over de snelheden?
<commandoline> (20:18:59) CasW: Dan moet je nog weer meer toevoegen aan die fiets
<CasW> Maar dan heb je alweer een ander soort fiets
<CasW> Dus dan doe je bijvoorbeeld class Mountainbike(Fiets)
<commandoline> dat is inderdaad een mogelijkheid
<commandoline> daarnaast kun je eigenlijk nooit alle eigenschappen van een object overnemen
<commandoline> sommige zijn ook niet relevant
<commandoline> je implementeert alleen wat je nodig hebt.
<commandoline> duidelijk, exalt?
<commandoline> in de tussentijd: ik heb zoals jullie hebben gezien op regel 22 gezorgd dat de __init__ van Voertuig aangeroepen.
<commandoline> waardoor de code weer werkt.
<commandoline> ok, nu de auto implementeren
<commandoline> ok, duidelijk wat ik tot nu toe allemaal heb getypt?
<CasW> self.vooruit
<commandoline> en ook hoe je het moet gebruiken?
<CasW> Niet Voertuig.vooruit
<commandoline> CasW: nee, want dan roept hij zichzelf aan
<commandoline> (20:25:42) FOAD: Ja.  Ik moet het nog in detail bestuderen, maar dat inheritance concept is leuk hoor.
<commandoline> het is een leuk concept, maar zorg wel dat je het alleen toepast als het echt nuttig is
<CasW> En bij Fiets dan? ;)
<commandoline> CasW: daar roept de method 'trap' de method 'vooruit' aan
<commandoline> in dat geval wordt de method niet opnieuw geimplementeerd
<CasW> Och ja, nu zie ik het pas, excuses
<commandoline> inheritance gebruiken om hele abstracte objecten te maken die amper wat doen op zichzelf heeft niet altijd evenveel nut.
<commandoline> ok, verder nog vragen?
<commandoline> goed, tijd voor het huiswerk voor de volgende keer dan
<commandoline> -- installeer: pyqt4 (python library) en laby (programmeerspelletje)
<commandoline> --- sudo apt-get install sudo apt-get install python-qt4 laby
<commandoline> -- schrijf de class die beschreven wordt bij deze link, op de plek van het commentaar:
<commandoline> --- http://paste.ubuntu.com/591811/
<commandoline> -- kijk hoe ver je kan komen bij het spel 'laby' (selecteer als programmeertaal Python). (Toepassingen > Spelletjes > Logica > Laby)
<commandoline> (20:30:24) CasW: Eenmaal sudo apt-get install
<commandoline> (20:30:28) CasW: Niet tweemaal
<commandoline> sudo apt-get install python-qt4 laby
<commandoline> wordt het dan
<commandoline> goed, succes allemaal
<commandoline> CasW, StefandeVries (neem ik aan) en ik zijn vaak in -mwanzo of een ander ubuntukanaal om vragen te beantwoorden
<commandoline> en ik blijf nu ook bereikbaar voor vragen
<commandoline> oja, je mag proberen om de classes die we hebben gemaakt te gebruiken
<commandoline> mocht je dat willen (en dan zie je direct of er nog fouten in zitten, ik heb dit nl. uit het hoofd getypt)
<commandoline> tot volgende week!
<commandoline> (dan trouwens waarschijnlijk vanaf de Ubuntu Jam in Burgum!)
<leoquant> commandoline, en CasW bedankt weer!
<commandoline> graag gedaan leoquant, jij ook bedankt weer :)
* ChanServ changed the topic of #Ubuntu-nl-mwanzo-klas to: Zaterdag 16-04-11 19.30-20.30 workshop Python (10):  #Ubuntu-nl-mwanzo-klas|  Info: http://wiki.ubuntu-nl.org/community/mwanzo/Workshop/BasiscursusPython| Leiding: commandoline en stefandevries| Logs op http://irclogs.ubuntu.com |Let ook op eventueel andere workshops| Alle cursisten join ook: #ubuntu-nl-mwanzo, daar kun je vragen stellen aan de workshopleiders.
#ubuntu-nl-mwanzo-klas 2011-04-11
* ChanServ changed the topic of #Ubuntu-nl-mwanzo-klas to: Zaterdag 16-04-11 19.30-20.30 workshop Python (10):  #Ubuntu-nl-klas  Info: http://wiki.ubuntu-nl.org/community/mwanzo/Workshop/BasiscursusPython| Leiding: commandoline en stefandevries| We zitten in een ander leslokaal nu!!!
<RawChid> hoi
<RawChid> Kun je hier een redirect van maken?
<leoquant> RawChid, ik  doe eerst dit even
<leoquant> daarna ga ik de calendars doen
<leoquant> FOAD, hajour exalt niekie en UndiFineD het workshop kanaal is nu #ubuntu-nl-klas, jullie kunnen daar nu terecht. dit kanaal gaat binnenkort dicht.
#ubuntu-nl-mwanzo-klas 2011-04-12
<leoquant> niekie en hajour ubuntu wmanzo workshops worden nu in #ubuntu-nl-klas gegeven, dit kanaal hier gaat binnenkort dicht.
<leoquant> JanC, ik heb iedereen aangeschreven via de mailinglist over de wisseling van kanalen. ik denk dat ik het maar op i zet nu
<JanC> leoquant: ga je dan ook die forward instellen?
<leoquant> dat was ik niet van plan
<JanC> dat heeft het voordeel dat mensen automatisch in het juiste kanaal terechtkomen als ze dit kanaal proberen
<leoquant> de documentatie daarover is wisselend, ambigu
<leoquant> je kunt problemen krijgen met rechten, en mijn effort is geweest om op alle fronten de informatie te wijzigen.
<JanC> in het slechtste geval kunnen we zelf niet meer in -mwanzo-klas, maar dat lijkt me geen ramp...  ;)
<leoquant> alleen in de ubuntu-nl supportkanalen zou een "1 week mededeling" in het topic wel prettig zijn
<leoquant> omdat de de meeste leden vanuit irc joinen
<leoquant> en soms lang niet echt online zijn en makkelijk de info hierover kunnen missen
<JanC> uhu
<JanC> sec  âº
<JanC> voilÃ   âº
<JanC> staat in de topic van -nl & -nl-offtopic nu
<leoquant> zeer bedankt
<leoquant> alles is afgedekt nu
<leoquant> zelfs de logbot maintainer is aangeschreven
<leoquant>  /msg ChanServ DROP #Ubuntu-nl-mwanzo-klas 817ec819:ec7fcefd
<leoquant> zo
<leoquant> gedropped
<leoquant> "we" kunnen gaan....

{'channel': 'ubuntu-nl-mwanzo-klas', 'month': 4}