Apply your regex knowledge to a practical text processing scenario. Your goal is to write a function that splits a paragraph into individual sentences. Each sentence ends with a period (`'.'`), exclamation mark (`'!'`), or question mark (`'?'`). Sentences may be followed by spaces or line breaks, and you should ensure that punctuation is included with each sentence in the output.

**Key requirements:**
- Use the `re` module for regular expressions;
- Detect sentence boundaries at `'.'`, `'!'`, or `'?'`;
- Include the punctuation mark at the end of each sentence;
- Remove leading and trailing whitespace from each sentence.

**Example input:**
```
paragraph = "Hello there! How are you? I hope you're enjoying learning Python."
```

**Expected output:**
```
['Hello there!', 'How are you?', "I hope you're enjoying learning Python."]
```

Use this challenge to strengthen your understanding of regex splitting and sentence boundary detection in 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

A comprehensive course on Python regular expressions, designed for learners with basic Python knowledge. This course covers regex syntax, pattern matching, advanced features, and practical applications through theory and hands-on tasks.

Learn the fundamentals of regular expressions in Python, including basic syntax, pattern matching, and essential regex functions.

Delve deeper into regex with grouping, quantifiers, anchors, and substitution techniques.

Master advanced regex features such as lookahead/lookbehind, non-greedy matching, and apply regex to real-world text processing problems.

Challenge: Split Sentences Using Regex

Solução

Awesome!

Challenge: Split Sentences Using Regex

Solução