[14:24] <FOAD> Zo.
[17:46] <leoquant>   
[18:30] <commandoline> Welkom allemaal, het is 19:30, dus laten we beginnen.
[18:30] <commandoline> laten we beginnen met het huiswerk van vorige keer bespreken, voordat we in een nieuw onderwerp duiken
[18:31] <commandoline> en daarvoor mag ik FOAD vandaag uitnodigen :)
[18:31] <FOAD> Dank u, dank u.
[18:31] <FOAD> Ik heb mijn poging op http://paste.ubuntu.com/582571/ geplaatst.  Vergeef me de idiosyncratische tekst maar.
[18:32] <FOAD> Eigenlijk gebeurt er niet zoveel, het programma doet letterlijk wat de opdracht vraag.  Ik was wel zo eigenwijs om het ding zichzelf niet te laten uitvoeren.
[18:32] <FOAD> En.. um.  Klopt het?
[18:32] <commandoline> mooi gebruik gemaakt van os.path
[18:33] <commandoline> maar laat ik nog even een linkje geven naar het iets simpelere voorbeeld dat wij hebben gemaakt
[18:33] <commandoline> FOAD, wil jij ondertussen deze regel even wat uitgebreider uitleggen?
[18:33] <DooitzedeJong> Kun je uitleggen wat er gebeurt bij de oplossing van FOAD
[18:33] <DooitzedeJong> FOAD?
[18:33] <commandoline>     if os.path.splitext( file )[ 1 ] == ".py" and os.path.realpath( sys.argv[ 0 ] ) != os.path.realpath( file ):
[18:33] <DooitzedeJong> commandoline was mij voor
[18:33] <FOAD> Natuurlijk.
[18:34] <DooitzedeJong> Bedankt
[18:34] <commandoline> http://paste.ubuntu.com/579221/, ondertussen
[18:34] <FOAD> De if controleert 2 dingen: 1) of de extensie van het bestand "file" gelijk is aan py (dus, dat het (waarschijnlijk) een python bestand is.
[18:35] <FOAD> Maar 2) ook of het bestand naar waar wordt gekeken niet toevallig het programma zelf is.  De naam van het programma zelf vind je via sys.argv[ 0 ].
[18:35] <FOAD> Ik gebruik realpath om zeker te weten dat hij absolute paden vergelijkt.  Ik weet eigenlijk niet zeker of het nodig is, maar ik denk het wel.
[18:35] <FOAD> Moet ik dat nog verder toelichten?
[18:35] <commandoline> DooitzedeJong> Wat betekent die !=
[18:36] <commandoline> DooitzedeJong> niet gelijk aan?
[18:36] <FOAD> De reden dat ik dit doe is dat het programma niet zichzelf gaat aanroepen, want dan kan het zo lang gaan duren.
 Inderdaad, DooitzedeJong
[18:36] <FOAD> !- betekent "niet gelijk aan".
[18:36] <commandoline> ok, bedankt voor de uitleg, FOAD. Heeft iemand idd nog vragen?
[18:36] <FOAD> Eh, !=
[18:37] <commandoline> ok, dan gaan we verder
[18:37] <commandoline> oh, nog een vraag
[18:37] <commandoline> <DooitzedeJong> Wat moet je invullen..
[18:37] <commandoline> <DooitzedeJong> bij dir?
[18:37] <StefandeVries> DooitzedeJong: de directory die je wilt scannen
[18:37] <FOAD> Ik besef me wel dat + "/" + een beetje os-afhankelijk is.
[18:37] <StefandeVries> DooitzedeJong: bijvoorbeeld ja
[18:38] <StefandeVries> Alle .py bestanden in die dir zullen dan worden uitgevoerd
 bijvoorbeeld /home ?
[18:38] <StefandeVries> ^
[18:38] <StefandeVries> Al beantwoord ;)
[18:39] <commandoline> OK, ik wil jullie vandaag wat leren over een andere manier van programma's ontwerpen
[18:39] <commandoline> tot nu toe hebben jullie procedureel geprogrammeerd
[18:40] <commandoline> je kunt met die manier van programmeren alles maken wat je ook kan met de methode die we vandaag gaan bespreken, maar daar wordt het niet altijd duidelijker op.
[18:40] <StefandeVries> DooitzedeJong: al je programma's werden regel voor regel afgewerkt.
[18:40] <commandoline> * altijd duidelijker van
 |Wat houdt dat in|
 ?
 van 1 tot 10 het proces afhandelen?
