Understanding Python Exceptions

When Python scripts execute, various errors can occur: syntax errors, undefined variables, division by zero, and more. The try...except statement handles these exceptions gracefully and displays error information. Additionally, try...finally blocks monitor error conditions and execute cleanup code regardless of whether an exception occurs, though this structure cannot display error details by itself. In practice, these structure are often combined for robust error handling.

Basic Exception Handling Syntax

try:
    main_code_block
except ExceptionTypeA:
    handler_for_type_a
except ExceptionTypeB:
    handler_for_type_b
except:
    catch_all_handler
else:
    success_block
finally:
    cleanup_block

When the main code block executes and an exception occurs, Python immediately stops executing that block and jumps to the appropriate exception handler. If the exception type matches ExceptionTypeA or ExceptionTypeB, the corresponding handler runs. Otherwise, the generic except block handles it.

If no exception occurs during execution of the main block, the else block executes (if present). Regardless of whether an exception occurred, the finally block always executes last.

The try...except Statement

This is the most straightforward exception handling structure.

Catching Specific Exceptions

When you know what type of exception might occur:

try:
    number = int(input("Enter an integer: "))
except ValueError:
    print("ValueError occurred")

Catching Any Exception

When you're uncertain about potential exceptions:

try:
    number = int(input("Enter an integer: "))
except Exception as e:
    print(f"Error occurred: {e}")

The first approach catches only ValueError, while the second captures any exception and stores it in variable e for detailed error reporting.

The try...except...final Structure

This pattern ensures cleanup code runs regardless of exceptions, making it ideal for resource management like closing database connections or file handles:

try:
    result = int(input("Enter an integer: "))
except Exception as e:
    print(f"Error occurred: {e}")
finally:
    value = 5 + 7
    print(value)

The code in the finally block executes whether the conversion succeeds or fails.

The try...except...else Structure

The else block runs only when no exceptions ocurr in the try block:

try:
    user_input = int(input("Enter an integer: "))
except Exception as e:
    print(f"Error occurred: {e}")
else:
    computed = user_input * 4
    print(computed)

This resembles an if...else flow: if an exception happens, the except block executes; otherwise, the else block runs.

The try...except...else...finally Structure

This comprehensive structure combines all patterns:

try:
    user_input = int(input("Enter an integer: "))
except Exception as e:
    print(f"Error occurred: {e}")
else:
    computed = user_input * 4
    print(computed)
finally:
    final_value = 3 * 4
    print(final_value)

Common Python Exception Types

Exception	Description
AssertionError	Assert statement failure
AttributeError	Accessing unknown object attributes
EOFError	End-of-file marker reached (Ctrl+d)
FloatingPointError	Invalid floating-point operation
GeneratorExit	generator.close() called
ImportError	Module import failure
IndexError	Sequence index out of range
KeyError	Dictionary key not found
KeyboardInterrupt	User interrupt (Ctrl+c)
MemoryError	Memory exhaustion
NameError	Undefined variable accessed
NotImplementedError	Abstract method not implemented
OSError	Operating system errors (e.g., file not found)
OverflowError	Numeric value exceeds limits
ReferenceError	Weak reference to collected object
RuntimeError	Generic runtime error
StopIteration	Iterator has no more values
SyntaxError	Invalid Python syntax
IndentationError	Incorrect indentation
TabError	Mixed tabs and spaces
SystemError	Python interpreter system error
SystemExit	Python interpreter shutdown
TypeError	Invalid type operation
UnboundLocalError	Accessing uninitialized local variable
UnicodeError	Unicode-related error
UnicodeEncodeError	Unicode encoding error
UnicodeDecodeError	Unicode decoding error
UnicodeTranslateError	Unicode translation error
ValueError	Invalid argument value
ZeroDivisionError	Division by zero

Important Guidelines

The order of blocks in a complete exception handler must follow this sequence: try → specific except → generic except → else → finally. All except statements must precede both else and finally, while else (if present) must come before finally.

Both else and finally are optional, but if else is used, at least one except block must exist. The else block cannot be used with a try...finally structure alone—without an except clause, this results in a syntax error.