## Instructions: Clean Up Extra Spaces with Regex

Text data often contains inconsistent spacing, such as multiple consecutive spaces between words. You need to write a function that uses regex substitution to convert any sequence of multiple spaces into a single space, making the text cleaner and easier to process.

- Use the `re` module for your solution;
- Replace every sequence of two or more consecutive spaces with a single space;
- Ensure the function returns the cleaned string.


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

class TestTask(unittest.TestCase):
    def test_basic_replacement(self):
        import user_code
        importlib.reload(user_code)
        input_text = "This    is   a    test."
        expected = "This is a test."
        result = user_code.normalize_spaces(input_text)
        _dynamic_test(
            self,
            isinstance(result, str) and result == expected,
            "Correctly replaced multiple spaces with a single space.",
            f"Expected: '{expected}', got: '{result}'",
        )

    def test_no_extra_spaces(self):
        import user_code
        importlib.reload(user_code)
        input_text = "No extra spaces here."
        expected = "No extra spaces here."
        result = user_code.normalize_spaces(input_text)
        _dynamic_test(
            self,
            isinstance(result, str) and result == expected,
            "Leaves single spaces untouched.",
            f"Expected: '{expected}', got: '{result}'",
        )

    def test_leading_and_trailing_spaces(self):
        import user_code
        importlib.reload(user_code)
        input_text = "   Leading and   trailing   spaces   "
        expected = " Leading and trailing spaces "
        result = user_code.normalize_spaces(input_text)
        _dynamic_test(
            self,
            isinstance(result, str) and result == expected,
            "Handles leading and trailing spaces correctly.",
            f"Expected: '{expected}', got: '{result}'",
        )

    def test_only_spaces(self):
        import user_code
        importlib.reload(user_code)
        input_text = "      "
        expected = " "
        result = user_code.normalize_spaces(input_text)
        _dynamic_test(
            self,
            isinstance(result, str) and result == expected,
            "Reduces all spaces to a single space.",
            f"Expected: '{expected}', got: '{result}'",
        )

    def test_empty_string(self):
        import user_code
        importlib.reload(user_code)
        input_text = ""
        expected = ""
        result = user_code.normalize_spaces(input_text)
        _dynamic_test(
            self,
            isinstance(result, str) and result == expected,
            "Handles empty string input.",
            f"Expected: '{expected}', got: '{result}'",
        )

    def test_tabs_and_newlines_untouched(self):
        import user_code
        importlib.reload(user_code)
        input_text = "a\\t\\t  b\\n   c"
        expected = "a\\t\\t b\\n c"
        result = user_code.normalize_spaces(input_text)
        _dynamic_test(
            self,
            isinstance(result, str) and result == expected,
            "Only spaces are replaced, not tabs or newlines.",
            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: Replace Multiple Spaces with a Single Space

Instructions: Clean Up Extra Spaces with Regex

Solution