A Python Crash Course

A Python Crash Course Dr. A.A.N. Ridder 12 september 2016 Samenvatting In dit document staan puntsgewijs een aantal kenmerken van de syntaxis van Python 2 (en veranderingen in Python 3) voor de cursus Numerical Methods in periode 2.1 van het EOR bachelor programma aan de VU. Inhoudsopgave 1 Python Opstarten 2 1.1 Een Python Programma Uitvoeren........................ 4 2 Een Voorbeeldprogramma 6 2.1 Python 2 versus Python 3............................. 8 3 Data Types 8 3.1 Mutable versus Immutable............................. 9 4 Variabelen 10 4.1 Types........................................ 10 4.2 Integers....................................... 11 4.3 Floats........................................ 11 4.4 Strings........................................ 11 4.4.1 Slicing.................................... 11 4.5 Lists......................................... 12 4.5.1 List Functies................................ 13 5 Meest Voorkomende Operaties 13 5.1 Tussen Numerieke Types (int,long,float,complex)................ 13 5.2 Tussen Serie Types (string,list,tuple)....................... 13 5.3 Vergelijkingen en Boolean Operaties....................... 14 6 Voorwaardelijke en Iteratie Blokken 14 6.1 if... elif... else............................. 14 6.2 for.......................................... 14 6.3 while........................................ 15 6.4 try... except................................. 16 7 Functies 16 7.1 Globale Variabelen................................. 18 7.2 Recursie en Iteratie................................. 18 1

8 Classes 19 9 Numerieke Methoden in Python 19 1 Python Opstarten Hier staat het voor de Python(x,y) distributie voor Windows, maar andere distributies en andere operating systemen (OS X, Linux) zijn bijna gelijk. Er zijn verschillende mogelijkheden. Python interpreter voor eenvoudige commando s en kleine programma s. Je krijgt een Windows console waarin je achter de prompt >>> één regelige commando s intikt. Vergelijkbaar met het Command Window van Matlab. IPython (interactieve Python): meer geavanceerd dan de interpreter. Bv, zogeheten magic functions kun je uitvoeren. Verder ook gebruik voor voor eenvoudige commando s en kleine programma s. De prompts worden genummerd, beginnend met In [1]. IPython QtConsole: zelfde als IPython. 2

IPython Notebook (Jupyter): je werkt in een web browser omgeving. Je kunt hierin documenten opstellen die tekst, Python-code en Python output integreert. Vergelijkbaar met de notebook van Mathematica. Spyder (Scientific Python Development EnviRonment): volledig geïntegreerde omgeving met een editor, object en variabele inspectie, files overzicht, console (Python, Ipython), foutaangeving, debugging,... Vergelijkbaar met Matlab IDE. 3

Idle (Python s Integrated DeveLopment Environment): een vereenvoudigde omgeving met minder functionaliteiten als Spyder. 1.1 Een Python Programma Uitvoeren Je schrijft Pythoncode bijna altijd in programma s die je wilt bewaren. Een Python programma wordt geschreven in een tekstbestand met behulp van een standaard teksteditor (Notepad, Wordpad), of met een programmeurs-editor (Notepad++, vim/gvim, jedit, Komodo Edit,...), of in de editor van Ipython Notebook, of in de editor van Spyder. Dat bestand bewaar je met extensie.py. Bijvoorbeeld het onderstaande is het bestand hello.py. # First Python program : hello. py from future import print_function print ( Hello, world. ) 4

Daarna wil je het programma uitvoeren. Pythoncode wordt niet gecompileerd, maar direct geïnterpreteerd en uitgevoerd. Dat kan ook weer op verschillende manieren. Je moet zorgen dat het current working directory dezelfde is als waarin je het bestand bewaard hebt. Als voorbeeld doen we het hier voor hello.py dat in h:\documents\nm\src staat. In een Windows shell: gebruik het cd commando om naar de juiste directory te gaan. Tik achter de prompt python hello.py. Voorbeeld met Windows PowerShell: PS H:\ > cd h:\ Documents \nm\src PS H:\ Documents \nm\src > python hello.py Hello, world. Python interpreter: >>> import os >>> os. getcwd () # controleer de huidige werkdirectory C :\\ Python27 >>> os. chdir ( h :\\ Documents \\ nm \\ src ) >>> os. getcwd () H :\\ Documents \\ nm \\ src >>> >>> execfile ( hello.py ) # voert hello.py uit Hello, world. IPython: In [ 1]: % pwd # controleer de huidige werkdirectory Out [1]: u C :\\ Users \\ arr600 In [2]: %cd h :\\ Documents \\ nm \\ src H:\ documents \nm\src In [3]: run hello.py Hello, world. IPython QtConsole: idem als IPython. IPython Notebook (Jupyter): begin een New Notebook. Ga daarin hetzelfde te werk als bij IPython. NB: Om een commando uit te laten voeren moet je de toetsen <shift> en <enter> tegelijk doen. Spyder: gebruik de knoppen om de working directory te veranderen en ga naar het menu item run of druk op de groen driehoekspijl. Idle: idem als de interpreter. Of, nadat je de working directory goed hebt, gebruik menu item open om het Python bestand te openen en gebruik dan menu item run module. 5

