Wie man re.findall() in Python verwendet, um alle passenden Teilstrings zu finden

Einführung

In diesem Tutorial werden wir die re.findall()-Funktion in Python untersuchen, ein leistungsstarkes Werkzeug zum Extrahieren von übereinstimmenden Teilzeichenfolgen aus Text. Diese Funktion ist Teil des eingebauten regulären Ausdrucksmoduls (regex) in Python und unerlässlich für Textverarbeitungstasks.

Am Ende dieses Labs können Sie re.findall() nutzen, um verschiedene Muster aus Text zu extrahieren, wie z. B. E-Mail-Adressen, Telefonnummern und URLs. Diese Fähigkeiten sind in der Datenanalyse, beim Web Scraping und in Textverarbeitungsanwendungen von großem Wert.

Ob Sie neu in Python sind oder Ihre Textverarbeitungskapazitäten verbessern möchten, dieser Schritt-für-Schritt-Ansatz wird Sie mit praktischem Wissen ausstatten, um reguläre Ausdrücke effektiv in Ihren Python-Projekten zu nutzen.

Skills Graph

Erste Schritte mit re.findall()

In diesem ersten Schritt werden wir uns mit der re.findall()-Funktion vertraut machen und lernen, wie man sie für einfache Mustererkennung einsetzt.

Grundlagen zu regulären Ausdrücken

Reguläre Ausdrücke (regex) sind spezielle Textzeichenfolgen, die zur Beschreibung von Suchmustern verwendet werden. Sie sind besonders nützlich, wenn Sie:

• Bestimmte Zeichenmuster in Texten finden möchten
• Die Formatierung von Texten überprüfen müssen (z. B. E-Mail-Adressen)
• Informationen aus Texten extrahieren wollen
• Text ersetzen müssen

Das re-Modul in Python

Python bietet ein eingebautes Modul namens re für die Arbeit mit regulären Ausdrücken. Eine der nützlichsten Funktionen dieses Moduls ist re.findall().

Beginnen wir damit, ein einfaches Python-Skript zu erstellen, um zu sehen, wie re.findall() funktioniert.

1. Öffnen Sie zunächst das Terminal und navigieren Sie in das Projektverzeichnis:

cd ~/project

2. Erstellen Sie mit einem Code-Editor eine neue Python-Datei namens basic_findall.py. In VSCode können Sie auf das "Explorer"-Symbol klicken (normalerweise das erste Symbol in der Seitenleiste), dann auf die Schaltfläche "Neue Datei" und die Datei basic_findall.py nennen.

3. Schreiben Sie in der Datei basic_findall.py folgenden Code:

import re

## Beispieltext
text = "Python is amazing. Python is versatile. I love learning Python programming."

## Verwenden von re.findall(), um alle Vorkommen von "Python" zu finden
matches = re.findall(r"Python", text)

## Ausgabe der Ergebnisse
print("Original text:")
print(text)
print("\nMatches found:", len(matches))
print("Matching substrings:", matches)

4. Speichern Sie die Datei und führen Sie sie über das Terminal aus:

python3 ~/project/basic_findall.py

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Original text:
Python is amazing. Python is versatile. I love learning Python programming.

Matches found: 3
Matching substrings: ['Python', 'Python', 'Python']

Analyse des Codes

Lassen Sie uns verstehen, was in unserem Code passiert:

• Wir haben das re-Modul mit import re importiert.
• Wir haben einen Beispieltext definiert, in dem das Wort "Python" mehrmals vorkommt.
• Wir haben re.findall(r"Python", text) verwendet, um alle Vorkommen von "Python" im Text zu finden.
• Das r vor der Zeichenfolge kennzeichnet eine rohe Zeichenfolge (raw string), was bei der Arbeit mit regulären Ausdrücken empfohlen wird.
• Die Funktion hat eine Liste aller übereinstimmenden Teilzeichenfolgen zurückgegeben.
• Wir haben die Ergebnisse ausgegeben und so gezeigt, dass "Python" drei Mal in unserem Text vorkommt.

Finden verschiedener Muster

Versuchen wir nun, ein anderes Muster zu finden. Erstellen Sie eine neue Datei namens findall_words.py:

import re

text = "The rain in Spain falls mainly on the plain."

## Finden aller Wörter, die mit 'ain' enden
matches = re.findall(r"\w+ain\b", text)

