Ik ben pasgeleden met Python begonnen en ik vind het een leuke programmeertaal. Hier dus een Python-topic.
- R-Mon
Python?
Python is een interpreted, interactive, object-oriented programmeertaal. Je kan er dus programma's mee maken (no shit!). Het is uitgevonden door Nederlanders in Amsterdam. Interpreted betekent dat je programma's alleen kan gebruiken via een interpreter. Hierdoor kan je programma's minder handig verspreiden, maar zijn ze wel op de meeste platformen te gebruiken. Ook werkt het op de commandline. Er zijn wel grafische mogelijkheden, maar zover ben ik nog niet.
Op de Python homepage (zie Linkjes) staat meer informatie. Leuk detail is dat de naam Python komt van Monty Python's Flying Circus. Sommige functies hebben hier ook hun naam van (pickle) en je wordt aangemoedigd in je documentatie te refereren aan Monty Python sketches. Is het moeilijk?
Dat valt wel mee. Python wordt gezien als de instaptaal waarna je verder kan gaan naar C(++). Als je al ervaring hebt met een scripttaal zoals PHP is de overstap naar Python heel klein, heb ik gemerkt.
En waar gebruiken ze Python dan zoal?
Bij Google bijvoorbeeld. "Python has been an important part of Google since the beginning, and remains so as the system grows and evolves. Today dozens of Google engineers use Python, and we're looking for more people with skills in this language." said Peter Norvig, director of search quality at Google, Inc.
Links
http://www.python.org - De Python homepage.
http://www.coolpython.nl/tutorials/tut/tut.html - Nederlandse beginnersgids. Redelijk simpel geschreven, leuk om te lezen.
http://www.python.org/doc/faq/ - Frequently Asked Questions.
Wat hebben we nodig?
Aan de slag.
Ga naar de Python homepage ( http://www.python.org ). Bovenin staat een link Download. Er staan een paar versies voor verschillende OS'sen. Ik ga ervanuit dat je Windows draait. 2.4 is de laatste versie, dus kiezen we die. Er staan twee Windows versies. Kies Python 2.4 Windows installer (Windows binary -- does not include source) (tenzij je Itanium
hebt natuurlijk). Als de download klaar is, klik je erop om het te installeren. De standaard map waar het naartoe gaat is C:python24, ik adviseer dat zo te laten.Geinstalleerd, en verder?
Ga naar de map waar je Python hebt geinstalleerd, en start python.exe op. Als het goed is krijg je een zwart schermpje met deze tekst:
| 1 2 3 | Python 2.4 blablabla Type help, copyright, credits or license blablabla >>> |
Ja? Mooi! Python is goed geinstalleerd.
Je kan Python commando's rechtstreeks in de interpreter intypen. Dit gaan we even oefenen. Nieuwe commando's tik je in op een regel die begint met >>> en je geeft ze door met een druk op Enter.
Allereerst gaan we rekenen. De interpreter kan worden gebruikt als uitgebreide rekenmachine. Tik maar eens:
| 1 | 2+2 |
en druk op Enter. Verbazingwekkend! En:
| 1 | 5*5 |
Oooooooooh. Daar komt 4 en 25 uit. Als rekentekens kan je de vaakgebruikte + - * / gebruiken.
NOOT: Vanaf nu zet ik >>> voor de commando's, deze moet je niet zelf intikken. De interpreter geeft ze als het goed is. En ik ga ervanuit dat je nu snapt dat je op Enter moet drukken na het intikken.
Dat waren getallen. Nu wat tekst. Hiervoor gebruiken we de functie print. Tik maar eens in:
| 1 | >>> print "Hallo wereld" |
Python zal dan Hallo wereld zeggen. Weer wat geleerd: Als je tekst invoert, moet dat tussen aanhalingstekens. Aanhalingstekens printen hebben we het later wel over. Als je een getal invoert tussen aanhalingstekens zal die worden gezien als tekst, je kan er dan niet direct mee rekenen.
Ik ga even bedenken wat ik verder zal laten zien. Ga maar lekker rekenen of de beginnersgidsdoorlezen. Misschien zometeen een nieuw deel.
.quote:Ben bezig.Op woensdag 23 maart 2005 17:20 schreef BaggerUser het volgende:
oke ik ben klaar met deze les, ik wacht al op de volgende
http://www.ibiblio.org/obp/thinkCSpy/
Oh ja, dit is natuurlijk gewoon een ordinaire tvp.
Commentaar kan heel handig zijn om tussen de code door uit te leggen wat het doet. Commentaar start je door een hekje (#) te plaatsen. Dit kan aan het einde van een regel code, of op een nieuwe regel. Alles wat na het hekje komt op dezelfde regel wordt genegeerd door de interpreter.
Vrijwel elke script-/programmeertaal heeft variabelen. Voor nieuwelingen: Variabelen zijn objecten waar je waardes in kan opslaan, om later te gebruiken.
De variabelen in Python werken volgens mij hetzelfde als in Javascript. Het zijn termen die uit een stuk bestaan. "x" is een geldige variabele, maar "gebruiker_nummer_1337" ook. Ze mogen beginnen met een underscore (_) en letters maar niet met een getal. Ook mag er geen normaal streepje (-) in voorkomen omdat die wordt gezien als een minteken.
Een waarde toekennen
Een waarde toekennen aan een variabele is heel makkelijk. Je hoeft niet eerst aan te geven dat je een variabele gaat gebruiken. Stel je wil x de waarde 5 geven, dan doe je dat zo:
| 1 | >>> x=5 |
Dit moet je zo lezen: x wordt 5. Als je nu dit doet:
| 1 | >>> x |
geeft Python de waarde van x terug. Tekst toewijzen doe je zo:
| 1 | >>> y="hallo wereld" |
Zoals ik al heb gezegd, tekst tussen aanhalingstekens. Als je nu
| 1 | >>> y |
invoert geeft Python "hallo wereld" terug. Op deze manier een variabele teruggeven is eigenlijk alleen maar handig in de interpreter. Als je het later in een echt programma wilt doen zou ik het zo doen:
| 1 | >>> print x |
Of welke variabele dan ook.
Een resultaat in een variabele stoppen
Hier worden variabelen het meeste voor gebruikt. Als je een functie uitvoert, kan je in plaats van het restultaat direct weer te geven het opslaan in een variabele. Laten we een simpele functie gebruiken, zoals 7+3. Ik zal ook het commentaar gebruiken.
| 1 2 | >>> x=7+3 # de uitkomst van de functie 7+3 wordt opgeslagen in x >>> print x # de waarde van x wordt teruggegeven |
Hierna: Meer rekenen met variabelen, datatypen, modules, if/else en uiteindelijk natuurlijk het echte werk
[/note to self]quote:Er is dus geen multi-line comment? Dat is irritant.Op woensdag 23 maart 2005 18:00 schreef R-Mon het volgende:Commentaar
Commentaar kan heel handig zijn om tussen de code door uit te leggen wat het doet. Commentaar start je door een hekje (#) te plaatsen. Dit kan aan het einde van een regel code, of op een nieuwe regel. Alles wat na het hekje komt op dezelfde regel wordt genegeerd door de interpreter.
lussen:
for i in range(10): doe iets 10 keer (range(10) = 0,1,2,3,.....,9)
while i < 10: zelfde eigenlijk, alleen moet je zelf de i ophogen
for i in list: iets voor alle items in een lijst doen
lijsten:
lijst = [1,2,3,4]
lijst[0] geeft 1
lijst[0:2] geeft [1,2]
lijst[-1] geeft 4
lijsten zijn dus zowel van voren als van achteren te benaderen! erg handig!
dictionary's:
dictionary's hebben { } ' s om zich heen
d={"hoi":2,"doei":1} waarbij hoi en doei de keys zijn, 2 en 1 de values.
d["hoi"] geeft 2.
d.keys() geeft een lijst: ["hoi","doei"]
d.values() geeft een lijst: [2,1]
Zelf werk ik heel erg veel met dictionary om frequenties van sequenties van woorden in een grote tekst te tellen en op deze manier statistiek over natuuurlijke taal te krijgen. Voorbeeldtoepassing van deze statistiek: spellingscorrectie (context afhankelijk). Maargoed ik dwaal af.
functies definieer je heel simpel in python:
def functie():
als je bepaalde opdrachten gewoon in een .py file gooit, zonder def te gebruiken, worden deze gewoon uitgevoerd wanneer er op f5 gedrukt wordt. Als je een functie wilt aanroepen, druk je eerst op f5 (je komt weer in de shell) en je doet gewoon simpelweg: functie(eventuele argumenten) en enter en python voert het uit.
Hoop dat men hier iets aan heeft, ben niet geboren om tutorials te schrijven.
[ Bericht 0% gewijzigd door a3aan op 23-03-2005 18:55:24 ]
| 1 2 3 4 5 | def fib(x): if n==1 or n==2: return 1 else: return fib(x-1) + fib(x-2) |
werkt dus ongeveer hetzelfde als een c++ functie...
Nog een kleine toevoeging aan de namen van variabelen:
_ als variabele heeft de waarde van de laatst afgedrukte expressie! Dus je kan niet zelf een variabele _ noemen.
Verder met vars
Okee, weer een stukje verder. Als je een getal in een variabele hebt gezet, kan je daar ook
mee rekenen. Kijk maar. Oja, commentaar hoef je niet over te typen.
| 1 2 3 4 | >>> x=10 >>> y=5 >>> x*y/2 # 10 keer 5 gedeeld door 2 -> 25 >>> x/y*10 # 10 gedeeld door 5 keer 10 -> 20 |
a3aan heeft er al een paar laten zien, de verschillende types data in Python. De types: Strings, getallen, lists, dictionaries en tuples.
Strings: Tekst, of tekens die als tekst behandeld moeten worden. Strings worden tussen aanhalingstekens gezet.
Getallen: Meerdere varianten. Integer (gehele getallen), float (kommagetal), complexe getallen (standaard twee getallen achter de komma. Voor een uitgebreidere uitleg zie http://www.coolpython.nl/(...)05110000000000000000
Lists: In PHP aangeduid als array. Niets anders dan een lijst met waardes. String uiteraard weer tussen aanhalingstekens. a3aan heeft het voorbeeld, en hoe je waardes kan oproepen.
Dictionaries: Associatieve arrays. De gids geeft een telefoonboek als voorbeeld: {"john":5551234, "joe":5554321} Je kan steeds de tweede waarde oproepen door de eerste te geven, zie a3aan weer.
Tuples: Vage dingen. De gids zegt dat je ze kan gebruiken voor x, y coordinaten en database records, maar ik snap niet waarom je daar geen lists voor kan gebruiken. Het gebruik: (234, "hoi") Normale haakjes er omheen dus.
Al deze dingen zijn in variabelen te stoppen.
| 1 2 3 4 5 | a = "hoi" b = 4 c = [734, "hallo"] d = {"python":"slang", "php":5327} e = (25, 54) |
quote:Dat vind ik al gepijpzeik.Op woensdag 23 maart 2005 19:14 schreef R-Mon het volgende:
verhaal
Die dingen heten gewoon strings, arrays en associatieve array's
Noem ze niet lijst en dictionary. Maar das een sidenote. functioneel is het hetzelfde
quote:Zo heten ze nou eenmaal. Maar goed, waarschijnlijk zal ik ze door elkaar gebruiken.Op woensdag 23 maart 2005 19:26 schreef Swetsenegger het volgende:
[..]
Dat vind ik al gepijpzeik.
Die dingen heten gewoon strings, arrays en associatieve array's
Noem ze niet lijst en dictionary. Maar das een sidenote. functioneel is het hetzelfde
a3aan en Mendelevium hebben het al laten zien. Zelf functies maken. Yay!
Het begin
| 1 | >>> def functienaam(): |
def geeft aan dat we zelf een functie gaan maken. De functienaam mag je zelf bedenken. De haakjes zijn nodig, als je variabelen in wil voeren zet je die ertussen. De dubbele punt geeft aan dat er een vervolg komt.
Natuurlijk wil je wel dat je functie wat doet. Tik me maar na:
| 1 2 3 4 | >>> def hallo(): ... print "hallo wereld" ... >>> hallo() |
Even uitleggen. Zoals de >>> een nieuw commando aangeven, geven de ... een vervolg aan. In dit geval het vervolg op def. Ook springt de regel in na de dubbele punt. Dit is erg belangrijk, omdat de interpreter anders niet begrijpt dat je verder gaat. Je kan inspringen door op TAB te drukken.
Dan, als de functie gedefinieerd is, wil je hem natuurlijk uitvoeren. Omdat de functie hallo heet, tikken we hallo() in. Tadaa! Hallo wereld.
Variabelen doorgeven
Soms wil je een variabele doorgeven aan een functie. Zoals ik al zei, gaan die tussen de haakjes.
De variabelen die binnen een functie worden gebruikt hebben niets te maken met de variabelen erbuiten. Je kan bepalen welke waardes doorgegeven worden door rekening te houden met de volgorde. Klinkt wazig, ik zal het laten zien.
We maken een functie:
| 1 2 3 | >>> def voorbeeld(x, y, z): ... print x, y, z ... |
Dan maken we even wat variabelen:
| 1 | >>> a, b, c=12, 34, 56 |
Zoals je ziet doe ik dit allemaal op een regel. Bij uitvoer zorgt ", " voor een spatie tussen de variabele en het volgende object. Komen we misschien nog op terug.
Als we dan de functie zo aanroepen:
| 1 | >>> voorbeeld(a, b, c) |
Krijgen we terug: 12 34 56
Als er het echter zo doen:
| 1 | >>> voorbeeld(c, b, a) |
Krijgen we: 56 34 12
De eerste meegegeven functie wordt dus ingevuld in (in dit geval) x, de tweede in y enz. Volgorde. Je kan ook waardes direct meegeven, bijvoorbeeld:
| 1 | >>> voorbeeld(b, 95, a) |
Probeer maar.
Python kent zoals andere talen de if en else statements. Hiermee kan je iets laten doen als er aan een bepaalde voorwaarde voldaan wordt.
De statements hebben deze vorm:
| 1 2 3 4 5 6 | >>> if voorwaarden: ... doe dit ... elif anderevoorwaarden: ... doe dat ... else: ... doe iets anders |
De if is altijd de eerste. Hier kan je voorwaarden meegeven aan welke moeten voldaan. Als er niet aan de voorwaarden wordt voldaan, gaan Python door naar de volgende statement als die er is. Een elif (else if) heeft ook voorwaarden waaraan voldaan moeten worden. Als er aan geen van de voorwaarden voldaan wordt worden de opdrachten bij de else statement uitgevoerd.
Voorwaarden
Deze kennen operators en booleans.
Operators:
== gelijk aan, je kan ook is gebruiken
> groter dan
< kleiner dan
>= groter of gelijk aan
<= kleiner of gelijk aan
in Hiermee kan je bepalen of een waarde voorkomt in een array (list, tuple, dictionaries)
Tussendoor ga ik even een nieuwe functie introduceren. Maak kennis met raw_input(). Hiermee kan je de gebruiker vragen om invoer. Er moet een vraag meegegeven worden. Om het netjes eruit te laten zien, kan je aan het eind van de vraag een spatie zetten. Voorbeeld:
| 1 | >>> raw_input("Hoe heet je? ") # let op de spatie |
Het resultaat (oftewel het ingetikte) kan je weer zetten in een variabele.
| 1 2 | >>> antwoord = raw_input("Hoe heet je? ") >>> print antwoord |
De functie heet niet voor niets raw_input. De gebruiker kan zowel strings als getallen invoeren. Laten we eens controleren wat de gebruiker invoert. Goed opletten!
| 1 2 3 4 5 6 7 8 9 10 11 | >>> x = int(raw_input("Voer een integer in: ")) >>> if x < 0: ... x = 0 ... print 'Negatief getal omgezet naar nul' ... elif x == 0: ... print 'Nul' ... elif x == 1: ... print 'Enkel' ... else: ... print 'Meer' ... |
Weer heb ik wat nieuws, de functie int(). Hiermee zet je de meegegeven waarde (in dit geval het resultaat van de raw_input, die gewoon tussen de haakjes van de int() is geplaatst) om in een heel getal (integer). Als de omzetting lukt geeft de functie True, als het niet lukt False een misschien zelfs een foutmelding.
Naast int() zijn er nog str() voor strings, float() voor kommagetallen, abs() voor absolute getallen en vast nog een paar.
True en False
...schrijf je in Python met een hoofdletter.
Geef maar een kik als je true en false niet snapt.quote:input([prompt])Op woensdag 23 maart 2005 20:52 schreef Mendelevium het volgende:
als je een integer wilt inlezen kun je beter gewoon input() gebruiken ipv raw_input()... lijkt me...
Equivalent to eval(raw_input(prompt))
Dankje, die kende ik nog niet.
tvp
quote:Inderdaad.Op woensdag 23 maart 2005 21:20 schreef Tiemie het volgende:
erg interessant, python is vrij strict toch? (met inspringen e.d.)
tvp
De body van de lus is ingesprongen (indented): inspringing is de manier waarop in Python statements gegroepeerd worden. Python beschikt (nog!) niet over intelligente editing op invoerregelniveau, dus je moet zelf nog een tab of spatie(s) typen voor elke ingesprongen regel. In de praktijk zul je de wat complexere invoer voor Python in een teksteditor voorbereiden; de meeste teksteditors hebben een faciliteit voor automatisch inspringen. Bij het interactief invoeren van een samengesteld statement, moet dit gevolgd worden door een lege regel om aan te geven dat het statement compleet is (aangezien de parser niet kan raden dat je de laatste regel hebt ingetypt). Merk op dat je iedere regel binnen een blok even ver moet laten inspringen.
quote:Hier is de gui-faq: http://www.python.org/doc/faq/gui.htmlOp woensdag 23 maart 2005 21:29 schreef Swetsenegger het volgende:
Leuk leuk, maar is er ook een grafische schil of draait alles in CL (net als C++)?
En een voorbeeld van een grafisch Python-programma: http://www.blogtk.com (gtk -> linux)
quote:Mooi voorbeeld... 404Op donderdag 24 maart 2005 12:46 schreef R-Mon het volgende:
En een voorbeeld van een grafisch Python-programma: http://www.blogtk.com (gtk -> linux)
quote:Ja die dus
is not is niet gelijk aan
Met de functie range() kan je lists maken met rijen getallen. Dit kan heel handig zijn om te
gebruiken in loops. De list die range() teruggeeft kan je natuurlijk weer in een variabele
stoppen.
De functie range() kan je op drie verschillende manieren gebruiken.
range(x) - Een lijst van x getallen beginnend bij 0.
range(x, y) - Een lijst die begint bij x en eindigt bij het y-de getal. Niet y! Het eerste
item in een array/list/dictionary is (altijd) het nulde item.
range(x, y, z) - Een lijst die begint bij x en doorloopt tot het y-de getal, met stappen van z.
| 1 2 3 4 5 6 | >>> range(5, 10) [5, 6, 7, 8, 9] >>> range(0, 10, 3) [0, 3, 6, 9] >>> range(-10, -100, -30) [-10, -40, -70] |
Met de functie len() kan je:
-de lengte van een string bepalen
-het aantal items in een list bepalen
Gebruik:
| 1 2 3 4 | >>> a="swetsenegger" >>>len(a) >>>b=[1,2,3,"do","re","mi"] >>>len(b) |
Python heeft natuurlijk ook loops, namelijk de for en while.
for
For loops worden bijvoorbeeld gebruikt om iets te doen met elk item van een list. Je
gebruikt ze zo:
| 1 2 3 | >>> for variabele uit object: ... opdrachten ... |
Dit wil zeggen, "Doe de opdrachten voor elk item in het object." De variabele die je opgeeft
kan je gebruiken in de opdrachten. Probeer dit maar eens:
| 1 2 3 | >>> for x in range(10): ... print x ... |
Dus, voor elk item in de lijst die range(10) geeft, wordt het huidige item (x) afgedrukt.
Als de opdrachten zijn uitgevoerd gaat Python door met het volgende item.
while
While statements kan je gebruiken om opdrachten uit te voeren zolang er aan een of meerdere
voorwaarden wordt voldaan. De voorwaarden werken hetzelfde als bij if en else.
Een voorbeeld. We maken een variabele x met waarde 0. Dan printen we "hoi!" en hogen we x
met 1 op, zolang x kleiner is dan 10.
| 1 2 3 4 5 | >>> x=1 >>> while x<10: ... print "hoi!" ... x=x+1 ... |
Een array netjes afdrukken:
| 1 2 3 4 | >>> a = ['Iene', 'miene', 'mutte'] >>> for i in range(len(a)): ... print i, a[i] ... |
Het is heel handig als je in bijvoorbeeld een loop netjes aan kan geven bij welke iteratie
(item, loop, rondje) je bent. Daarom wil je wel eens een variabele mengen in een zin. Hiervoor gebruiken we komma's.
| 1 2 3 | >>> x = 16 >>> print "Jij zegt dat x", x, "is!" Jij zegt dat x 17 is! |
Zie je hoe het werkt? Een string, gevolgd door een komma, dan de variabele, dan weer een komma, en dan weer een string.
Meer, meer, meer
Python heeft iets grappigs. Je kan strings heel makkelijk meerdere keren na elkaar afdrukken. Doe dit maar eens:
| 1 2 | >>> g="la" >>> print 10*g |
Je kan het ook met getallen doen, maar dan moet je ze wel omvormen naar een string:
| 1 2 | >>> h=123 >>> print 6*str(h) |
Weer even terug naar de statements (if, elif, else, while). Om meerdere voorwaarden te gebruiken zijn er booleans. In Python zijn er and en or. Je zet ze gewoon tussen de voorwaarden.
| 1 | if x<6 and x is not 2 |
Meer over voorwaarden enz. staat op http://www.coolpython.nl/(...)07110000000000000000
Break kan je gebruiken om uit een lus te komen.
| 1 2 3 4 | >>> while True: ... print "fok" ... break ... |
Er valt nog veel meer te vertellen over al deze dingen. Je kan natuurlijk hier vragen stellen maar in de beginnersgids staat alles ook heel duidelijk uitgelegd.
Als je de Python-interpreter afsluit en weer opstart, gaan de definities die je aangemaakt had (functies en variabelen) verloren. Als je een wat groter programma wilt schrijven, kun je dus in plaats daarvan beter een teksteditor gebruiken om de invoer voor de interpreter op te stellen en in een bestand op te slaan, en dit bestand vervolgens aan de interpreter te geven als invoer. Dit noemen we “een script schrijven”. Naarmate je programma langer wordt, wil je het misschien in verschillende bestanden opsplitsen, om het onderhoud te vergemakkelijken. Of je hebt misschien een handige functie geschreven die je in meerdere programma's wilt gebruiken, zonder de functie in ieder afzonderlijk programma te moeten kopiëren.
Ter ondersteuning hiervan is het in Python mogelijk om definities in een apart bestand te zetten, en dit vervolgens te gebruiken in een script of in een interactieve interpretersessie. Zo'n bestand heet een module; definities uit een module kunnen geïmporteerd worden in andere modules of in de main module (de main module is de verzameling variabelen waar je toegang toe hebt in een script dat op top-level wordt uitgevoerd, of in “rekenmachine-modus”).
Een module is een bestand wat Python-definities en -statements bevat. De bestandsnaam wordt gevormd door de modulenaam met het achtervoegsel .py. Binnen de module is de modulenaam (als een string) beschikbaar als de waarde van de globale variabele __name__.
Modules gebruiken
Om een module te gebruiken moet je hem importeren. Er zijn verschillende manieren om dingen uit een module te gebruiken (de hele module importeren, alleen de functies importeren).
De module os bevat functies om bijvoorbeeld de omgeving (OS) en bestanden te manipuleren. Om een functie/object van een geimporteerde module op te roepen, gebruik je modulenaam.objectnaam.
Kijk eens rechtsonderin, als het goed is zie je de tijd daar. Die gaan we veranderen.
(Ik weet niet of dit ook onder Linux werkt maar het zal haast wel.)Open de interpreter.
| 1 2 | >>> import os # module os importeren >>> os.system('time 0:15') # functie system aanroepen en de tijd veranderen |
Tadaa, het is nu kwart over twaalf 's nachts. Je kan dezelfde functie gebruiken om de tijd weer goed te zetten (en anders op de normale manier).
Python komt standaard met de "Standard Library". Deze bestaat uit een paar veel gebruikte modules. Zoals:
os - OS manipuleren etc
glob - bestandslijsten maken voor bijv zoekacties
sys - handige Python functies (bijv commandline argumenten uitlezen)
re - regular expressions
math - wiskundige functies en constanten (pi)
random - functies voor willekeurigheid
urllib2 en smtplib - toegang tot internet
leukdatetime - functies voor datum en tijd
zlib, gzip, bz2, zipfile, en tarfile - datacompressie
Zie ook http://www.coolpython.nl/(...)12800000000000000000
En de Python Library Reference http://docs.python.org/lib/lib.html
We gaan een module maken
Ik denk dat ik genoeg heb verteld, dus we gaan het maar gewoon proberen. Pak je tekstverwerker erbij! (zie OP)
Fibonacci was een wiskundige die een formule had gemaakt om een rij getallen te vormen waarbij twee opeenvolgende termen de volgende term volgen. Dat gaan we namaken.
Open je editor (voorheen tekstverwerker
)Tik dit over, let op de TABs. (Overtikken is leerzamer dan kopieren. Dan krijg je meer door wat het nou eigenlijk doet.)
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | # Module voor Fibonaccigetallen def fib(n): # druk Fibonaccireeks af tot n a, b = 0, 1 # a en b definieren while b < n: # zolang b kleiner is dan n print b, # b afdrukken a, b = b, a+b # a wordt b, en b wordt a+b def fib2(n): # geef Fibonaccireeks tot n terug resultaat = [] # resultaat wordt een lege array a, b = 0, 1 # a en b definieren while b < n: # zolang b kleiner is dan n resultaat.append(b) # voeg b toe aan resultaat a, b = b, a+b # a wordt b, en b wordt a+b return resultaat # geef resultaat terug |
Gedaan? Sla het op als fibo.py (.py is de python extensie) in dezelfde map als de Python interpreter (c:\python24\).
Start de interpreter weer. Importeer onze nieuwe module:
| 1 | >>> import fibo |
Nu kunnen we de functies fib() en fib2() aanroepen.
| 1 2 | >>> fibo.fib(1000) >>> fibo.fib2(100) |
Als je de functie vaak wil gebruiken kan je de naam.naam afkorten door het in een variabele te stoppen:
| 1 2 | >>> fib = fibo.fib >>> fib(500) |
Bepaalde dingen importeren
Als je slechts een functie uit een module wil importeren:
| 1 | >>> from fibo import fib |
Twee of meer:
| 1 | >>> from fibo import fib, fib2 |
Alle namen (functies, variabelen, enz):
| 1 | >>> from fibo import * |
Als je op deze manier hoef je niet meer de modulenaam aan te geven. Je fib() dus meteen aanroepen:
| 1 2 | >>> from fibo import fib >>> fib(1000) |
Functies die al in de module worden aangeroepen worden uitgevoerd zodra de module worden geimporteerd. Op die manier kun je een heel programma laten draaien door een module te importeren. Doen we nog wel.
quote:Dankjewel.Op zaterdag 26 maart 2005 13:20 schreef Pizza_Shooter het volgende:
Helder en duidelijk uitgelegd. Complimenten.
quote:Overigens wel een vraagje: als je nou niet alles in de interpreter in wilt tikken, maar gewoon in crimson editor, moet je dan die .py bestanden steeds importeren, of kan dat ook anders?
quote:Heb al wat gevonden..Op zaterdag 26 maart 2005 13:59 schreef Pizza_Shooter het volgende:
[..]
Overigens wel een vraagje: als je nou niet alles in de interpreter in wilt tikken, maar gewoon in crimson editor, moet je dan die .py bestanden steeds importeren, of kan dat ook anders?
Je kan in Crimson Editor zogenaamde 'User tools' instellen en dan kan je dus je bestand (test.py) in python.exe laten openen. Dat werkt wel goed eigenlijk.
Of doe ik nu heel ingewikkeld?
quote:Als het goed werkt, houden zo. Welke instellingen gebruik je? (wil ik ookOp zaterdag 26 maart 2005 14:05 schreef Pizza_Shooter het volgende:
[..]
Heb al wat gevonden..
Je kan in Crimson Editor zogenaamde 'User tools' instellen en dan kan je dus je bestand (test.py) in python.exe laten openen. Dat werkt wel goed eigenlijk.
Of doe ik nu heel ingewikkeld?
)Jammer genoeg komt dit topic nu pas, wat er tot nu toe is besproken heb ik al zelf uitgevogeld (icm met af en toe wat hulp van medestudenten en docent). Maar zodra de classes en de gui (Tkinter) erbij komen dan ben ik er absoluut bij
quote:Onder Tools -> Conf. user toolsOp zaterdag 26 maart 2005 14:19 schreef R-Mon het volgende:
[..]
Als het goed werkt, houden zo. Welke instellingen gebruik je? (wil ik ook
Menutext: Load in Python
Command: C:\Python24\python.exe
Argument: test.py
En als hot key Ctrl + d ofzo. Werkt prima. Vergeet overigens niet 'Close on exit' uit te vinken..
quote:lukt nietOp zaterdag 26 maart 2005 14:33 schreef Pizza_Shooter het volgende:
[..]
Onder Tools -> Conf. user tools
Menutext: Load in Python
Command: C:\Python24\python.exe
Argument: test.py
En als hot key Ctrl + d ofzo. Werkt prima. Vergeet overigens niet 'Close on exit' uit te vinken..
quote:
Heb je em zo ingesteld?
Iemand enig idee, ^ werkt namelijk niet.
quote:Oh, dat zou kunnen, even testen..Op zaterdag 26 maart 2005 15:10 schreef SuperRembo het volgende:
Is dat niet ** ?
quote:Jep, dat werkt.Op zaterdag 26 maart 2005 15:11 schreef Pizza_Shooter het volgende:
[..]
Oh, dat zou kunnen, even testen..
| 1 2 3 4 5 6 7 8 9 | # Rente berekenen bedrag = int(raw_input("Bedrag: ")) aant_jaar = int(raw_input("Hoeveel jaar? ")) rente = 1.03 tot_bedrag = bedrag * (rente ** aant_jaar) print "Uw kapitaal bedraagt dan ongeveer ", tot_bedrag, "euro" |
quote:Ah ik snap het al. Ik had iets uitgebreiders moeten doen dan 2+2.Op zaterdag 26 maart 2005 15:04 schreef Pizza_Shooter het volgende:
[..]
[afbeelding]
Heb je em zo ingesteld?
De prompt die Crimson Editor opent is niet de interpreter, dus je kan niet "ff snel" wat doen. Maar hij doet het wel. Ik hou het toch liever bij de echte interpreter.En Ctrl+D wordt al gebruikt. Ctrl+1 is de default.
quote:Op zaterdag 26 maart 2005 15:11 schreef Pizza_Shooter het volgende:
[..]
Oh, dat zou kunnen, even testen..
| 1 2 3 4 | >>> 2**2**2**2**2 20035299304068464649790723515602557504478254755697514192650169737108940595563114 ... 5337539755822087777506072339445587895905719156736L |
Ik heb toch ook maar ff python geinstalleerd
[ Bericht 92% gewijzigd door SuperRembo op 26-03-2005 15:31:29 ]
quote:DudeOp zaterdag 26 maart 2005 15:20 schreef SuperRembo het volgende:
[..]
[ code verwijderd ]
Ik heb toch ook maar ff python geinstalleerd
Kan je dat zo wel even weghalen?quote:k dan.Op zaterdag 26 maart 2005 15:23 schreef R-Mon het volgende:
[..]
Dude
De module pickle bevat functies om Python dingen heel makkelijk weg te schrijven naar een bestand. Daarna kunnen ze net zo makkelijk weer unpickled worden. The following types can be pickled:
* None, True, and False
* integers, long integers, floating point numbers, complex numbers
* normal and Unicode strings
* tuples, lists, sets, and dictionaries containing only picklable objects
* functions defined at the top level of a module
* built-in functions defined at the top level of a module
* classes that are defined at the top level of a module
* instances of such classes whose __dict__ or __setstate__() is picklable
Onpicklebare objecten zullen een PicklingError teruggeven. (
)Laten we dan maar wat picklen.
| 1 | >>> import pickle #pickle module laden, anders komen we nergens |
Ho, wacht, even wat anders. Eerst maar een bestand leren openen. De functie open() geeft een file- object terug, en wordt meestal gebruikt met twee argumenten: "open(filenaam, modus)". Voor de duidelijkheid, open() zit niet in pickle maar standaard in een kale Python.
De modus waarop je een bestand opent bepaalt wat je ermee kan doen.
r alleen lezen; default
w alleen schrijven (als er al een bestand met de gegeven naam aanwezig is, zal dat overschreven worden; als er nog geen bestand bestaat wordt het gemaakt)
a append: wat je naar het bestand schrijft zal achteraan worden gezet
r+ lezen en schrijven
Een bestand openen en sluiten (aangenomen dat het bestand bestaat):
| 1 2 | >>> file = open("lijst.txt") >>> file.close() |
close() is een methode van bestandsobjecten. Een functie die je erachter moet plakken dus. Gil als je dit niet snapt.
Nu verder met picklen.
Picklen doe je zo. Eerst gaan we wat picklen, en daarna weer unpicklen.
| 1 2 3 4 5 | >>> import pickle # pickle laden >>> f = open("pickle.txt", "w") # bestand pickle.txt maken en openen voor schrijven >>> geblaat = "Ik heb een augurk, jij hebt een augurk, wij hebben een augurk." >>> pickle.dump(geblaat, f) # dump! niets anders dan wegschrijven >>> f.close() |
Als je nu in je Python-map kijkt zie je een bestand pickle.txt staan. Als je hem opent kan je je tekst er nog wel uithalen, maar een staan ook een zooi tekens omheen. Niet aankomen!
Tijd om het te gaan unpicklen.
| 1 2 3 | >>> import pickle # pickle laden als je dat nog niet hebt gedaan >>> f = open("pickle.txt") # we gaan het lezen, dus gebruiken we de default modus r >>> pickle.load(f) |
En als het goed is krijg je dan je zinnetje weer voor je neus. Je kan, uiteraard, weer het resultaat van load() in een variabele zetten.
| 1 | >>> p = pickle.load(f) |
Helaas is dit topic een beetje stil gevallen. Nu heb ik vandaag python geinstalleerd en ik wil er eens mee aan de slag.
Eerste korte vraag. Ondanks dat python een interpretated taal is kan ik wel executables maken met python?
[ Bericht 28% gewijzigd door Swetsenegger op 25-11-2005 21:27:29 ]
quote:http://www.py2exe.org/Op vrijdag 25 november 2005 21:22 schreef Swetsenegger het volgende:
Enorme rotschop.
Helaas is dit topic een beetje stil gevallen. Nu heb ik vandaag python geinstalleerd en ik wil er eens mee aan de slag.
Eerste korte vraag. Ondanks dat python een interpretated taal is kan ik wel executables maken met python?
| 1 |
Wat is er precies verkeerd aan deze reguliere expressie? of kan hij niet zo goed tegen die aanhalingstekens?
Ziet er leuk uit, van de week Python maar uit proberen
quote:Heb het antwoord al, het patroon kwam helemaal niet in mijn lijst voor, nogal wiedes dat het verkeerd ging.Op woensdag 12 april 2006 11:46 schreef MrBean het volgende:
ah ik zocht dit topic al.
[ code verwijderd ]
Wat is er precies verkeerd aan deze reguliere expressie? of kan hij niet zo goed tegen die aanhalingstekens?
Nu wil ik met behulp van een raw_input een dictionary updaten met elk value: 'woord' een eigen key: x.
| 1 2 3 4 5 | for x in range(0,2,1): d = raw_input('geef woord '+ `x`+': ') b = {x: d} a = a.update(b) |
Tot en met b werkt het maar als ik de dictionary a probeer te updaten met dictionary b werkt het niet en geeft die bij print a none aan.
| 1 2 3 4 5 6 7 | b = dict() for x in range(0,2,1): x = x+1 d = raw_input('geef woord '+ `x`+': ') b[x]=d a.update(b) |