Python Regular Expression-tutorial

Regular expressions, vaak afgekort tot regex, zijn een reeks tekens waarmee je controleert of een patroon in een gegeven tekst (string) voorkomt of niet. Als je ooit zoekmachines, zoek-en-vervang-tools van tekstverwerkers en editors hebt gebruikt, heb je regular expressions al in actie gezien. Ze worden aan de serverkant gebruikt om tijdens registratie het formaat van e-mailadressen of wachtwoorden te valideren, voor het parsen van tekstbestanden om bepaalde strings te vinden, te vervangen of te verwijderen, enzovoort. Ze helpen bij het manipuleren van tekstuele data, wat vaak een vereiste is voor data science-projecten met text mining.

In deze tutorial loop je door de belangrijkste concepten van regular expressions met Python. Je begint met het importeren van re – de Python-bibliotheek die regular expressions ondersteunt. Daarna zie je hoe basis-/gewone tekens worden gebruikt om matches uit te voeren, gevolgd door wildcards of speciale tekens. Vervolgens leer je hoe je herhalingen gebruikt in je regular expressions. Je leert ook hoe je groepen en benoemde groepen maakt binnen je zoekopdracht, zodat je matches makkelijker kunt benaderen. Daarna maak je kennis met het concept greedy vs. non-greedy matching.

Dat lijkt al best veel, en daarom is er een handige samenvattende tabel opgenomen om je te helpen onthouden wat je tot nu toe hebt gezien, met korte definities. Zeker even bekijken!

Deze tutorial behandelt ook een aantal zeer nuttige functies uit de re-bibliotheek, zoals: compile(), search(), findall(), sub() voor zoeken en vervangen, split(), en meer. Je leert ook over compilatievlaggen die je kunt gebruiken om je regex te verbeteren.

Tot slot is er een case study – waar je je kennis in de praktijk brengt! Dus laten we gaan regexen…

Regular expressions in Python

In Python worden regular expressions ondersteund door de re-module. Dat betekent dat je deze module moet importeren met import als je ze in je Python-scripts wilt gebruiken:

import re

De re-bibliotheek in Python biedt verschillende functies die het de moeite waard maken om onder de knie te krijgen. Een aantal daarvan bekijk je van dichtbij in deze tutorial.

Basispatronen: gewone tekens

Veel basispatronen kun je in Python eenvoudig afhandelen met gewone tekens. Gewone tekens zijn de simpelste regular expressions. Ze matchen precies zichzelf en hebben geen speciale betekenis in de regex-syntax.

Voorbeelden zijn 'A', 'a', 'X', '5'.

Gewone tekens kun je gebruiken voor simpele exacte matches:

pattern = r"Cookie"
sequence = "Cookie"
if re.match(pattern, sequence):
    print("Match!")
else: print("Not a match!")

Match!

De meeste letters en tekens matchen zichzelf, zoals je in het voorbeeld zag.

De functie match() geeft een match-object terug als de tekst overeenkomt met het patroon. Anders geeft hij None terug. De module re bevat ook verschillende andere functies, en een aantal daarvan leer je later in de tutorial.

Laten we ons nu richten op gewone tekens!

Valt je de r op aan het begin van het patroon Cookie?
Dit heet een ruwe stringliteral (raw string literal). Het verandert hoe de stringliteral wordt geïnterpreteerd. Zulke literals worden opgeslagen zoals ze verschijnen.

Zo is \ gewoon een backslash als het wordt voorafgegaan door een r, in plaats van als een escape-sequentie te worden geïnterpreteerd. Je zult zien wat dit betekent bij speciale tekens. Soms bevat de syntax backslash-geëscape-tekens, en om te voorkomen dat deze als escape-sequenties worden geïnterpreteerd, gebruik je het ruwe r-voorvoegsel.

TIP: Je hebt het in dit voorbeeld niet per se nodig; toch is het goed om het uit gewoonte te gebruiken voor consistentie.

Wildcards: speciale tekens

