Vous allez écrire une fonction qui extrait tous les mots commençant par la lettre majuscule **'A'** à partir d'une chaîne donnée. Cet exercice permet de s'entraîner à utiliser les expressions régulières de base et le module `re` de Python. Seuls les mots débutant par un 'A' majuscule doivent être sélectionnés—**la recherche doit être sensible à la casse**.

**Points clés :**

- Utilisation du module `re` de Python ;
- Correspondance uniquement des mots commençant par un 'A' majuscule ;
- Préservation de la forme originale de chaque mot trouvé dans le texte.


import unittest
import user_code
import ast
import re   
import unittest
import importlib
import io
from contextlib import redirect_stdout

class TestTask(unittest.TestCase):
    def test_basic_extraction(self):
        import user_code
        importlib.reload(user_code)
        text = "Alice and Andrew went to the Aquarium."
        result = user_code.find_words_starting_with_a(text)
        expected = ["Alice", "Andrew", "Aquarium"]
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            f"Correctly finds words starting with 'A': {expected}",
            f"Expected {expected}, got {result}",
        )

    def test_no_matches(self):
        import user_code
        importlib.reload(user_code)
        text = "bob and charlie went home."
        result = user_code.find_words_starting_with_a(text)
        expected = []
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Returns empty list when no words start with 'A'",
            f"Expected empty list, got {result}",
        )

    def test_case_sensitive(self):
        import user_code
        importlib.reload(user_code)
        text = "apple Apple ALice aaron Aaron"
        result = user_code.find_words_starting_with_a(text)
        expected = ["Apple", "ALice", "Aaron"]
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Function is case-sensitive and includes only words starting with uppercase 'A'",
            f"Expected {expected}, got {result}",
        )

    def test_punctuation(self):
        import user_code
        importlib.reload(user_code)
        text = "Amy, Ann! Alan? Aardvark."
        result = user_code.find_words_starting_with_a(text)
        expected = ["Amy", "Ann", "Alan", "Aardvark"]
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Correctly extracts words with punctuation after them",
            f"Expected {expected}, got {result}",
        )

    def test_single_word(self):
        import user_code
        importlib.reload(user_code)
        text = "Aardvark"
        result = user_code.find_words_starting_with_a(text)
        expected = ["Aardvark"]
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Correctly returns single word starting with 'A'",
            f"Expected {expected}, got {result}",
        )

    def test_word_boundaries(self):
        import user_code
        importlib.reload(user_code)
        text = "AnA A1 A_ A!"
        result = user_code.find_words_starting_with_a(text)
        expected = ["AnA", "A1", "A_", "A"]
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Correctly matches all words starting with 'A' including numbers and underscores",
            f"Expected {expected}, got {result}",
        )

    def test_preserves_original(self):
        import user_code
        importlib.reload(user_code)
        text = "Aardvark Annabelle"
        result = user_code.find_words_starting_with_a(text)
        expected = ["Aardvark", "Annabelle"]
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Returns words exactly as they appear in the text",
            f"Expected {expected}, got {result}",
        )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\s{2,}", " ", text)
    text = re.sub(r"\s*([,:?])\s*", r"\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    for i, node in enumerate(tree.body):
        if isinstance(node, ast.Assign):
            for target in node.targets:
                if isinstance(target, ast.Name) and target.id == var_name:
                    start_line = node.lineno - 1
                    line = lines[start_line]
                    indent = ' ' * (len(line) - len(line.lstrip()))
                    lines[start_line] = f"{indent}{var_name} = {value}"
                    next_line = len(lines)
                    for next_node in tree.body[i+1:]:
                        if hasattr(next_node, 'lineno'):
                            next_line = next_node.lineno - 1
                            break
                    if next_line > start_line + 1:
                        lines[start_line+1:next_line] = []
                    
                    return '\\n'.join(lines)
    return code

if __name__ == "__main__":
    unittest.main()


test_main.py

Un cours complet sur les expressions régulières en Python, conçu pour les apprenants ayant des connaissances de base en Python. Ce cours couvre la syntaxe des regex, la correspondance de motifs, les fonctionnalités avancées et les applications pratiques à travers la théorie et des exercices pratiques.

Apprenez les bases des expressions régulières en Python, y compris la syntaxe de base, la correspondance de motifs et les fonctions regex essentielles.

Approfondissement des expressions régulières avec les groupements, les quantificateurs, les ancres et les techniques de substitution.

Maîtrise des fonctionnalités avancées des expressions régulières telles que le lookahead/lookbehind, la correspondance non-gourmande, et application des expressions régulières à des problèmes réels de traitement de texte.

Challenge : Trouver des mots commençant par une lettre spécifique

Solution