print("Original text:")
print(text)
print("\nWords ending with 'ain':", matches)

Führen Sie dieses Skript aus:

python3 ~/project/findall_words.py

Die Ausgabe sollte wie folgt aussehen:

Original text:
The rain in Spain falls mainly on the plain.

Words ending with 'ain': ['rain', 'Spain', 'plain']

In diesem Beispiel:

• \w+ passt auf ein oder mehrere Wortzeichen (Buchstaben, Ziffern oder Unterstriche).
• ain passt auf die literalen Zeichen "ain".
• \b repräsentiert eine Wortgrenze und stellt sicher, dass wir nur komplette Wörter finden, die mit "ain" enden.

Experimentieren Sie mit diesen Beispielen, um ein Gefühl dafür zu bekommen, wie re.findall() mit einfachen Mustern funktioniert.

Arbeiten mit komplexeren Mustern

In diesem Schritt werden wir komplexere Muster mit re.findall() untersuchen und lernen, wie man Zeichenklassen und Quantifizierer verwendet, um flexible Suchmuster zu erstellen.

Finden von Zahlen in Texten

Zunächst schreiben wir ein Skript, um alle Zahlen aus einem Text zu extrahieren. Erstellen Sie eine neue Datei namens extract_numbers.py:

import re

text = "There are 42 apples, 15 oranges, and 123 bananas in the basket. The price is $9.99."

## Find all numbers (integers and decimals)
numbers = re.findall(r'\d+\.?\d*', text)

print("Original text:")
print(text)
print("\nNumbers found:", numbers)

## Finding only whole numbers
whole_numbers = re.findall(r'\b\d+\b', text)
print("Whole numbers only:", whole_numbers)

Führen Sie das Skript aus:

python3 ~/project/extract_numbers.py

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Original text:
There are 42 apples, 15 oranges, and 123 bananas in the basket. The price is $9.99.

Numbers found: ['42', '15', '123', '9.99']
Whole numbers only: ['42', '15', '123', '9']

Lassen Sie uns die verwendeten Muster analysieren:

• \d+\.?\d* passt auf:

  • \d+: Ein oder mehrere Ziffern
  • \.?: Ein optionaler Dezimalpunkt
  • \d*: Null oder mehrere Ziffern nach dem Dezimalpunkt

• \b\d+\b passt auf:

  • \b: Wortgrenze
  • \d+: Ein oder mehrere Ziffern
  • \b: Eine weitere Wortgrenze (um sicherzustellen, dass wir eigenständige Zahlen treffen)

Finden von Wörtern einer bestimmten Länge

Erstellen wir ein Skript, um alle vierbuchstabigen Wörter in einem Text zu finden. Erstellen Sie find_word_length.py:

import re

text = "The quick brown fox jumps over the lazy dog. A good day to code."

## Find all 4-letter words
four_letter_words = re.findall(r'\b\w{4}\b', text)

print("Original text:")
print(text)
print("\nFour-letter words:", four_letter_words)

## Find all words between 3 and 5 letters
words_3_to_5 = re.findall(r'\b\w{3,5}\b', text)
print("Words with 3 to 5 letters:", words_3_to_5)

Führen Sie dieses Skript aus:

python3 ~/project/find_word_length.py

Die Ausgabe sollte wie folgt aussehen:

Original text:
The quick brown fox jumps over the lazy dog. A good day to code.

Four-letter words: ['over', 'lazy', 'good', 'code']
Words with 3 to 5 letters: ['The', 'over', 'the', 'lazy', 'dog', 'good', 'day', 'code']

In diesen Mustern:

• \b\w{4}\b passt genau auf 4 Wortzeichen, die von Wortgrenzen umgeben sind
• \b\w{3,5}\b passt auf 3 bis 5 Wortzeichen, die von Wortgrenzen umgeben sind

Verwenden von Zeichenklassen

Zeichenklassen ermöglichen es uns, bestimmte Zeichenmengen zu treffen. Erstellen Sie character_classes.py:

import re

text = "The temperature is 72°F or 22°C. Contact us at: [email protected]"

## Find words containing both letters and digits
mixed_words = re.findall(r'\b[a-z0-9]+\b', text.lower())

print("Original text:")
print(text)
print("\nWords with letters and digits:", mixed_words)

## Find all email addresses
emails = re.findall(r'\b[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}\b', text)
print("Email addresses:", emails)