2 Een Voorbeeldprogramma Eerst een voorbeelprogramma om enige kenmerken van Python toe te lichten. Het programma berekent Fibonacci getallen. Het bestand waarin de code staat heet fib.py. De regelnummers zijn er voor het gemak bijgezet, maar die staan natuurlijk niet in het programma. 1 # Second Python program : fib. py 2 from future import print_function, division 3 from timeit import default_timer as timer 4 5 # berekent n- de Fibonacci getal 6 def fib (n): 7 a,b = 0,1 8 for i in xrange (n): 9 a,b = b,a+b 10 return a 11 12 # print de eerst n Fibonacci getallen 13 # efficiente methode 14 def fibprinteff (n): 15 a,b = 0,1 16 print ( F( 0 ) =, a) 17 for i in xrange (1,n): 18 a,b = b,a+b 19 print ("F(", i, ") = ", a) 20 21 22 print de eerst n Fibonacci getallen 23 minder efficiente methode 24 25 def fibprintineff ( n): 26 for i in xrange (n): 27 print ( F(, i, ) =, fib (i)) 28 29 def main (): # hoofd functie 30 k = int ( input ( Geef aan of je een enkele Fibonacci getal \ 31 wil berekenen (1) of meer getallen ( 2): )) 32 if k == 1: 33 n = int ( input (" Geef n (n-de Fibonacci getal ): ")) 34 print ( F(,n, ) =, fib (n)) 35 else : 36 n = int ( input (" Geef aantal n: ")) 37 tijdstart = timer () 38 fibprinteff ( n) 39 tijdeind = timer () 40 print (" Rekentijd efficiente methode = ",\ 41 tijdeind - tijdstart ) 42 print (" ") 43 6

44 tijdstart = timer () 45 fibprintineff ( n) 46 tijdeind = timer () 47 print (" Rekentijd inefficiente methode = ",\ 48 tijdeind - tijdstart ) 49 50 if name == " main ": 51 main () # aanroep hoofdfunctie Regels 1,5,12,13,29,50: Alle tekst na het hekje-teken (#) wordt gezien als commentaar. NB: geldt per regel. Regels 21-24: meerregelige commentaar zet je tussen drievoudige aanhalingstekens (quotes). Regels 2-3: zie sectie 2.1. Regels 6-10: een blok van je eigen gedefinieerde functie, genaamd fib, met input argument een integer n. De functie voert het n-de Fibonacci uit (return). Functies worden gedefinieerd door def, zie regels 5,14,25,29. Geen begin en end of beginaccolade ({) en eindaccolade (}) om begin en eind van de code van de functie aan te geven, maar inspringen met een gelijk aantal spaties (standaard is 4 spaties). Regels 8-9: een blok van een for opdracht. Dit is een blok binnen het functie-blok, en dan moet je verder inspringen. Zie ook regels 17-19 (for blok), regels 32-48 (if else blok). Een dubbele punt (:) aan het einde van de regel die een blok aankondigt, zie bv regels 6,8,32,35. Python herkent einde van een blok opdrachten doordat de code verder gaat met minder indentatie. Zie bv regels 10,14,25,29,35,50 Regels hoeven niet te worden afgeslotem met een puntkomma (;) Het type van een variabele hoeft niet gedefinieerd te worden! Python herkent die zelf. Regel 7: verkorte korte notatie voor de toewijzingen a=0 en b=1. Zie ook regel 9. Regels 16,19: strings komen met enkele quotes ( string ) of met dubbele quotes ( string ). Geen verschil. Regel 30: het slash-teken aan het eind van een regel betekent dat het commando doorgaat op de volgende regel. Zie ook regels 40,47. Regels 37,39,44,46: timer is een Python functie om de rekentijd van de uitvoering uit te rekenen. Je moet de module aangeven waarin die functie zit (zie regel 3). Meestal gebruik je dit niet. 7

