Python is een programmeertaal die ontwikkeld is door Guido van Rossum en de Python gemeenschap. Python is gericht op eenvoud en leesbaarheid, en is daardoor snel te leren. Je kunt het hier downloaden voor verschillende besturingssystemen. Voor Windows kies je gewoonlijk de default versie (“For x86 processors”), namelijk python-2.5.1.msi, of eventueel een nieuwere versie.

Het programma installeert zichzelf als je het bestand opent (dubbelklik in Windows Explorer, of “Openen” in het download venster).

Als alles goed gaat, heb je in Start - Programma's - Python25 nu verschillende programma's staan, waaronder twee manieren om Python uit te voeren.

Er zijn twee manieren waarop je Python code kunt uitvoeren:

In deze inleiding zal voornamelijk gebruikt gemaakt worden van de interactieve vertaler.

Een van de meest basale datatypen in Python is een getal. Je kunt een aantal rekenkundige operatoren op getallen toepassen. Het resultaat van de berekening zal teruggegeven worden. Hier zie je een aantal voorbeelden van berekeningen met gehele getallen:

>>> 2 + 3
5
>>> 2 * 3
6
>>> 6 / 3
2
>>> 2 - 3
-1
      

Als een van de twee getallen een drijvende-comma-getal is, dan wordt het resultaat dat ook:

>>> 2.0 - 3
-1.0
>>> 6 / 2.0
3.0
      

In echte programma's wil je een getal of het resultaat van een berekening vrijwel altijd opslaan. Dit kan met behulp van een zogenaamde variabele. Een variabele is een verwijzing naar het stukje geheugen waarin een gegeven staat. Een variabele kan gedeclareerd en geïnitialiseerd worden met het is-teken (=). Bijvoorbeeld:

>>> a = 2
>>> b = 3
>>> c = a * b
>>> c
6
      

In de eerste twee regels worden twee variabelen gemaakt, met respectievelijk de naam a en b, die respectievelijk verwijzen naar de getallen 2 en 3. Vervolgens wordt variabele c gedeclareerd en geïnitialiseerd met de vermenigvuldiging van de waarde van a en b. Tenslotte kun je zien dat de waarde van c 6 is.

Een andere basaal datatype is de string (tekenreeks). Een string is een stukje tekst. Een string kun je maken door een stuk tekst tussen enkele of dubbele aanhalingstekens te zetten, bijvoorbeeld:

>>> "Hallo wereld!"
'Hallo wereld!'
>>> 'Hallo wereld!'
'Hallo wereld!'
      

Net als getallen kun je strings aan een variabele toekennen:

>>> boodschap = "Hallo wereld!"
>>> boodschap
'Hallo wereld!'
      

Je kunt strings ook bijelkaar optellen. De afzonderlijke strings worden dan gecombineerd tot een string:

>>> "Jan" + "-" + "Willem"
'Jan-Willem'
      

Er zijn een aantal belangrijke functies die aan strings gerelateerd zijn. Een functie is een stuk code dat je kunt aanroepen dat verschillende argumenten (parameters) accepteert en (meestal) een waarde teruggeeft. De len() functie kan bijvoorbeeld gebruikt worden om de lengte (het aantal karakters) van een string te bepalen. De string wordt tussen haakjes meegegeven als een argument, en de functie geeft de lengte van de string is een getal terug. Bijvoorbeeld:

>>> bericht = "Hallo wereld!"
>>> berichtLengte = len(bericht)
>>> berichtLengte
13
      

Een lijst is een samengestelde datatype, die een lijst met waarden bevat. Dit kunnen getallen, strings, maar ook lijsten zijn. Je kunt een lijst maken met behulp van vierkante haken, elk element dient gescheiden te worden met een comma. Een aantal voorbeelden:

>>> [1, 3, 5, 11]
[1, 3, 5, 11]
>>> ["appel", "banaan", "peer"]
['appel', 'banaan', 'peer']
>>> [1, 'appel', 2, 'peer']
[1, 'appel', 2, 'peer']
      

