Python – Leren programmeren – deel 3

Welkom terug bij de 3e Python – Leren Programmeren post! In deel 1 hebben we gekeken naar wat Python is en in deel 2 hebben we al een goede basis gelegd. Wat opvalt is dat het allemaal nog steeds heel goed en duidelijk leesbaar is. Als je de basisregels onthoud kun je dus heel snel een script of programma schrijven. In deze post gaan we verder met een aantal functies en imports.

Imports

Binnen een Python script is het mogelijk om functies van andere scripts te importeren. Python komt met een volle bibliotheek aan mogelijkheden welke kant-en-klaar voor je gereed zijn om te gebruiken. Mocht de benodigde functie niet aanwezig zijn dan kun je de Python bibliotheek altijd proberen aan te vullen door de gewenste functie package te downloaden op het internet. Als je de functie in de bibliotheek hebt staan kun je deze aanroepen in Python. Imports staan meestal bovenin het script.

Je huidige bibliotheek is in PyCharm te zien aan de linkerkant:

Zo is “base64.py” een module die standaard aanwezig zijn. We importeren deze als volgt:

import base64

We kunnen base64.py gebruiken om zaken te versleutelen via de base64 standaard (op zichtzelf staand een zwakke standaard). Bijvoorbeeld:

import base64
 
original_string = "Dit is gewone data"
print (original_string)
 
encode2byte = str.encode(original_string)
type(bytes) # Zorgt ervoor dat de string omgezet wordt naar Byte Data (benodigd voor base64).

encoded_string = base64.b64encode(encode2byte)
print (encoded_string)

Als we dit script uit zouden voeren zonder de “base64.py” module te importeren dan zou dat resulteren in de volgende fout: “NameError: name ‘base64’ is not defined”.

Functies

Een functie in Python is een blok code die wordt gebruikt om één specifieke taak uit te voeren en in de rest van het script herbruikbaar is. Functies zorgen voor een betere modulariteit voor de toepassing en een hoge mate van code hergebruik.

We hebben al gespeeld met een aantal ingebouwde Python functies zoals print. Maar in dit hoofdstuk gaan we onze eigen functies creëren.

Om een functie te maken starten we de functie met het keyword “def” welke afkomstig is van definiëren / define. Na “def” plaatsen we de functienaam. Deze naam kunnen we later in het script weer aanroepen om de functie te gebruiken. Na de functienaam volgen haakjes (). Tussen deze haakje kunnen we input parameters en argumenten plaatsen. Daarna volgt een dubbele punt: en begint de functiecode. De functiecode kan starten met een “function docstring” ofwel de uitleg van de functie. Tenslotte schrijven we de functie en als de functie klaar is sluiten we deze af met een “return” welke (optioneel) een waarde terugstuurt naar de caller. Een “return statement” zonder waarde is hetzelfde als “return None”.

Een eigen functie wordt als volgt gemaakt:

def happyBirthday(persoon):
    "Zing Happy Birthday voor alle opgegeven personen."
    print("Happy Birthday to you!")
    print("Happy Birthday to you!")
    print("Happy Birthday, lieve " + persoon + ".")
    print("Happy Birthday to you!")
    return
 
happyBirthday('Maaike')
happyBirthday('Andre')
happyBirthday('Tineke')

Wat gebeurt er in deze functie:

1. Met “def happyBirthday” definiëren we een functie genaamd “happyBirthday”.
2. Met “(persoon)” maken we de variabele “persoon” aan in de functie welke gevuld kan worden met meegestuurde data.
3. Vervolgens openen we de functie met een dubbele punt : en plaatsen we de functie docstring waarin we uitleggen wat de functie doet. Deze docstring (comment) staat tussen “”.
4. Na de docstring start de functie welke verschillende regels tekst op het scherm print. Op de een na laatste regel wordt verwezen naar de variabele “persoon”. Hier wordt dus de data ingevuld welke meegestuurd is tijdens het aanroepen van de functie.
5. Met een return eindigen we de functie.

Vervolgens zien we dat we in Python 3x de functie aanroepen. We roepen de functie aan gevolgd door de parameters die meegestuurd moeten worden. In dit geval sturen we 3x een andere naam mee, namelijk: 1x Maaike, 1x Andre en 1x met Tineke.

