📌 Introduction
In real-world programming, errors are unavoidable. Even well-written programs can fail due to unexpected inputs, system issues, or logical mistakes.
Python provides a powerful system called exception handling that allows developers to manage errors safely without crashing the program.
In this guide, you will learn:
- What exceptions are
- How exception handling works in Python
- How to use try-except blocks
- How exception classes work
- How to create custom exceptions using OOP
1. ⚠️ What is an Exception?
An exception is an error that occurs while a program is running.
Instead of stopping the program completely, Python allows you to handle these errors gracefully.
💡 Example of an Exception
x = 10
y = 0
print(x / y)
📤 Output:
ZeroDivisionError
👉 This error happens because division by zero is not allowed.
2. ❓ Why is Exception Handling Important?
Exception handling helps you:
✔ Prevent program crashes
✔ Improve user experience
✔ Handle unexpected inputs
✔ Keep program running smoothly
✔ Make debugging easier
👉 In real applications, this is essential for stability.
3. 🧩 Try-Except Block
Python uses try and except blocks to handle errors safely.
💡 Basic Example:
try:
x = 10
y = 0
print(x / y)
except ZeroDivisionError:
print("Error: Cannot divide by zero")
👉 Instead of crashing, the program prints a friendly message.
4. 🔄 Handling Multiple Exceptions
A program can face different types of errors, so we can handle them separately.
💡 Example:
try:
x = int("abc")
except ValueError:
print("Error: Invalid number format")
except ZeroDivisionError:
print("Error: Division by zero")
👉 Each error is handled in a specific way.
5. 🧾 Finally Block
The finally block always executes, whether an error occurs or not.
💡 Example:
try:
print("Processing...")
result = 10 / 2
except ZeroDivisionError:
print("Error occurred")
finally:
print("Program execution completed")
👉 Useful for cleanup tasks like closing files or connections.
6. ➕ Else Block
The else block runs only when no exception occurs.
💡 Example:
try:
result = 10 / 2
except ZeroDivisionError:
print("Error occurred")
else:
print("No error occurred. Result is:", result)
7. 🧠 What are Exception Classes?
In Python, every error is an object created from a class.
All exception classes inherit from:
BaseException
Most user-level exceptions come from:
Exception
👉 This is why Python exceptions are part of Object-Oriented Programming.
8. 📚 Common Built-in Exception Classes
| Exception Type | Meaning |
|---|---|
| ValueError | Invalid value |
| TypeError | Wrong data type |
| ZeroDivisionError | Division by zero |
| IndexError | Invalid list index |
| KeyError | Missing dictionary key |
9. 🏗️ Creating Custom Exception Classes
Python allows you to define your own exception types using OOP.
💡 Example:
class AgeError(Exception):
pass
💡 Using Custom Exception:
class AgeError(Exception):
pass
def check_age(age):
if age < 18:
raise AgeError("Age must be 18 or above")
print("Valid age")
try:
check_age(15)
except AgeError as e:
print("Custom Error:", e)
10. 🔗 Exception Class Hierarchy
Understanding the structure helps you handle errors better.
BaseException
↓
Exception
↓
ValueError
TypeError
ZeroDivisionError
IndexError
KeyError
11. 🚨 Raising Exceptions Manually
You can trigger errors intentionally using raise.
💡 Example:
def divide(a, b):
if b == 0:
raise ZeroDivisionError("Cannot divide by zero")
return a / b
print(divide(10, 2))
👉 This is useful for enforcing rules in your program.
12. 🏦 Real-World Example: Bank System
Let’s see how exception handling works in real applications.
💡 Example:
class InsufficientBalance(Exception):
pass
class BankAccount:
def __init__(self, balance):
self.balance = balance
def withdraw(self, amount):
if amount > self.balance:
raise InsufficientBalance("Not enough balance")
self.balance -= amount
return self.balance
account = BankAccount(1000)
try:
account.withdraw(1500)
except InsufficientBalance as e:
print("Transaction Error:", e)
13. ⭐ Why Use Custom Exceptions?
Custom exceptions help you:
✔ Define business rules clearly
✔ Improve code readability
✔ Make debugging easier
✔ Separate logic from error handling
👉 This is widely used in professional applications.
14. ⚠️ Common Mistakes
❌ Using empty except blocks
✔ Always specify the error type
❌ Ignoring exceptions
✔ Log or handle errors properly
❌ Overusing custom exceptions
✔ Use them only when needed
15. 🚀 Best Practices
✔ Use specific exceptions instead of generic ones
✔ Always handle expected errors
✔ Use finally for cleanup tasks
✔ Keep error messages clear
✔ Use custom exceptions for business logic
🏁 Conclusion
Exception handling is a core part of Python programming and Object-Oriented Programming.
It allows you to build applications that are:
- Stable
- Reliable
- User-friendly
- Professional
By mastering exceptions and custom exception classes, you can write safer and more robust Python programs for real-world applications.
0 Comments