2.1 Python 2 versus Python 3 Een aantal belangrijke verschillen tussen Python 2 en Python 3 zijn print. In Python 2 is print een trefwoord (keyword), dus moet je schrijven print String die je wilt printen In Python 3 is print een built-in functie, en dan wordt het print ( String die je wilt printen ) Om in Python 2 dezelfde functionaliteit te krijgen zet je bovenaan het programma from future import print_function division. In Python 2 is deling van 2 integers weer een integer (eventueel door afronding naar beneden). Python 3 converteert automatisch naar floating point getal (double) indien deling niet als integer uitkomt: 9/5 wordt 1 in Python 2 en wordt 1.8 in Python 3. Ook hier heeft de Python 3 functionaliteit de voorkeur, door from future import division range en xrange. xrange wordt in Python 2 gebruikt om een rij getallen te genereren, zie regels 8,17,26: xrange(5) genereert 0, 1,..., 4 en xrange(1,5) genereert 1,..., 4. In Python 3 is deze built-in functie vervangen door range. Heb je Python 3 code die je door Python 2 laat interpreteren, dan moet je overal range vervangen door xrange. Maar eenvoudiger is aan je (Python 3) code toe te voegen try : xrange except : xrange = range Python 3 kent geen type long meer. 3 Data Types Tabel 1: Belangrijste types. type voorbeelden eigenschap integer ( int ) 4352, 345 immutable real ( float ) 34.2943, 5.0 immutable complex 3.9 + 4j immutable boolean ( bool ) False, True immutable string ( str ) hallo, who immutable NoneType None immutable list [2, 6, 9.8, hallo ], mutable tuple (2, 6, 9.8, hallo ), immutable dictionary ( dict ) { Jan :25, Marie :22} mutable set set([1,4, fas,3.7,1,4, aas ]) mutable 8

Python 2 heeft daarnaast nog het type long integer ( long ), aangegeven door L achter het getal te zetten: 355L, -59L, etc. 3.1 Mutable versus Immutable Een immutable variabele kan niet deels gewijgigd worden, natuurlijk wel de (hele) variabele. Voorbeeld: >>> x = morgen # string >>> print (x [0]) m >>> x [0] = z Traceback ( most recent call l as t): File "<stdin >", line 1, in <module > TypeError : str object does not support item as signment >>> >>> x = goede + x # x wordt in zijn geheel gewijzigd >>> print (x) goedemorgen Bij een mutable variabele kan dat wel: >>> x = [1,2,3,4] # list >>> x [2] = -1 >>> print (x) [1, 2, -1, 4] Let op dat bij mutable variabele een toewijzing geen kopie creëert, en dus hebben veranderingen bij beide effect (dit heet variables are passed by reference). Voorbeeld (merk ook het verschil tussen x += en x = x +): >>> x = [1,2,3,4] >>> y = x >>> x [2] = -1 >>> print (y) [1, 2, -1, 4] >>> x += [5,6] >>> print (y) [1, 2, -1, 4, 5, 6] >>> x = x + [7,8] >>> print (y) [1, 2, -1, 4, 5, 6] >>> print (x) [1, 2, -1, 4, 5, 6, 7, 8] Om het memory management beter te zien, kun je de functie id() gebruiken die het adres in het geheugen retourneert: >>> x = 2 >>> y = x >>> id(x),id(y) (140206669871680, 140206669871680) 9

>>> x = 3 >>> id(x),id(y) (140206669871656, 140206669871680) >>> x = [2] >>> y = x >>> id(x),id(y) ( 4479959552, 4479959552) >>> x [0] = 3 # adres van x blijft hetzelfde >>> id(x),id(y) ( 4479959552, 4479959552) >>> x = [3] # x krijgt een ander adres >>> id(x),id(y) ( 4479959480, 4479959552) 4 Variabelen 4.1 Types Tabel 1 geeft een overzicht van de belangrijkste types in Python. Volledige informatie krijg je bv in de interpreter door >>> help ( types ) Zoals al eerder gezegd, variabele type hoef je niet te declareren (zoals wel in Java, C, C++, Ox). Dat Python het type herkent kun je nagaan met de functie type(): >>> x =1; print ( type (x)) <type int > >>> x =1.; print ( type (x)) <type float > >>> x =1+1 j; print ( type (x)) <type complex > >>> x =[2,5.0, morgen ]; print ( type (x)) <type list > >>> x =2**10; print ( type (x)) <type int > >>> x =2**1000; print ( type (x)) < type long > # in Python 2 < type int > # in Python 3 Wil je een ander type dan wat Python zou doen, dan kun je dat aangeven: >>> x = float (6); print (x, type (x)) 6.0 <type float > >>> x = int (7.3); print (x, type (x)) 7 <type int > >>> x = str (887); print (x, type (x)) 887 <type str > >>> x [2] # check 7 10