Speciale tekens matchen niet zichzelf zoals je ze ziet, maar hebben een speciale betekenis wanneer ze in een regular expression worden gebruikt. Simpel gezegd kun je ze zien als gereserveerde metatekens die iets anders aanduiden dan hoe ze eruitzien.

Laten we wat voorbeelden bekijken om speciale tekens in actie te zien…

Maar voordat je dat doet: de voorbeelden hieronder maken gebruik van twee functies, namelijk: search() en group().
Met de search-functie doorzoek je de gegeven string/sequentie op de eerste locatie waar de regular expression een match oplevert.
De group-functie geeft de string terug die door de regex is gematcht. Je ziet beide functies later uitgebreider.

Terug naar de speciale tekens.

. - Een punt. Matcht elk enkel teken behalve de regeleindeteken (newline).

re.search(r'Co.k.e', 'Cookie').group()

'Cookie'

^ - Een dakje. Matcht het begin van de string.

Handig als je zeker wilt weten dat een document/zin met bepaalde tekens begint.

re.search(r'^Eat', "Eat cake!").group()

## However, the code below will not give the same result. Try it for yourself:
# re.search(r'^eat', "Let's eat cake!").group()

'Eat'

$ - Matcht het einde van de string.

Handig als je zeker wilt weten dat een document/zin met bepaalde tekens eindigt.

re.search(r'cake$', "Cake! Let's eat cake").group()

## The next search will return the NONE value, try it:
# re.search(r'cake$', "Let's get some cake on our way home!").group()

'cake'

[abc] - Matcht a of b of c.
[a-zA-Z0-9] - Matcht elke letter van (a tot z) of (A tot Z) of (0 tot 9).

TIP: Tekens die niet binnen een bereik vallen, kun je matchen door de set te complementeren. Als het eerste teken van de set ^ is, worden alle tekens die niet in de set zitten gematcht.

re.search(r'[0-6]', 'Number: 5').group()

'5'

## Matches any character except 5
re.search(r'Number: [^5]', 'Number: 0').group()

## This will not match and hence a NONE value will be returned
#re.search(r'Number: [^5]', 'Number: 5').group()

'Number: 0'

\ - Backslash.
Waarschijnlijk het meest veelzijdige metateken!

• Als het teken na de backslash een herkende escape-tekensequentie is, wordt de speciale betekenis daarvan gebruikt (Scenario 1)
• Als het teken na de \ geen herkende escape-tekensequentie is, dan wordt de \ behandeld als elk ander teken en gewoon doorgegeven (Scenario 2).
• \ kan voor alle metatekens worden gezet om hun speciale betekenis te verwijderen (Scenario 3).

## (Scenario 1) This treats '\s' as an escape character, '\s' defines a space
re.search(r'Not a\sregular character', 'Not a regular character').group()

'Not a regular character'

## (Scenario 2) '\' is treated as an ordinary character, because '\r' is not a recognized escape character
re.search(r'Just a \regular character', 'Just a \regular character').group()

'Just a \regular character'

## (Scenario 3) '\s' is escaped using an extra `\` so its interpreted as a literal string '\s'
re.search(r'Just a \\sregular character', 'Just a \sregular character').group()

'Just a \\sregular character'

Er is een vooraf gedefinieerde set speciale reeksen die beginnen met '\' en ook erg handig zijn bij zoeken en matchen. Laten we er een paar van dichtbij bekijken…

\w - Kleine letter 'w'. Matcht elke enkele letter, cijfer of underscore.
\W - Hoofdletter 'W'. Matcht elk teken dat geen deel uitmaakt van \w (kleine w).

print("Lowercase w:", re.search(r'Co\wk\we', 'Cookie').group())

## Matches any character except single letter, digit or underscore
print("Uppercase W:", re.search(r'C\Wke', 'C@ke').group())

## Uppercase W won't match single letter, digit
print("Uppercase W won't match, and return:", re.search(r'Co\Wk\We', 'Cookie'))

Lowercase w: Cookie
Uppercase W: C@ke
Uppercase W won't match, and return: None

\s - Kleine 's'. Matcht één witruimte-teken zoals: spatie, newline, tab, return.
\S - Hoofdletter 'S'. Matcht elk teken dat geen deel uitmaakt van \s (kleine s).

