In many real-world scenarios, you need to present data in a way that's both readable and visually organized, such as generating reports, displaying high scores, or logging events. Mastering custom output formatting with strings is essential for producing professional, clear output that aligns information in columns, making it easy to scan and interpret. You will now apply your string formatting skills to a practical scenario: aligning names and scores in a columnar format. This exercise will reinforce your understanding of alignment options and help you create output that's both attractive and functional.


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

class TestTask(unittest.TestCase):
    def test_basic_alignment(self):
        import user_code
        importlib.reload(user_code)
        data = [("Alice", 95), ("Bob", 88), ("Charlie", 100), ("Dana", 72)]
        expected = (
            "Alice    95\\n"
            "Bob      88\\n"
            "Charlie 100\\n"
            "Dana     72"
        )
        result = user_code.format_scores(data)
        _dynamic_test(
            self,
            isinstance(result, str),
            "Output is a string.",
            f"Output is not a string: {type(result)}"
        )
        result_lines = result.split("\\n")
        expected_lines = expected.split("\\n")
        _dynamic_test(
            self,
            len(result_lines) == len(expected_lines),
            "Correct number of lines.",
            f"Expected {len(expected_lines)} lines, got {len(result_lines)}"
        )
        for i, (actual, exp) in enumerate(zip(result_lines, expected_lines)):
            _dynamic_test(
                self,
                actual == exp,
                f"Line {i+1} formatted correctly.",
                f"Line {i+1} incorrect: expected '{exp}', got '{actual}'"
            )

    def test_column_widths(self):
        import user_code
        importlib.reload(user_code)
        data = [("A", 1), ("BBBB", 10000), ("CC", 500)]
        result = user_code.format_scores(data)
        lines = result.split("\\n")
        name_width = max(len(name) for name, _ in data)
        score_width = max(len(str(score)) for _, score in data)
        for i, (name, score) in enumerate(data):
            line = lines[i]
            parts = line.split()
            _dynamic_test(
                self,
                line.startswith(name.ljust(name_width)),
                f"Name '{name}' is left-aligned to width {name_width}.",
                f"Name '{name}' not left-aligned: '{line}'"
            )
            _dynamic_test(
                self,
                line.endswith(str(score).rjust(score_width)),
                f"Score '{score}' is right-aligned to width {score_width}.",
                f"Score '{score}' not right-aligned: '{line}'"
            )

    def test_empty_list(self):
        import user_code
        importlib.reload(user_code)
        data = []
        result = user_code.format_scores(data)
        _dynamic_test(
            self,
            result == "",
            "Returns empty string for empty input.",
            f"Expected empty string, got: '{result}'"
        )

    def test_single_entry(self):
        import user_code
        importlib.reload(user_code)
        data = [("Zoe", 7)]
        result = user_code.format_scores(data)
        expected = "Zoe 7"
        _dynamic_test(
            self,
            result == expected,
            "Handles single entry correctly.",
            f"Expected '{expected}', got '{result}'"
        )

    def test_score_as_string(self):
        import user_code
        importlib.reload(user_code)
        data = [("Eve", 12345), ("Alex", 7)]
        result = user_code.format_scores(data)
        lines = result.split("\\n")
        expected_width = max(len(str(score)) for _, score in data)
        for (name, score), line in zip(data, lines):
            score_str = str(score).rjust(expected_width)
            _dynamic_test(
                self,
                line.endswith(score_str),
                f"Score '{score}' is right-aligned.",
                f"Score '{score}' not right-aligned: '{line}'"
            )

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: Custom Output Formatting

Oplossing

Awesome!

Challenge: Custom Output Formatting

Oplossing