Leer Geneste Functies, Omkeren en Samenvoegen van Strings | Geavanceerde Reguliere Expressies en Toepassingen

Veeg om het menu te tonen

In dit hoofdstuk ontdek je hoe je de kracht van reguliere expressies kunt benutten in geavanceerde Python-scenario's, waaronder werken met geneste functies, strings omkeren en strings samenvoegen. Deze technieken stellen je in staat om tekstgegevens efficiënter en flexibeler te manipuleren en analyseren, waardoor nieuwe mogelijkheden ontstaan voor automatisering, opschonen van data en complexe patroonherkenning.

Je leert hoe reguliere expressies kunnen:

De functionaliteit van geneste functies verbeteren voor het extraheren of transformeren van data;
Het proces van het omkeren van strings vereenvoudigen op basis van specifieke patronen;
Dynamisch en aanpasbaar samenvoegen van strings mogelijk maken met patroon-gebaseerde regels.

Het beheersen van deze toepassingen helpt je om meer beknopte, leesbare en krachtige Python-code te schrijven voor uiteenlopende praktische taken, van het verwerken van logbestanden tot het bouwen van datapijplijnen.

Reguliere expressies gebruiken binnen geneste functies

Wanneer je reguliere expressies in Python gebruikt, definieer je vaak patronen en zoeklogica binnen functies. Soms is het nodig om reguliere expressies te gebruiken binnen geneste functies — functies die binnen andere functies zijn gedefinieerd. Begrijpen hoe scope en toegang tot variabelen in deze context werken, helpt je om duidelijke, herbruikbare code te schrijven.

Definitie: Geneste functies

Een geneste functie is een functie die binnen een andere functie is gedefinieerd. De binnenste functie heeft toegang tot variabelen van de omringende functie dankzij Python’s lexicale scope (ook wel closure genoemd).

Scope en reguliere expressies

De binnenste functie kan reguliere expressiepatronen en gecompileerde objecten gebruiken die in de buitenste functie zijn gedefinieerd;
Je kunt reguliere expressie-matches of resultaten van de buitenste naar de binnenste functie doorgeven voor verdere verwerking;
Het compileren van een regexpatroon in de buitenste functie verhoogt de efficiëntie als de binnenste functie hetzelfde patroon meerdere keren gebruikt.

Praktisch voorbeeld: Data filteren en extraheren

Stel dat je een lijst met e-mailadressen wilt verwerken, waarbij je alleen de geldige selecteert en het gebruikersnaamgedeelte extraheert. Je kunt een geneste functie gebruiken om de extractielogica te kapselen:

import re

def filter_and_extract_usernames(emails):
    pattern = re.compile(r"([\w.-]+)@[\w.-]+\.\w+")
    
    def extract_username(email):
        match = pattern.match(email)
        if match:
            return match.group(1)
        return None
    
    usernames = []
    for email in emails:
        username = extract_username(email)
        if username:
            usernames.append(username)
    return usernames

emails = [
    "alice.smith@example.com",
    "bob99@invalid",
    "carol.jones@domain.org"
]

print(filter_and_extract_usernames(emails))
# Output: ['alice.smith', 'carol.jones']

Belangrijke punten:

Het pattern wordt één keer gecompileerd in de buitenste functie en hergebruikt in de geneste extract_username functie;
De binnenste functie heeft toegang tot het regexpatroon uit de omringende scope;
Deze structuur houdt de code georganiseerd en efficiënt, vooral bij het verwerken van complexe data parsing taken.

Reguliere expressies gebruiken binnen geneste functies is een krachtige techniek voor het bouwen van modulaire, onderhoudbare code die tekstgegevens efficiënt verwerkt.


              123456789101112131415
            
import re

def find_and_replace(text, pattern, replacement):
    def inner_replace():
        # Use re.sub to replace all matches of the pattern in the text
        result = re.sub(pattern, replacement, text)
        return result
    return inner_replace()

sample_text = "The rain in Spain stays mainly in the plain."
pattern = r"ain"
replacement = "###"

result = find_and_replace(sample_text, pattern, replacement)
print(result)

Strings omkeren in Python

Het omkeren van een string is een veelvoorkomende taak bij het verwerken van tekstgegevens. Python biedt een eenvoudige manier om strings om te keren met slicing, en je kunt dit ook combineren met reguliere expressies voor geavanceerde tekstmanipulatie.

Hoe een string om te keren

Je kunt elke string in Python omkeren met slicing:

text = "Hello, world!"
reversed_text = text[::-1]
print(reversed_text)  # Output: !dlrow ,olleH

Toelichting:

text[::-1] maakt een nieuwe string door alle tekens uit text in omgekeerde volgorde te nemen.

Gebruiksscenario's

Het omkeren van strings is nuttig in verschillende situaties:

Controleren of een string een palindroom is;
Het verbergen van gevoelige informatie door deze achterstevoren weer te geven;
Creëren van leuke teksteffecten voor gebruikersinterfaces.

Regex combineren met stringomkering

Je kunt reguliere expressies gebruiken om specifieke patronen in een string te vinden en vervolgens alleen die delen om te keren. Dit is handig wanneer je bepaalde woorden of patronen wilt omkeren, niet de hele string.

Voorbeeld: Alle woorden die met een hoofdletter beginnen omkeren

import re

def reverse_capital_words(text):
    def reverse_match(match):
        return match.group()[::-1]
    # Find all words starting with a capital letter
    pattern = r'\b[A-Z][a-zA-Z]*\b'
    return re.sub(pattern, reverse_match, text)

sentence = "Alice and Bob went to Wonderland."
result = reverse_capital_words(sentence)
print(result)  # Output: "ecilA and boB went to .dnalrednoW"

Werking:

Het regex-patroon \b[A-Z][a-zA-Z]*\b vindt woorden die met een hoofdletter beginnen.
De functie reverse_match keert elk gevonden woord om.
re.sub vervangt elke match door de omgekeerde versie.

Het combineren van reguliere expressies met stringomkering maakt het mogelijk om complexe teksttransformaties op een beknopte en flexibele manier uit te voeren.


              123456789101112131415161718
            
import re

# Original string
txt = "Python 3.12 is powerful!"

# Reverse the string
reversed_txt = txt[::-1]
print("Reversed string:", reversed_txt)

# Regex pattern to find all sequences of digits in the reversed string
pattern = r"\\d+"
digits = re.findall(pattern, reversed_txt)
print("Digits found in reversed string:", digits)

# Regex pattern to find all words in the reversed string
word_pattern = r"[A-Za-z]+"
words = re.findall(word_pattern, reversed_txt)
print("Words found in reversed string:", words)

Strings samenvoegen in Python

Het samenvoegen van strings is een veelvoorkomende taak bij het werken met tekstgegevens. Vaak is het nodig om meerdere strings tot één te combineren, zoals het samenvoegen van woorden, regels of resultaten van een reguliere expressie-zoekopdracht.

Gebruik van `join()` om een lijst van strings te combineren

De methode str.join() is de standaardmanier om een lijst van strings samen te voegen tot één string. Je geeft een scheidingsteken op en roept join() daarop aan met de lijst die je wilt combineren.

words = ['Python', 'is', 'fun']
sentence = ' '.join(words)
print(sentence)  # Output: Python is fun

Belangrijke punten over join():

Het scheidingsteken (zoals een spatie, komma of nieuwe regel) komt vóór .join();
Het argument van join() moet een iterabele van strings zijn (zoals een lijst of tuple);
Het resultaat is één string met alle items, gescheiden door het gekozen scheidingsteken.

Regex-matches samenvoegen tot één string

Wanneer je de functie re.findall() gebruikt, krijg je een lijst met alle niet-overlappende matches. Je kunt join() gebruiken om deze matches samen te voegen tot één string.

import re

text = 'cat, dog, bat, rat'
animals = re.findall(r'\w{3}', text)
all_animals = ', '.join(animals)
print(all_animals)  # Output: cat, dog, bat, rat

Veelvoorkomende toepassingen:

Alle regex-matches samenvoegen tot een door komma's gescheiden string;
Regels tekst samenvoegen tot één blok;
CSV-regels maken van lijsten met waarden.

Efficiënt samenvoegen van strings helpt bij het verwerken, weergeven en opslaan van tekstgegevens op een leesbare en gestructureerde manier.


              12345678910111213141516171819202122
            
import re

# Joining a list of strings with a space
words = ["Python", "Regular", "Expressions"]
joined_words = " ".join(words)
print("Joined list:", joined_words)

# Using regex to extract all words starting with a capital letter
text = "Alice and Bob are learning Regular Expressions in Python."
pattern = r"\\b[A-Z][a-z]+\\b"
capitalized_words = re.findall(pattern, text)
print("Capitalized words:", capitalized_words)

# Joining regex match groups with a hyphen
joined_matches = "-".join(capitalized_words)
print("Hyphen-joined matches:", joined_matches)

# Using regex groups and joining them
match = re.match(r"(\\w+) (\\w+)", "Hello World")
if match:
    groups_joined = ", ".join(match.groups())
    print("Groups joined:", groups_joined)

1. Wat is een geneste functie in Python en hoe kan deze nuttig zijn bij het werken met reguliere expressies

2. Welke Python-methode wordt vaak gebruikt om een lijst van strings samen te voegen tot één string, en hoe kan deze worden gecombineerd met regex-matches

Was alles duidelijk?

Bedankt voor je feedback!

Sectie 3. Hoofdstuk 6

Vraag AI

Vraag wat u wilt of probeer een van de voorgestelde vragen om onze chat te starten.