print("Lowercase s:", re.search(r'Eat\scake', 'Eat cake').group())
print("Uppercase S:", re.search(r'cook\Se', "Let's eat cookie").group())

Lowercase s: Eat cake
Uppercase S: cookie

\d - Kleine d. Matcht decimaal cijfer 0-9.
\D - Hoofdletter d. Matcht elk teken dat geen decimaal cijfer is.

# Example for \d
print("How many cookies do you want? ", re.search(r'\d+', '100 cookies').group())

How many cookies do you want?  100

Het symbool + na \d in het voorbeeld hierboven wordt gebruikt voor herhaling. Je ziet dit later uitgebreider in de sectie herhalingen…

\t - Kleine t. Matcht tab.
\n - Kleine n. Matcht newline.
\r - Kleine r. Matcht return.
\A - Hoofdletter a. Matcht alleen aan het begin van de string. Werkt ook over meerdere regels.
\Z - Hoofdletter z. Matcht alleen aan het einde van de string.
TIP: ^ en \A zijn in wezen hetzelfde, net als $ en \Z. Behalve bij MULTILINE-modus. Lees er meer over in de sectie vlaggen.

\b - Kleine b. Matcht alleen het begin of einde van het woord.

# Example for \t
print("\\t (TAB) example: ", re.search(r'Eat\tcake', 'Eat    cake').group())

# Example for \b
print("\\b match gives: ",re.search(r'\b[A-E]ookie', 'Cookie').group())

\t (TAB) example:  Eat    cake
\b match gives:  Cookie

Herhalingen

Het wordt behoorlijk omslachtig als je lange patronen in een sequentie wilt vinden. Gelukkig handelt de re-module herhalingen af met de volgende speciale tekens:

+ - Controleert of het voorafgaande teken één of meer keer voorkomt vanaf die positie.

re.search(r'Co+kie', 'Cooookie').group()

'Cooookie'

* - Controleert of het voorafgaande teken nul of meer keer voorkomt vanaf die positie.

# Checks for any occurrence of a or o or both in the given sequence
re.search(r'Ca*o*kie', 'Cookie').group()

'Cookie'

? - Controleert of het voorafgaande teken exact nul of één keer voorkomt vanaf die positie.

# Checks for exactly zero or one occurrence of a or o or both in the given sequence
re.search(r'Colou?r', 'Color').group()

'Color'

Maar wat als je wilt controleren op een exact aantal herhalingen van een sequentie?

Bijvoorbeeld het controleren van de geldigheid van een telefoonnummer in een applicatie. De module re kan dit ook heel netjes afhandelen met de volgende regular expressions:

{x} - Herhaal exact x keer.
{x,} - Herhaal minstens x keer of meer.
{x, y} - Herhaal minstens x keer maar niet meer dan y keer.

re.search(r'\d{9,10}', '0987654321').group()

'0987654321'

De kwalificatoren + en * worden greedy genoemd. Je ziet later wat dit betekent.

Groeperen in regular expressions

Met de group-functionaliteit van regular expressions kun je delen van de gematchte tekst oppakken. Delen van een regex-patroon tussen haakjes () heten groepen. De haakjes veranderen niet wat de expressie matcht, maar vormen groepen binnen de gematchte sequentie. Je gebruikt de functie group() al de hele tutorial in de voorbeelden. De kale match.group() zonder argument is, zoals gebruikelijk, nog steeds de volledige gematchte tekst.

Laten we dit concept met een eenvoudig voorbeeld begrijpen. Stel, je valideert e-mailadressen en wilt de gebruikersnaam en host controleren. Dan wil je aparte groepen binnen je gematchte tekst maken.

statement = 'Please contact us at: support@datacamp.com'
match = re.search(r'([\w\.-]+)@([\w\.-]+)', statement)
if statement:
  print("Email address:", match.group()) # The whole matched text
  print("Username:", match.group(1)) # The username (group 1)
  print("Host:", match.group(2)) # The host (group 2)

Email address: support@datacamp.com
Username: support
Host: datacamp.com

