#ubuntu-nl-klas 2011-04-18
* ChanServ changed the topic of #ubuntu-nl-klas to: Zaterdag 23-04-11 19.30-20.30 workshop Python (11):  #Ubuntu-nl-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.
<leoquant> moment StefandeVries
<leoquant> ã
<leoquant> top
<StefandeVries> Werkt! :)
<leoquant> dank
<StefandeVries> mode -v leoquant
#ubuntu-nl-klas 2011-04-23
<FOAD> Ik ben er klaar voor.
<DooitzedeJong> Ik ook :)
<FOAD> Booyaka booyaka!
<DooitzedeJong> Wolkom Hannie
<commandoline> Welkom allemaal bij de 11e les uit de pythoncursus!
<commandoline> deze keer weer gewoon via chat
<commandoline> laten we beginnen met het huiswerk
<commandoline> http://paste.ubuntu.com/597948/
<commandoline> ik heb samen met Dooitze vandaag een uitwerking gemaakt
<commandoline> met daarbij een interface die de meeste fouten e.d. afvangt.
<commandoline> de interface kunnen jullie zelf bekijken
<commandoline> wat ik wel even wil bespreken
<commandoline> is de Woordenlijst class
<commandoline> want daar zit alle logica in die jullie zelf ook (of niet :P) tegengekomen zijn
<commandoline> ten eerste is er een __init__ die de property data definieert.
<commandoline> de gebruiker communiceert daarmee via de verwijder(), zoek_op() en voeg_toe_of_verander_betekenis() methods
<commandoline> die doen overigens niet veel bijzonders, ze vangen bijv. ook geen exceptions af
<commandoline> dat doet de interface bij deze implementatie
<commandoline> interessanter zijn de laad() en sla_op() methods
<commandoline> de laad opent het bestand op regel 30
<commandoline> en loopt door iedere regel op een manier die jullie nog niet kennen, maar wel handig is :)
<commandoline> for regel in bestand:
<commandoline> namelijk
<commandoline> daarna scheiden we het woord van de betekenis:
<commandoline> woord, betekenis = regel.split(" = ", 1)
<commandoline> opnieuw een trucje
<commandoline> erboven staat uitleg
<commandoline> daarna roepen we op het resultaat nog .strip() aan
<commandoline> en wordt ieder woord toegevoegd aan de dictionary self.data.
<commandoline> oja, over die split()
<commandoline> die krijgt hier dus een tweede argument
<commandoline> dat argument geeft aan hoe vaak er gesplit moet worden
<commandoline> sla op doet ongeveer het omgekeerde:
<commandoline> - die loopt door iedere entry van self.data
<commandoline> - bouwt daaruit een regel op
<commandoline> - en voegt die toe aan 'tekst'
<commandoline> daarna wordt het bestand geopend, dit keer met schrijfrechten, en daarna wordt de data weggeschreven m.b.v write()
<commandoline> de interface zou ik zeker nog een keertje doorkijken vanwege de foutafhandeling die erin zit
<commandoline> nl. IOError en KeyError, maar ook allerlei if-statements etc.
<commandoline> hannie's programma ziet er ook goed uit, het bekijken waard :)
<commandoline> iemand nog vragen over jullie uitwerkingen of de uitwerking van Dooitze en mij?
<commandoline> of andere vragen?
<DooitzedeJong> Hannie gaf aan dat het laden wel goed werkte maar "writelines"
<DooitzedeJong> niet helemaal
<DooitzedeJong> Van de code van Hannie: http://paste.ubuntu.com/597946/
<commandoline> ok, toch even kort dan:
<commandoline> nee, laat maar, kom ik later op terug :P
<commandoline> jullie kennen nu al veel python zoals ook wel te zien is aan de programma's.
<commandoline> wat ik vandaag wil doen is nog een aantal overgebleven dingetjes uitleggen
<commandoline> ten eerste: tuples
<commandoline> tuples zijn gelijk aan lists, het verschil is dat ze 'unmutable' zijn.
<commandoline> dat houdt in dat je ze niet meer kan aanpassen nadat je ze hebt aangemaakt
<commandoline> dat heeft een aantal voordelen:
<commandoline> - je weet zeker dat je list niet wordt aangepast, als je dat niet wilt
<commandoline> - het is een beetje sneller
<commandoline> (19:52:07) hannie: moet ik bij tuples denken aan 'paren'?
<commandoline> hannie: dat is de letterlijke vertaling ja, maar denk maar gewoon aan python lists.
<commandoline> die snelheid is trouwens pas meetbaar als je een heleboel tuples hebt, maar als je toch je list niet hoeft aan te passen, kan je net zo goed een tuple gebruiken
<commandoline> - je kunt tuples gebruiken als keys in dictionary
<commandoline> we hebben tot nu toe daarvoor vooral strings gebruikt
<commandoline> bijv. een list kan nl. niet
<commandoline> een tuple dus wel
<commandoline> een list kan nl. veranderen, en dat is niet handig voor een dictionary key
<commandoline> een tuple kan dat niet, en daarom kan het wel
<commandoline> ok, nog even over hoe je een tuple aanmaakt:
<commandoline> (19:55:13) hannie: commandoline, een list kan nl. niet?????
<commandoline> klopt, een list kan je niet als dictionary key gebruiken.
<commandoline> tuple = ("item1", "item2", "item3")
<commandoline> je kan nu allerlei dingen doen die je ook met lists kan:
<commandoline> tuple[0] #item1
<commandoline> "item1" in tuple #True
<commandoline> wat niet kan:
<commandoline> tuplle.append("waarde")
<commandoline> *tuple
<commandoline> ok, probeer het even uit zoals hannie al zegt.
<commandoline> vragen over tuples? Want dit is eigenlijk alles wat je ervan moet weten :)
<commandoline> (19:58:50) hannie: ik krijg een AttributeError
<commandoline> (19:59:25) hannie: ik deed: tuple.append('item4')
<commandoline> dat klopt
<commandoline> want dat kan dus niet, een tuple heeft i.t.t. een list geen attributes
<commandoline> (properties)
<commandoline> (en methods)
<commandoline> en daarom krijg je die error.
<commandoline> (20:00:06) hannie: Hoe kan je dan een item toevoegen?
<commandoline> niet, een tuple is niet meer te veranderen na het aanmaken
<commandoline> en dat is dus het verschil met een lijst
<commandoline> zie voor de voordelen een stukje naar boven
<commandoline> ok, duidelijk?
<FOAD> Ja
<commandoline> (20:01:44) hannie: maar wat is dan het voordeel t.o.v. een lijst?
<commandoline> (20:02:08) hannie: alleen sneller?
<commandoline> nee, ze zijn dus ook te gebruiken als keys in dictionaries
<commandoline> terwijl dat met lists niet kan
<commandoline> (20:02:56) hannie: kan je daar een voorbeeldje van geven?
<commandoline> dict = {}
<commandoline> dict[(1, 2)] = "test"
<commandoline> dict[[1, 2]] = "test"
<commandoline> het eerste werkt, het tweede niet
<commandoline> (20:03:35) hannie: en hoe krijg ik dan die tuple in dic{}?
<commandoline> de eerste van de voorbeelden hierboven gebruikt een tuple als key
<commandoline> de tweede een list
<commandoline> (20:04:55) hannie: zie je dat aan de ronde haakjes ()?
<commandoline> klopt, er is Ã©Ã©n uitzondering:
<commandoline> tuple = (1,)
<commandoline> als je Ã©Ã©n item hebt, moet die komma erbij
<commandoline> anders werkt het als voorrangshaakje (net zoals bij wiskunde)
<commandoline> ook, het volgende onderwerp wat ik behandelen is 'variable length argument lists'
<commandoline> beter bekend als '*args, **kwargs'
<commandoline> http://paste.ubuntu.com/597960/
<commandoline> oh, ik ben nog wat vergeten...
<commandoline> http://paste.ubuntu.com/597962/
<commandoline> het * voor args geeft aan dat er op die plaats 0, 1 of meer argumenten kunnen worden gegeven
<commandoline> en die argumenten komen dan in de tuple args terecht
<commandoline> (20:10:02) FOAD: Moet het "*args" heten?
<commandoline> nee, maar dat is wel aanbevolen, omdat iedere python programmeur direct zal weten wat je bedoelt als je *args gebruikt
<commandoline> overigens, het is ook nog mogelijk om sum() zo aan te roepen:
<commandoline> sum(*[1, 2, 4, 934])
<commandoline> dat doet dus precies het omgekeerde
<commandoline> alle items in een list worden ingevoerd als argumenten
<commandoline> ok, door naar **kwargs
<commandoline> (20:11:47) hannie: en mag dat ook tekst zijn?
<commandoline> je kan op zich een string als argument meegeven, maar dat heeft als nadeel dat python tekst niet op kan tellen
<commandoline> en dan krijg je Ã©Ã©n of andere exception
<commandoline> oja, de functie sum() zit standaard in python, die hoef je zelf niet te schrijven
<commandoline> (20:13:40) hannie: maar je telt gewoon een reeks cijfers bij elkaar op dus
<commandoline> klopt
<commandoline> ok, voordat ik **kwargs uit kan leggen moeten jullie weten dat je in python argumenten bij hun naam kan noemen, bijv:
<commandoline> def doeIets(a, b=8, c=2):
<commandoline>     #doe iets met a, b en c
<commandoline> stel nu dat je argument a en c wil meegeven, maar dat je b wilt laten staan, je kan dan dit doen:
<commandoline> doeIets(5, c=4)
<commandoline> wat ook kan:
<commandoline> doeIets(a=3, b=4, c=2)
<commandoline> het mag dus altijd, de argumenten bij naam noemen
<commandoline> begrijpen jullie wat ik daar doe?
<commandoline> (20:16:04) hannie: neemt 5 dan de plaats in van variabele a?
<commandoline> a wordt 5
<commandoline> (20:16:10) FOAD: En dan maakt de volgorde niet uit?
<commandoline> ik geloof het niet, hoewel ik dat eigenlijk niet zeker weet...
<commandoline> dat zou je kunnen uitproberen :)
<commandoline> (20:17:26) hannie: hoe kan c=2 dan c=4 worden? Dat deel begrijp ik niet
<commandoline> argumenten kan je overschrijven
<commandoline> iets concreter:
<commandoline> def maak_person(naam="jan"):
<commandoline>     #maak een persoon aan
<commandoline> dan kan je deze twee dingen doen:
<commandoline> person = maak_person()
<commandoline> person = maak_person("klaas")
<commandoline> (20:18:07) hannie: maar dan kan je toch gewoon 'c' declareren i.p.v. c-2?
<commandoline> dat kan, maar dan is de standaard keuze dus niet beschikbaar
<commandoline> goed, er bestaat in python een functie dict()
<commandoline> je kan er een dictionary mee maken, hoewel we dat niet hebben gedaan omdat het makkelijker is om {} te gebruiken
<commandoline> (20:20:16) hannie: even herleidend: ju kunt het argument dus meteen al een waarde meegeven
<commandoline> (20:20:31) hannie: en die kan je later weer vervangen. Heb ik dat zo goed begrepen?
<commandoline> ja
<commandoline> (20:20:52) FOAD: Je geeft een soort van default waardes mee.
<commandoline> dat is hoe ze heten, default values :)
<commandoline> ok, de functie dict() kan je bijv. zo aanroepen:
<commandoline> woordenboek = dict(voorbeeld="example", test="try")
<commandoline> daarna is woordenboek gelijk aan:
<commandoline> {"voorbeeld": "example", "test": "try"}
<commandoline> het punt is, we geven hier geen argumenten op die dict standaard al kent
<commandoline> als je zelf een dergelijk effect wilt bereiken, kan je **kwargs gebruiken
<commandoline> (20:23:41) hannie: Ik zie nog niet helemaal het voordeel van een defaultwaarde instellen, maar dat komt nog wel
<commandoline> het is vaak nuttig als je een argumenten hebt, waarvan de standaardinstelling in 90% van de gevallen voldoet. Dan hoeft de aanroeper niet 90% van de keren datzelfde argument mee te geven
<commandoline> een voorbeeldje:
<commandoline> http://paste.ubuntu.com/597964/
<commandoline> ho, een sterretje te weinig...
<commandoline> http://paste.ubuntu.com/597965/
<commandoline> ok, de standaard dict functie zit ingewikkelder in elkaar
<commandoline> maar ik hoop dat het idee duidelijk is, dat je alle 'keyword arguments' kunt opvragen in een dictionary
<commandoline> (20:28:34) hannie: leg je die sterretjes nog even uit?
<commandoline> Ã©Ã©n sterretje (bij conventie gevolgd door 'args') geeft aan dat je alle normale argumenten wilt hebben in de tuple 'args'
<commandoline> twee sterretjes (bij conventie gevolgd door 'kwargs') geven aan dat je alle 'keyword' argumenten wilt hebben in een dictionary genaamd 'kwargs'
<commandoline> en keywordargumenten zijn dus alle argumenten waarbij je een naam noemt bij het aanroepen
<commandoline> in het bovenstaande voorbeeld dus a=4
<commandoline> maar ook c=4
<commandoline> zodra we a niet noemden
<commandoline> doeIets(3, c=4) was het ofzo
<commandoline> dan is 3 een 'normaal' argument (dat je zou krijgen met *args), en is c=4 een keyword argument, dat je zou krijgen via **kwargs.
<commandoline> ok, vragen?
<commandoline> het is vooral belangrijk om dit passief te snappen want het komt best veel voor in code. Actief snappen is handig, maar niet noodzakelijk en komt dan vanzelf wel
<commandoline> Goed, dan nog even het huiswerk
<commandoline> het is als je python schrijft handig om Ã©Ã©n stijl qua code aan te houden
<commandoline> een voorbeeld is dat sommige mensen functie( argument1 , argument2 ) schrijven
<commandoline> en anderen: functie(argument1, argument2)
<commandoline> beide werkt, maar er zijn richtlijnen die vaststellen wat je het beste kan doen.
<commandoline> de belangrijkste voor python is PEP8, de python style guide
<commandoline> http://www.python.org/dev/peps/pep-0008/
<commandoline> ik zou jullie aanraden om eens te kijken waar je wat ongeveer kan vinden daar.
<commandoline> (even de kopjes scannen)
<commandoline> (20:35:39) FOAD: Het eerste is mooier.
<commandoline> (20:35:43) FOAD: Is dat het antwoord?
<commandoline> (20:36:18) hannie: dat 2e druist in tegen onze schrijfwijze
<commandoline> volgens PEP8 is het tweede mooier
<commandoline> en het is ook wat ik doe :)
<commandoline> en dat is tegelijk ook het huiswerk voor deze keer, kijk even hoe PEP 8 in elkaar zit
<commandoline> zodat je er iets in op zou kunnen zoeken
<commandoline> ok, tot volgende week, dat is waarschijnlijk de laatste, of anders op Ã©Ã©n na laatste, les!
