## Introduction to Logging Exceptions

You need a reliable way to track errors in your Python code. Simply printing error messages is not enough—print statements are easy to miss, especially in large or long-running applications. The recommended approach is to use the `logging` module to record exceptions, because it provides a standardized way to capture error details and manage where those messages go.

**In this challenge, you will not use the `logging` module.** Instead, you will use print statements to imitate logging output. By prefixing error messages with `ERROR:`, you can simulate how logging modules format and display error information. This approach helps you understand the importance of structured error reporting and prepares you to adopt the `logging` module in real-world projects.

Logging exceptions ensures that important error information is not lost and can be reviewed whenever necessary. This is a key practice in building reliable, maintainable, and professional Python applications.

import unittest
import user_code
import importlib
import io
from contextlib import redirect_stdout
import re

class TestTask(unittest.TestCase):
    def test_error_output_format(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.process_numbers([10, 20, 0, "a"], 0)
        output = f.getvalue()
        # Check for ERROR prefix and both error messages
        error_msgs = [
            'ERROR: An error occurred: division by zero',
            "ERROR: An error occurred: unsupported operand type(s) for /: 'str' and 'int'"
        ]
        found = [msg in output for msg in error_msgs]
        _dynamic_test(
            self,
            all(found),
            "All expected error messages are printed with 'ERROR:' prefix.",
            f"Expected error prints not found. Got: {output}"
        )

    

    def test_successful_result_print(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.process_numbers([8], 2)
        output = f.getvalue()
        _dynamic_test(
            self,
            "Result: 4.0" in output,
            "Successful result is printed in correct format.",
            f"Expected result print not found. Got: {output}"
        )

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:
    import ast
    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: Logging Exceptions

Introduction to Logging Exceptions

Simulating Logging with Print Statements

解答