Reguläre Ausdrucks-Erfassungsgruppen (Regular Expression Capture Groups) sind in Python leistungsstarke Werkzeuge zum Extrahieren und Bearbeiten von Textdaten. In diesem Lab lernen Sie die wesentlichen Techniken zur Verwendung von Erfassungsgruppen kennen und erhalten praktische Einblicke, wie diese fortschrittlichen Mustererkennungsmechanismen komplexe String-Parsing- und Datenextraktionsaufgaben vereinfachen können.
Erfassungsgruppen (Capture Groups) sind eine leistungsstarke Funktion in regulären Ausdrücken (Regular Expressions), mit der Sie bestimmte Teile eines übereinstimmenden Musters extrahieren und gruppieren können. In Python werden sie mit Klammern () innerhalb eines Regex-Musters definiert.
Beginnen wir mit der Erstellung eines Python-Skripts, um die grundlegende Verwendung von Erfassungsgruppen zu demonstrieren.
Öffnen Sie das integrierte Terminal in der WebIDE und navigieren Sie zum Projektverzeichnis, falls Sie sich noch nicht dort befinden.
cd ~/projectErstellen Sie eine neue Datei namens basic_capture.py mit dem Befehl touch.
touch basic_capture.pyÖffnen Sie basic_capture.py im WebIDE-Editor und fügen Sie den folgenden Python-Code hinzu:
import re
text = "Contact email: john.doe@example.com"
pattern = r"(\w+)\.(\w+)@(\w+)\.(\w+)"
match = re.search(pattern, text)
if match:
username = match.group(1)
lastname = match.group(2)
domain = match.group(3)
tld = match.group(4)
print(f"Username: {username}")
print(f"Lastname: {lastname}")
print(f"Domain: {domain}")
print(f"TLD: {tld}")
else:
print("No match found.")Speichern Sie die Datei.
Führen Sie nun das Skript mit dem Python-Befehl aus.
python basic_capture.pySie sollten die folgende Ausgabe sehen:
Username: john
Lastname: doe
Domain: example
TLD: comDiese Ausgabe zeigt, dass das Skript die verschiedenen Teile der E-Mail-Adresse mithilfe von Erfassungsgruppen erfolgreich extrahiert hat.
Sie können auch auf alle erfassten Gruppen als Tupel (tuple) mit der Methode groups() zugreifen. Ändern Sie die Datei basic_capture.py, um die folgenden Zeilen nach dem if match:-Block einzufügen:
all_groups = match.groups()
print(f"All groups: {all_groups}")Speichern Sie die Datei und führen Sie das Skript erneut aus.
python basic_capture.pyDie Ausgabe enthält nun das Tupel aller erfassten Gruppen:
Username: john
Lastname: doe
Domain: example
TLD: com
All groups: ('john', 'doe', 'example', 'com')Dies demonstriert, wie man grundlegende Erfassungsgruppen verwendet und auf die erfassten Daten zugreift.
Benannte Erfassungsgruppen bieten eine lesbarere Möglichkeit, auf erfasste Daten zuzugreifen, indem jeder Gruppe ein Name zugewiesen wird. Die Syntax für eine benannte Erfassungsgruppe lautet (?P<name>...).
Erstellen wir ein neues Python-Skript, um benannte Erfassungsgruppen zu demonstrieren.
Erstellen Sie eine neue Datei namens named_capture.py im Verzeichnis ~/project.
touch ~/project/named_capture.pyÖffnen Sie named_capture.py im WebIDE-Editor und fügen Sie den folgenden Python-Code hinzu:
import re
text = "Product: Laptop, Price: $999.99"
pattern = r"Product: (?P<product>\w+), Price: \$(?P<price>\d+\.\d+)"
match = re.search(pattern, text)
if match:
product = match.group('product')
price = match.group('price')
print(f"Product: {product}, Price: ${price}")
else:
print("No match found.")Speichern Sie die Datei.
Führen Sie das Skript mit dem Python-Befehl aus.
python ~/project/named_capture.pySie sollten die folgende Ausgabe sehen:
Product: Laptop, Price: $999.99Diese Ausgabe zeigt, dass das Skript den Produktnamen und den Preis mithilfe von benannten Erfassungsgruppen erfolgreich extrahiert hat. Sie können auf die erfassten Daten zugreifen, indem Sie den Gruppennamen als Schlüssel in der group()-Methode verwenden.
Benannte Erfassungsgruppen machen Ihre Regex-Muster (Regular Expression Patterns) und den nachfolgenden Code verständlicher, insbesondere bei komplexen Mustern mit vielen Erfassungsgruppen.
Erfassungsgruppen werden häufig zur Datenextraktion aus verschiedenen Textformaten wie Protokolldateien (Log Files), URLs und strukturierten Daten verwendet.
Erstellen wir ein Skript, um einen Protokolleintrag (Log Entry) mithilfe von Erfassungsgruppen zu parsen.
Erstellen Sie eine neue Datei namens log_parser.py im Verzeichnis ~/project.
touch ~/project/log_parser.pyÖffnen Sie log_parser.py im WebIDE-Editor und fügen Sie den folgenden Python-Code hinzu:
import re
log_entry = '2023-06-15 14:30:45 [ERROR] Database connection failed'
pattern = r'(\d{4}-\d{2}-\d{2}) (\d{2}:\d{2}:\d{2}) \[(\w+)\] (.+)'
match = re.match(pattern, log_entry)
if match:
date = match.group(1)
time = match.group(2)
log_level = match.group(3)
message = match.group(4)
print(f"Date: {date}")
print(f"Time: {time}")
print(f"Level: {log_level}")
print(f"Message: {message}")
else:
print("No match found.")Speichern Sie die Datei.
Führen Sie das Skript mit dem Python-Befehl aus.
python ~/project/log_parser.pySie sollten die folgende Ausgabe sehen:
Date: 2023-06-15
Time: 14:30:45
Level: ERROR
Message: Database connection failedDieses Skript hat den Protokolleintrag erfolgreich geparst und Datum, Uhrzeit, Protokollebene (Log Level) und Nachricht mithilfe von Erfassungsgruppen extrahiert.
Ein weiterer häufiger Anwendungsfall ist das Extrahieren von Informationen aus URLs. Erstellen Sie eine neue Datei namens url_parser.py im Verzeichnis ~/project.
touch ~/project/url_parser.pyÖffnen Sie url_parser.py und fügen Sie den folgenden Code hinzu:
import re
def parse_url(url):
pattern = r'(https?://)?([^/]+)(/.*)?'
match = re.match(pattern, url)
if match:
protocol = match.group(1) or 'http://'
domain = match.group(2)
path = match.group(3) or '/'
return {
'protocol': protocol,
'domain': domain,
'path': path
}
return None
## Example usage
url = 'https://www.example.com/path/to/page'
parsed_url = parse_url(url)
if parsed_url:
print(f"Protocol: {parsed_url['protocol']}")
print(f"Domain: {parsed_url['domain']}")
print(f"Path: {parsed_url['path']}")
else:
print("Invalid URL format.")
url_no_protocol = 'example.org/another/path'
parsed_url_no_protocol = parse_url(url_no_protocol)
if parsed_url_no_protocol:
print(f"\nProtocol: {parsed_url_no_protocol['protocol']}")
print(f"Domain: {parsed_url_no_protocol['domain']}")
print(f"Path: {parsed_url_no_protocol['path']}")
else:
print("\nInvalid URL format.")Speichern Sie die Datei.
Führen Sie das Skript aus.
python ~/project/url_parser.pyDie Ausgabe zeigt die geparsten Komponenten der URLs:
Protocol: https://
Domain: www.example.com
Path: /path/to/page
Protocol: http://
Domain: example.org
Path: /another/pathDiese Beispiele demonstrieren die praktische Anwendung von Erfassungsgruppen beim Extrahieren strukturierter Daten aus Text.
Über die grundlegenden Erfassungsgruppen hinaus bietet Python Regex (reguläre Ausdrücke) erweiterte Funktionen wie verschachtelte Erfassungsgruppen, nicht-erfassende Gruppen und Lookarounds.
Erfassungsgruppen können innerhalb anderer Erfassungsgruppen verschachtelt werden, um detailliertere Informationen zu extrahieren.
Erstellen Sie eine neue Datei namens nested_capture.py im Verzeichnis ~/project.
touch ~/project/nested_capture.pyÖffnen Sie nested_capture.py und fügen Sie den folgenden Code hinzu:
import re
def parse_complex_data(text):
pattern = r'((\w+)\s(\w+))\s\[(\d+)\]'
match = re.match(pattern, text)
if match:
full_name = match.group(1)
first_name = match.group(2)
last_name = match.group(3)
id_number = match.group(4)
return {
'full_name': full_name,
'first_name': first_name,
'last_name': last_name,
'id': id_number
}
return None
text = 'John Doe [12345]'
result = parse_complex_data(text)
if result:
print(f"Full Name: {result['full_name']}")
print(f"First Name: {result['first_name']}")
print(f"Last Name: {result['last_name']}")
print(f"ID: {result['id']}")
else:
print("No match found.")Speichern Sie die Datei.
Führen Sie das Skript aus.
python ~/project/nested_capture.pyDie Ausgabe zeigt die extrahierten Daten, einschließlich des vollständigen Namens und seiner Komponenten:
Full Name: John Doe
First Name: John
Last Name: Doe
ID: 12345Hier ist ((\w+)\s(\w+)) eine verschachtelte Erfassungsgruppe. group(1) erfasst den gesamten Namen "John Doe", group(2) erfasst "John" und group(3) erfasst "Doe". group(4) erfasst die ID.
Manchmal müssen Sie Teile eines Musters gruppieren, um Quantifizierer oder Alternativen anzuwenden, aber Sie müssen den Inhalt nicht erfassen. Nicht-erfassende Gruppen (?:...) werden für diesen Zweck verwendet.
Erstellen Sie eine neue Datei namens non_capturing.py im Verzeichnis ~/project.
touch ~/project/non_capturing.pyÖffnen Sie non_capturing.py und fügen Sie den folgenden Code hinzu:
import re
def extract_domain_info(url):
## (?:) creates a non-capturing group
pattern = r'https?://(?:www\.)?([^/]+)'
match = re.match(pattern, url)
if match:
domain = match.group(1) ## Only the domain is captured
return domain
return None
url1 = 'https://www.example.com/path'
domain1 = extract_domain_info(url1)
print(f"Domain from '{url1}': {domain1}")
url2 = 'http://example.org/another/path'
domain2 = extract_domain_info(url2)
print(f"Domain from '{url2}': {domain2}")Speichern Sie die Datei.
Führen Sie das Skript aus.
python ~/project/non_capturing.pyDie Ausgabe zeigt die extrahierten Domainnamen:
Domain from 'https://www.example.com/path': example.com
Domain from 'http://example.org/another/path': example.orgIn diesem Beispiel gleicht (?:www\.)? "www." ab, falls es existiert, erfasst es aber nicht, sodass group(1) direkt den Domainnamen erfasst.
Die Verwendung von nicht-erfassenden Gruppen kann die Leistung geringfügig verbessern und die Indizes der erfassten Gruppen sauberer halten, wenn Sie nur bestimmte Teile eines größeren Musters erfassen müssen.
In diesem Lab haben Sie gelernt, wie man Regex-Erfassungsgruppen (reguläre Ausdrücke) in Python verwendet. Sie begannen mit grundlegenden Erfassungsgruppen und erkundeten dann benannte Erfassungsgruppen (named capture groups) für eine bessere Lesbarkeit. Sie haben auch die Verwendung von Erfassungsgruppen für praktische Datenextraktionsaufgaben wie das Parsen von Protokolldateien (Log Files) und URLs geübt. Abschließend wurden Sie in fortgeschrittene Techniken wie verschachtelte und nicht-erfassende Gruppen eingeführt. Durch die Beherrschung dieser Konzepte können Sie bestimmte Teile von Textdaten mithilfe von regulären Ausdrücken in Python effektiv extrahieren und bearbeiten.
