When working with files in Python, you must ensure that every file you open is also closed properly. This prevents resource leaks and keeps your programs running smoothly. The **`finally`** clause is a powerful tool for this purpose: it guarantees that specific cleanup code will run, even if an error occurs while processing the file.

Suppose you try to read from a file that might not exist or could cause an error while being read. No matter what happens, you need to close the file to avoid leaving it open accidentally. By placing the file-closing code inside a **`finally`** block, you make sure that the file is always closed, whether or not an exception is raised.

In this challenge, you will practice using **`finally`** to handle files safely and reliably.


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

class TestTask(unittest.TestCase):
    def setUp(self):
        # Create an example file
        with open('example.txt', 'w') as f:
            f.write('Hello, world!')

    def tearDown(self):
        # Remove test file if it exists
        if os.path.exists('example.txt'):
            os.remove('example.txt')

    def test_read_existing_file(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.read_file_contents('example.txt')
        _dynamic_test(
            self,
            result == 'Hello, world!',
            'Function returns correct contents for existing file',
            f"Expected 'Hello, world!', got {result}",
        )

    def test_read_nonexistent_file(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            result = user_code.read_file_contents('does_not_exist.txt')
        output = f.getvalue()
        _dynamic_test(
            self,
            result is None,
            'Function returns None for nonexistent file',
            f"Expected None for nonexistent file, got {result}",
        )
        _dynamic_test(
            self,
            'an error occurred while reading the file.' in normalize_text(output),
            'Error message is printed when file does not exist',
            f"Expected error message in output, got: {output}",
        )

    def test_file_always_closed(self):
        import user_code
        importlib.reload(user_code)
        # This test checks that the file can be deleted after reading, i.e. it is closed
        user_code.read_file_contents('example.txt')
        try:
            os.remove('example.txt')
            file_closed = True
        except Exception:
            file_closed = False
        _dynamic_test(
            self,
            file_closed,
            'File is properly closed after reading',
            'File was not closed after reading',
        )

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: File Handling with finally

解答