In professional Python development, documenting how your code handles errors is just as important as catching or raising exceptions. Clear documentation helps other developers—and your future self—understand what can go wrong and how to respond. This is especially vital for functions that interact with external resources or complex data, where unexpected situations may arise.

## Why Document Exception Handling?

Documenting exception handling in your Python code:

- **Clarifies which errors may occur**;
- **Helps others use your code safely**;
- **Makes maintenance and debugging easier**;
- **Promotes consistent error handling across projects**.

Clear documentation leads to safer and more reliable code.

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

class TestTask(unittest.TestCase):
    def test_returns_first_line(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.read_first_line('Hello World!\\nSecond line')
        _dynamic_test(
            self,
            isinstance(result, str) and result.strip() == 'Hello World!',
            "Function returns first line as string",
            f"Expected 'Hello World!', got '{result}'",
        )

    def test_empty_string_returns_empty(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.read_first_line("")
        _dynamic_test(
            self,
            result == '',
            "Returns empty string for empty input",
            f"Expected empty string, got '{result}'",
        )

    def test_file_not_found_raises(self):
        import user_code
        importlib.reload(user_code)
        try:
            user_code.read_first_line(None)
        except FileNotFoundError:
            _dynamic_test(
                self,
                True,
                "Raises FileNotFoundError for non-string input",
                "Should raise FileNotFoundError for non-string input",
            )
        except Exception as e:
            _dynamic_test(
                self,
                False,
                "",
                f"Expected FileNotFoundError, got {type(e)}",
            )
        else:
            _dynamic_test(
                self,
                False,
                "",
                "Did not raise FileNotFoundError for non-string input",
            )

    def test_other_exception_raises_runtimeerror(self):
        import user_code
        importlib.reload(user_code)
        class BadStr(str):
            def splitlines(self):
                raise ValueError("Bad splitlines")
        try:
            user_code.read_first_line(BadStr('test'))
        except RuntimeError as e:
            _dynamic_test(
                self,
                "Failed to read the first line" in str(e),
                "Raises RuntimeError for other exceptions",
                f"Expected RuntimeError with message, got: {e}",
            )
        except Exception as e:
            _dynamic_test(
                self,
                False,
                "",
                f"Expected RuntimeError, got {type(e)}",
            )
        else:
            _dynamic_test(
                self,
                False,
                "",
                "Did not raise RuntimeError for error in splitlines",
            )

    def test_docstring_mentions_exceptions(self):
        import user_code
        importlib.reload(user_code)
        doc = getattr(user_code.read_first_line, "__doc__", "")
        _dynamic_test(
            self,
            "FileNotFoundError" in doc and "RuntimeError" in doc,
            "Docstring documents exceptions raised",
            f"Docstring does not mention all required exceptions: {doc}",
        )

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 introducing Python's error handling mechanisms, including try-except blocks, exception types, and best practices for writing robust code.

Learn what exceptions are in Python, why they occur, and how to handle them using basic try-except blocks.

Explore more advanced features of Python's exception handling, including else, finally, and handling multiple exceptions.

Learn how to define your own exceptions and follow best practices for robust error handling in Python.

Challenge: Documenting Error Handling

Why Document Exception Handling?

解答