Het resultaat ziet er dan als volgt uit:

Happy Birthday to you!
Happy Birthday to you!
Happy Birthday, lieve Maaike.
Happy Birthday to you!
Happy Birthday to you!
Happy Birthday to you!
Happy Birthday, lieve Andre.
Happy Birthday to you!
Happy Birthday to you!
Happy Birthday to you!
Happy Birthday, lieve Tineke.
Happy Birthday to you!

Let ook op de witruimte binnen de functie. Zoals al eerder gezegd definieert Python hiermee verschillende codeblokken. Dus na “def happyBirthday(persoon):” springt de werkelijke functie in met een tab. Nadat de functie met een “return” is afgesloten springt de code weer een tab terug.

Deze tabs verhogen de leesbaarheid en zonder deze tabs zou de functie resulteren in een fout “IndentationError: expected an indented block”.

Globale variabelen (global variables) zijn ook beschikbaar binnen functies. Variabele binnen functies zijn alleen beschikbaar binnen de functie. Normaliter is slim om variabelen zoveel mogelijk binnen de functie te houden om verwarring te voorkomen. Als een variabele echter benodigd is binnen meerdere functies of op meerdere locaties in de code dan is het goed om er een globale variabele van te maken.

Reguliere expressie en Escapes

Binnen Python kunnen we ook werken met reguliere expressies en zullen we soms bepaalde zaken moeten “escapen”. Als je wilt weten hoe reguliere expressies werken check dan even deze post: https://jarnobaselier.nl/reguliere-expressie-regular-expression-regexp-regex-re/. Dan laat ik je verderop zien hoe we dat in Python doen. Maar we starten met de escapes.

Het kan voorkomen dat bepaalde zaken “escaped” moeten worden. Neem als voornbeeld de docstring uit bovenstaande functie:
“Zing Happy Birthday voor alle opgegeven personen.”

Dit werkt prima. Maar als ik er de volgende zin van wil maken (en dus quotes binnen quotes ga gebruiken) dan werkt het niet:
“Zing “Happy Birthday” voor alle opgegeven personen.”

Dit zal resulteren in de error: “SyntaxError: invalid syntax”.

In dit geval zullen we de quotes van “Happy Birthday” moeten “escapen” zodat deze als gewone platte tekst geïnterpreteerd wordt. Dit doen we door de toevoeging van het “\” symbool (1 backslash) voor het teken dat je wilt escapen. Dus de volgende docstring is dan wel geldig:
“Zing \”Happy Birthday\” voor alle opgegeven personen.”

In bovenstaande voorbeeld hadden we “Happy Birthday” ook tussen enkele quotes kunnen plaatsen omdat de uitvoer gedefinieerd is tussen dubbele quotes. Dit werkt ook visa versa. Ook speciale karakters e.d. kunnen allen “escaped” worden met de backslash.

Eigenlijk is de backslash een onderdeel van RegEx. RegEx ofwel reguliere expressies worden volledig ondersteund in Python en worden mogelijk gemaakt middels de “re” module. Bij het schrijven van reguliere expressies in Python is het raadzaam om “raw strings” te gebruiken in plaats van gewone Python strings. Ruwe strings beginnen met een speciale prefix (r). Bij een ruwe string zal Python backslashes en andere speciale karakters in de string niet proberen te verwerken zodat deze direct geparsed worden aan de reguliere expressie (re) module.

Dit betekend dat een patroon, zoals “\ n \ w” niet wordt geïnterpreteerd en gewoon kan worden geschreven als “r \ n \ w” in plaats van “\\ n \\ w”. Dat is makkelijker om te schrijven en lezen.

In principe kunnen we binnen Python alle RegEx sympolen gebruiken zoals ook hier https://jarnobaselier.nl/reguliere-expressie-regular-expression-regexp-regex-re/ beschreven zijn. Hierbij een paar voorbeelden:

• [] – brackets
  Tussen brackets geven we de toegestane waardes op. [abc] betekend dus dat op die plek (1 karakter) een a, b of c moet staan om aan het filter te matchen. Het “-“ teken kan ook gebruikt worden als “tot en met” symbool. Dit is dus ook geldig: [a-c].
• \ – backslash
  De backslash is al besproken en is het “escape” karakter. Wil je dus zoeken op het symbool “*” (een RegEx wildcard) dan kun je \* gebruiken. Zoek je op de backslash dan gebruik je “\\”.
