In Python, exception handling isn't just a safety net for when code breaks; it's a core design pattern used to manage flow control smoothly. Python embraces a philosophy known as EAFP: Easier to Ask for Forgiveness than Permission. Instead of checking ahead of time if something might fail, you run the code, and if it breaks, you catch the error.
Embedded Files
1. The Core Syntax: try, except, else, and finally
1. The Core Syntax: try, except, else, and finally
The complete exception block consists of four clauses, though you'll rarely use all four at once.
try:
# 1. Code that might raise an exception
file = open("data.txt", "r")
content = file.read()
value = int(content.strip())
except FileNotFoundError:
# 2. Runs ONLY if a FileNotFoundError occurs
print("Error: The file does not exist.")
except ValueError:
# 3. Runs ONLY if the content couldn't be turned into an int
print("Error: The file content is not a valid integer.")
else:
# 4. Runs ONLY if the try block succeeded with ZERO exceptions
print(f"Success! The value is {value}")
finally:
# 5. ALWAYS runs, no matter what (even if the code crashed or returned)
print("Cleaning up resources...")
try:
file.close()
except NameError:
pass # File was never opened
Why use else?
Why use else?
Placing code in the else block rather than the try block keeps your try block small. This ensures you don't accidentally catch an exception from code you weren't trying to protect.
2. Catching Multiple & Specific Exceptions
2. Catching Multiple & Specific Exceptions
You should always target specific exceptions rather than using a blanket catch-all.
# GOOD: Specific exception handling
user_input=0
try:
result = 10 / user_input
except ZeroDivisionError:
print("You can't divide by zero!")
# BAD: Catch-all hides unexpected bugs (like typos in variables)
try:
result = 10 / user_input
except:
print("Something went wrong.")
If you want to handle multiple distinct errors the exact same way, you can group them into a tuple:
try:
# Some network/file operations
pass
except (FileNotFoundError, ConnectionRefusedError) as e:
print(f"System resource unavailable: {e}")
3. The Exception Hierarchy
3. The Exception Hierarchy
In Python, all built-in exceptions inherit from a base class called BaseException. However, standard system and application exceptions inherit from Exception.
When catching errors, Python checks except blocks from top to bottom. Always catch more specific errors before general ones.
try:
result = 1 / 0
except Exception: # General class
print("Caught an exception!")
except ZeroDivisionError: # Specific class - NEVER REACHED
print("Divided by zero!")
Because ZeroDivisionError is a subclass of Exception, the first block will swallow it, and the second block will never execute.
4. Raising Exceptions & Chaining
4. Raising Exceptions & Chaining
You can intentionally trigger an exception using the raise keyword. This is useful for enforcing business logic validation.
def set_age(age):
if age < 0:
raise ValueError("Age cannot be negative.")
return age
Exception Chaining (raise ... from)
Exception Chaining (raise ... from)
Sometimes, you catch one exception and want to raise a different, higher-level exception, but you don't want to lose the original traceback. You chain them using from:
try:
connect_to_database()
except ConnectionError as original_error:
raise RuntimeError("Application failed to initialize") from original_error
5. Creating Custom Exceptions
5. Creating Custom Exceptions
When building larger applications or libraries, creating your own exceptions makes your code significantly more readable and maintainable. Custom exceptions should inherit from Exception.
class InsufficientFundsError(Exception):
"""Raised when a wallet balance drops below the transaction amount."""
def __init__(self, balance, amount):
super().__init__(f"Attempted to withdraw ${amount} but balance is only ${balance}.")
# Usage
def withdraw(balance, amount):
if amount > balance:
raise InsufficientFundsError(balance, amount)
return balance - amount
Page updated
Google Sites
Report abuse