Dans ce chapitre, vous découvrirez comment exploiter la puissance des expressions régulières dans des scénarios Python avancés, notamment l’utilisation de fonctions imbriquées, l’inversion de chaînes de caractères et la concaténation de chaînes. Ces techniques permettent de manipuler et d’analyser les données textuelles de manière plus efficace et flexible, ouvrant de nouvelles possibilités pour l’automatisation, le nettoyage de données et la recherche de motifs complexes.

Vous apprendrez comment les expressions régulières peuvent :

• Améliorer la fonctionnalité des fonctions imbriquées pour extraire ou transformer des données ;
• Simplifier le processus d’inversion de chaînes selon des motifs spécifiques ;
• Permettre une concaténation dynamique et personnalisable de chaînes à l’aide de règles basées sur des motifs.

La maîtrise de ces applications vous aidera à écrire un code Python plus concis, lisible et puissant pour un large éventail de tâches concrètes, du traitement de fichiers journaux à la création de pipelines de données.

Utilisation des expressions régulières dans les fonctions imbriquées

Lorsque vous utilisez des expressions régulières en Python, vous définissez souvent des motifs et la logique de recherche à l’intérieur de fonctions. Parfois, il peut être nécessaire d’utiliser des expressions régulières dans des fonctions imbriquées — des fonctions définies à l’intérieur d’autres fonctions. Comprendre le fonctionnement de la portée et de l’accès aux variables dans ce contexte vous aide à écrire un code clair et réutilisable.

Définition : Fonctions imbriquées

Une fonction imbriquée est une fonction définie à l’intérieur d’une autre fonction. La fonction interne peut accéder aux variables de la fonction englobante grâce au scoping lexical de Python (aussi appelé fermeture).

Portée et expressions régulières

• La fonction interne peut utiliser les motifs d’expressions régulières et les objets compilés définis dans la fonction externe ;
• Vous pouvez transmettre des correspondances ou des résultats d’expressions régulières de la fonction externe à la fonction interne pour un traitement supplémentaire ;
• Compiler un motif regex dans la fonction externe améliore l’efficacité si la fonction interne utilise le même motif plusieurs fois.

Exemple pratique : Filtrage et extraction de données

Supposons que vous souhaitiez traiter une liste d’adresses e-mail, filtrer les valides et extraire la partie nom d’utilisateur. Vous pouvez utiliser une fonction imbriquée pour encapsuler la logique d’extraction :

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

Points clés :

• Le pattern est compilé une seule fois dans la fonction externe et réutilisé dans la fonction imbriquée extract_username ;
• La fonction interne accède au motif regex depuis la portée englobante ;
• Cette structure permet de garder le code organisé et efficace, en particulier lors du traitement de tâches complexes d’analyse de données.

L’utilisation d’expressions régulières dans des fonctions imbriquées est une technique puissante pour construire un code modulaire et maintenable qui traite efficacement les données textuelles.

Inversion de chaînes en Python

L'inversion d'une chaîne est une tâche courante lors du traitement de données textuelles. Python offre un moyen simple d'inverser des chaînes à l'aide du slicing, et il est également possible de combiner cette technique avec les expressions régulières pour des manipulations avancées du texte.

Comment inverser une chaîne

Il est possible d'inverser n'importe quelle chaîne en Python grâce au slicing :

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

Explication :

• text[::-1] crée une nouvelle chaîne en prenant tous les caractères de text mais dans l'ordre inverse.

Scénarios d'utilisation

L'inversion de chaînes est utile dans plusieurs situations :

• Vérification si une chaîne est un palindrome ;
• Masquage d'informations sensibles en les affichant à l'envers ;
• Création d'effets de texte ludiques pour les interfaces utilisateur.

Combinaison des regex avec l'inversion de chaînes

Il est possible d'utiliser les expressions régulières pour trouver des motifs spécifiques dans une chaîne, puis d'inverser uniquement ces parties. Cela s'avère utile lorsque l'on souhaite inverser certains mots ou motifs, et non l'ensemble de la chaîne.

Exemple : inverser tous les mots commençant par une majuscule

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"

Fonctionnement :

• Le motif regex \b[A-Z][a-zA-Z]*\b correspond aux mots commençant par une majuscule.
• La fonction reverse_match inverse chaque mot correspondant.
• re.sub remplace chaque correspondance par sa version inversée.

La combinaison des expressions régulières avec l'inversion de chaînes permet d'effectuer des transformations textuelles complexes de manière concise et flexible.

Fusion de chaînes en Python

La fusion de chaînes est une opération courante lors du traitement de données textuelles. Il est souvent nécessaire de combiner plusieurs chaînes en une seule, par exemple pour assembler des mots, des lignes ou des résultats issus d'une recherche par expression régulière.

Utilisation de join() pour combiner une liste de chaînes

La méthode str.join() est la manière standard de concaténer une liste de chaînes en une seule chaîne. Il suffit de spécifier une chaîne séparatrice, puis d'appeler join() sur celle-ci avec la liste à combiner.

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

Points clés concernant join() :

• Le séparateur (comme un espace, une virgule ou un saut de ligne) précède .join() ;
• L'argument de join() doit être un itérable de chaînes (comme une liste ou un tuple) ;
• Le résultat est une seule chaîne contenant tous les éléments, séparés par le séparateur choisi.

Fusionner les correspondances regex en une seule chaîne

Lorsque la fonction re.findall() est utilisée, elle retourne une liste de toutes les correspondances non chevauchantes. Il est possible d'utiliser join() pour combiner ces correspondances en une seule chaîne.

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

Cas d'utilisation courants :

• Combinaison de toutes les correspondances regex en une chaîne séparée par des virgules ;
• Fusion de lignes de texte en un seul bloc ;
• Création de lignes CSV à partir de listes de valeurs.

La fusion efficace de chaînes permet de traiter, d'afficher et de stocker des données textuelles de manière lisible et structurée.