4.2 Integers Een integer van type int neemt in Python 2 op de VU (Windows PC; 32 bit architectuur) een waarde aan van 2 31,..., 2 31 1, op een Mac (64 bit architectuur) van 2 63,..., 2 63 1. Long integers (long) hebben feitelijk geen begrenzing. In Python 3 zijn deze twee types geïntegreerd tot één type int. Een integer van dit type kan dus zo groot worden als wilt (de begrenzing is het geheugen van je computer). 4.3 Floats Float variabelen volgen de principes van floating point numbers die uitgelegd worden in het boek, sectie 1.3. Dit onderwerp komt ook aan bod bij de colleges. 4.4 Strings Strings zijn niet belangrijk voor een vak over numerieke methoden, maar worden wel vaak gebruikt bij andere software toepassingen. Je kunt vele functies uitvoeren met strings, zie de help functie, bv help( str ). Handig zijn, de lengte van een string via len(), en de zogeheten slicing. 4.4.1 Slicing Een string is eigenlijk een serie (of volgorde) van enkelvoudige symbolen. Je kunt elk symbool afzonderlijk benaderen (indicering []), maar ook grotere delen van de string (dat heet slicing). Door slicing kun je een deel van een string selecteren of kopiëren. Voorbeelden >>> s = dit is een string >>> n = len (s); n 17 >>> x = s [ 2: 5]; x # symbolen op posities 2,3,4 t i >>> x = s [ 12:]; x # alle symbolen vanaf positie 12 tring >>> x = s [2:15:3]; x # symbolen op posities 2,5,8,11,14 tsesi >>> s[ -1] # symbool op laatste positie g Een voorbeeldprogramma: from future import print_function def main (): zin = " De eerste zin van een verhaal moet \ de aandacht van de lezer trekken " zin_zonder_klinkers = "" for letter in zin : if letter not in " AEOIUaeoiu ": zin_zonder_klinkers += letter print ( zin_zonder_klinkers ) 11

if name == " main ": main () 4.5 Lists Een list is een (geordende) lijst van objecten (getallen, teksten,...). Lists worden veel gebruikt in Python software. Lists worden geconstrueerd door de objecten tussen vierkanten haken,[], te zetten gescheiden door komma s. Wat dat betreft lijken ze op vectoren. En als de objecten weer lists zijn, lijken ze op matrices (zie ook voorbeelden hieronder). Voor numerieke methoden zullen we echter gebruik maken van de data types array en matrix van de module NumPy omdat we daarmee de gebruikelijke algebraïsche operaties kunnen uitvoeren (dat gaat niet met lists). Slicing van een list gaat net zo als bij strings. >>> x = [1,200, -35,40,80, -100] >>> len (x) 6 >>> x [1:5] [200, -35, 40, 80] >>> x [ -4: -1] [ -35, 40, 80] >>> x[0], x[ -1] (1, -100) >>> x += [ 999, 1000] >>> x [1, 200, -35, 40, 80, -100, 999, 1000] >>> >>> A = [[1,2,3],[4,5,6]] >>> A [0] [1, 2, 3] >>> A [0][0] 1 >>> A [0][1] 2 >>> A [1][1] 5 >>> A += [7,8] >>> A [[1, 2, 3], [4, 5, 6], 7, 8] De slicing y = x[:] creëert een kopie, en zo kun je x veranderen zonder dat y meeverandert. >>> x = [1,2,3,4]; y = x [:] >>> x [1] = 0; print (x,y) [1, 0, 3, 4] [1, 2, 3, 4] De elementen in een list hoeven niet alle hetzelfde type te hebben. >>> x = [2,3,4.4,5+6j, hallo,[9,9,9]] >>> for e in x:... print ( type (e)) 12