[18:41] <commandoline> was de vraag
[18:41] <DooitzedeJong> Die is beantwoord
[18:41] <DooitzedeJong> Ga verder
[18:42] <commandoline> ho, hier wat verwarring, ok, verder
[18:42] <commandoline> de methode die we gaan bespreken heet in het Engels 'Object Oriented Programming', kortweg OOP
[18:44] <commandoline> de Nederlandse vertaling daarvan is Objectgeoriënteerd programmeren
[18:45] <commandoline> deze manier van programmeren is dus gewoon een andere manier om tegen het probleem dat je programma moet oplossen aan te kijken
[18:46] <commandoline> Voordat ik ga uitleggen hoe we die manier van programmeren toepassen in Python, wil ik jullie eerst proberen duidelijk te maken wat het hele concept inhoudt.
[18:46] <commandoline> want pas als je dat begrijpt, kan je het toepassen in de praktijk
[18:47] <commandoline> OK, zoals het woord al zegt, gaat objectgeoriënteerd programmeren over objecten
[18:47] <commandoline> de eerste vraag om te stellen is dus: wat is een object?
[18:48] <commandoline> objecten zoals je die gebruikt bij programmeren, lijken best sterk op objecten die je in de praktijk ziet
[18:49] <commandoline> Laten we eens een voorbeeld nemen
[18:50] <commandoline> Bijvoorbeeld een fiets
[18:50] <commandoline> een object zoals je dat gebruikt bij OOP, heeft twee kenmerken:
[18:51] <commandoline> - het object bevat handelingen (de zogenaamde methods)
[18:51] <commandoline> - het object bevat eigenschappen (de zogenaamde properties in het Engels)
[18:51] <commandoline> Het is ook mogelijk om die manier van kijken toe te passen op een object uit de praktijk, dus op het voorbeeld van de fiets.
[18:51] <commandoline> een fiets heeft handelingen:
[18:52] <commandoline> - versnelling veranderen
[18:52] <commandoline> - remmen
[18:52] <commandoline> - versnellen
[18:52] <StefandeVries> hannie: ja dus ;)
[18:52] <commandoline> ook heeft een fiets eigenschappen:
[18:53] <commandoline> bijv. de huidige versnelling, en de huidige snelheid
[18:53] <commandoline> het komt dus vaak voor, dat de handelingen die de fiets heeft de eigenschappen van de fiets veranderen.
[18:53] <commandoline> je kan zo'n manier van kijken naar objecten op allerlei dingen die je ziet toepassen
[18:54] <commandoline> is dit ongeveer duidelijk? Kunnen jullie je er wat bij voorstellen?
[18:55] <commandoline> hmm, ik heb nog niet iedereen overtuigd
[18:55] <commandoline> nog een voorbeeldje dan:
[18:55] <commandoline> oh, het gaat alleen om toepassen in een programma, dan ga ik toch door
[18:55] <StefandeVries> FOAD: daarom is dit nog conceptuele uitleg, en geen Pythontoepassing
[18:55] <commandoline> jullie hebben namelijk al objecten gebruikt
[18:56] <commandoline> eentje die jullie je allemaal zullen herinneren, is de list
[18:56] <commandoline> de list is een object
[18:56] <commandoline> ten eerste heeft het methods, we hebben nl. het volgende gedaan:
[18:56] <commandoline> list = [1, 2, 3]
[18:56] <commandoline> list.append(4)
[18:56] <commandoline> append is een method, een handeling, van list
[18:57] <commandoline> list heeft ook eigenschappen/properties, maar die kunnen we niet direct zien in dit geval.
[18:58] <commandoline> en list is nog maar één object
 Is het aantal elementen niet een property van list?