Je kunt de waarde van individuele elementen van een lijst krijgen door een lijst te laten volgen met scherpe haken, met daarin het nummer van een element. Je moet bij 0 beginnen te tellen om het nummer van een element te krijgen. Je kunt dit ook met variabelen doen die naar een lijst verwijzen. Bijvoorbeeld:

>>> [1, 'appel', 2, 'peer'][1]
'appel'
>>> fruit = ["appel", "banaan", "peer"]
>>> fruit[2]
'peer'
      

Met deze notatie kun je elementen veranderen, door er een toewijzing van te maken met het is-teken:

>>> fruit = ["appel", "banaan", "peer"]
>>> fruit[2] = "kiwi"
>>> fruit
['appel', 'banaan', 'kiwi']
      

Je kunt ook meerdere elementen uit een lijst kiezen. In dat geval zal er weer een lijst teruggegeven worden. Je kunt dit doen door tussen de vierkante haken het nummer van het eerste element te zetten, gevolgd door een dubbele punt, gevolgd door het eerste element dat je niet meer wilt opnemen. Als je dus het eerste tot en met het vierde element op wilt nemen, dan is dat het eerste tot het vijfde element, en wordt de notatie dus [0:4]. In het volgende voorbeeld worden het tweede tot en met het derde element uit een lijst opgevraagd (zoals gezegd is element 0 het eerste element):

>>> fruit = ["appel", "banaan", "peer", "kiwi"]
>>> fruit[1:3]
['banaan', 'peer']
      

Door het getal voor of na de dubbele punt weg te laten kun je alle elementen tot of vanaf een bepaald element opvragen:

>>> fruit = ["appel", "banaan", "peer", "kiwi"]
>>> fruit[:3]
['appel', 'banaan', 'peer']
>>> fruit[2:]
['peer', 'kiwi']
      

Een handige truc om een kopie van een lijst te maken, is beide getallen weg te laten:

>>> fruit = ["appel", "banaan", "peer", "kiwi"]
>>> fruitKopie = fruit[:]
>>> fruitKopie
['appel', 'banaan', 'peer', 'kiwi']
      

Lijsten zijn op een slimme manier in Python opgenomen, waardoor alle lijsten functies hebben die op de lijst zelf toegepast kunnen worden. Een van die functies is sort(), waarmee je een lijst kunt sorteren. Je kunt een lijstfunctie oproepen door de lijst of een variabele die naar een lijst verwijst te laten volgen door een punt, en dan de naam van de functie. Laten we naar een voorbeeld kijken:

>>> fruit = ["appel", "banaan", "peer", "kiwi"]
>>> fruit.sort()
>>> fruit
['appel', 'banaan', 'kiwi', 'peer']
      

Zoals je kunt zien heeft sort() de elementen in de lijst gesorteerd. sort() werkt zonder argumenten, maar toch laten we de haakjes staan, zodat Python weet dat de functie aangeroepen moet worden.

Een vergelijkbare functie is reverse(), die de elementen in een lijst omdraait:

>>> getallen = [1, 2, 3, 4]
>>> getallen.reverse()
>>> getallen
[4, 3, 2, 1]
      

Je kunt elementen aan een bestaande lijst toevoegen met de append() functie. Het argument van deze functie wordt toegevoegd aan de lijst:

>>> mijnLijst = ["appel", "peer"]
>>> mijnLijst
['appel', 'peer']
>>> mijnLijst.append("banaan")
>>> mijnLijst
['appel', 'peer', 'banaan']
      

Soms wil je ook een nieuwe waarde op een bepaalde plek toevoegen in plaats van het einde van de lijst. Dit kun je doen met de insert() functie. Het eerste argument geeft aan voor welke element het nieuwe element toegevoegd moet worden, en het tweede argument is het element dat toegevoegd moet worden. Bijvoorbeeld:

>>> boodschappen = ["boter", "eieren"]
>>> boodschappen.insert(1, "kaas")
>>> boodschappen
['boter', 'kaas', 'eieren']
      

