Comment utiliser re.findall() en Python pour trouver toutes les sous-chaînes correspondantes

Introduction

Dans ce tutoriel, nous allons explorer la fonction re.findall() de Python, un outil puissant pour extraire des sous-chaînes correspondantes à partir de texte. Cette fonction fait partie du module d'expressions régulières (regex) intégré à Python et est essentielle pour les tâches de traitement de texte.

À la fin de ce labo (LabEx), vous serez en mesure d'utiliser re.findall() pour extraire différents motifs à partir de texte, tels que des adresses e-mail, des numéros de téléphone et des URL. Ces compétences sont précieuses dans l'analyse de données, le scraping web et les applications de traitement de texte.

Que vous soyez nouveau dans le monde de Python ou que vous cherchiez à améliorer vos capacités de traitement de texte, ce guide étape par étape vous dotera des connaissances pratiques nécessaires pour utiliser efficacement les expressions régulières dans vos projets Python.

Skills Graph

Prise en main de re.findall()

Dans cette première étape, nous allons apprendre à propos de la fonction re.findall() et à l'utiliser pour des correspondances de motifs de base.

Comprendre les expressions régulières

Les expressions régulières (regex) sont des chaînes de caractères spéciales utilisées pour décrire des motifs de recherche. Elles sont particulièrement utiles lorsque vous avez besoin de :

• Trouver des motifs de caractères spécifiques dans un texte
• Valider le format d'un texte (comme les adresses e-mail)
• Extraire des informations d'un texte
• Remplacer du texte

Le module re en Python

Python propose un module intégré appelé re pour travailler avec les expressions régulières. L'une de ses fonctions les plus utiles est re.findall().

Commençons par créer un simple script Python pour voir comment re.findall() fonctionne.

1. Tout d'abord, ouvrez le terminal et accédez au répertoire de notre projet :

cd ~/project

2. Créez un nouveau fichier Python nommé basic_findall.py à l'aide de l'éditeur de code. Dans VSCode, vous pouvez cliquer sur l'icône "Explorateur" (généralement la première icône dans la barre latérale), puis cliquer sur le bouton "Nouveau fichier" et le nommer basic_findall.py.

3. Dans le fichier basic_findall.py, écrivez le code suivant :

import re

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

## Using re.findall() to find all occurrences of "Python"
matches = re.findall(r"Python", text)

## Print the results
print("Original text:")
print(text)
print("\nMatches found:", len(matches))
print("Matching substrings:", matches)

4. Enregistrez le fichier et exécutez-le depuis le terminal :

python3 ~/project/basic_findall.py

Vous devriez voir une sortie similaire à ceci :

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

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

Analyser le code

Comprenons ce qui se passe dans notre code :

• Nous avons importé le module re avec import re
• Nous avons défini un texte d'exemple avec plusieurs occurrences du mot "Python"
• Nous avons utilisé re.findall(r"Python", text) pour trouver toutes les occurrences de "Python" dans le texte
• Le r avant la chaîne de caractères désigne une chaîne brute (raw string), ce qui est recommandé lorsqu'on travaille avec des expressions régulières
• La fonction a renvoyé une liste de toutes les sous-chaînes correspondantes
• Nous avons imprimé les résultats, montrant que "Python" apparaît 3 fois dans notre texte

Rechercher différents motifs

Maintenant, essayons de trouver un motif différent. Créez un nouveau fichier nommé findall_words.py :

import re

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

## Find all words ending with 'ain'
matches = re.findall(r"\w+ain\b", text)

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

Exécutez ce script :

python3 ~/project/findall_words.py

La sortie devrait être :

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

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

Dans cet exemple :

• \w+ correspond à un ou plusieurs caractères de mot (lettres, chiffres ou underscores)
• ain correspond aux caractères littéraux "ain"
• \b représente une limite de mot, garantissant que nous correspondons à des mots complets se terminant par "ain"

Expérimentez avec ces exemples pour comprendre comment re.findall() fonctionne avec des motifs de base.

Travailler avec des motifs plus complexes

Dans cette étape, nous allons explorer des motifs plus complexes avec re.findall() et apprendre à utiliser les classes de caractères et les quantificateurs pour créer des motifs de recherche flexibles.

Trouver des nombres dans un texte

Tout d'abord, écrivons un script pour extraire tous les nombres d'un texte. Créez un nouveau fichier nommé 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)

Exécutez le script :

python3 ~/project/extract_numbers.py

Vous devriez voir une sortie similaire à :

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']

Analysons les motifs utilisés :

• \d+\.?\d* correspond à :

  • \d+ : Un ou plusieurs chiffres
  • \.? : Un point décimal facultatif
  • \d* : Zéro ou plusieurs chiffres après le point décimal

• \b\d+\b correspond à :

  • \b : Limite de mot
  • \d+ : Un ou plusieurs chiffres
  • \b : Une autre limite de mot (pour s'assurer que nous correspondons à des nombres autonomes)

Trouver des mots d'une longueur spécifique

Créons un script pour trouver tous les mots de quatre lettres dans un texte. Créez 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)

Exécutez ce script :

python3 ~/project/find_word_length.py

La sortie devrait être :

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']

Dans ces motifs :

• \b\w{4}\b correspond exactement à 4 caractères de mot entourés de limites de mot
• \b\w{3,5}\b correspond à 3 à 5 caractères de mot entourés de limites de mot

Utilisation des classes de caractères

Les classes de caractères nous permettent de correspondre à des ensembles spécifiques de caractères. Créons 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)

Exécutez le script :

python3 ~/project/character_classes.py

La sortie devrait être similaire à :

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]']

Ces motifs démontrent :

• \b[a-z0-9]+\b : Des mots contenant des lettres minuscules et des chiffres
• Le motif d'e-mail correspond au format standard des adresses e-mail

Expérimentez avec ces exemples pour comprendre comment différents composants de motif fonctionnent ensemble pour créer des motifs de recherche puissants.

Utilisation des indicateurs (flags) et des groupes de capture

Dans cette étape, nous allons apprendre à utiliser les indicateurs (flags) pour modifier le comportement des expressions régulières et à utiliser les groupes de capture pour extraire des parties spécifiques des motifs correspondants.

Comprendre les indicateurs (flags) dans les expressions régulières

Les indicateurs (flags) modifient la façon dont le moteur d'expressions régulières effectue sa recherche. Le module re de Python propose plusieurs indicateurs (flags) qui peuvent être passés en tant que paramètre optionnel à re.findall(). Explorons quelques indicateurs (flags) courants.

Créez un nouveau fichier nommé 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)

Exécutez le script :

python3 ~/project/regex_flags.py

La sortie devrait être similaire à :

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']

Les indicateurs (flags) courants incluent :

• re.IGNORECASE (ou re.I) : Rend le motif insensible à la casse
• re.MULTILINE (ou re.M) : Fait en sorte que ^ et $ correspondent au début/à la fin de chaque ligne
• re.DOTALL (ou re.S) : Fait en sorte que . corresponde à n'importe quel caractère, y compris les caractères de nouvelle ligne

Utilisation des groupes de capture

Les groupes de capture vous permettent d'extraire des parties spécifiques du texte correspondant. Ils sont créés en plaçant une partie de l'expression régulière entre parenthèses.

Créez un fichier nommé 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)

Exécutez le script :

python3 ~/project/capturing_groups.py

La sortie devrait être :

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')]

Dans cet exemple :

• Chaque ensemble de parenthèses () crée un groupe de capture
• La fonction renvoie une liste de tuples, où chaque tuple contient les groupes capturés
• Cela nous permet d'extraire et d'organiser des données structurées à partir de texte

Exemple pratique : Analyse de fichiers de logs

Maintenant, appliquons ce que nous avons appris à un exemple pratique. Imaginez que nous ayons un fichier de logs avec des entrées que nous voulons analyser. Créez un fichier nommé 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)

Exécutez le script :

python3 ~/project/log_parser.py

La sortie devrait être similaire à :

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']

Cet exemple démontre :

• L'utilisation de groupes de capture pour extraire des informations structurées
• Le traitement et l'affichage des informations capturées
• Le filtrage pour des types spécifiques d'entrées de logs

Les indicateurs (flags) et les groupes de capture améliorent la puissance et la flexibilité des expressions régulières, permettant une extraction de données plus précise et structurée.

Applications pratiques de re.findall()

Dans cette étape finale, nous allons explorer des applications pratiques et réelles de re.findall(). Nous allons écrire des codes pour extraire des e-mails, des URL et effectuer des tâches de nettoyage de données.

Extraction d'adresses e-mail

L'extraction d'e-mails est une tâche courante dans le domaine de l'exploration de données (data mining), du scraping web et de l'analyse de texte. Créez un fichier nommé 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)

Exécutez le script :

python3 ~/project/email_extractor.py

La sortie devrait être similaire à :

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]']

Extraction d'URL

L'extraction d'URL est utile pour le scraping web, la validation de liens et l'analyse de contenu. Créez un fichier nommé 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)

Exécutez le script :

python3 ~/project/url_extractor.py

La sortie devrait être similaire à :

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']

Nettoyage de données avec re.findall()

Créons un script pour nettoyer et extraire des informations d'un ensemble de données désordonné. Créez un fichier nommé 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)

Exécutez le script :

python3 ~/project/data_cleaning.py

La sortie devrait être similaire à :

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+']

Combinaison de re.findall() avec d'autres fonctions de chaînes de caractères

Enfin, voyons comment nous pouvons combiner re.findall() avec d'autres fonctions de chaînes de caractères pour un traitement avancé de texte. Créez un fichier nommé 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)")

Exécutez le script :

python3 ~/project/combined_processing.py

La sortie devrait être similaire à :

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)

Ces exemples démontrent comment re.findall() peut être combiné avec d'autres fonctionnalités de Python pour résoudre des problèmes réels de traitement de texte. La capacité à extraire des données structurées à partir de texte non structuré est une compétence essentielle pour l'analyse de données, le scraping web et de nombreuses autres tâches de programmation.

Résumé

Dans ce tutoriel, vous avez appris à utiliser la puissante fonction re.findall() de Python pour la correspondance et l'extraction de motifs de texte. Vous avez acquis des connaissances pratiques dans plusieurs domaines clés :

1. Correspondance de motifs de base - Vous avez appris à trouver des sous-chaînes simples et à utiliser des motifs d'expressions régulières de base pour correspondre à des motifs de texte spécifiques.

2. Motifs complexes - Vous avez exploré des motifs plus complexes, notamment des classes de caractères, des limites de mots et des quantificateurs, pour créer des motifs de recherche flexibles.

3. Indicateurs (flags) et groupes de capture - Vous avez découvert comment modifier le comportement de recherche à l'aide d'indicateurs (flags) tels que re.IGNORECASE et comment extraire des données structurées à l'aide de groupes de capture.

4. Applications pratiques - Vous avez appliqué vos connaissances à des scénarios pratiques tels que l'extraction d'adresses e-mail et d'URL, l'analyse de fichiers de logs et le nettoyage de données.

Les compétences que vous avez développées dans ce laboratoire sont précieuses pour une large gamme de tâches de traitement de texte, notamment :

• Extraction et nettoyage de données
• Analyse de contenu
• Scraping web
• Analyse de fichiers de logs
• Validation de données

Grâce aux expressions régulières et à la fonction re.findall(), vous disposez désormais d'un outil puissant pour gérer les données textuelles dans vos projets Python. En continuant à pratiquer et à appliquer ces techniques, vous deviendrez plus compétent pour créer des motifs efficaces répondant à vos besoins spécifiques de traitement de texte.