Een andere manier om hetzelfde te doen is met het gebruik van <>-haken. Hiermee maak je benoemde groepen. Benoemde groepen maken je code leesbaarder. De syntax voor het maken van een benoemde groep is: (?P<name>...). Vervang het deel name door de naam die je aan je groep wilt geven. De ... staat voor de rest van de matchingsyntax. Zie dit in actie met hetzelfde voorbeeld als hiervoor…

statement = 'Please contact us at: support@datacamp.com'
match = re.search(r'(?P<email>(?P<username>[\w\.-]+)@(?P<host>[\w\.-]+))', statement)
if statement:
  print("Email address:", match.group('email'))
  print("Username:", match.group('username'))
  print("Host:", match.group('host'))

Email address: support@datacamp.com
Username: support
Host: datacamp.com

TIP: Je kunt altijd toegang krijgen tot benoemde groepen met nummers in plaats van met de naam. Maar naarmate het aantal groepen toeneemt, wordt het moeilijker om ze alleen met nummers te beheren. Maak er dus een gewoonte van om benoemde groepen te gebruiken.

Greedy vs. non-greedy matching

Wanneer een speciaal teken zoveel mogelijk van de zoeksequentie (string) matcht, heet dat een "greedy match". Dit is het normale gedrag van een regular expression, maar soms is dit niet gewenst:

pattern = "cookie"
sequence = "Cake and cookie"

heading  = r'<h1>TITLE</h1>'
re.match(r'<.*>', heading).group()

'<h1>TITLE</h1>'

Het patroon <.*> matchte de hele string, tot aan de tweede keer dat > voorkwam.

Als je echter alleen de eerste <h1>-tag wilde matchen, kun je de non-greedy kwalificator *? gebruiken, die zo weinig mogelijk tekst matcht.

Door ? na de kwalificator toe te voegen, laat je de match non-greedy of minimaal verlopen; dat wil zeggen, er worden zo min mogelijk tekens gematcht. Als je <.*?> draait, krijg je alleen een match met <h1>.

heading  = r'<h1>TITLE</h1>'
re.match(r'<.*?>', heading).group()

'<h1>'

Samenvattende tabel

Je bent al een heel eind gekomen met regular expressions. Het is veel informatie en concepten om te verwerken! De volgende tabel vat alles samen wat je tot nu toe in deze tutorial hebt gezien. Geen zorgen als je nog niet alle metatekens kunt plaatsen. Met tijd en oefening ga je de eigenheid van deze tekens zien en leer je wanneer je wat gebruikt…

Deze tutorial bespreekt niet alle speciale reeksen die Python biedt. Bekijk de referentie van de standaardbibliotheek voor een volledige lijst.

Je hebt de basis van regex te pakken! Er zijn echter nog meer concepten die je kunnen helpen om prachtige regular expressions te maken voor zoeken en matchen.

TIP: Hoewel regular expressions erg krachtig en nuttig zijn, pas op voor lange, verwarrende expressies die voor anderen – en ook voor jezelf – lastig te begrijpen en te onderhouden zijn.

Functies geleverd door 're'

De re-bibliotheek in Python biedt verschillende functies om je taken makkelijker te maken. Je hebt er al een paar gezien, zoals re.search(), re.match(). Laten we verder kijken…

compile(pattern, flags=0)

Regular expressions worden door Python als strings behandeld. Met compile() kun je echter een regex-patroon compileren tot een regular expression-object. Als je een expressie meerdere keren in één programma moet gebruiken, is het efficiënter om compile() te gebruiken en het resulterende object te hergebruiken dan het als string op te slaan. Dit komt doordat de gecompileerde versies van de meest recente patronen die aan compile() en de functies op module-niveau zijn doorgegeven, in cache worden gehouden.

pattern = re.compile(r"cookie")
sequence = "Cake and cookie"
pattern.search(sequence).group()

'cookie'

# This is equivalent to:
re.search(pattern, sequence).group()

'cookie'

search(pattern, string, flags=0)