[18:58] <StefandeVries> FOAD: nee, het is een enkel een property van die specifieke list
[18:59] <Ronnie>  DooitzedeJong: dus bijvoorbeeld adresboek is ook een object?
[18:59] <Ronnie> het adresboek dat jullie gemaakt hebben nog niet, maar er is wel gemakkelijk een object met handelnigen van te maken
[18:59] <Ronnie> bijvoorbeeld de handeling (voeg adres toe)
[19:00] <commandoline> hmm, laat ik nog even wat dingen toevoegen over de twee vragen:
[19:00] <Ronnie> of verwijder adres, zoek adres etc
[19:00] <commandoline> FOAD, het aantal elementen van een lijst is eigenlijk geen property, omdat ze d.m.v. de len()-method worden verkregen. Intern gaat dat via een method, voor de geïnteresseerden.
[19:01] <commandoline> over het adresboek, wij hebben voor het adresboek een dictionary gebruikt
[19:01] <commandoline> en een dictionary is een object.
[19:02] <commandoline> het is alleen geen Adresboek-object, wat, zoals Ronnie al zei, bijv. een method voeg_adres_toe zou hebben
[19:02] <commandoline> eigenlijk is vrijwel alles in python een object, hoewel je dat niet meteen ziet.
[19:03] <commandoline> ints, floats, strings, functies, dictionaries, lists, etc. zijn allemaal objects
[19:03] <commandoline> 'Everything is an object'
[19:03] <commandoline> wordt dan ook wel eens over python gezegd.
 Kun je concreet een voorbeeld van een method geven?
[19:03] <commandoline> bij een list dus 'append'
[19:03] <commandoline> bij een string bijv. 'endswith'
[19:03] <commandoline> en bij een dictionary bijv. 'keys'
 waarom noem je len() een method? het is toch een functie. Zijn alle functies dan methods?
[19:04] <commandoline> als ik dat inderdaad heb gedaan, is dat fout
[19:04] <commandoline> len() is een functie
[19:04] <commandoline> maar wat ik dacht ik zei is dat het intern een method aanroept
[19:05] <commandoline> maar die onmerking maakt het geheel nu complexer, dus vergeet dat maar ;)
[19:05] <commandoline> ok, ik hoor iedereen vragen om codevoorbeelden, dus ik zal jullie er een aantal geven.
[19:06] <commandoline> ten eerste toch nog even als herhaling: http://paste.ubuntu.com/582591/
[19:07] <commandoline> je ziet 2 dingen:
[19:07] <commandoline> - een object kan meerdere keren aangemaakt worden
[19:07] <commandoline> - een object kan worden aangepast door het aanroepen van een handeling (method)
[19:08] <commandoline> is dat duidelijk?
[19:09] <commandoline> goed, dan het tweede voorbeeld:
[19:09] <commandoline> http://paste.ubuntu.com/582592/
[19:09] <commandoline> je ziet hier een nieuwe constructie
[19:09] <commandoline> de zogenaamde class
 Wordt het eigenlijk een variabele?