Führen Sie das Skript aus:

python3 ~/project/character_classes.py

Die Ausgabe sollte ähnlich der folgenden sein:

Original text:
The temperature is 72°F or 22°C. Contact us at: [email protected]

Words with letters and digits: ['72°f', '22°c', '[email protected]']
Email addresses: ['[email protected]']

Diese Muster zeigen:

• \b[a-z0-9]+\b: Wörter, die Kleinbuchstaben und Ziffern enthalten
• Das E-Mail-Muster passt auf das Standardformat für E-Mail-Adressen

Experimentieren Sie mit diesen Beispielen, um zu verstehen, wie verschiedene Musterkomponenten zusammenwirken, um leistungsstarke Suchmuster zu erstellen.

Verwenden von Flags und Erfassungsgruppen (Capturing Groups)

In diesem Schritt werden wir lernen, wie man Flags verwendet, um das Verhalten von regulären Ausdrücken zu ändern, und wie man Erfassungsgruppen einsetzt, um bestimmte Teile von übereinstimmenden Mustern zu extrahieren.

Grundlagen zu Flags in regulären Ausdrücken

Flags ändern, wie der reguläre Ausdrucks-Engine die Suche durchführt. Python's re-Modul bietet mehrere Flags, die als optionaler Parameter an re.findall() übergeben werden können. Lassen Sie uns einige häufige Flags untersuchen.

Erstellen Sie eine neue Datei namens regex_flags.py:

import re

text = """
Python is a great language.
PYTHON is versatile.
python is easy to learn.
"""

## Case-sensitive search (default)
matches_case_sensitive = re.findall(r"python", text)

## Case-insensitive search using re.IGNORECASE flag
matches_case_insensitive = re.findall(r"python", text, re.IGNORECASE)

print("Original text:")
print(text)
print("\nCase-sensitive matches:", matches_case_sensitive)
print("Case-insensitive matches:", matches_case_insensitive)

## Using the multiline flag
multiline_text = "First line\nSecond line\nThird line"
## Find lines starting with 'S'
starts_with_s = re.findall(r"^S.*", multiline_text, re.MULTILINE)
print("\nMultiline text:")
print(multiline_text)
print("\nLines starting with 'S':", starts_with_s)

Führen Sie das Skript aus:

python3 ~/project/regex_flags.py

Die Ausgabe sollte ähnlich der folgenden sein:

Original text:

Python is a great language.
PYTHON is versatile.
python is easy to learn.


Case-sensitive matches: ['python']
Case-insensitive matches: ['Python', 'PYTHON', 'python']

Multiline text:
First line
Second line
Third line

Lines starting with 'S': ['Second line']

Häufige Flags sind:

• re.IGNORECASE (oder re.I): Macht das Muster gross- und kleinschreibungsunabhängig
• re.MULTILINE (oder re.M): Lässt ^ und $ den Anfang/Ende jeder Zeile matchen
• re.DOTALL (oder re.S): Lässt . jedes Zeichen einschließlich Zeilenumbrüche matchen

Verwenden von Erfassungsgruppen

Erfassungsgruppen ermöglichen es Ihnen, bestimmte Teile des übereinstimmenden Textes zu extrahieren. Sie werden erstellt, indem man einen Teil des regulären Ausdrucks in Klammern setzt.

Erstellen Sie eine Datei namens capturing_groups.py:

import re

## Sample text with dates in various formats
text = "Important dates: 2023-11-15, 12/25/2023, and Jan 1, 2024."

## Extract dates in YYYY-MM-DD format
iso_dates = re.findall(r'(\d{4})-(\d{1,2})-(\d{1,2})', text)

## Extract dates in MM/DD/YYYY format
us_dates = re.findall(r'(\d{1,2})/(\d{1,2})/(\d{4})', text)

print("Original text:")
print(text)
print("\nISO dates (Year, Month, Day):", iso_dates)
print("US dates (Month, Day, Year):", us_dates)

## Extract month names with capturing groups
month_dates = re.findall(r'(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s+(\d{1,2}),\s+(\d{4})', text)
print("Month name dates (Month, Day, Year):", month_dates)

Führen Sie das Skript aus:

python3 ~/project/capturing_groups.py

Die Ausgabe sollte wie folgt aussehen:

Original text:
Important dates: 2023-11-15, 12/25/2023, and Jan 1, 2024.