Elementen kunnen verwijderd worden met de del() functie, dit is geen functie van een lijst. Je moet als parameter het element meegeven dat je wilt verwijderen:

>>> boodschappen = ["boter", "kaas", "eieren"]
>>> del(boodschappen[2])
>>> boodschappen
['boter', 'kaas']
      

Het woordenboek (dictionary) is een datatype dat is te vergelijken met een lijst. In een lijst is een element automatisch gekoppeld aan een nummer, in een woordenboek kun je een element koppelen aan een zogenaamde sleutel. Een sleutel kan een getal zijn, maar bijvoorbeeld ook een string. Een woordenboek wordt gemaakt met accolades:

>>> kleuren = {'gras': 'groen', 'lucht': 'blauw'}
      

Net als in een lijst zijn elementen gescheiden met een komma. In een woordenboek is een waarde voorafgegaan door een sleutel (key). De sleutel en de waarde worden gescheiden met een dubbele punt. Je kunt elementen net als een lijst opvragen met vierkante haken, maar je moet een waarde nu opvragen met de sleutel:

>>> kleuren = { 'gras': 'groen', 'lucht': 'blauw'}
>>> kleuren["gras"]
'groen'
      

De waarden kunnen van alles bevatten, zoals nummers, strings, maar ook lijsten:

>>> fruit = ['appel', 'banaan']
>>> groente = ['bloemkool', 'broccoli']
>>> soorten = {'groente': groente, 'fruit': fruit}
>>> soorten['fruit']
['appel', 'banaan']
      