Met deze functie doorzoek je de gegeven string/sequentie op de eerste locatie waar de regex een match oplevert. Als deze wordt gevonden, retourneert hij een corresponderend match-object; anders None als geen enkele positie in de string met het patroon overeenkomt. Let op dat None iets anders is dan het vinden van een match met lengte nul op een bepaald punt in de string.

pattern = "cookie"
sequence = "Cake and cookie"

re.search(pattern, sequence)

<re.Match object; span=(9, 15), match='cookie'>

match(pattern, string, flags=0)

Retourneert een corresponderend match-object als nul of meer tekens aan het begin van de string met het patroon overeenkomen. Anders geeft hij None terug als de string niet overeenkomt met het gegeven patroon.

pattern = "C"
sequence1 = "IceCream"
sequence2 = "Cake"

# No match since "C" is not at the start of "IceCream"
print("Sequence 1: ", re.match(pattern, sequence1))
print("Sequence 2: ", re.match(pattern,sequence2).group())

Sequence 1:  None
Sequence 2:  C

search() versus match()

De functie match() controleert standaard alleen op een match aan het begin van de string, terwijl search() overal in de string op een match controleert.

findall(pattern, string, flags=0)

Vindt alle mogelijke matches in de volledige sequentie en retourneert ze als een lijst met strings. Elke geretourneerde string stelt één match voor.

statement = "Please contact us at: support@datacamp.com, xyz@datacamp.com"

#'addresses' is a list that stores all the possible match
addresses = re.findall(r'[\w\.-]+@[\w\.-]+', statement)
for address in addresses:
    print(address)

support@datacamp.com
xyz@datacamp.com

finditer(string, [position, end_position])

Vergelijkbaar met findall() – het vindt alle mogelijke matches in de hele sequentie maar retourneert regex match-objecten als een iterator.

TIP: finditer() kan een uitstekende keuze zijn als je meer informatie over je zoekresultaten wilt. Het geretourneerde regex match-object bevat niet alleen de gematchte sequentie, maar ook hun posities in de oorspronkelijke tekst.

statement = "Please contact us at: support@datacamp.com, xyz@datacamp.com"

#'addresses' is a list that stores all the possible match
addresses = re.finditer(r'[\w\.-]+@[\w\.-]+', statement)
for address in addresses:
    print(address)

<re.Match object; span=(22, 42), match='support@datacamp.com'>
<re.Match object; span=(44, 60), match='xyz@datacamp.com'>

sub(pattern, repl, string, count=0, flags=0)
subn(pattern, repl, string, count=0)

sub() is de substitute-functie. Deze retourneert de string die wordt verkregen door de meest linkse, niet-overlappende voorkomens van het patroon in de string te vervangen door repl. Als het patroon niet wordt gevonden, wordt de string ongewijzigd geretourneerd.

subn() lijkt op sub(). Het retourneert echter een tuple met de nieuwe stringwaarde en het aantal vervangingen dat in de tekst werd uitgevoerd.

statement = "Please contact us at: xyz@datacamp.com"
new_email_address = re.sub(r'([\w\.-]+)@([\w\.-]+)', r'support@datacamp.com', statement)
print(new_email_address)

Please contact us at: support@datacamp.com

split(string, [maxsplit = 0])

Dit splitst de string overal waar het patroon matcht en retourneert een lijst. Als het optionele argument maxsplit ongelijk is aan nul, dan wordt maximaal 'maxsplit' keer gesplitst.

statement = "Please contact us at: xyz@datacamp.com, support@datacamp.com"
pattern = re.compile(r'[:,]')

address = pattern.split(statement)
print(address)

['Please contact us at', ' xyz@datacamp.com', ' support@datacamp.com']

start() - Retourneert de startindex van de match.
end() - Retourneert de index waar de match eindigt.
span() - Retourneert een tuple met de (start-, eind-)posities van de match.

pattern = re.compile('COOKIE', re.IGNORECASE)
match = pattern.search("I am not a cookie monster")

print("Start index:", match.start())
print("End index:", match.end())
print("Tuple:", match.span())

Start index: 11
End index: 17
Tuple: (11, 17)

Compilatievlaggen