ISO dates (Year, Month, Day): [('2023', '11', '15')]
US dates (Month, Day, Year): [('12', '25', '2023')]
Month name dates (Month, Day, Year): [('Jan', '1', '2024')]

In diesem Beispiel:

• Jede Klammer () erstellt eine Erfassungsgruppe
• Die Funktion gibt eine Liste von Tupeln zurück, wobei jedes Tupel die erfassten Gruppen enthält
• Dies ermöglicht es uns, strukturierte Daten aus Texten zu extrahieren und zu organisieren

Praktisches Beispiel: Parsen von Log-Dateien

Nun wenden wir das, was wir gelernt haben, auf ein praktisches Beispiel an. Stellen Sie sich vor, wir haben eine Log-Datei mit Einträgen, die wir analysieren möchten. Erstellen Sie eine Datei namens log_parser.py:

import re

## Sample log entries
logs = """
[2023-11-15 08:30:45] INFO: System started
[2023-11-15 08:35:12] WARNING: High memory usage (85%)
[2023-11-15 08:42:11] ERROR: Connection timeout
[2023-11-15 09:15:27] INFO: Backup completed
"""

## Extract timestamp, level, and message from log entries
log_pattern = r'\[(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})\] (\w+): (.+)'
log_entries = re.findall(log_pattern, logs)

print("Original logs:")
print(logs)
print("\nParsed log entries (timestamp, level, message):")
for entry in log_entries:
    timestamp, level, message = entry
    print(f"Time: {timestamp} | Level: {level} | Message: {message}")

## Find all ERROR logs
error_logs = re.findall(r'\[\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\] ERROR: (.+)', logs)
print("\nError messages:", error_logs)

Führen Sie das Skript aus:

python3 ~/project/log_parser.py

Die Ausgabe sollte ähnlich der folgenden sein:

Original logs:

[2023-11-15 08:30:45] INFO: System started
[2023-11-15 08:35:12] WARNING: High memory usage (85%)
[2023-11-15 08:42:11] ERROR: Connection timeout
[2023-11-15 09:15:27] INFO: Backup completed


Parsed log entries (timestamp, level, message):
Time: 2023-11-15 08:30:45 | Level: INFO | Message: System started
Time: 2023-11-15 08:35:12 | Level: WARNING | Message: High memory usage (85%)
Time: 2023-11-15 08:42:11 | Level: ERROR | Message: Connection timeout
Time: 2023-11-15 09:15:27 | Level: INFO | Message: Backup completed

Error messages: ['Connection timeout']

Dieses Beispiel zeigt:

• Die Verwendung von Erfassungsgruppen zur Extraktion von strukturierten Informationen
• Die Verarbeitung und Anzeige der erfassten Informationen
• Das Filtern nach bestimmten Typen von Log-Einträgen

Flags und Erfassungsgruppen erhöhen die Leistungsfähigkeit und Flexibilität von regulären Ausdrücken und ermöglichen eine präzisere und strukturierte Datenextraktion.

Praktische Anwendungen von re.findall()

In diesem letzten Schritt werden wir praktische, realweltliche Anwendungen von re.findall() untersuchen. Wir werden Code schreiben, um E-Mail-Adressen, URLs zu extrahieren und Datenbereinigungsaufgaben durchzuführen.

Extrahieren von E-Mail-Adressen

Das Extrahieren von E-Mail-Adressen ist eine häufige Aufgabe in der Datenanalyse, beim Web-Scraping und bei der Textanalyse. Erstellen Sie eine Datei namens email_extractor.py:

import re

## Sample text with email addresses
text = """
Contact information:
- Support: [email protected]
- Sales: [email protected], [email protected]
- Technical team: [email protected]
Personal email: [email protected]
"""

## Extract all email addresses
email_pattern = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'
emails = re.findall(email_pattern, text)

print("Original text:")
print(text)
print("\nExtracted email addresses:")
for i, email in enumerate(emails, 1):
    print(f"{i}. {email}")

## Extract specific domain emails
gmail_emails = re.findall(r'\b[A-Za-z0-9._%+-]+@gmail\.com\b', text)
print("\nGmail addresses:", gmail_emails)

Führen Sie das Skript aus:

python3 ~/project/email_extractor.py

Die Ausgabe sollte ähnlich der folgenden sein:

Original text:

Contact information:
- Support: [email protected]
- Sales: [email protected], [email protected]
- Technical team: [email protected]
Personal email: [email protected]


