Python Try Except

Python Try Except at a Glance

An exception interrupts the normal flow of a program. A structured error handler lets the script react deliberately instead of ending with an unhandled traceback.

1. Understand Exceptions

When an error occurs while Python is running your code, Python raises an exception. If nothing handles it, execution stops and Python displays a traceback that identifies the exception type and the line that failed.

print(my_variable)
print("Testing exceptions")

Traceback (most recent call last):
  File "main.py", line 1, in <module>
    print(my_variable)
NameError: name 'my_variable' is not defined

The variable does not exist, so Python raises NameError. The second print() call never runs. A different mistake produces a different exception:

"This is the HTTP status code: " + 404

TypeError: can only concatenate str (not "int") to str

This time Python raises TypeError because a string and an integer cannot be joined directly. Fix mistakes you control, but also prepare for external failures that can happen even when the code is correct, such as an unavailable device, a timeout, or a missing file.

2. Use try and except

Put the operation that might fail under try. If that operation raises a matching exception, Python skips the remaining statements in the try block and runs the corresponding except block.

try:
    print(my_variable)
except NameError:
    print("Variable does not exist")

print("Program continues")

Variable does not exist
Program continues

The exception is handled, so the program continues after the block. Catching NameError explicitly also tells the reader which failure this code expects.

3. Handle Multiple Exceptions

One operation can fail in more than one expected way. Add separate handlers when each failure needs a different message or recovery action.

try:
    result = 10 / 0
except ZeroDivisionError:
    print("Cannot divide by zero.")
except NameError:
    print("A variable does not exist.")
except Exception as error:
    print(f"Another error occurred: {error}")

Cannot divide by zero.

Python uses the first matching handler. Put specific exceptions first and a broader Exception handler last. The as error form stores the original message so a log can retain useful diagnostic detail.

4. Run Success-Only Code with else

The optional else block runs only when the try block completes without raising an exception.

try:
    print("Trying print")
except Exception:
    print("An error occurred.")
else:
    print("Everything is OK.")

try:
    print(my_variable)
except NameError:
    print("Variable does not exist.")
else:
    print("Everything is OK.")

Keep success-only processing in else. This makes the protected try block smaller and prevents an unrelated error in later processing from being mistaken for the original expected failure.

5. Always Clean Up with finally

The finally block runs whether the protected code succeeds or raises an exception. It is useful for releasing resources, closing a connection, or recording that an operation finished.

try:
    print("Print something.")
except Exception:
    print("An error occurred.")
finally:
    print("This always runs.")

Print something.
This always runs.

If the try block fails, the matching handler runs first and finally still runs afterward. For ordinary files, a with open(...) context manager is usually clearer because it closes the file automatically.

6. Raise Your Own Exception

Use raise when your program detects a condition that makes it unsafe or meaningless to continue. Choose an exception type that describes the problem.

connection_status = "FAIL"

if connection_status != "OK":
    raise OSError("Connection failed.")

Traceback (most recent call last):
  File "main.py", line 4, in <module>
    raise OSError("Connection failed.")
OSError: Connection failed.

A precise type such as OSError communicates more than a general Exception. In a larger project, a custom exception can describe a domain-specific failure, but built-in types are a good starting point.

7. Handle a File Error in a Network Script

Network automation often begins with saved configurations, inventories, or logs. The following read-only example handles a missing file and reports completion without changing a device.

try:
    with open("router-config.txt", "r", encoding="utf-8") as file:
        config = file.read()
except FileNotFoundError:
    print("Configuration file was not found.")
except PermissionError:
    print("Permission denied while reading the file.")
else:
    print(f"Loaded {len(config.splitlines())} configuration lines.")
finally:
    print("File check completed.")

Loaded 87 configuration lines.
File check completed.

Configuration file was not found.
File check completed.

8. Recognize Common Exception Types

The exception type helps you decide whether the script can recover, should ask for different input, or must stop safely.

9. Guided Practice

10. Conclusion

Python raises an exception when an operation cannot continue normally. Use try around a focused risky operation, catch the specific exceptions you expect, place success-only work in else, and reserve finally for cleanup that must always happen. Use raise when your own validation detects an unsafe state.

• Unhandled exceptions stop the current program flow.
• Specific handlers are clearer and safer than a bare catch-all block.
• Error messages should help the operator decide what to check next.
• Robust automation fails safely before it acts on missing or invalid data.