[19:09] <commandoline> in dat voorbeeld werden lists opgeslagen  ín een variabele
[19:09] <commandoline> het eerste wat jullie moeten weten is wat een class is:
[19:10] <commandoline> het is het ontwerp/de blauwdruk van een object
[19:10] <commandoline> zoals we ook al bij list zagen, is het mogelijk om meerdere lists aan te maken
[19:10] <commandoline> in het tweede voorbeeld, wordt een nieuwe class gedefinieerd:
[19:10] <commandoline> Adresboek
[19:11] <commandoline> en daardoor wordt het mogelijk om meerdere adresboeken te maken.
[19:11] <commandoline> voordat ik de code regel voor regel ga uitleggen, wil ik eerst even stilstaan bij hoe het mogelijk is om deze class te gebruiken:
[19:11] <commandoline> - ten eerste is het nodig om een object te maken, net zoals in voorbeeld één.
[19:12] <commandoline> in dat geval ging het om deze regel:
[19:12] <commandoline> list1 = []
[19:12] <commandoline> in dit geval gaat dat zo:
[19:12] <commandoline> adresboek1 = Adresboek()
[19:12] <commandoline> overigens wordt de overeenkomst misschien duidelijker, als je weet dat je het eerste geval ook zo kan schrijven:
[19:12] <commandoline> list1 = list()
[19:13] <commandoline> Het lijkt een functieaanroep, maar wat het in werkelijkheid is, is het maken van een object op basis van de eisen van de class.
[19:14] <commandoline> het is nu mogelijk om methods (handelingen) van het object adresboek1 aan te roepen:
[19:14] <commandoline> adresboek1.voeg_toe("commandoline", "mail@adres-zeg-ik.niet")
[19:15] <commandoline> als ik daarna mijn mailadres weer wil verwijderen, kan dat zo:
[19:15] <commandoline> adresboek1.verwijder("commandoline")
[19:16] <commandoline> het voordeel hiervan bovenop dat van een dictionary is klein in dit geval
[19:16] <Ronnie> hannie: horen [] en {} ook tot de eigenschappen?
[19:16] <commandoline> maar als dit object zou moeten controleren of het adresboek geldig was, dan zou het al veel schelen.
[19:17] <commandoline> hannie, ik kom er straks even op terug, als ik vertel wat de eigenschappen hier zijn
[19:17] <commandoline> het voordeel van een object gebruiken is dus, dat je niet precies hoeft te weten wat er onder de motorkap gebeurt
[19:18] <commandoline> en opnieuw ook hergebruik, net zoals bij functies
[19:18] <commandoline> Goed, dat over het gebruik van deze class
[19:18] <Ronnie>  Cugel_laptop: Is def __init__  een verplicht onderdeel van een classdefinitie?
[19:18] <commandoline> nu even verder over hoe de class zelf is opgebouwd
[19:18] <Ronnie> nee, dat is niet perse nodig
[19:19] <Ronnie> uitleg hierover komt nog
[19:19] <commandoline> op lijn 1 zien jullie de declaratie van de class
[19:19] <commandoline> het lijkt wel wat op het definieren van een functie
[19:19] <commandoline> in dit geval krijgt de class de naam 'Adresboek'
[19:20] <commandoline> en het laatste stukje, (object), mag je voorlopig aannemen als een verplicht iets
 zijn dat twee underscores?
[19:20] <commandoline> __init__ bevat idd vier underscores
[19:20] <commandoline> twee aan beide kanten
[19:20] <commandoline> zodra dat is gebeurd, begint de classdefinitie
[19:21] <commandoline> we zien daarin functies, zoals we die al eerder hebben gezien
[19:21] <commandoline> ik begin niet met de eerste, maar met de tweede:
[19:21] <commandoline> voeg_toe
[19:21] <commandoline> dat is een hele normale functie, op één ding na.
[19:21] <commandoline> het eerste argument is 'self'
[19:21] <commandoline> en jullie hebben zonet gezien, dat we dat argument niet meegeven, we deden immers:
[19:21] <commandoline> adresboek1 = Adresboek()
[19:22] <commandoline> adresboek1.voeg_toe("commandoline", "mijn_mail@adres.nl")
[19:22] <commandoline> dat eerste argument wordt gevuld door python
[19:22] <commandoline> python geeft dan het object mee, waarop de method (de handeling) wordt aangeroepen
[19:22] <commandoline> dus eigenlijk is het gelijk aan dit, als dat het iets duidelijker maakt:
[19:23] <commandoline> Adresboek.voeg_toe(adresboek1, "commandoline", "mijn_mail@adres.nl")
[19:23] <commandoline> dat geeft de method dus de mogelijkheid, om iets te veranderen aan het object zelf
[19:24] <commandoline> in dit geval wordt de eigenschap 'adressen' verandert.
[19:24] <commandoline> Dat is een dictionary, en er wordt een adres aan toegevoegd
[19:24] <commandoline> verwijder doet iets soortgelijks
[19:24] <commandoline> __init__ is nog wel bijzonder
[19:24] <commandoline> die method wordt aangeroepen door python tijdens het maken van het object
[19:24] <commandoline> dus, bij deze regel code:
[19:24] <commandoline> adresboek1 = Adresboek()
[19:25] <commandoline> wat die method doet, is niks anders dan het toevoegen van de eigenschap 'adressen' aan het object
[19:25] <commandoline> goed, nog vragen?
[19:26] <commandoline> dit is een ingewikkeld onderwerp, we gaan er iig de komende en waarschijnlijk ook nog de daaropvolgende les ermee verder
 self, is dat een bewaarplaats waar later iets in komt?