Extracted email addresses:
1. [email protected]
2. [email protected]
3. [email protected]
4. [email protected]
5. [email protected]

Gmail addresses: ['[email protected]']

Extrahieren von URLs

Das Extrahieren von URLs ist nützlich für das Web-Scraping, die Link-Validierung und die Inhaltsanalyse. Erstellen Sie eine Datei namens url_extractor.py:

import re

## Sample text with various URLs
text = """
Visit our website at https://www.example.com
Documentation: http://docs.example.org/guide
Repository: https://github.com/user/project
Forum: https://community.example.net/forum
Image: https://images.example.com/logo.png
"""

## Extract all URLs
url_pattern = r'https?://[^\s]+'
urls = re.findall(url_pattern, text)

print("Original text:")
print(text)
print("\nExtracted URLs:")
for i, url in enumerate(urls, 1):
    print(f"{i}. {url}")

## Extract specific domain URLs
github_urls = re.findall(r'https?://github\.com/[^\s]+', text)
print("\nGitHub URLs:", github_urls)

## Extract image URLs
image_urls = re.findall(r'https?://[^\s]+\.(jpg|jpeg|png|gif)', text)
print("\nImage URLs:", image_urls)

Führen Sie das Skript aus:

python3 ~/project/url_extractor.py

Die Ausgabe sollte ähnlich der folgenden sein:

Original text:

Visit our website at https://www.example.com
Documentation: http://docs.example.org/guide
Repository: https://github.com/user/project
Forum: https://community.example.net/forum
Image: https://images.example.com/logo.png


Extracted URLs:
1. https://www.example.com
2. http://docs.example.org/guide
3. https://github.com/user/project
4. https://community.example.net/forum
5. https://images.example.com/logo.png

GitHub URLs: ['https://github.com/user/project']

Image URLs: ['https://images.example.com/logo.png']

Datenbereinigung mit re.findall()

Erstellen wir ein Skript, um Informationen aus einem ungeordneten Datensatz zu bereinigen und zu extrahieren. Erstellen Sie eine Datei namens data_cleaning.py:

import re

## Sample messy data
data = """
Product: Laptop X200, Price: $899.99, SKU: LP-X200-2023
Product: Smartphone S10+, Price: $699.50, SKU: SP-S10P-2023
Product: Tablet T7, Price: $299.99, SKU: TB-T7-2023
Product: Wireless Earbuds, Price: $129.95, SKU: WE-PRO-2023
"""

## Extract product information
product_pattern = r'Product: (.*?), Price: \$([\d.]+), SKU: ([A-Z0-9-]+)'
products = re.findall(product_pattern, data)

print("Original data:")
print(data)
print("\nExtracted and structured product information:")
print("Name\t\tPrice\t\tSKU")
print("-" * 50)
for product in products:
    name, price, sku = product
    print(f"{name}\t${price}\t{sku}")

## Calculate total price
total_price = sum(float(price) for _, price, _ in products)
print(f"\nTotal price of all products: ${total_price:.2f}")

## Extract only products above $500
expensive_products = [name for name, price, _ in products if float(price) > 500]
print("\nExpensive products (>$500):", expensive_products)

Führen Sie das Skript aus:

python3 ~/project/data_cleaning.py

Die Ausgabe sollte ähnlich der folgenden sein:

Original data:

Product: Laptop X200, Price: $899.99, SKU: LP-X200-2023
Product: Smartphone S10+, Price: $699.50, SKU: SP-S10P-2023
Product: Tablet T7, Price: $299.99, SKU: TB-T7-2023
Product: Wireless Earbuds, Price: $129.95, SKU: WE-PRO-2023


Extracted and structured product information:
Name		Price		SKU
--------------------------------------------------
Laptop X200	$899.99	LP-X200-2023
Smartphone S10+	$699.50	SP-S10P-2023
Tablet T7	$299.99	TB-T7-2023
Wireless Earbuds	$129.95	WE-PRO-2023

Total price of all products: $2029.43

Expensive products (>$500): ['Laptop X200', 'Smartphone S10+']

Kombinieren von re.findall() mit anderen String-Funktionen

Schließlich sehen wir uns an, wie wir re.findall() mit anderen String-Funktionen für fortgeschrittene Textverarbeitung kombinieren können. Erstellen Sie eine Datei namens combined_processing.py:

import re

## Sample text with mixed content
text = """
Temperature readings:
- New York: 72°F (22.2°C)
- London: 59°F (15.0°C)
- Tokyo: 80°F (26.7°C)
- Sydney: 68°F (20.0°C)
"""

## Extract all temperature readings in Fahrenheit
fahrenheit_pattern = r'(\d+)°F'
fahrenheit_temps = re.findall(fahrenheit_pattern, text)

## Convert to integers
fahrenheit_temps = [int(temp) for temp in fahrenheit_temps]

print("Original text:")
print(text)
print("\nFahrenheit temperatures:", fahrenheit_temps)

## Calculate average temperature
avg_temp = sum(fahrenheit_temps) / len(fahrenheit_temps)
print(f"Average temperature: {avg_temp:.1f}°F")

## Extract city and temperature pairs
city_temp_pattern = r'- ([A-Za-z\s]+): (\d+)°F'
city_temps = re.findall(city_temp_pattern, text)

print("\nCity and temperature pairs:")
for city, temp in city_temps:
    print(f"{city}: {temp}°F")

## Find the hottest and coldest cities
hottest_city = max(city_temps, key=lambda x: int(x[1]))
coldest_city = min(city_temps, key=lambda x: int(x[1]))

print(f"\nHottest city: {hottest_city[0]} ({hottest_city[1]}°F)")
print(f"Coldest city: {coldest_city[0]} ({coldest_city[1]}°F)")

Führen Sie das Skript aus:

python3 ~/project/combined_processing.py

Die Ausgabe sollte ähnlich der folgenden sein:

Original text:

Temperature readings:
- New York: 72°F (22.2°C)
- London: 59°F (15.0°C)
- Tokyo: 80°F (26.7°C)
- Sydney: 68°F (20.0°C)


Fahrenheit temperatures: [72, 59, 80, 68]
Average temperature: 69.8°F

City and temperature pairs:
New York: 72°F
London: 59°F
Tokyo: 80°F
Sydney: 68°F

Hottest city: Tokyo (80°F)
Coldest city: London (59°F)

Diese Beispiele zeigen, wie re.findall() mit anderen Python-Funktionalitäten kombiniert werden kann, um reale Textverarbeitungsprobleme zu lösen. Die Fähigkeit, strukturierte Daten aus unstrukturiertem Text zu extrahieren, ist eine essentielle Fähigkeit für die Datenanalyse, das Web-Scraping und viele andere Programmieraufgaben.

Zusammenfassung

In diesem Tutorial haben Sie gelernt, wie Sie die leistungsstarke re.findall()-Funktion in Python für die Mustererkennung und -extraktion in Texten nutzen können. Sie haben praktisches Wissen in mehreren Schlüsselbereichen erworben:

1. Grundlegende Mustererkennung - Sie haben gelernt, wie man einfache Teilstrings findet und grundlegende reguläre Ausdrucksmuster verwendet, um bestimmte Textmuster zu finden.

2. Komplexe Muster - Sie haben komplexere Muster untersucht, einschließlich Zeichenklassen, Wortgrenzen und Quantoren, um flexible Suchmuster zu erstellen.

3. Flags und Erfassungsgruppen (Capturing Groups) - Sie haben entdeckt, wie man das Suchverhalten mit Flags wie re.IGNORECASE ändern kann und wie man strukturierte Daten mit Erfassungsgruppen extrahieren kann.

4. Praktische Anwendungen - Sie haben Ihr Wissen auf praktische Szenarien angewendet, wie das Extrahieren von E-Mail-Adressen und URLs, das Parsen von Log-Dateien und das Bereinigen von Daten.

Die Fähigkeiten, die Sie in diesem Lab entwickelt haben, sind für eine Vielzahl von Textverarbeitungstasks wertvoll, darunter:

• Datenextraktion und -bereinigung
• Inhaltsanalyse
• Web-Scraping
• Parsen von Log-Dateien
• Datenvalidierung

Mit regulären Ausdrücken und der re.findall()-Funktion verfügen Sie jetzt über ein leistungsstarkes Werkzeug für die Verarbeitung von Textdaten in Ihren Python-Projekten. Wenn Sie diese Techniken weiter üben und anwenden, werden Sie sicherer darin werden, effiziente Muster für Ihre spezifischen Textverarbeitungsanforderungen zu erstellen.