Zo kun je programmeren in Python - Deel 2

Door: koen-vervloesem | 07 augustus 2020 06:09

script, laptop, programmeren, code
How To

Na onze eerste kennismaking met Python is het tijd om wat complexere datastructuren te bekijken: lijsten en dictionary’s. We duiken ook in de structuur van strings, zodat je afzonderlijke letters kunt manipuleren. Start je Python-interpreter maar alvast op!

In de vorige les leerde je met drie datatypes in Python werken: int, float en str. Vooral int en float zijn vrij eenvoudige datatypes. Maar in veel programma’s heb je types met meer structuur nodig, we noemen dit ook wel datastructuren. In dit deel leer je met twee belangrijke datastructuren van Python werken.

Lijsten

In veel programma’s werk je niet met één specifiek gegeven, maar met een hele reeks. Een lijst (in Python list) is daarvoor ideaal. Zo maak je bijvoorbeeld een lijst met namen aan:

>>> namen = ['kees', 'jan', 'pieter', 'jan', 'joris', 'rob']
>>> len(namen)

6

>>> lege_lijst = []

>>> len(lege_lijst)

0

De functie len, die we uit de vorige les kennen om de lengte van een string terug te geven, werkt ook op een lijst: dan krijg je het aantal elementen in die lijst.

Overigens kan een lijst elementen van verschillende types bevatten, zoals een float, twee strings en een int. Maar vaak heeft een lijst alleen elementen van hetzelfde type.

Functies, parameters en argumenten

Python deelt heel wat functionaliteit op in functies: stukjes code die een specifieke taak uitvoeren, zoals len om de lengte van een lijst of string op te vragen. Een functie kan een parameter hebben: een variabele waarmee de functie werkt en die als waarde het object krijgt dat je aan die functie doorgeeft. Dat object noemen we het argument van de functie. Een functie kan ook meerdere parameters (en dus argumenten) hebben. In deel 6 leer je je eigen functies definiëren en wordt dit allemaal nog veel duidelijker.

Elementen in een lijst

Python kent ook heel wat mogelijkheden om met de elementen in een lijst te werken. Zo vraag je eenvoudig een element uit de lijst op een specifieke positie (ook ‘index’ genoemd) op:

>>> namen[2]
'pieter'

Merk op dat de positie in een lijst vanaf 0 begint te tellen: het eerste element is namen[0], het tweede namen[1], het derde namen[2] enzovoort. Je zou dan denken dat je het laatste element moet opvragen met:

>>> namen[len(namen)-1]
'rob'

Dat werkt inderdaad, maar Python laat ook een negatieve positie toe, waarmee je vanachter in de lijst begint te tellen. Het laatste element heeft dan positie -1:

>>> namen[-1]
'rob'
>>> namen[-2]
'joris'

Als je goed hebt opgelet, zie je dat de string ‘jan’ twee keer in bovenstaande lijst zit. Dat aantal keren kun je opvragen met de functie count:

>>> namen.count('jan')
2
>>> namen.count('pieter')
1
>>> namen.count('koen')
0

Je kunt ook de positie van een element in een lijst opvragen:

>>> namen.index('jan')
1
>>> namen.index('pieter')
2
>>> namen.index('koen')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: 'koen' is not in list

Zoals je ziet krijg je een foutmelding (ValueError) als het gevraagde element zich niet in de lijst bevindt. Voor een element dat zich meerdere keren in de lijst bevindt, geeft de functie index alleen de eerste positie terug. Maar je kunt ook vragen om vanaf een specifieke positie te zoeken:

>>> namen.index('jan', 2)
3

Een lijst veranderen

Als je een lijst hebt aangemaakt, kun je die nog altijd veranderen. In het eenvoudigste geval verander je bijvoorbeeld één element:

>>> namen
['kees', 'jan', 'pieter', 'jan', 'joris', 'rob']
>>> namen[1] = 'koen'
>>> namen
['kees', 'koen', 'pieter', 'jan', 'joris', 'rob']

Je kunt een lijst ook omdraaien of sorteren:

>>> namen.reverse()
>>> namen
['rob', 'joris', 'jan', 'pieter', 'koen', 'kees']
>>> namen.sort()
>>> namen
['jan', 'joris', 'kees', 'koen', 'pieter', 'rob']

Verder kun je ook een element aan het einde van een lijst toevoegen, of op een specifieke positie tussen de andere elementen voegen:

>>> namen
['jan', 'joris', 'kees', 'koen', 'pieter', 'rob']
>>> namen.append('aniek')
>>> namen
['jan', 'joris', 'kees', 'koen', 'pieter', 'rob', 'aniek']
>>> namen.insert(0, 'lies')
>>> namen
['lies', 'jan', 'joris', 'kees', 'koen', 'pieter', 'rob', 'aniek']
>>> namen.insert(4, 'mireille')
>>> namen
['lies', 'jan', 'joris', 'kees', 'mireille', 'koen', 'pieter', 'rob', 'aniek']

Je kunt ook bestaande elementen verwijderen. Zo verwijder je met de functie remove(x) het eerste element waarvan de waarde gelijk is aan x:

>>> namen
['lies', 'jan', 'joris', 'kees', 'mireille', 'koen', 'pieter', 'rob', 'aniek']
>>> namen.remove('pieter')
>>> namen
['lies', 'jan', 'joris', 'kees', 'mireille', 'koen', 'rob', 'aniek']
>>> namen.remove('pieter')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list

Zoals je ziet, krijg je een foutmelding als je vraagt om een element te verwijderen dat niet in de lijst zit.

Je kunt ook een element op een gegeven positie verwijderen. Dat doe je met de functie pop:

>>> namen
['lies', 'jan', 'joris', 'kees', 'mireille', 'koen', 'rob', 'aniek']
>>> namen.pop(2)
'joris'
>>> namen
['lies', 'jan', 'kees', 'mireille', 'koen', 'rob', 'aniek']

Als je goed hebt opgelet, zie je dat de functie pop niet alleen een element verwijdert, maar op de opdrachtregel ook als waarde het verwijderde element teruggeeft ('joris').

Snijden in een lijst

Python heeft een krachtige manier om een lijst in stukken te snijden: ‘slicing’. Herinner je de notatie [n] voor het n-de element? Met [n:] krijg je de elementen terug vanaf index n, met [:n] de elementen tot index n (niet inbegrepen) en met [m:n] de elementen van index m tot n (die laatste niet inbegrepen). Enkele voorbeelden maken dit duidelijk:

>>> namen = ['lies', 'jan', 'kees', 'mireille', 'koen', 'rob']
>>> namen[1:]
['jan', 'kees', 'mireille', 'koen', 'rob']
>>> namen[:4]
['lies', 'jan', 'kees', 'mireille']
>>> namen[1:4]
['jan', 'kees', 'mireille']

Omdat Python begint te tellen vanaf 0 en in de beginpositie van een slice het element zelf meerekent maar in de eindpositie niet, is de notatie van slicing nogal verwarrend. Het helpt daarom om deze posities te beschouwen als de posities van de komma’s in de lijst, te tellen vanaf 1. Alles tussen de komma’s op die posities is dan de gevraagde slice. Neem bijvoorbeeld namen[1:4]. Omdat namen gelijk is aan ['lies', 'jan', 'kees', 'mireille', 'koen', 'rob'], nemen we alles tussen de eerste en de vierde komma, dus van vóór 'jan' tot ná 'mireille', oftewel ['jan', 'kees', 'mireille'].

Slicing is ook een krachtige manier om een deel van een lijst te veranderen. Zo vervang je eenvoudig voorgaande slice in de lijst door een andere naam:

>>> namen
['lies', 'jan', 'kees', 'mireille', 'koen', 'rob']
>>> namen[1:4] = ['bas']
>>> namen
['lies', 'bas', 'koen', 'rob']

Nog eens strings

In een string krijg je net zoals in een lijst toegang tot het n-de element met de notatie [n]. Zo krijg je met 'aniek'[1] het tweede teken van de string 'aniek', of de letter n. Ook slicing werkt bij een string: 'aniek'[1:4] is gelijk aan nie. Maar let op: in tegenstelling tot een lijst kun je een string niet veranderen. De poging 'aniek'[1:4] = 'r' geeft een foutmelding.

Dictionary’s

In een lijst heeft elk element als index zijn positie, zodat je eenvoudig het element op een specifieke positie kunt opvragen. Een andere datastructuur is de ‘dictionary’, die als index voor zijn elementen een sleutel gebruikt, vaak een string of een getal. Elke sleutel van de dictionary moet uniek zijn, zodat je eenvoudig de waarde die bij een specifieke sleutel hoort kunt opvragen.

Een voorbeeld maakt duidelijk hoe je met een dictionary werkt:

>>> scores = {'lies': 5, 'bas': 2, 'kees': 1, 'aniek': 3}
>>> scores['aniek']
3
>>> scores['bert']
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'bert'
>>> len(scores)
4

Op deze manier kun je eenvoudig de score van een persoon opvragen op basis van zijn of haar naam. Je ziet hier ook dat je een foutmelding krijgt als je een element opvraagt met een index die niet in de dictionary bestaat.

Een dictionary kun je net zoals een lijst veranderen. Je kunt de waarde bij een specifieke sleutel veranderen, maar je kunt even eenvoudig een nieuw element toevoegen: ken gewoon een waarde toe aan een nieuwe sleutel. Bijvoorbeeld:

>>> scores
{'lies': 5, 'bas': 2, 'kees': 1, 'aniek': 3}
>>> scores['lies'] += 1
>>> scores
{'lies': 6, 'bas': 2, 'kees': 1, 'aniek': 3}
>>> scores['bert'] = 1
>>> scores
{'lies': 6, 'bas': 2, 'kees': 1, 'aniek': 3, 'bert': 1}

Een sleutel en de bijbehorende waarde uit de dictionary verwijderen, doe je met het speciale keyword del:

>>> scores
{'lies': 6, 'bas': 2, 'kees': 1, 'aniek': 3, 'bert': 1}
>>> del scores['kees']
>>> scores
{'lies': 6, 'bas': 2, 'aniek': 3, 'bert': 1}

Samenvatting

In dit deel zijn we lang stil blijven staan bij een van de meest gebruikte datastructuren in Python: de lijst. De kennis die je hebt opgedaan over lijsten, kun je voor heel wat andere datatypes in Python hergebruiken. Zo toonden we hoe de notatie voor een index en voor ‘slicing’ hetzelfde is bij een string. Een ander belangrijk datatype dat je in dit deel zag, is de dictionary, waarin je geen positie maar een sleutel als index gebruikt. In het volgende deel verlaten we de interactieve Python-sessies en schrijven we onze eerste programma’s.

Opdracht 1

Je hebt de volgende lijst met namen:

>>> namen = ['lies', 'jan', 'kees', 'mireille', 'koen', 'rob', 'aniek']

Splits deze lijst in zijn laatste element en de rest van de lijst.

Uitwerking opdracht 1

>>> namen
['lies', 'jan', 'kees', 'mireille', 'koen', 'rob', 'aniek']
>>> laatste_persoon = namen.pop()
>>> namen
['lies', 'jan', 'kees', 'mireille', 'koen', 'rob']
>>> laatste_persoon
'aniek'

Dit is een veel gebruikte toepassing van de functie pop(), die niet alleen het element op een specifieke index verwijdert, maar ook het verwijderde element teruggeeft. Waarschijnlijk heb je deze opdracht opgelost met:

laatste_persoon = namen.pop(-1)

Maar de -1 is niet nodig: zonder index geeft de functie pop het laatste element terug.

Opdracht 2

Haal uit een string alle tekens behalve het eerste en het laatste.

Uitwerking opdracht 2

>>> naam = 'aniek'
>>> naam[1:-1]
'nie'

Slicing werkt bij een string exact zoals bij een lijst. Bovendien kunnen we ook gebruikmaken van een negatieve index in slicing: -1 verwijst dan naar het laatste element. Omdat Python begint te tellen vanaf 0 en in de beginpositie van een slice het teken zelf meerekent maar in de eindpositie niet, verwijst de slice [1:-1] dus naar alle tekens in de string behalve het eerste en het laatste.

Cheatsheet

datastructuur: een datatype dat uit elementen bestaat die met elkaar samenhangen.
dictionary: een datastructuur waarin je elementen opvraagt aan de hand van een unieke sleutel.

index (in een lijst): positie van een element in een lijst, te beginnen vanaf 0.

index (in een dictionary): sleutel van een element waarmee het uit een dictionary op te vragen is.

lijst: een datastructuur waarin je elementen opvraagt aan de hand van hun positie.
slicing: het in stukken snijden van een lijst of string.

0 Reactie(s) op: Zo kun je programmeren in Python - Deel 2

  • Om te reageren moet je ingelogd zijn. Nog geen account? Registreer je dan en praat mee!
  • Er zijn nog geen reacties op dit artikel.

Wanneer je een reactie plaatst ga je akoord
met onze voorwaarden voor reacties.