In dit voorbeeld worden er eerst twee lijsten aangemaakt, met variabelen die er naar verwijzen (fruit en groente. Vervolgens worden beide lijsten met een sleutel toegevoegd aan een nieuw woordenboek.

Je kunt ook achteraf elementen toevoegen:

>>> kleuren = { 'gras': 'groen', 'lucht': 'blauw'}
>>> kleuren['wolken'] = 'wit'
>>> kleuren
{'lucht': 'blauw', 'gras': 'groen', 'wolken': 'wit'}
      

Vaak weet je al welke sleutels je wilt gebruiken om een waarde uit een woordenboek te vinden, maar soms wil je ook weten welke sleutels er in een woordenboek gebruikt zijn. Hier kun je achter komen met de keys() functie die woordenboeken hebben:

>>> kleuren = { 'gras': 'groen', 'lucht': 'blauw'}
>>> kleuren.keys()
['lucht', 'gras']
      

Variabelen werken anders dan je misschien zou verwachten. Neem het volgende voorbeeld:

>>> a = ['rood', 'blauw']
>>> b = a
>>> b[0] = 'paars'
>>> print a
['paars', 'blauw']
      

Na het toewijzen van a aan b (b = a), zijn veranderingen aan b ook zichtbaar via a. Dit komt doordat een variabele slechts een verwijzing is naar een object in het geheugen. In het bovenstaande voorbeeld gebeurd dus het volgende:

Van sommige typen zal er echter altijd een kopie gemaakt worden op het moment dat je het probeert te veranderen. Van de typen die we behandeld hebben zijn dit getallen en strings. Hier zie je een voorbeeld:

>>> a = 'rood'
>>> b = a
>>> b = 'paars'
>>> print a
rood
      

In dit voorbeeld is b na het uitvoeren van b = a wel een verwijzing naar hetzelfde object als a naar verwijst, maar op het moment dat je het object probeert te veranderen wordt er een nieuw object gemaakt. a houdt hierdoor z'n oorspronkelijke waarde (of beter gezegd: het object waar a naar verwijst).

Soms wil je een echte kopie van bijvoorbeeld een lijst of woordenboek maken, in plaats van een verwijzing naar het bestaande object. Voor lijsten kun je dit doen door alle elementen op te vragen, en dus effectief een kopie te maken:

>>> a = ['rood', 'blauw']
>>> b = a[:]
      

Dictionaries bieden de copy() functie:

>>> a = {'jan': 2, 'klaas': 5}
>>> b = a.copy()
      

De for-lus is een van de meest gebruikte controlestructuren. Je kunt een for lus op de volgende manier omschrijven: “Voor elke element e in de verzameling van elementen v, doe het volgende: [...]”. Deze beschrijving is bijna letterlijk, zoals je in het volgende voorbeeld kunt zien:

for nummer in [1, 2, 3, 4]:
    print nummer * nummer

print "Klaar!"
      

Dit stukje code gaat elk element in de lijst bijlangs. Voor elk element wordt de code uitgevoerd waar spaties of tabs voor staan. Het huidige element is beschikbaar via de variabele nummer. Er staan geen spaties voor de laatste regel, dus deze regel wordt niet als onderdeel van de lus uitgevoerd. Als je dit uitvoert in de Python vertaler zul je het volgende zien:

>>> for nummer in [1, 2, 3, 4]:
...     print nummer * nummer
... 
1
4
9
16
>>> print "Klaar!"
Klaar!
      

Voor het inspringen in de lus kun je zowel spaties als tabs gebruiken, zolang je ze maar niet mengt, dus gebruik spaties of een tab voor elke regel die als onderdeel van die als onderdeel van de lus uitgevoerd moet worden. Overigens voegt de Idle editor automatisch voor elke nieuwe regel in een lus een tab toe, totdat je zelf de tab met de backspace toets verwijderd. In de interactieve vertaler moet je, als je wilt stoppen met inspringen, een keer extra op Enter/Return drukken zodat de puntjes aan het begin van de regel verdwijnen.

Zoals je kunt zien wordt elk getal met zichzelf vermenigvuldigd, en het resultaat wordt naar het scherm geprint.

Je kunt op die manier door alle lijsten lopen. Naast een lijst van getallen bijvoorbeeld door een lijst van strings:

>>> for fruit in ['appel', 'peer', 'banaan']:
...     print fruit
... 
appel
peer
banaan
      

Toen we naar woordenboeken keken, heb je gezien dat je een lijstje kunt krijgen met alle sleutels. Dit kan heel erg handig zijn als je iets wilt doen met elke element in een woordenboek. Stel bijvoorbeeld dat je een woordenboek hebt voor bankrekeningen met namen als sleutels, en saldi als waarden, dan zou je op de volgende manier iedereen 5% rente kunnen geven:

>>> rekeningen = {'Jan': 300, 'Piet': 2500, 'Klaas': 630}
>>> for rekening in rekeningen.keys():
...     rekeningen[rekening] = rekeningen[rekening] * 1.05
... 
>>> rekeningen
{'Jan': 315.0, 'Piet': 2625.0, 'Klaas': 661.5}
      

In de lus gebeurt het volgende: rekeningen.keys() geeft een lijstje terug met sleutels, bijvoorbeeld: ['Jan', 'Piet', 'Klaas']. Vervolgens gaat de lus elk element bijlangs, en wordt de code rekeningen[rekening] = rekeningen[rekening] * 1.05 voor elk uitgevoerd element. Deze regel vermenigvuldigt een waarde uit het woordenboek met 1.05, en slaat het resultaat weer op. Je kunt zien hoe dit werkt door even te bedenken hoe dit er uit ziet met een ingevulde sleutel:

De rechterkant van het is-teken wordt eerst verwerkt, hierin staat nog een naam van een variabele, Python zal hier de waarde invullen van de variabele, en dan de vermenigvuldiging doen:

De laatste stap heb je gezien toen we naar woordenboeken keken, het kent de waarde 315 toe aan de sleutel 'Jan'.

Je kunt een programma ook beslissingen laten maken. Bij het maken van beslissingen is het belangrijk of iets waar of onwaar is. In Python zijn de volgende dingen onwaar (False):

In andere gevallen zijn getallen, strings, lijsten en woordenboeken waar (True). Daarnaast zijn er nog een aantal logische operatoren die waar of onwaar kunnen zijn. De belangrijkste zijn: == (is gelijk aan), != (is niet gelijk aan), < (kleiner dan), > (groter dan), <= (kleiner dan of gelijk aan), en >= (groter dan of gelijk aan).

Je kunt deze operatoren in de Python vertaler uitproberen:

>>> 1 == 1
True
>>> 1 == 2
False
>>> 1 != 2
True
>>> 1 < 2
True
>>> "hallo" == "wereld"
False
      

Je kunt iets dat waar of onwaar is in een zogenaamde if statement zetten. Een if statement voert een stuk code uit als een bewering waar is. Bijvoorbeeld:

>>> scorekaart = {'Jan': 2, 'Kees': 4, 'Klaas': 1}
>>> for persoon in scorekaart.keys():
...     if scorekaart[persoon] > 3:
...         print persoon + " heeft meer dan drie punten"
... 
Kees heeft meer dan drie punten
      

Dit stukje code kijkt naar een aantal scores, als de score van een persoon meer dan drie is, dan wordt dit naar het scherm geprint. Je kunt ook code opgeven die uitgevoerd moet worden als de if statement niet waar was. Dit kan met else:.

>>> scorekaart = {'Jan': 2, 'Kees': 4, 'Klaas': 1}
>>> for persoon in scorekaart.keys():
...     if scorekaart[persoon] > 3:
...         print persoon + " heeft meer dan drie punten"
...     else:
...         print persoon + " heeft niet genoeg punten"
...
Jan heeft niet genoeg punten
Kees heeft meer dan drie punten
Klaas heeft niet genoeg punten
      

Soms wil je iets doen dat de volgende vorm heeft:

Dit kun je doen door meerdere if statements achterelkaar te gebruiken. Echter, stel dat je het volgende doet:

if cijfer < 6:
    print "Onvoldoende"
if cijfer < 8:
    print "Voldoende"
      

Beide if statements worden in dit geval uitgevoerd. Soms wil je dat, maar in dit geval niet. Stel bijvoorbeeld dat cijfer gelijk aan 3 is, dan zal zowel “Onvoldoende” als “Voldoende” geprint worden. Je wilt in dit geval dus een constructie waarin de de tweede if statement alleen bekeken wordt wanneer het eerste if statement niet waar is. Dit kan met elif:

if cijfer < 6:
    print "Onvoldoende"
elif cijfer < 8:
    print "Voldoende"
      

Je kunt zelfs meerdere elif statements gebruiken en else toevoegen:

if cijfer < 6:
    print "Onvoldoende"
elif cijfer < 8:
    print "Voldoende"
elif cijfer < 9:
    print "Ruim voldoende"
else:
    print "Uitmuntend"
      

Nu we naar een aantal controlestructuren hebben gekeken, is het verstandig nog even naar programmastructuur te kijken. Elke controlestructuur heeft een zogenaamde scope. De scope is het stuk code waarop de controlestructuur van toepassing is. Bij een for lus wordt de code in de scope bijvoorbeeld herhaald, bij een if statement wordt de code in de scope uitgevoerd als de bewering waar is.

Zoals we al kort gezien hebben, definieert Python een scope op basis van inspringen met witruimte. Dit kan een tab zijn, maar ook meerdere spaties. Maar het is belangrijk hier consistent in te zijn: als je tabs gebruikt, doe dat dan in je hele programma, als je spaties gebruikt doe dat in je hele programma en gebruik altijd hetzelfde aantal spaties.

Je kunt in een scope natuurlijk ook een controlestructuur hebben, waardoor je nog een keer in moet springen. Dus als je een scope in een scope hebt (twee niveaus diep), dan gebruik je twee tabs, of twee keer het aantal spaties dat je gewoonlijk gebruikt. Zodra je weer op de oude hoeveelheid witruimte teruggaat, zit je weer in de oude scope. Een voorbeeld:

for word in words:
        # for-scope
        print word
        if len(word) > 5:
                # for->if scope
                print "Langer dan 5 karakters!"
        # for-scope
        print "---"
      

Het kan soms gebeuren dat je toch tabs en spaties doorelkaar gebruikt, de Idle omgeving kan dit corrigeren: