Appliquer les connaissances sur les expressions régulières à un scénario pratique de traitement de texte. L'objectif est d'écrire une fonction qui divise un paragraphe en phrases individuelles. Chaque phrase se termine par un point (`'.'`), un point d'exclamation (`'!'`) ou un point d'interrogation (`'?'`). Les phrases peuvent être suivies d'espaces ou de sauts de ligne, et il faut s'assurer que la ponctuation soit incluse avec chaque phrase dans le résultat.

**Exigences clés :**
- Utiliser le module `re` pour les expressions régulières ;
- Détecter les limites de phrase aux caractères `'.'`, `'!'` ou `'?'` ;
- Inclure le signe de ponctuation à la fin de chaque phrase ;
- Supprimer les espaces en début et fin de chaque phrase.

**Exemple d'entrée :**
```
paragraph = "Hello there! How are you? I hope you're enjoying learning Python."
```

**Résultat attendu :**
```
['Hello there!', 'How are you?', "I hope you're enjoying learning Python."]
```

Utiliser ce défi pour renforcer la compréhension du découpage avec regex et de la détection des limites de phrase en Python.


import unittest
import user_code
import ast
import re   
import unittest
import importlib

class TestTask(unittest.TestCase):
    def test_simple_split(self):
        import user_code
        importlib.reload(user_code)
        text = "Hello! How are you? I am fine."
        expected = ["Hello!", "How are you?", "I am fine."]
        result = user_code.split_sentences(text)
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Correctly splits sentences with !, ? and .",
            f"Expected {expected}, got {result}",
        )

    def test_trailing_spaces(self):
        import user_code
        importlib.reload(user_code)
        text = "Hello!   How are you?   I am fine.  "
        expected = ["Hello!", "How are you?", "I am fine."]
        result = user_code.split_sentences(text)
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Removes extra spaces between and after sentences.",
            f"Expected {expected}, got {result}",
        )

    def test_multiline_paragraph(self):
        import user_code
        importlib.reload(user_code)
        text = "Hello!\\nHow are you?\\nI am fine.\\n"
        expected = ["Hello!", "How are you?", "I am fine."]
        result = user_code.split_sentences(text)
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Handles newlines between sentences.",
            f"Expected {expected}, got {result}",
        )

    def test_empty_string(self):
        import user_code
        importlib.reload(user_code)
        text = ""
        expected = []
        result = user_code.split_sentences(text)
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Returns empty list for empty input.",
            f"Expected empty list, got {result}",
        )

    def test_no_sentence_endings(self):
        import user_code
        importlib.reload(user_code)
        text = "This is not a sentence ending"
        expected = []
        result = user_code.split_sentences(text)
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Returns empty list if no sentence-ending punctuation.",
            f"Expected empty list, got {result}",
        )

    def test_multiple_punctuation(self):
        import user_code
        importlib.reload(user_code)
        text = "Wait. . . What? ! Seriously? !"
        expected = ["Wait.", ".", ".", "What?", "!", "Seriously?", "!"]
        result = user_code.split_sentences(text)
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Handles consecutive punctuation marks individually.",
            f"Expected {expected}, got {result}",
        )

    def test_leading_trailing_whitespace(self):
        import user_code
        importlib.reload(user_code)
        text = "   Hello!  "
        expected = ["Hello!"]
        result = user_code.split_sentences(text)
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Removes leading and trailing whitespace from sentence.",
            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 : Diviser des Phrases à l'Aide des Expressions Régulières

Solution