Pas je kennis van regex toe op een praktische tekstverwerkingssituatie. Het doel is om een functie te schrijven die een alinea opdeelt in afzonderlijke zinnen. Elke zin eindigt met een punt (`'.'`), uitroepteken (`'!'`) of vraagteken (`'?'`). Zinnen kunnen gevolgd worden door spaties of regeleinden, en de interpunctie moet bij elke zin in de uitvoer worden opgenomen.

**Belangrijke vereisten:**
- Gebruik de `re`-module voor reguliere expressies;
- Detecteer zinsgrenzen bij `'.'`, `'!'` of `'?'`;
- Neem het leesteken op aan het einde van elke zin;
- Verwijder voor- en achterliggende spaties van elke zin.

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

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

Gebruik deze uitdaging om je begrip van regex-splitsing en het detecteren van zinsgrenzen in Python te versterken.


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

Een uitgebreide cursus over Python-regular expressions, ontworpen voor cursisten met basiskennis van Python. Deze cursus behandelt regex-syntaxis, patroonherkenning, geavanceerde functies en praktische toepassingen via theorie en praktische opdrachten.

Leer de basisprincipes van reguliere expressies in Python, inclusief de basis-syntaxis, patroonherkenning en essentiële regex-functies.

Verdiep je verder in regex met groepering, kwantoren, ankers en substitutietechnieken.

Beheers geavanceerde regex-functies zoals lookahead/lookbehind, niet-gretige overeenkomsten, en pas regex toe op tekstverwerkingsproblemen uit de praktijk.

Challenge: Zinnen Splitsen Met Regex

Oplossing