Skip to main content

Exception Handling in Python: try, except, else, and finally Explained

Exception Handling in Python: try, except, else, and finally Explained

Exception Handling in Python: try, except, else and finally Explained

Exception handling helps you write robust Python programs by gracefully managing errors during runtime. The try, except, else, and finally clauses form a flexible system for catching, responding to, and cleaning up after exceptions. This guide covers the syntax, patterns, and real-world examples for using these tools effectively.

Table of Content

Why Use Exception Handling?

  • Graceful Recovery: Handle errors without crashing your program.
  • Cleaner Code: Keep logic and error handling separate.
  • Better Debugging: Catch, log, or re-raise errors with context.
  • Resource Management: Clean up files, network connections, or locks even when problems happen.

Syntax & Structure

try:
    # code that may raise an exception
except ExceptionType1:
    # code to execute if ExceptionType1 occurs
except ExceptionType2 as e:
    # code to execute if ExceptionType2 occurs, access the exception as code e
else:
    # code executed if no exception was raised in try
finally:
    # code executed no matter what (cleanup, release resources)
  • try: The block where you write code that could fail.
  • except: Handles specific or general exceptions raised in the try block.
  • else: Runs only if no exception was raised in the try block.
  • finally: Always runs—good for cleanup logic (like closing files), even if an error or return happens.

Basic Examples

1. Catching a Single Exception

try:
    value = int(input("Enter a number: "))
    print("Your number is:", value)
except ValueError:
    print("That was not a valid integer.")

Output (if user enters "abc")

That was not a valid integer.

2. Catching All Exceptions (not recommended except for quick scripts)

try:
    risky_operation()
except Exception as e:
    print("An error occurred:", e)

Multiple "except" Clauses

Handle different error types in their own blocks for precise control.

Reading a File, Handling File and Value Errors

try:
    with open("data.txt") as f:
        data = int(f.read())
except FileNotFoundError:
    print("The file data.txt was not found.")
except ValueError:
    print("Could not convert the file contents to an integer.")

"else" and "finally" Clauses

  • else: Runs after try only if no exceptions occurred.
  • finally: Always runs. Use for resource cleanup or important final steps.

1. "try" + "else" Example

try:
    result = 10 / 2
except ZeroDivisionError:
    print("Cannot divide by zero.")
else:
    print("Division succeeded. Result:", result)

Output

Division succeeded. Result: 5.0

2. "try" + "finally" Example

try:
    f = open("data.txt", "r")
    content = f.read()
except FileNotFoundError:
    print("File not found.")
finally:
    if 'f' in locals():
        f.close()
        print("File closed.")

Output if file not found

File not found.

Comparison Table: Basic "try-except" Patterns

Pattern try-except Version Best For
Catching a single error 
try:
    result = operation()
except ValueError:
    handle_value_error()
Simple situations (user input, parsing)
Handling multiple exceptions 
try:
    process()
except (FileNotFoundError, ValueError):
    handle_problem()
Mixed I/O or conversion logic
Ensuring cleanup 
try:
    use_resource()
finally:
    release_resource()
Resource/file/network management

Useful Tips

  • Be specific: Catch the narrowest exception type you can, not Exception unless necessary.
  • Never use bare except: It also catches system-exiting exceptions like KeyboardInterrupt and SystemExit
  • Avoid side effects: Keep try blocks minimal—only the code that might fail.
  • Use finally for cleanup: Always close files and release resources there.
  • Logging: For production systems, log exceptions using Python’s logging module for traceability.
  • Re-raise if needed: Use raise inside except to propagate unhandled errors up the call stack.

Conclusion

Python's try, except, else, and finally let you write reliable code that handles errors cleanly, responds to unexpected situations, and always cleans up afterward. Practicing these patterns will help you debug, maintain, and scale your Python programs with confidence.

Comments

Post a Comment