Building on your knowledge of string methods, you will now put your skills to the test by cleaning and standardizing raw user input. This is a common task in real-world data processing, where data often comes in messy or inconsistent formats. Your goal is to ensure that the input is tidy, consistent, and ready for further processing by applying a series of string transformations.


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

class TestTask(unittest.TestCase):
    def test_leading_trailing_whitespace(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.clean_string("   Hello World   ")
        _dynamic_test(
            self,
            result == "hello_world",
            "Removes leading/trailing whitespace and processes string correctly.",
            f"Expected 'hello_world', got '{result}'",
        )

    def test_all_lowercase_conversion(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.clean_string("Python Programming")
        _dynamic_test(
            self,
            result == "python_programming",
            "Converts all characters to lowercase and replaces spaces.",
            f"Expected 'python_programming', got '{result}'",
        )

    def test_replaces_spaces_with_underscores(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.clean_string("  DATA science  ")
        _dynamic_test(
            self,
            result == "data_science",
            "Replaces spaces with underscores and processes string correctly.",
            f"Expected 'data_science', got '{result}'",
        )

    def test_no_spaces_or_whitespace(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.clean_string("python")
        _dynamic_test(
            self,
            result == "python",
            "Handles string with no spaces or whitespace.",
            f"Expected 'python', got '{result}'",
        )

    def test_already_clean_string(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.clean_string("already_clean")
        _dynamic_test(
            self,
            result == "already_clean",
            "Handles already clean string correctly.",
            f"Expected 'already_clean', got '{result}'",
        )

    def test_empty_string(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.clean_string("")
        _dynamic_test(
            self,
            result == "",
            "Handles empty string correctly.",
            f"Expected empty string, 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 beginner-friendly course focused on mastering string manipulation and handling various data formats in Python. Learn essential techniques for processing, formatting, and converting data, with hands-on practice and quizzes to reinforce your understanding.

Learn the core techniques for working with strings in Python, including slicing, searching, and modifying text.

Develop skills for formatting strings and converting between data types for effective data presentation and processing.

Gain practical experience handling structured data formats such as CSV and JSON using Python's built-in capabilities.

Challenge: String Cleaning

Løsning