... <type int > <type int > <type float > <type complex > <type str > <type list > 4.5.1 List Functies Tabel 2: Enige handige functies voor lists. Veronderstel dat x = [10,20,30,40] een list is. functie beschrijving voorbeeld append(<object>) voegt object toe aan het eind x.append( cent ) count(<object>) telt aantal keer object x.count( cent ) del(<slice>) verwijdert de objecten op de slice plaatsen del(x[2:4]) extend(<list>) voegt list toe aan het eind x.extend([50,60,70]) index(<object>) geeft index van eerst optreden van object x.index(20) insert(<index>,<object>) voegt object toe vóór index x.insert(2,1000) len() retourneert de lengte len(x) pop(<index> retourneert en verwijdert het object op de index positie y = x.pop(3) remove(<object>) verwijdert eerste optreden van object x.remove( cent ) reverse() draait volgorde om x.reverse() sort() sorteert x van laag naar hoog x.sort() 5 Meest Voorkomende Operaties 5.1 Tussen Numerieke Types (int,long,float,complex) +,-,*,/: gebruikelijk. //: integer deling. %: modulo. **: machtsverheffen. x += y is equivalent aan x = x+y (idem de andere operaties). 5.2 Tussen Serie Types (string,list,tuple) De slicing is al gezien in sectie 4.4 voor strings en in sectie 4.5 voor lists. Voor tuples gaat het net zo. Ook van belang zijn (laat x,y twee variabelen van hetzelfde serietype zijn): x + y: voegt samen. n*x: serie van n keer serie x (n is positieve integer). t in x: test of object t in de serie x zit. t not in x: idem maar dan ontkennend. for t in x: itereeert over de objecten van x. 13

5.3 Vergelijkingen en Boolean Operaties x == y: True als x en y gelijk zijn. x!= y: True als x en y ongelijk zijn. <,>,<=,>=: gebruikelijk. x and y: logische AND, dus True als x en y allebei True zijn; anders False. x or y: logische OR, dus True als minstens een van x of y True is; anders False. not x: negatie van x, dus True als x False is; en omgekeerd. 6 Voorwaardelijke en Iteratie Blokken 6.1 if... elif... else Gebruik is net zo als in bv Java, C++, Ox, enz. De logische test hoeft niet tussen haken. En, elif,else zijn optioneel. Let wel op de indentaties, en op de dubbele punten. Voorbeeld: >>> def ITM (u):... if u <0.25:... x = 0... elif u <0.4:... x = 1... elif u <0.7:... x = 2... elif u <0.8:... x = 3... else :... x = 4... return x... >>> import random >>> u = random. random (); print ( ITM (,u, ) =, ITM (u)) ITM ( 0.410655677074 ) = 2 >>> u = random. random (); print ( ITM (,u, ) =, ITM (u)) ITM ( 0.538572567763 ) = 2 >>> u = random. random (); print ( ITM (,u, ) =, ITM (u)) ITM ( 0.268389436716 ) = 1 >>> u = random. random (); print ( ITM (,u, ) =, ITM (u)) ITM ( 0.954158198741 ) = 4 6.2 for De gebruikelijke structuur is for item in serie : code item doorloopt de elementen van serie, beginnend met het element met index 0, en eindigend met het laatste element. serie is (meestal) xrange of range, of een string, list, tuple, array of matrix. 14

>>> for i in xrange ( 4):... for j in xrange (7,10):... print (i,j)... 0 7 0 8 0 9 1 7 1 8 1 9 2 7 2 8 2 9 3 7 3 8 3 9 Gebruik break om een for loop eerder te beëindigen namelijk als een conditie is voldaan. >>> for i in xrange ( 4):... for j in xrange (7,10):... print (i,j)... if i >0:... break... 0 7 0 8 0 9 1 7 1 8 1 9 6.3 while De gebruikelijke structuur is while voorwaarde : code In de code zit meestal een iteratie die het programma doet terugkeren naar de voorwaarde. Als voorbeeld een bestand, genaamd bisectie.py. # bisectie methode voor nulpunt vinden from future import print_function, division def bisfun (x): return x **3-3. 0* x + 1.0 def bisectie (a0,b0, tol ): a,b = a0,b0 fa,fb = bisfun (a), bisfun (b) 15

if fa*fb >0.0: print ( verkeerde startwaarden ) quit () i = 0 while b-a>tol : i += 1 c = 0.5*( a+b) fc = bisfun (c) if fa*fc <0: b = c else : a = c fa = fc c = 0.5*( a+b) fc = bisfun (c) return c,fc,i def main (): c,fc,i = bisectie (0,1,1.0e -8) print ( nulpunt, c, met functiewaarde, fc, \ gevonden na, i, iteraties ) if name == " main ": main () 6.4 try... except Zogeheten exception handling is een geavanceerde techniek om uitzonderingsregels in je code te krijgen. Het kan ook gebruikt worden om gevaarlijke codes (bv delen door 0) te controleren. Hier is een voorbeeld om te illustreren: >>> try :... y = 4/0... print ( uitkomst :, y)... except Zero Divisi onerr or :... print ( kan niet delen door 0 )... kan niet delen door 0 7 Functies Python heeft vele built-in functies die je vaak gebruikt, zoals print(), max(), len(), xrange(), input(), abs(),... Via def() definieer je je eigen functies zoals we al menig keer zagen. 16

def functienaam ( formele parameters ): code Meestal retourneert een functie output, maar dat hoeft niet. De lijst met formele parameters mag eventueel leeg zijn. In een ander deel van je programma geef je de parameters bepaalde waarden (de functie krijgt argumenten), en roep je de functie met die argumenten aan. Pas dan wordt de functie uitgevoerd. Voorbeeldprogramma: from future import print_function def def func1 (x): print ( het kwadraat van,x, is, x*x) func2 (x,y): func1 (x) return x*y def main (): x = float ( input ( Geef x: )) y = float ( input ( Geef y: )) z = func2 (x,y) print ( x*y =,z) if name == " main ": main () Variabelen in de code van een functie zijn lokale variabelen en worden niet herkend in andere functies (scoping). Hier is een voorbeeld: from future import print_function def func1 (x): y = 5 x += y return x def main (): x = float ( input ( Geef x: )) print ( x =,x) try : print ( y =,y) except : print ( y niet gedefinieerd in main () ) x = func1 (x) print ( x =,x) if name == " main ": main () De output van dit programma is Geef x: 7.3 17

x = 7.3 y niet gedefinieerd in main () x = 12. 3 7.1 Globale Variabelen Globale variabelen kunnen wel in verschillende functies worden aangeroepen, ze kunnen niet gewijzigd worden in die functies. Advies is om globale variabelen NIET te gebruiken, het maakt meestal de code onoverzichteloijk. from future import print_function y = 5 # globale variabele def func1 (x): x += y return x def main (): x = float ( input ( Geef x: )) z = func1 (x) print ( x =,x) try : print ( y =,y) except : print ( y niet gedefinieerd in main () ) print ( z =,z) if name == " main ": main () De output van dit programma is Geef x: 7.3 x = 7.3 y = 5 x = 12. 3 7.2 Recursie en Iteratie Recursie is een efficiënte en overzichtelijke wijze van rekenen en verdient daarom de voorkeur om gecodeerd te worden indien je het herkent. Er zijn twee implementatiemethoden: (i) recursieve, en (ii) iteratieve. Wegens geheugengebruik, en daardoor tijdaspect verdient de iteratieve methode de voorkeur. Bovendien heeft Python recursielimiet van 1000. Voorbeeld: # berekening van n! from future import print_function from timeit import default_timer as timer def facr (n): 18

if n == 1: return n else : return n* facr (n -1) def faci (n): f = n while n >1: n -= 1 f *= n return f def main (): n = int ( input ( Geef n: )) tijdstart = timer () f1 = facr (n) tijdeind = timer () print (" Rekentijd recursieve methode : ", tijdeind - tijdstart ) tijdstart = timer () f1 = faci (n) tijdeind = timer () print (" Rekentijd iteratieve methode : ", tijdeind - tijdstart ) if name == " main ": main () De output van dit programma is Geef n: 1000 Rekentijd recursieve methode : 0.00327205657959 Rekentijd iteratieve methode : 0.00101208686829 8 Classes Python beschikt ook de mogelijkheid tot object geörienteerd programmeren door middel van het class structuur waarin je objecten, data, en functies kunt definiëren. Voor numerieke toepassingen is dit minder van belang, en zal dus (in dit crash-document) worden overgeslagen. 9 Numerieke Methoden in Python Hiervoor heb je modules nodig zoals Random, Math, NumPy, Matplotlib, SciPy,... Meer hierover in het document Scientific Computing with Python dat op de site en op Blackboard staat. 19