• ^ – dakje
  Het dakje (tussen brackets) betekend “alles behalve”. Dus [^a-z] betekend alles behalve de letters a tot en met z.
• . – punt
  Een punt betekend een willekeurig karakter (behalve \n).
• * – sterretje
  Het sterretje betekend dat het voorgaande karakter 0x of vaker voor mag komen. “123*” kan dus zijn “12”, “123”, “1233”, “12333”, “123333” etc.
• + – plus
  Het plusteken betekend dat het voorgaande karakter 1x of vaker voor mag komen. “123+” kan dus zijn “123”, “1233”, “12333”, “123333” etc. maar niet “12”.
• ? – vraagteken
  Het vraagteken wil zeggen dat het voorgaande karakter maximaal 1x voor mag komen. Dus “123?” kan “123” en “12” zijn.
• \n
  Een nieuwe lijn / witregel
• \d
  Elk decimaal teken, dus hetzelfde als [0-9]
• \D
  Geen decimaal teken, dus hetzelfde als [^0-9]
• \s
  Elk whitespace karakter, dus hetzelfde als [ \t\n\r\f\v]
• \S
  Geen whitespace karakter, dus hetzelfde als [^ \t\n\r\f\v]
• \t
  Een tab
• \w
  Elk alfanumeriek karakter, dus hetzelfde als [a-zA-Z0-9_]
• \W
  Geen alfanumeriek karakter, dus hetzelfde als [^a-zA-Z0-9_]

Hier een RegEx voorbeeld in Python:

import re
regex = re.compile("[a-zA-Z]+" "[0-9]+" "[a-z]*")
 
str = "Xcddddddddc8dddd"
print(regex.match(str).group())

In dit simpele voorbeeld zien we de volgende zaken:

1. We importeren de re module zodat we regex kunnen gebruiken.
2. We definieren een regex mask welke we “regex” noemen.
3. We plaatsen een willekeurige string/
4. We matchen de string aan de regex mask en printen de uitkomst.

Als we dit voorbeeld uitbreiden dan zien we het volgende:

import re
regex1 = re.compile("[a-zA-Z]")
regex2 = re.compile("[a-zA-Z]+" "[0-9]")
regex3 = re.compile("[a-zA-Z]+" "[0-9]+" "[a-z]*")
regex4 = re.compile("[a-zA-Z]+" "[0-9]+" "[a-zA-Z]*")
 
str = "Ikben1grootfanvanPython"
print(regex1.match(str).group())
print(regex2.match(str).group())
print(regex3.match(str).group())
print(regex4.match(str).group())

De 1e mask matched alleen het 1e karakter omdat deze overeenkomt met een kleine letter of een hoofdletter [a-zA-Z]. De 2e mask gaat door t/m het 1e cijfer [a-zA-Z]+” “[0-9]. De derde mask gaat door tot de hoofdletter [a-zA-Z]+” “[0-9]+” “[a-z]* en de laatste mask matched met de gehele string [a-zA-Z]+” “[0-9]+” “[a-zA-Z]*.

In bovenstaande voorbeeld gebruik ik “print(regex4.match(str).group())” i.p.v. “print(regex1.match(str))” zodat we ook werkelijk de string te zien krijgen die gematched i.p.v het gegeven of er een match is of niet (none).

Bovenstaande match functie controleert of een string matched op een RegEx mask. I.p.v. “match” kunnen we ook “search” gebruiken voor het zoeken naar een specifiek stukje tekst. Bijvoorbeeld:

import re
regex1 = re.compile("[*1*]")
 
str = "Ikben1grootfanvanPython"
print(regex1.search(str).group())

Als we bovenstaande verbeteren dan kunnen we zelfs zoeken en vervangen met de re.sub functie. In onderstaande voorbeeld vervangen we alle e’s en o’s voor een “a”.

import re
 
string = "Dit is een voorbeeld"
 
replaced = re.sub('[eo]', 'a', string)
 
print (replaced)

Conclusie

Dat is al aardig pittig toch? In de volgende post gaan we een ander essentieel onderdeel bespreken, namelijk de loops. Na de volgende post zal je zelf in staat zijn om al aardig te scripten in Python. Tot de volgende post!