Python – Een introductie
Python is een programmeertaal met een interpreter, maar vanuit de interpreter kunnen we ook naar de File/Line. Het venster zal dan er anders uit zien.
Als we Python starten, krijgen we de versie te zien met de datum en meer informatie. Onder de informatie staan deze tekens: >>>. Achter deze tekens kunnen we Python regels invoeren. Regels, onder andere expressies en statements. Python kan bijvoorbeeld als een rekenmachine werken. In andere interpreters moeten we met een print statement beginnen als we een expressie uit willen voeren, maar in Python is dat niet nodig.
Laten we eens kennismaken met Python. Volg onderstaande introductie om te begrijpen hoe het werkt.
Python gebruiken als een rekenmachine
Numerieke waarden
In elke programmeertaal kunnen we expressies gebruiken met getallen. De operatoren +, -, * en / werken op dezelfde manier. Ook de haakjes kunnen we gebruiken om te groeperen.
Typ achter de >>> 2 + 2. Het antwoord zal onder direct 4 zijn. Gebruik geen = en ook geen ? of print om sommen uit te rekenen.
Typ de volgende expressies net zo:
>>> 50 – 5 * 6
20 Dit geeft Python als antwoord.
>>> (50 – 5 * 6) / 4
5.0
>>> 8 / 5 # deling geeft altijd een floating point waarde
1.6
De waarden 4 en 20 zijn van het type int. De waarde 1.6 is van het type float. Later meer over soorten numerieke types.
Het #-teken kunt u gebruiken voor commentaarregels. In Python worden ze standaard schuingedrukt.
De deling (/) retourneert altijd een float. Om een integer resultaat te krijgen kunt u de // operator gebruiken. Voor een rest deling gebruikt u de % operator.
>>> 17 / 3 # klassieke deling retourneert een float
5.666666666666667
>>> 17 // 3 # dit kapt de nummers rechts van de punt af
5
>>> 17 % 3 # de % operator retourneert de rest van de deling
2
>>> 5 * 3 + 2 # resultaat * deler + rest
17
Python kent ook een macht-operator als twee **:
>>> 5 ** 2 # kwadraat
25
>>> 2 ** 7 # 2 tot de macht van 7
128
Het gelijkheidsteken = wordt gebruikt om waarden toe te kennen aan variabelen:
>>> width = 20
>>> height = 5 * 9
>>> width * height
900
Als u probeert een variabele te gebruiken die nog niet bestaat, geeft Python (met een hoop informatie) een foutmelding:
>>> n # probeer toegang te krijgen tot een ongedefinieerde variabele
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'n' is not defined
In directe mode wordt het laatste gedrukte resultaat toegekend aan de variabele _. Hiermee wordt bedoeld dat als u Python gebruikt als een rekenmachine, het soms gemakkelijker is om met het laatste resultaat verder te kunnen rekenen:
>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_, 2)
113.06
Deze variabele moet u zien als een alleen-lezen variabele. Ken geen waarde er aan toe – u zult automatisch een lokale variabele met dezelfde naam aanmaken, waardoor de ingebouwde variabele zijn magie kwijtraakt.
Strings
Python kan ook strings manipuleren die in verschillende manieren uitgedrukt kunnen worden. Ze kunnen tussen enkele aanhalingstekens (‘…’) of dubbele aanhalingstekens (“…”) worden getypt met hetzelfde resultaat. Het \ teken kan worden gebruikt om de aanhalingstekens te vermijden:
>>> 'spam eggs' # enkele aanhalingstekens
'spam eggs'
>>> 'doesn\'t' # gebruik \' om het enkele aanhalingsteken te vermijden
"doesn't"
>>> "doesn't" # of gebruik in plaats daarvan dubbele aanhalingstekens
"doesn't"
>>> '"Yes," he said.'
'"Yes," he said.'
>>> "\"Yes,\" he said."
'"Yes," he said.'
>>> '"Isn\'t," she said.'
'"Isn\'t," she said.'
In de interpreter, de directe mode, wordt in de uitvoerstring tussen aanhalingstekens de speciale tekens vermeden met backslash es. Dit maakt soms verschillen met de invoer (de aanhalingstekens kunnen veranderen), de twee strings zijn hetzelfde. De string staat tussen dubbele aanhalingstekens als de string als inhoud een enkel aanhalingsteken bevat en geen dubbele aanhalingstekens, anders staat het tussen enkele aanhalingstekens. De print() functie kan een beter leesbare uitvoer geven door de eerste en laatste aanhalingstekens niet af te drukken en door het af te drukken van ontsnapte tekens en speciale tekens:
>>> '"Isn\'t," she said.'
'"Isn\'t," she said.'
>>> print('"Isn\'t," she said.')
"Isn't," she said.
>>> s = 'First line.\nSecond line.' # \n is nieuwe regel
>>> s # zonder print(), \n wordt ook afgedrukt
'First line.\nSecond line.'
>>> print(s) # met print(), \n zorgt voor een nieuwe regel
First line.
Second line.
Wilt u geen tekens achter een \ als speciale tekens, gebruik dan raw strings door een r voor het eerste aanhalingsteken toe te voegen:
>>> print('C:\some\name') # hier betekent \n nieuwe regel!
C:\some
ame
>>> print(r'C:\some\name') # onthoud de r voor het aanhalingsteken
C:\some\name
Letterlijke stringwaarden kunnen uit meerdere regels bestaan. Een mogelijkheid is gebruik te maken van 3 aanhalingstekens: """…""" of '''…'''. Het einde van de regels zijn automatisch ingevoegd in een string, maar het is mogelijk om dat te voorkomen door een \ aan het einde van een regel toe te voegen, zoals onderstaand voorbeeld:
print("""\
Usage: thingy [OPTIONS]
-h Display this usage message
-H hostname Hostname to connect to
""")
produceert de volgende uitvoer (merk op dat de geïnitialiseerde nieuwe regel niet ingevoegd is):
Usage: thingy [OPTIONS]
-h Display this usage message
-H hostname Hostname to connect to
Strings kunnen samengevoegd worden (aan elkaar worden gezet) met de + operator en worden herhaald met *:
>>> # 3 keer 'un', gevolgd door 'ium'
>>> 3 * 'un' + 'ium'
'unununium'
Twee of meer letterlijke strings (dat wil zeggen, de een tussen aanhalingstekens) gevolgd met elke andere zullen automatisch samengevoegd worden:
>>> 'Py' 'thon'
'Python'
Dit werkt alleen met elke letterlijke string, maar niet met variabelen of expressies:
>>> prefix = 'Py'
>>> prefix 'thon' # kan niet samengevoegd worden met een variabele
en een letterlijke string
...
SyntaxError: invalid syntax
>>> ('un' * 3) 'ium'
...
SyntaxError: invalid syntax
Wilt u toch waarden van variabelen of van een variabele en een letterlijke string samenvoegen, gebruik dan +:
>>> prefix + 'thon'
'Python'
Deze mogelijkheid is nuttig wanneer u lange strings wilt breken:
>>> text = ('Put several strings within parentheses '
... 'to have them joined together.')
>>> text
'Put several strings within parentheses to have them joined together.'
Strings kunnen worden geïndexeerd (subscripted) met index 0 als eerste teken. Er is geen apart teken-type; een teken is simpelweg een string met als grootte 1:
>>> word = 'Python'
>>> word[0] # teken in plaats 0
'P'
>>> word[5] # teken in plaats 5
'n'
De indexnummers mogen ook negatief zijn om aan de rechterkant te beginnen:
>>> word[-1] # laatste teken
'n'
>>> word[-2] # tweede laatste teken
'o'
>>> word[-6]
'P'
Onthoud dat -0 hetzelfde is als 0, negatieve indexnummers beginnen met -1.
In tegenstelling tot indexering is slicing (snijden) ook toegestaan. Door slicing te gebruiken, kunt u substrings (gedeelde strings) weergeven:
>>> word[0:2] # tekens vanaf plaats 0 (opgenomen) tot 2 (uitgesloten)
'Py'
>>> word[2:5] # tekens vanaf plaats 2 (opgenomen) tot 5 (uitgesloten)
'tho'
Onthoud dat de start altijd opgenomen is en het eind altijd uitgesloten is.
Dit zorgt ervoor dat s[:i] + s[i:] altijd gelijk is aan s:
>>> word[:2] + word[2:]
'Python'
>>> word[:4] + word[4:]
'Python'
Een indexnummer dat te hoog is geeft als resultaat een foutmelding:
>>> word[42] # word heeft maar 6 tekens
...
IndexError: string index out of range
Hoewel, een buiten slice indexnummer zal soepel verlopen, wanneer u slicing gebruikt:
>>> word[4:42]
'on'
>>> word[42:]
''
Python strings kunnen niet gewijzigd worden – ze zijn onveranderbaar. Daarom zal een toekenning aan een indexpositie in een string een foutmelding retourneren:
>>> word[0] = 'J'
...
TypeError: 'str' object does not support item assignment
>>> word[2:] = 'py'
...
TypeError: 'str' object does not support item assignment
Als u een andere string nodig heeft, moet u een nieuwe maken:
>>> 'J' + word[1:]
'Jython'
>>> word[:2] + 'py'
'Pypy'
De ingebouwde functie len() retourneert de lengte van een string:
>>> s = 'supercalifragilisticexpialidocious'
>>> len(s)
34
Lijsten
Python kent een aantal samengestelde gegevenstypes die gebruikt worden voor het groeperen van andere waarden. De meest veelzijdige is de lijst die geschreven kan worden als een lijst uit komma-gescheiden waarden (items) tussen vierkante haken. Lijsten mogen als inhoud verschillende item-types hebben, maar meestal hebben alle items hetzelfde type:
>>> squares = [1, 4, 9, 16, 25]
>>> squares
[1, 4, 9, 16, 25]
Lijsten kunnen, net zoals bij strings en bij alle andere ingebouwde types, geïndexeerd en gesliced (in delen teruggegeven) worden:
>>> squares[0] # geïndexeerd retourneert het item
1
>>> squares[-1]
25
>>> squares[-3:] # slicing retourneert een nieuwe lijst
[9, 16, 25]
Alle slice bewerkingen retourneren nieuwe lijsten met als inhoud de gevraagde elementen. Dit betekent dat de volgende slice een nieuwe (ondiepe) kopie van de lijst retourneert:
>>> squares[:]
[1, 4, 9, 16, 25]
Lijsten ondersteunen ook samenvoegingen:
>>> squares + [36, 49, 64, 81, 100]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
Hoewel strings onveranderbaar zijn, zijn lijsten een veranderbaar type. Het is toegestaan hun inhoud te wijzigen:
>>> cubes = [1, 8, 27, 65, 125] # er is wat fout gegaan hier
>>> 4 ** 3 # de kubus van 4 is 64, niet 65!
64
>>> cubes[3] = 64 # vervang de foute waarde
>>> cubes
[1, 8, 27, 64, 125]
U kunt ook nieuwe items aan het einde van de lijst toevoegen met gebruik van de append() methode:
>>> cubes.append(216) # voeg de kubus van 6 toe
>>> cubes.append(7 ** 3) # en de kubus van 7
>>> cubes
[1, 8, 27, 64, 125, 216, 343]
Toekennen aan slices is ook mogelijk, de lengte van de lijst kan worden gewijzigd en ook worden schoongemaakt:
>>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> letters
['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> # vervang sommige waarden
>>> letters[2:5] = ['C', 'D', 'E']
>>> letters
['a', 'b', 'C', 'D', 'E', 'f', 'g']
>>> # verwijder ze nu
>>> letters[2:5] = []
>>> letters
['a', 'b', 'f', 'g']
>>> # maak nu de hele lijst schoon door ze allemaal te verwijderen
>>> letters[:] = []
>>> letters
[]
De ingebouwde functie len() werkt ook op lijsten:
>>> letters = ['a', 'b', 'c', 'd']
>>> len(letters)
4
Het is ook mogelijk lijsten te nesten. Elk item zal dan een lijst zijn:
>>> a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'
De eerste stappen naar programmeren
Natuurlijk kunnen we Python voor gecompliceerdere dingen gebruiken dan het toevoegen van twee aan twee aan elkaar. We kunnen bijvoorbeeld een sub-volgorde Fibonacci serie schrijven, als volgt:
>>> # Fibonacci series:
... # de som van twee elementen definieert het volgende
... a, b = 0, 1
>>> while b < 10:
... print(b)
... a, b = b, a+b
...
1
1
2
3
5
8
De eerste regel is een meervoudige toekenning: de variabelen a en b krijgen tegelijk de nieuwe waarden 0 en 1. In de laatste regel wordt dit opnieuw gedaan, hier gedemonstreerd dat een expressie aan de rechterkant voorrang heeft voordat een toekenning plaatsvindt. De expressies aan de rechterkant worden van links naar rechts uitgevoerd.
De while lus voert alles uit zolang de conditie (hier: b < 10) waar is. Zoals in C is in Python ook elke niet-nul integer waarde waar, een nul is onwaar. De conditie mag ook een string zijn of een lijstwaarde. Van elke volgorde is een niet-nul lengte een waar, een lege is een onwaar. De test in het voorbeeld is een simpele vergelijking. De standaard vergelijking operatoren zijn hetzelfde als in C.
Samenvatting
Python is een programmeertaal om prima als beginner ermee te starten. U hebt kunnen zien hoe de structuur van Python eruit ziet. Maar we kunnen nog meer doen in Python, zoals het bovenstaande voorbeeld laat zien met een while lus. We kunnen met gegevensstructuren werken, modules maken en zelfs eigen klassen bouwen. In de volgende Bulletin ga ik daarom verder met Python om nog meer te kunnen ontdekken wat we met deze programmeertaal kunnen doen.
