3. De basis van Python
3.1. Script [bases_01]: basisbewerkingen
Het script [bases_01] laat de eerste kenmerken van Python zien.
# ----------------------------------
def affiche(chaine):
# geeft een tekenreeks weer
print("chaine=%s" % chaine)
# ----------------------------------
def affiche_type(variable):
# geeft het type van de variabele weer
print("type[%s]=%s" % (variable, type(variable)))
# ----------------------------------
def f1(param):
# voegt 10 toe aan param
return param + 10
# ----------------------------------
def f2():
# retourneert een tuple met 3 waarden
return "un", 0, 100
# -------------------------------- hoofdprogramma ------------------------------------
# dit is een opmerking
# variabele gebruikt zonder te zijn gedeclareerd
nom = "dupont"
# een schermweergave
print("nom=%s" % nom)
# een lijst met elementen van verschillende typen
liste = ["un", "deux", 3, 4]
# het aantal elementen
n = len(liste)
# een lus
for i in range(n):
print("liste[%d]=%s" % (i, liste[i]))
# initialisatie van 2 variabelen met een tuple
(chaine1, chaine2) = ("chaine1", "chaine2")
# samenvoeging van de 2 strings
chaine3 = chaine1 + chaine2
# weergave van het resultaat
print("[%s,%s,%s]" % (chaine1, chaine2, chaine3))
# gebruik van een functie
affiche(chaine1)
# het type van een variabele kan bekend zijn
affiche_type(n)
affiche_type(chaine1)
affiche_type(liste)
# het type van een variabele kan tijdens de uitvoering veranderen
n = "a changé"
affiche_type(n)
# een functie kan een resultaat retourneren
res1 = f1(4)
print("res1=%s" % res1)
# een functie kan een lijst met waarden retourneren
(res1, res2, res3) = f2()
print("(res1,res2,res3)=[%s,%s,%s]" % (res1, res2, res3))
# deze waarden hadden in een variabele kunnen worden opgeslagen
liste = f2()
for i in range(len(liste)):
print("liste[%s]=%s" % (i, liste[i]))
# tests
for i in range(len(liste)):
# geeft alleen de tekenreeksen weer
if type(liste[i]) == "str":
print("liste[%s]=%s" % (i, liste[i]))
# nog meer tests
for i in range(len(liste)):
# geeft alleen gehele getallen >10 weer
if type(liste[i]) == "int" and liste[i] > 10:
print("liste[%s]=%s" % (i, liste[i]))
# een while-lus
liste = (8, 5, 0, -2, 3, 4)
i = 0
somme = 0
while i < len(liste) and liste[i] > 0:
print("liste[%s]=%s" % (i, liste[i]))
somme += liste[i] # som = som + lijst[i]
i += 1 # i = i + 1
print("somme=%s" % somme)
# einde programma
Opmerkingen
- regel 2: het sleutelwoord def definieert een functie;
- regel 2: de functie ontvangt de parameter [chaine]. Het type van de parameter wordt niet aangegeven. Python maakt uitsluitend gebruik van doorgeven per waarde. Dit verschilt per gegevenstype:
- bij een eenvoudig type (getal, booleaanse waarde…) is deze waarde de waarde die door de gegevens wordt ingekapseld (4, True…);
- bij een complex type (lijst, klasse, …) is deze waarde het adres van het gegeven;
- regels 3-4: de inhoud van de functie. Deze is één tab naar rechts ingesprongen. Het is deze inspringing in combinatie met het teken : van de instructie def die de inhoud van de functie definieert. Dit geldt voor alle instructies met inhoud: if, else, while, for, try, except;
- regel 4: de syntaxis die hier wordt gebruikt is [print('text1%F1text2%F2…' % data1, data2)]:
- de [%Fi] (hier %s) zijn weergaveformaten:
- %s (string): voor een tekenreeks;
- %d (decimaal): voor getekende decimale gehele getallen;
- %f (float): decimaal formaat voor reële getallen;
- %e (exponentieel): exponentieel formaat voor een reëel getal;
- …
- [data1, data2…] zijn de uitdrukkingen waarvan we de waarde willen weergeven:
- [data1] wordt weergegeven in de notatie F1;
- [data2] wordt weergegeven in de notatie F2;
- …
- regel 10: Python beheert het type van variabelen intern. Het type van een variabele kan worden achterhaald met de functie type(variable), die een variabele van het type 'type' retourneert. De uitdrukking '%s' % (type(variabele)) is een tekenreeks die het type van de variabele weergeeft;
- regel 25: het hoofdprogramma. Dit volgt gewoonlijk (maar niet noodzakelijkerwijs) na de definitie van alle functies in het script. De inhoud ervan is niet ingesprongen;
- regel 28: in Python worden variabelen niet gedeclareerd. Python is hoofdlettergevoelig. De variabele Nom is anders dan de variabele nom. Een tekenreeks kan worden omsloten door aanhalingstekens " of apostrofs '. Je kunt dus 'dupont' of "dupont" schrijven;
- regel 34: er is een verschil tussen een tuple (1,2,3) (let op de ronde haakjes) en een lijst [1,2,3] (let op de vierkante haakjes). Het tupel is niet-wijzigbaar, terwijl de lijst dat wel is. In beide gevallen wordt element nr. i aangeduid als [i];
- regel 40: range(n) is het tuple (0,1,2,…,n-1);
- regel 41: de notatie %d wordt gebruikt voor getallen met teken;
- regel 74: len(var) is het aantal elementen van de verzameling var (tuple, lijst, woordenboek…);
- regel 84: met de structuur [for in …] kan een iterabele structuur worden doorlopen. Lijsten en tuples zijn iterabele elementen;
- regel 86: de andere booleaanse operatoren zijn or en not;
- regel 93: berekent de som van de getallen >0 in de lijst;
De uitvoer op het scherm is als volgt:
C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\Scripts\python.exe C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/bases/bases_01.py
nom=dupont
liste[0]=un
liste[1]=deux
liste[2]=3
liste[3]=4
[chaine1,chaine2,chaine1chaine2]
chaine=chaine1
type[4]=<class 'int'>
type[chaine1]=<class 'str'>
type[['un', 'deux', 3, 4]]=<class 'list'>
type[a changé]=<class 'str'>
res1=14
(res1,res2,res3)=[un,0,100]
liste[0]=un
liste[1]=0
liste[2]=100
liste[0]=8
liste[1]=5
somme=13
Process finished with exit code 0
3.2. Script [bases_02]: opmaakreeksen
Python 3 heeft een nieuwe manier geïntroduceerd om tekenreeksen op te maken:
# opmaakreeksen
# de formaten zijn die van de programmeertaal C
# geheel getal
int1 = 10
print(f"[int1={int1}]")
print(f"[int1={int1:4d}]")
print(f"[int1={int1:04d}]")
# drijvende-kommagetal
float1=8.2
print(f"[float1={float1}]")
print(f"[float1={float1:8.2f}]")
print(f"[float1={float1:.3e}]")
# tekenreeks
str1="abcd"
print(f"[str1={str1}]")
print(f"[str1={str1:8s}]")
str2="jean de florette"
print(f"[{str2:20.10s}]")
# geformatteerde strings kunnen aan variabelen worden toegewezen
str3=f"[{str2:20.10s}]"
print(str3)
De syntaxis van de opgemaakte tekenreeks is als volgt:
waarbij:
- [expri]: een uitdrukking;
- [formati]: het formaat van de uitdrukking [expri]. Deze formaten zijn die van de programmeertaal C:
- %d: voor gehele getallen;
- %f: decimale notatie voor reële getallen;
- %e: exponentiële notatie voor reële getallen;
- %s: voor tekenreeksen. Dit is het formaat dat wordt gebruikt wanneer er geen formaat is opgegeven voor [expri];
- %nd, %nf, %ns: geeft [expri] weer op n tekens: de tekenreeks wordt ofwel afgekapt, ofwel aangevuld met spaties;
- regel 7: [04d], geheel getal van 4 tekens, links aangevuld met nullen;
- regel 11: [8.2f], een decimaal getal van 8 tekens, waarvan 2 achter de komma;
- regel 12: [.3e], een reëel getal in exponentiële vorm met 3 decimalen voor de mantisse;
- regel 18: [20.10s], de eerste 10 tekens van een tekenreeks, aangevuld met spaties tot 20 tekens;
De resultaten van de uitvoering zijn als volgt:
3.3. Script [bases_03]: typewijzigingen
We richten ons hier op typewijzigingen met gegevens van het type str (tekenreeks), int (geheel getal), float (reëel getal) en bool (booleaanse waarde).
# typeomzettingen
# int --> str, float, bool
x = 4
print(x, type(x))
x = str(4)
print(x, type(x))
x = float(4)
print(x, type(x))
x = bool(4)
print(x, type(x))
# bool → int, float, str
x = True
print(x, type(x))
x = int(True)
print(x, type(x))
x = float(True)
print(x, type(x))
x = str(True)
print(x, type(x))
# str --> int, float, bool
x = "4"
print(x, type(x))
x = int("4")
print(x, type(x))
x = float("4")
print(x, type(x))
x = bool("4")
print(x, type(x))
# float → str, int, bool
x = 4.32
print(x, type(x))
x = str(4.32)
print(x, type(x))
x = int(4.32)
print(x, type(x))
x = bool(4.32)
print(x, type(x))
# afhandeling van fouten bij typeconversie
try:
x = int("abc")
print(x, type(x))
except ValueError as erreur:
print(erreur)
# diverse gevallen
x = bool("abc")
print(x, type(x))
x = bool("")
print(x, type(x))
x = bool(0)
print(x, type(x))
x = None
print(x, type(x))
x = bool(None)
print(x, type(x))
x = bool(0.0)
print(x, type(x))
# alle gegevens zijn klasse-instanties en beschikken als zodanig over methoden
# tekenreeks
str1 = "abc"
print(str1.capitalize())
# geheel getal
int1 = 4
print(int1.bit_length())
# booleaanse waarde
bool1=True
print(bool1.conjugate())
# reëel getal
float1=8.2
print (float1.is_integer())
Er zijn talrijke typeconversies mogelijk. Sommige kunnen mislukken, zoals die in de regels 46-47, die proberen de tekenreeks 'abc' om te zetten in een geheel getal. We hebben de fout afgehandeld met een structuur try / except. Een algemene vorm van deze structuur
is als volgt:
try:
actions
except Exception as ex:
actions
finally:
actions
Als een van de acties in de try-blok een uitzondering genereert (een fout signaleert), wordt er onmiddellijk doorgeschakeld naar de except-clausule. Als de acties in de try-blok geen uitzondering genereren, wordt de except-clausule genegeerd. De attributen Exception en ex van de instructie except zijn optioneel. Wanneer ze aanwezig zijn, specificeert Exception het type uitzondering dat door de instructie except wordt opgevangen en bevat ex de uitzondering die zich heeft voorgedaan. Er kunnen meerdere except-instructies zijn, als men verschillende soorten uitzonderingen in dezelfde try wil afhandelen.
De instructie finally is optioneel. Als deze aanwezig is, worden de acties van de finally altijd uitgevoerd, ongeacht of er een uitzondering is opgetreden of niet.
We komen later nog terug op de uitzonderingen.
De regels 49-61 tonen verschillende pogingen om gegevens van het type str, int, float en NoneType om te zetten in een booleaanse waarde. Dit is altijd mogelijk. De regels zijn als volgt:
- bool(int i) is gelijk aan False als i gelijk is aan 0, en aan True in alle andere gevallen;
- bool(float f) is gelijk aan False als f gelijk is aan 0,0, en aan True in alle andere gevallen;
- bool(str string) is gelijk aan False als string 0 tekens bevat, en aan True in alle andere gevallen;
- bool(None) is False. None is een speciale waarde die aangeeft dat de variabele bestaat maar geen waarde heeft.
De schermresultaten zijn als volgt:
Merk op dat alle gegevens objecten zijn, dat wil zeggen instanties van een klasse. Dit betekent dat ze methoden kunnen hebben. Dit wordt geïllustreerd in de regels 63-75 van de code. We willen hier niet uitleggen wat de gebruikte methoden doen, maar alleen laten zien dat ze bestaan.
3.4. Script [bases_04]: bereik van variabelen
Het script [bases_04] laat zien dat Python geen blokbereikvariabelen kent:
# bereik van variabelen
i = 4
if True:
i += 1
j = 7
print(f"i={i}, j={j}")
Resultaten
Opmerkingen
De resultaten laten twee dingen zien:
- regel 4: de variabele [i] uit het blok [if] is dezelfde als de variabele i die op regel 2 wordt gebruikt;
- regel 6: de variabele [j] is de variabele die in het blok [if] is geïnitialiseerd;
In sommige programmeertalen, waarin variabelen moeten worden gedeclareerd, is een variabele die in een blok is gedefinieerd (zoals in de regels 3-5) buiten dat blok niet bekend. In Python is dat niet het geval.
3.5. Script [bases_05]: lijsten - 1
Het script [bases_05] ziet er als volgt uit:
# eendimensionale lijsten
# initialisatie
list1 = [0, 1, 2, 3, 4, 5]
# doorlopen - 1
print(f"list1 a {len(list1)} éléments")
for i in range(len(list1)):
print(f"list1[{i}]={list1[i]}")
list1[1] = 10
# doorlopen - 2
print(f"list1 a {len(list1)} éléments")
for element in list1:
print(element)
# twee elementen toevoegen
list1[len(list1):] = [10, 11]
# met het formaat %s kan de lijst op één regel worden weergegeven
print("%s" % list1)
# de laatste twee elementen verwijderen
list1[len(list1) - 2:] = []
# met de standaardopmaak wordt de lijst op één regel weergegeven
print(f"{list1}")
# een lijst toevoegen aan het begin van de lijst
list1[:0] = [-10, -11, -12]
print(f"{list1}")
# twee items in het midden van de lijst invoegen
list1[3:3] = [100, 101]
print(f"{list1}")
# twee elementen in het midden van de lijst verwijderen
list1[3:4] = []
print(f"{list1}")
Opmerkingen:
- de notatie array[i:j] verwijst naar de elementen i tot en met j-1 van de array;
- de notatie [i:] verwijst naar de elementen i en volgende van de matrix;
- de notatie [:i] verwijst naar de elementen 0 tot en met i-1 van de array;
- regel 19: print (%s) % (list1) geeft de tekenreeks weer: "[ list1[0], list1[2]…, list1[n-1]]";
- regel 24: de notatie print ('f{list1}') doet hetzelfde;
Resultaten
C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\Scripts\python.exe C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/bases/bases_05.py
list1 a 6 éléments
list1[0]=0
list1[1]=1
list1[2]=2
list1[3]=3
list1[4]=4
list1[5]=5
list1 a 6 éléments
0
10
2
3
4
5
[0, 10, 2, 3, 4, 5, 10, 11]
[0, 10, 2, 3, 4, 5]
[-10, -11, -12, 0, 10, 2, 3, 4, 5]
[-10, -11, -12, 100, 101, 0, 10, 2, 3, 4, 5]
[-10, -11, -12, 101, 0, 10, 2, 3, 4, 5]
Process finished with exit code 0
3.6. Script [bases_06]: lijsten - 2
De vorige code kan anders worden geschreven (bases_06) door gebruik te maken van bepaalde methoden van de lijsten:
# eendimensionale lijsten
# initialisatie
list1 = [0, 1, 2, 3, 4, 5]
# doorlopen - 1
print(f"list1 a {len(list1)} éléments")
for i in range(len(list1)):
print(f"list1[{i}]={list1[i]}")
# een element wijzigen
list1[1] = 10
# doorlopen - 2
print(f"list1 a {len(list1)} éléments")
for element in list1:
print(element)
# twee elementen toevoegen
list1.extend([10, 11])
print(f"{list1}")
# verwijdering van de laatste twee elementen
del list1[len(list1) - 2:]
print(f"{list1}")
# een tuple toevoegen aan het begin van de lijst
for i in (-12, -11, -10):
list1.insert(0, i)
print(f"{list1}")
# invoegen in het midden van de lijst
for i in (101, 100):
list1.insert(3, i)
print(f"{list1}")
# verwijdering in het midden van de lijst
del list1[3:4]
print(f"{list1}")
De verkregen resultaten zijn dezelfde als bij de vorige versie.
3.7. script [bases_07]: het woordenboek
Het script [bases_07] laat zien hoe je een woordenboek, ook wel associatieve array genoemd, kunt definiëren en gebruiken.
# een functie die controleert of de sleutel 'mari' voorkomt in het woordenboek 'conjoints'
def existe(conjoints, mari):
if mari in conjoints:
print(f"La clé [{mari}] existe associée à la valeur [{conjoints[mari]}]")
else:
print(f"La clé [{mari}] n'existe pas")
# ----------------------------- Main
# een woordenboek
conjoints = {"Pierre": "Gisèle", "Paul": "Virginie", "Jacques": "Lucette", "Jean": ""}
# doorloop - 1
print(f"Nombre d'éléments du dictionnaire : {len(conjoints)}")
for (clé, valeur) in conjoints.items():
print(f"conjoints[{clé}]={valeur}")
# lijst met sleutels van het woordenboek
print("liste des clés-------------")
clés = conjoints.keys()
print(f"{clés}")
# lijst met waarden van het woordenboek
print("liste des valeurs------------")
valeurs = conjoints.values()
print(f"{valeurs}")
# zoeken naar een sleutel
existe(conjoints, "Jacques")
existe(conjoints, "Lucette")
existe(conjoints, "Jean")
# een sleutel-waarde verwijderen
del (conjoints["Jean"])
print(f"Nombre d'éléments du dictionnaire : {len(conjoints)}")
print(f"{conjoints}")
# de sleutels en waarden van een woordenboek zijn geen lijsten
print(f"type des clés : {type(clés)}")
print(f"type des valeurs : {type(valeurs)}")
# ze kunnen worden omgezet in lijsten
lclés = list(clés)
print(f"clés : {type(lclés)}, {lclés}")
lvaleurs = list(valeurs)
print(f"valeurs : {type(lvaleurs)}, {lvaleurs}")
Opmerkingen:
- regel 11: de vaste definitie van een woordenboek;
- regel 15: conjoints.items() maakt de lijst met (sleutel, waarde)-paren van het woordenboek samenhangend;
- regel 20: conjoints.keys() geeft de sleutels van het associatieve array terug;
- regel 25: conjoints.values() geeft de waarden van het woordenboek ‘conjoints’ weer;
- regel 3: 'mari' in 'conjoints' levert True op als de sleutel mari in het woordenboek conjoints voorkomt, anders False;
- regel 36: een woordenboek kan in één regel worden weergegeven.
Resultaten
C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\Scripts\python.exe C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/bases/bases_07.py
Nombre d'éléments du dictionnaire : 4
conjoints[Pierre]=Gisèle
conjoints[Paul]=Virginie
conjoints[Jacques]=Lucette
conjoints[Jean]=
liste des clés-------------
dict_keys(['Pierre', 'Paul', 'Jacques', 'Jean'])
liste des valeurs------------
dict_values(['Gisèle', 'Virginie', 'Lucette', ''])
La clé [Jacques] existe associée à la valeur [Lucette]
La clé [Lucette] n'existe pas
La clé [Jean] existe associée à la valeur []
Nombre d'éléments du dictionnaire : 3
{'Pierre': 'Gisèle', 'Paul': 'Virginie', 'Jacques': 'Lucette'}
type des clés : <class 'dict_keys'>
type des valeurs : <class 'dict_values'>
clés : <class 'list'>, ['Pierre', 'Paul', 'Jacques']
valeurs : <class 'list'>, ['Gisèle', 'Virginie', 'Lucette']
Process finished with exit code 0
Opmerkingen:
- in de regels 16-17 van de resultaten valt op dat de sleutels en waarden van een woordenboek geen lijst vormen, maar een type 'dict_keys';
- regels 18-19: door een eenvoudige typewijziging kunnen ze worden omgezet naar het type [list];
3.8. script [bases_08]: de tuples
Het tuple vertoont overeenkomsten met de lijst, maar is niet wijzigbaar:
# tuples
# initialisatie
tuple1 = (0, 1, 2, 3, 4, 5)
# doorlopen - 1
print(f"tuple1 a {len(tuple1)} elements")
for i in range(len(tuple1)):
print(f"tuple1[{i}]={tuple1[i]}")
# doorlopen - 2
print(f"tuple1 a {len(tuple1)} elements")
for element in tuple1:
print(element)
# een tuple kan op één regel worden weergegeven
print(f"tuple1={tuple1}")
# een tuple kan niet worden gewijzigd
tuple1[0] = 10
Resultaten
C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\Scripts\python.exe C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/bases/bases_08.py
tuple1 a 6 elements
tuple1[0]=0
tuple1[1]=1
tuple1[2]=2
tuple1[3]=3
tuple1[4]=4
tuple1[5]=5
tuple1 a 6 elements
0
1
2
3
4
5
tuple1=(0, 1, 2, 3, 4, 5)
Traceback (most recent call last):
File "C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/bases/bases_08.py", line 19, in <module>
tuple1[0] = 10
TypeError: 'tuple' object does not support item assignment
Process finished with exit code 1
Opmerkingen:
- regels 17-20 van de resultaten: hieruit blijkt dat een tuple niet kan worden gewijzigd.
3.9. Script [bases_09]: meerdimensionale lijsten en woordenboeken
Het script [bases_09] laat zien hoe je een meerdimensionale lijst of een meerdimensionaal woordenboek kunt definiëren en gebruiken:
# meerdimensionale lijsten
# initialisatie
multi = [[0, 1, 2], [10, 11, 12, 13], [20, 21, 22, 23, 24]]
# doorlopen
for i1 in range(len(multi)):
for i2 in range(len(multi[i1])):
print(f"multi[{i1}][{i2}]={multi[i1][i2]}")
# weergave in één regel
print(f"multi={multi}")
# meerdimensionale woordenboeken
# initialisatie
multi = {"zéro": [0, 1], "un": [10, 11, 12, 13], "deux": [20, 21, 22, 23, 24]}
# doorlopen
for (clé, valeur) in multi.items():
for i2 in range(len(valeur)):
print(f"multi[{clé}][{i2}]={multi[clé][i2]}")
# weergave op één regel
print(f"multi={multi}")
Opmerkingen
- regel 7: multi[i1] is een lijst;
- regel 18: waarde is een lijst;
Resultaten
C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\Scripts\python.exe C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/bases/bases_09.py
multi[0][0]=0
multi[0][1]=1
multi[0][2]=2
multi[1][0]=10
multi[1][1]=11
multi[1][2]=12
multi[1][3]=13
multi[2][0]=20
multi[2][1]=21
multi[2][2]=22
multi[2][3]=23
multi[2][4]=24
multi=[[0, 1, 2], [10, 11, 12, 13], [20, 21, 22, 23, 24]]
multi[zéro][0]=0
multi[zéro][1]=1
multi[un][0]=10
multi[un][1]=11
multi[un][2]=12
multi[un][3]=13
multi[deux][0]=20
multi[deux][1]=21
multi[deux][2]=22
multi[deux][3]=23
multi[deux][4]=24
multi={'zéro': [0, 1], 'un': [10, 11, 12, 13], 'deux': [20, 21, 22, 23, 24]}
Process finished with exit code 0
3.10. Script [bases_10]: koppelingen tussen tekenreeksen en lijsten
Het script [bases_10] laat zien hoe je in een lijst de elementen van een tekenreeks kunt ophalen die door hetzelfde scheidingsteken worden gescheiden.
# reeks naar lijst
chaine = '1:2:3:4'
liste = chaine.split(':')
print(type(liste))
# lijstweergave
print(f"liste a {len(liste)} éléments")
print(f"liste={liste}")
# van lijst naar tekenreeks
chaine2 = ":".join(liste)
print(f"chaine2={chaine2}")
# een leeg veld toevoegen
chaine += ":"
print(f"chaine={chaine}")
liste = chaine.split(":")
# lijstweergave
print(f"liste a {len(liste)} éléments")
print(f"liste={liste}")
# laten we opnieuw een leeg veld toevoegen
chaine += ":"
print(f"chaine={chaine}")
liste = chaine.split(":")
# lijst weergeven
print(f"liste a {len(liste)} éléments")
print(f"liste={liste}")
Opmerkingen:
- regel 3: de methode chaine.split(scheidingsteken) splitst de tekenreeks chaine in elementen die worden gescheiden door séparateur en geeft deze weer in de vorm van een lijst. De uitdrukking '1:2:3:4'.split(":") heeft dus de waarde van de lijst ('1','2','3','4');
- regel 11: 'scheidingsteken'.join(lijst) heeft als waarde de tekenreeks 'lijst[0]+scheidingsteken+lijst[1]+scheidingsteken+…'.
Resultaten
C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\Scripts\python.exe C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/bases/bases_10.py
<class 'list'>
liste a 4 éléments
liste=['1', '2', '3', '4']
chaine2=1:2:3:4
chaine=1:2:3:4:
liste a 5 éléments
liste=['1', '2', '3', '4', '']
chaine=1:2:3:4::
liste a 6 éléments
liste=['1', '2', '3', '4', '', '']
Process finished with exit code 0
3.11. Script [bases_11]: reguliere expressies
Het script [bases_11] laat zien hoe je reguliere expressies kunt gebruiken:
# we importeren de module voor reguliere expressies
import re
# --------------------------------------------------------------------------
def compare(modèle, chaine):
# vergelijkt de tekenreeks [chaîne] met het patroon [modèle]
# weergave van de resultaten
print(f"\nRésultats({chaine},{modèle})")
match = re.match(modèle, chaine)
if match:
print(match.groups())
else:
print(f"La chaîne [{chaine}] ne correspond pas au modèle [{modèle}]")
# reguliere expressies in Python
# de verschillende velden van een tekenreeks ophalen
# het patroon: een reeks cijfers omgeven door willekeurige tekens
# we willen alleen de reeks cijfers ophalen
modèle = r"^.*?(\d+).*?$"
# we vergelijken de tekenreeks met het patroon
compare(modèle, "xyz1234abcd")
compare(modèle, "12 34")
compare(modèle, "abcd")
# het patroon: een reeks cijfers omgeven door willekeurige tekens
# we willen de reeks cijfers en de velden ervoor en erna
modèle = r"^(.*?)(\d+)(.*?)$"
# we vergelijken de tekenreeks met het patroon
compare(modèle, "xyz1234abcd")
compare(modèle, "12 34")
compare(modèle, "abcd")
# het patroon: een datum in de notatie dd/mm/jj
modèle = r"^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$"
compare(modèle, "10/05/97")
compare(modèle, " 04/04/01 ")
compare(modèle, "5/1/01")
# het patroon – een decimaal getal
modèle = r"^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*$"
compare(modèle, "187.8")
compare(modèle, "-0.6")
compare(modèle, "4")
compare(modèle, ".6")
compare(modèle, "4.")
compare(modèle, " + 4")
# einde
Opmerkingen:
- let op de module [re] die in regel 2 wordt geïmporteerd. Deze module bevat de functies voor het beheer van reguliere expressies;
- regel 10: de vergelijking van een tekenreeks met een reguliere uitdrukking (patroon) levert de booleaanse waarde True op als de tekenreeks overeenkomt met het patroon, en False anders;
- regel 12: match.groups() is een tuple waarvan de elementen de delen van de tekenreeks zijn die overeenkomen met de door haakjes omgeven elementen van de reguliere uitdrukking. In het patroon:
- ^.*?(\d+).*?, is match.groups() een tuple met één element omdat er één haakje is;
- ^(.*?)(\d+)(.*?)$, zal match.groups() een tuple met 3 elementen zijn omdat er drie haakjes staan;
- regel 21: een letterlijke reguliere expressie wordt geschreven als r"xxx". Het is het symbool r dat de tekenreeks tot een reguliere expressie maakt;
Met reguliere expressies kunnen we het formaat van een tekenreeks toetsen. Zo kunnen we controleren of een tekenreeks die een datum weergeeft, de indeling dd/mm/jj heeft. Hiervoor gebruiken we een patroon en vergelijken we de tekenreeks met dit patroon. In dit voorbeeld moeten j, m en a dus cijfers zijn. Het patroon voor een geldige datumnotatie is dan "\d\d/\d\d/\d\d", waarbij het symbool \d een cijfer aangeeft. De volgende symbolen kunnen in een patroon worden gebruikt:
Teken | Beschrijving |
\ | Geeft aan dat het volgende teken een speciaal teken of een letterlijk teken is. Bijvoorbeeld: "n" staat voor het teken "n", terwijl "\n" staat voor een nieuwe regel. De reeks "\\" staat voor "\", terwijl "\(" staat voor "(". |
^ | Komt overeen met het begin van de reeks. |
$ | Komt overeen met het einde van de tekenreeks. |
* | Komt overeen met het vorige teken, nul of meerdere keren. Zo komt "zo*" overeen met "z" of met "zoo". |
+ | Komt overeen met het vorige teken, één of meerdere keren. Zo komt "zo+" overeen met "zoo", maar niet met "z". |
? | Komt overeen met het vorige teken, nul of één keer. Bijvoorbeeld: "a?ve?" komt overeen met "ve" in "lever". |
. | Komt overeen met elk willekeurig teken, behalve het regeleinde. |
(sjabloon) | Zoekt naar modèle en slaat de overeenkomst op. De overeenkomende subreeks kan worden opgehaald uit de verzameling match.groups(). Om overeenkomsten te vinden met tekens tussen haakjes ( ), gebruik je "\(" of "\)". |
x|y | Komt overeen met x of met y. Bijvoorbeeld: "z|foot" komt overeen met "z" of met "foot". "(z|f)oo" komt overeen met "zoo" of met "foo". |
{n} | n is een niet-negatief geheel getal. Komt exact overeen met n maal het teken. Bijvoorbeeld: "o{2}" komt niet overeen met "o" in "Bob," maar met de eerste twee "o" in "fooooot". |
{n,} | n is een niet-negatief geheel getal. Komt overeen met ten minste n keer het teken. Bijvoorbeeld: "o{2,}" komt niet overeen met "o" in "Bob", maar met alle "o" in "fooooot". "o{1,}" is gelijk aan "o+" en "o{0,}" is gelijk aan "o*". |
{n,m} | m en n zijn niet-negatieve gehele getallen. Komt overeen met ten minste n en ten hoogste m keer het teken. Bijvoorbeeld: "o{1,3}" komt overeen met de eerste drie "o" in "foooooot" en "o{0,1}" komt overeen met "o?". |
[xyz] | Tekenset. Komt overeen met een van de opgegeven tekens. Bijvoorbeeld: "[abc]" komt overeen met "a" in "plat". |
[^xyz] | Negatieve tekenreeks. Komt overeen met elk teken dat niet is opgegeven. Bijvoorbeeld: "[^abc]" komt overeen met "p" in "plat". |
[a-z] | Tekenreeks. Komt overeen met elk teken in de opgegeven reeks. Bijvoorbeeld: "[a-z]" komt overeen met elk klein letterteken tussen "a" en "z". |
[^m-z] | Negatief tekenbereik. Komt overeen met elk teken dat niet in de opgegeven reeks voorkomt. Bijvoorbeeld: "[^m-z]" komt overeen met elk teken dat niet tussen "m" en "z" voorkomt. |
\b | Komt overeen met een grens die een woord aangeeft, met andere woorden, de positie tussen een woord en een spatie. Bijvoorbeeld: "er\b" komt overeen met "er" in "lever", maar niet met "er" in "verbe". |
\B | Komt overeen met een grens die geen woord vertegenwoordigt. "en*t\B" komt overeen met "ent" in "bien entendu". |
\d | Komt overeen met een teken dat een cijfer vertegenwoordigt. Komt overeen met [0-9]. |
\D | Komt overeen met een teken dat geen cijfer vertegenwoordigt. Komt overeen met [^0-9]. |
\f | Komt overeen met een pagina-einde-teken. |
\n | Komt overeen met een regeleinde-teken. |
\r | Komt overeen met een carriage return-teken. |
\s | Komt overeen met alle witruimte, inclusief spatie, tab, pagina-einde, enz. Komt overeen met "[ \f\n\r\t\v]". |
\S | Komt overeen met elk niet-wit spatiekarakter. Komt overeen met "[^ \f\n\r\t\v]". |
\t | Komt overeen met een tabteken. |
\v | Komt overeen met een verticaal tabteken. |
\w | Komt overeen met elk teken dat een woord vertegenwoordigt en een onderstrepingsteken bevat. Komt overeen met "[A-Za-z0-9_]". |
\W | Komt overeen met elk teken dat geen woord vertegenwoordigt. Komt overeen met "[^A-Za-z0-9_]". |
\num | Komt overeen met num, waarbij num een positief geheel getal is. Verwijst naar opgeslagen overeenkomsten. Bijvoorbeeld: "(.)\1" komt overeen met twee opeenvolgende identieke tekens. |
\n | Komt overeen met n, waarbij n een octale escape-waarde is. Octale escape-waarden moeten uit 1, 2 of 3 cijfers bestaan. Bijvoorbeeld: "\11" en "\011" komen beide overeen met een tab-teken. "\0011" is gelijk aan "\001" & "1". Octale escape-waarden mogen niet hoger zijn dan 256. Als dat wel het geval is, worden alleen de eerste twee cijfers in de uitdrukking meegenomen. Hiermee kunnen de codes ASCII in reguliere uitdrukkingen worden gebruikt. |
\xn | Komt overeen met n, waarbij n een hexadecimale escape-waarde is. Hexadecimale escape-waarden moeten verplicht uit twee cijfers bestaan. Bijvoorbeeld: "\x41" komt overeen met "A". "\x041" is gelijk aan "\x04" & "1". Hiermee kunnen de codes ASCII in reguliere expressies worden gebruikt. |
Een element in een sjabloon kan één of meerdere keren voorkomen. Laten we enkele voorbeelden bekijken rond het symbool \d, dat één cijfer vertegenwoordigt:
sjabloon | betekenis |
\d | een cijfer |
\d? | 0 of 1 cijfer |
\d* | 0 of meer cijfers |
\d+ | 1 of meer cijfers |
\d{2} | 2 cijfers |
\d{3,} | minstens 3 cijfers |
\d{5,7} | tussen 5 en 7 cijfers |
Laten we nu eens kijken naar het patroon waarmee het verwachte formaat van een tekenreeks kan worden beschreven:
gezochte tekenreeks | model |
een datum in de indeling dd/mm/jj | \d{2}/\d{2}/\d{2} |
een tijd in de notatie hh:mm:ss | \d{2}:\d{2}:\d{2} |
een geheel getal zonder teken | \d+ |
een reeks spaties, eventueel leeg | \s* |
een geheel getal zonder teken dat voorafgegaan of gevolgd kan worden door spaties | \s*\d+\s* |
een geheel getal dat een teken kan hebben en voorafgegaan of gevolgd kan worden door spaties | \s*[+|-]?\s*\d+\s* |
een reëel getal zonder teken dat voorafgegaan of gevolgd kan worden door spaties | \s*\d+(.\d*)?\s* |
een reëel getal dat een teken kan hebben en voorafgegaan of gevolgd kan worden door spaties | \s*[+-]?\s*\d+(.\d*)?\s* |
een tekenreeks die het woord 'juste' bevat | \bjuste\b |
Je kunt aangeven waar in de tekenreeks naar het patroon wordt gezocht:
patroon | betekenis |
^patroon | het patroon begint in de tekenreeks |
patroon$ | het patroon beëindigt de reeks |
^patroon$ | het patroon begint en eindigt de reeks |
patroon | het patroon wordt overal in de tekenreeks gezocht, te beginnen bij het begin ervan. |
gezochte tekenreeks | patroon |
een tekenreeks die eindigt met een uitroepteken | !$ |
een tekenreeks die eindigt op een punt | \.$ |
een tekenreeks die begint met de reeks // | ^// |
een tekenreeks die uit slechts één woord bestaat, eventueel gevolgd of voorafgegaan door spaties | ^\s*\w+\s*$ |
een tekenreeks die bestaat uit twee woorden, eventueel voorafgegaan of gevolgd door spaties | ^\s*\w+\s*\w+\s*$ |
een tekenreeks die het woord 'secret' bevat | \bsecret\b |
De deelverzamelingen van een patroon kunnen worden „opgehaald”. Zo kan men niet alleen controleren of een tekenreeks overeenkomt met een bepaald patroon, maar kan men ook uit die tekenreeks de elementen ophalen die overeenkomen met de deelverzamelingen van het patroon die tussen haakjes zijn geplaatst. Als we dus een tekenreeks analyseren die een datum dd/mm/jj bevat en we bovendien de elementen dd, mm en jj van deze datum willen ophalen, gebruiken we het patroon (\d\d)/(\d\d)/(\d\d).
Resultaten van het script
C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\Scripts\python.exe C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/bases/bases_11.py
Résultats(xyz1234abcd,^.*?(\d+).*?$)
('1234',)
Résultats(12 34,^.*?(\d+).*?$)
('12',)
Résultats(abcd,^.*?(\d+).*?$)
La chaîne [abcd] ne correspond pas au modèle [^.*?(\d+).*?$]
Résultats(xyz1234abcd,^(.*?)(\d+)(.*?)$)
('xyz', '1234', 'abcd')
Résultats(12 34,^(.*?)(\d+)(.*?)$)
('', '12', ' 34')
Résultats(abcd,^(.*?)(\d+)(.*?)$)
La chaîne [abcd] ne correspond pas au modèle [^(.*?)(\d+)(.*?)$]
Résultats(10/05/97,^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$)
('10', '05', '97')
Résultats( 04/04/01 ,^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$)
('04', '04', '01')
Résultats(5/1/01,^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$)
La chaîne [5/1/01] ne correspond pas au modèle [^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$]
Résultats(187.8,^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*$)
('', '187.8')
Résultats(-0.6,^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*$)
('-', '0.6')
Résultats(4,^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*$)
('', '4')
Résultats(.6,^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*$)
('', '.6')
Résultats(4.,^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*$)
('', '4.')
Résultats( + 4,^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*$)
('+', '4')
Process finished with exit code 0