Merkte je de term re.IGNORECASE in het laatste voorbeeld op? Heb je door wat het belang ervan is?

Het gedrag van een expressie kan worden aangepast door een vlagwaarde te specificeren. Je kunt vlaggen toevoegen als extra argument aan de verschillende functies die je in deze tutorial hebt gezien. Enkele nuttige zijn:

IGNORECASE (I) - Maakt hoofdletterongevoelige matches mogelijk.
DOTALL (S) - Laat . elk teken matchen, inclusief newline.
MULTILINE (M) - Laat begin- (^) en einde- ($) ankers ook newlines matchen.
VERBOSE (X) - Hiermee kun je witruimte en commentaar in een regex schrijven om deze leesbaarder te maken.

statement = "Please contact us at: support@DataCamp.com, xyz@DATACAMP.com"

# Using the VERBOSE flag helps understand complex regular expressions
pattern = re.compile(r"""
[\w\.-]+ #First part
@ #Matches @ sign within email addresses
datacamp.com #Domain
""", re.X | re.I)

addresses = re.findall(pattern, statement)                       
for address in addresses:
    print("Address: ", address)

Address:  support@DataCamp.com
Address:  xyz@DATACAMP.com

TIP: Je kunt meerdere vlaggen ook combineren met bitwise OR |.

Case study: werken met regular expressions

Nu je hebt gezien hoe regular expressions in Python werken aan de hand van voorbeelden, is het tijd om zelf aan de slag te gaan! In deze case study zet je al je kennis in.

Je werkt met het eerste deel van een gratis e-boek getiteld "The Idiot", geschreven door Fjodor Dostojevski van Project Gutenberg. De roman gaat over prins (Knjaz) Lev Nikolajevitsj Mysjkin, een argeloze man wiens goede, vriendelijke, eenvoudige aard er ten onrechte toe leidt dat velen denken dat hij intelligentie en inzicht mist. De titel verwijst ironisch naar deze jonge man.

Je schrijft een aantal regular expressions om de tekst te parsen en enkele oefeningen te voltooien.

import re
import requests
the_idiot_url = 'https://www.gutenberg.org/files/2638/2638-0.txt'

def get_book(url):
    # Sends a http request to get the text from project Gutenberg
    raw = requests.get(url).text
    # Discards the metadata from the beginning of the book
    start = re.search(r"\*\*\* START OF THIS PROJECT GUTENBERG EBOOK .* \*\*\*",raw ).end()
    # Discards the text starting Part 2 of the book
    stop = re.search(r"II", raw).start()
    # Keeps the relevant text
    text = raw[start:stop]
    return text

def preprocess(sentence):
    return re.sub('[^A-Za-z0-9.]+' , ' ', sentence).lower()

book = get_book(the_idiot_url)
processed_book = preprocess(book)
#print(processed_book)

• Oefening: Vind het aantal keer dat het voornaamwoord "the" in het corpus voorkomt. Tip: gebruik de functie len().

len(re.findall(r'the', processed_book))

302

• Oefening: Probeer elke losstaande instantie van 'i' om te zetten naar 'I' in het corpus. Zorg dat je de 'i' die binnen een woord voorkomt niet verandert:

processed_book = re.sub(r'\si\s', " I ", processed_book)
#print(processed_book)

• Oefening: Hoe vaak is er iemand geciteerd ("") in het corpus?

len(re.findall(r'\”', book))

0

• Oefening: Welke woorden zijn verbonden door '--' in het corpus?
  Probeer dit zelf! Deel je antwoord gerust in de reacties hieronder.

Gefeliciteerd!

Je bent aan het einde gekomen van deze Python-regular expressions-tutorial! Er valt nog veel meer te ontdekken op je data science-reis met Python.

Regex kan een belangrijke rol spelen in de data-preprocessingfase. Bekijk DataCamps cursus Cleaning Data in Python. Deze cursus leert je manieren om je data beter te verkennen door deze op te schonen en op te maken voor data-analyse. Aan het eind zit ook een case study waarin je je kersverse kennis kunt toepassen.

Bekijk ook onze Python String Replace-tutorial.