[19:26] <commandoline> dat argument wordt dus ingevuld door python, als je een method aanroept
[19:26] <commandoline> het is altijd het huidige object
[19:26] <commandoline> bijv:
[19:26] <commandoline> adresboek1 = Adresboek()
[19:27] <commandoline> adresboek2 = Adresboek()
[19:27] <commandoline> adresboek1.voeg_toe("naam", "mailadres")
[19:27] <commandoline> adresboek2.voeg_toe("naam", "mailadres")
[19:27] <commandoline> wat er eigenlijk gebeurd bij het aanroepen van de method
[19:27] <commandoline> is in beide gevallen anders
[19:28] <commandoline> terwijl het hetzelfde lijkt
[19:28] <commandoline> want achter de schermen gebeurt:
[19:28] <commandoline> Adresboek.voeg_toe(adresboek1, "naam", "mailadres")
[19:28] <commandoline> Adresboek.voeg_toe(adresboek2, "naam", "mailadres")
 en adresboek1, 2 enz. gebruik je later in een programma?
[19:28] <commandoline> inderdaad, het is in het adresboekprogramma dus opeens mogelijk om voor meerdere personen een adresboek te maken
[19:29] <commandoline> zonder een regel te veranderen aan de class Adresboek
[19:29] <commandoline> opnieuw een voordeel van classes :)
[19:29] <commandoline> ok, het huiswerk:
[19:30] <commandoline> maak een programma dat niks anders doet dan methods van Adresboek aanroepen
[19:30] <commandoline> maak daarbij adresboeken aan voor meerdere personen.
[19:31] <commandoline> probeer ook uit wat de laatste twee methods doen
[19:31] <commandoline> probeer dus gewoon een echte situatie na te bootsen
[19:31] <commandoline> de echte handelingen die normaal op een Adresboek losgelaten zouden worden
[19:31] <commandoline> begrijpt iedereen dat?
[19:32] <commandoline> ten slotte nog even een verbeterd linkje, deze class werkt nl. niet ;)
[19:32] <commandoline> er is eigenlijk altijd wel hulp in #ubuntu-nl-mwanzo
[19:33] <commandoline> http://paste.ubuntu.com/582607/
[19:34] <commandoline> probeer gewoon objects te maken van deze class dus en ze te gebruiken, dat is kortweg de opdracht
[19:34] <commandoline> succes ermee en bedankt voor jullie komst!
[19:34] <FOAD> Dank je wel commandoline en support!
[19:34] <commandoline> ik ben hier nog even voor vragen
[19:35] <FOAD> Ik vond het erg leuk om mijn oplossing te presenteren.
[19:35] <commandoline> bedankt voor de complimenten allemaal :)
[19:46] <hannie> commandoline, en anderen, prettige avond nog
[19:46] <commandoline> jij ook, hannie
[19:51] <commandoline> let op allemaal: de les gaat volgende week niet door
[19:51] <commandoline> i.v.m. dat ik wat anders heb
[19:52] <Cugel_laptop> Jammer.
[19:56] <FOAD> Wat.
[19:56] <FOAD> :(
[19:56] <leoquant> FOAD,?
[19:56] <FOAD> Ik wil Python.
[19:57] <leoquant> di 22 mrt is er weer wat anders
[19:57] <FOAD> Oh leuk, daar ga ik ook aan meedoen.
[19:57] <leoquant> python komt waarschijnlijk een week later weer. de topics worden vrij direct bijgewerkt hier
[19:58] <commandoline> leoquant, python kómt een week daarna weer.
[19:58] <leoquant> juist! ツ
[19:59] <leoquant> deo volente
[20:00] <Cugel_laptop> Wat komt er dan volgende week.
[20:01] <commandoline> een workshop 'Werken met de wiki' door RawChid. :)
[20:02] <DooitzedeJong> Wat gaat RawChid ons dan vertellen
[20:03] <DooitzedeJong> ?
[20:03] <commandoline> http://wiki.ubuntu-nl.org/community/mwanzo/Workshop/WikiInleiding
[20:04] <DooitzedeJong> Dom dat ik daar niet aan dacht, ben net de wiki aan het aanpassen :P
[20:42] <DooitzedeJong> ik ga
[20:43] <DooitzedeJong> UndiFineD, we bespreken het nog wel even
[20:43] <DooitzedeJong> doeg
[20:43] <DooitzedeJong> oops verkeerde kanaal
[20:43] <UndiFineD> ok