Opening Files and Getting File Handles

The Failed Opening

When a program calls open() for a file that is not where the program expects it to be, Python cannot obtain a file handle. Instead, it raises FileNotFoundError. Without error handling, execution stops at the failed call, so statements after it do not run.

Control Flow Without Handling

file_handle = open("missing_notes.txt")
print("This line does not run")

In this example, the call to open() is the point of failure when missing_notes.txt does not exist. Python does not assign a file handle to file_handle. Because the error is not caught, the print() statement is never reached, and the program terminates with a traceback.

Reading the Traceback

A traceback is the error information Python displays when the failure is not handled. It identifies where the failure occurred, shows the code that failed, and names the error type as FileNotFoundError. The error means that Python looked for the requested file but did not find it where the program said it would be.

• The opening part indicates that a traceback is being reported.
• The location information identifies the file and line where the failure occurred.
• The code information shows the statement that failed.
• The final error information names FileNotFoundError and gives details about the missing file.

Handling the Failure

A try statement marks code that might fail. A matching except statement provides the response when that code raises the specified error. If open() raises FileNotFoundError inside the try block, Python jumps to the matching except block. After the except block finishes, execution continues normally.

try:
    file_handle = open("missing_notes.txt")
    print("File opened")
except FileNotFoundError:
    print("The file was not found")

print("The program continues")

The file was not found
The program continues

The first print() inside the try block is skipped because the failure occurs before it. Control moves directly to except FileNotFoundError. The handler prints its message, and then the final print() runs because the error has been handled rather than left uncaught.

Handle or No Handle

The important state change is whether the program obtains a file handle. When the requested file is available, open() can provide a handle for the program to use. When the file is missing, FileNotFoundError occurs instead, so no file handle is obtained from that call.

Common Mistakes

• Assuming that every open() call produces a file handle.

  If the requested file does not exist, open() raises FileNotFoundError and no handle is obtained.

  Fix: Consider that opening can fail, and place the call in a try block when the failure should be handled.

• Expecting statements after an uncaught open() failure to run.

  An uncaught FileNotFoundError stops execution immediately.

  Fix: Use a matching except FileNotFoundError block if the program should respond and continue.

• Treating the traceback as a syntax error.

  FileNotFoundError is a runtime error caused by the unavailable file, not by invalid Python syntax.

  Fix: Read the traceback for the failed line and the error type, then decide whether to handle the missing file.

• Putting the file-opening call outside the try block.

  The failure occurs before Python enters the try block, so that except block cannot handle this call.

  Fix: Put the operation that might raise FileNotFoundError inside the try block.

Practice the Branch

Key Takeaways

1. Calling open() for a missing file raises FileNotFoundError and does not provide a file handle.
2. Without handling, the error stops execution and displays a traceback.
3. The traceback identifies the failure location, the failed code, and the FileNotFoundError type.
4. A try block contains the operation that might fail, while a matching except block defines the response.
5. After the except block completes, execution can continue with later statements.