## Handling Multiple Exceptions in File Processing

When you process files in Python, you must prepare for unexpected situations, such as missing files or unreadable content. Using multiple exception handling allows you to manage these scenarios gracefully and keep your application reliable.

### Why Handle Multiple Exceptions?

- Files may not exist at the specified location, causing a `FileNotFoundError`;
- Files may contain characters that cannot be decoded, leading to a `UnicodeDecodeError`;
- Handling each error separately helps you provide clear, specific feedback and prevents your program from crashing.

By catching these exceptions individually, you can inform users exactly what went wrong and ensure your application continues to run smoothly. This approach is essential for robust, user-friendly Python programs that work reliably in real-world situations.


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

class TestTask(unittest.TestCase):
    def setUp(self):
        # Create a valid UTF-8 file
        with open('test_valid.txt', 'w') as f:
            f.write('This is a test file.')
        # Create a file with invalid utf-8 bytes
        with open('test_invalid.txt', 'wb') as f:
            f.write(b'\\xff\\xfe\\xfd')
        # Ensure nonexistent file does not exist
        if os.path.exists('test_missing.txt'):
            os.remove('test_missing.txt')

    def tearDown(self):
        for fname in ['test_valid.txt', 'test_invalid.txt']:
            try:
                os.remove(fname)
            except Exception:
                pass

    def test_file_not_found(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.read_file_contents('test_missing.txt')
        output = normalize_text(f.getvalue())
        expected = normalize_text("Error: The file was not found.")
        _dynamic_test(
            self,
            expected in output,
            "Correct message for missing file.",
            f"Expected message: '{expected}', got: '{output}'",
        )

    def test_unicode_decode_error(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.read_file_contents('test_invalid.txt')
        output = normalize_text(f.getvalue())
        expected = normalize_text("Error: Could not decode the file contents.")
        _dynamic_test(
            self,
            expected in output,
            "Correct message for UnicodeDecodeError.",
            f"Expected message: '{expected}', got: '{output}'",
        )

    def test_file_success(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.read_file_contents('test_valid.txt')
        output = normalize_text(f.getvalue())
        expected = normalize_text('This is a test file.')
        _dynamic_test(
            self,
            expected in output,
            "File contents are printed correctly.",
            f"Expected file contents: '{expected}', 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:
    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: Handling Data Processing Robustly

Handling Multiple Exceptions in File Processing

Why Handle Multiple Exceptions?

Ratkaisu

Awesome!

Challenge: Handling Data Processing Robustly

Handling Multiple Exceptions in File Processing

Why Handle Multiple Exceptions?

Ratkaisu