📘 Multiple Exceptions: Handling Different Errors

🎯 Introduction

Welcome to this exciting tutorial on handling multiple exceptions in Python! 🎉 Have you ever wondered how to gracefully handle different types of errors in your programs? Today, we’ll explore the art of catching and managing multiple exceptions like a pro!

You’ll discover how handling multiple exceptions can make your Python applications more robust and user-friendly. Whether you’re building web applications 🌐, processing data 📊, or creating automation scripts 🤖, understanding multiple exception handling is essential for writing bulletproof code.

By the end of this tutorial, you’ll feel confident handling any combination of errors that come your way! Let’s dive in! 🏊‍♂️

📚 Understanding Multiple Exceptions

🤔 What are Multiple Exceptions?

Handling multiple exceptions is like being a skilled juggler 🤹 - you need to catch different types of balls (errors) and handle each one appropriately. Think of it as having different safety nets for different circus acts!

In Python terms, multiple exception handling allows you to catch and respond to different error types in a single try block. This means you can:

• ✨ Handle different errors with specific responses
• 🚀 Keep your code running smoothly
• 🛡️ Provide meaningful feedback to users

💡 Why Handle Multiple Exceptions?

Here’s why developers love multiple exception handling:

1. Specific Error Handling 🎯: Respond appropriately to each error type
2. Better User Experience 💻: Provide helpful error messages
3. Code Resilience 🛡️: Prevent crashes from unexpected errors
4. Cleaner Code 🧹: Organize error handling logically

Real-world example: Imagine building a file processor 📁. You might encounter file not found errors, permission errors, or disk full errors - each needing different handling!

🔧 Basic Syntax and Usage

📝 Simple Example

Let’s start with a friendly example:

# 👋 Hello, Multiple Exceptions!
def divide_numbers(a, b):
    try:
        # 🎯 The risky operation
        result = a / b
        print(f"Result: {result} ✨")
        return result
    except ZeroDivisionError:
        # 🚫 Handle division by zero
        print("Oops! Can't divide by zero! 🤯")
        return None
    except TypeError:
        # ❌ Handle wrong data types
        print("Please provide numbers only! 🔢")
        return None

# 🎮 Let's test it!
divide_numbers(10, 2)    # Works great!
divide_numbers(10, 0)    # Catches zero division
divide_numbers(10, "2")  # Catches type error

💡 Explanation: Notice how we handle each exception type separately! This gives us precise control over error responses.

🎯 Common Patterns

Here are patterns you’ll use daily:

# 🏗️ Pattern 1: Multiple except blocks
def process_user_input(data):
    try:
        # 🎨 Process the data
        value = int(data)
        result = 100 / value
        return f"Success! Result is {result} 🎉"
    except ValueError:
        # 📝 Handle conversion errors
        return "Please enter a valid number! 🔢"
    except ZeroDivisionError:
        # 🚫 Handle division by zero
        return "Zero is not allowed! 🚫"
    except Exception as e:
        # 🛡️ Catch-all for unexpected errors
        return f"Something went wrong: {e} 😅"

# 🎨 Pattern 2: Catching multiple exceptions together
def read_config_file(filename):
    try:
        # 📖 Try to read the file
        with open(filename, 'r') as f:
            return f.read()
    except (FileNotFoundError, PermissionError) as e:
        # 📁 Handle file-related errors together
        print(f"File error: {e} 📁")
        return None

# 🔄 Pattern 3: Exception hierarchy
def safe_operation(data):
    try:
        # 🎯 Some risky operation
        process_data(data)
    except KeyboardInterrupt:
        # ⌨️ Always catch this first!
        print("Operation cancelled by user! 🛑")
        raise  # Re-raise to allow proper cleanup
    except Exception as e:
        # 🛡️ General exception handler
        print(f"Error occurred: {e} 😔")

💡 Practical Examples

🛒 Example 1: Online Shopping Cart

Let’s build something real:

# 🛍️ Define our shopping cart with error handling
class ShoppingCart:
    def __init__(self):
        self.items = {}  # 🛒 Our cart storage
        self.max_items = 10  # 📦 Cart limit
    
    def add_item(self, item_name, price, quantity):
        """Add item to cart with multiple error checks! 🎯"""
        try:
            # 🔍 Validate inputs
            if not isinstance(item_name, str):
                raise TypeError("Item name must be text! 📝")
            
            if price <= 0:
                raise ValueError("Price must be positive! 💰")
            
            if quantity <= 0:
                raise ValueError("Quantity must be at least 1! 🔢")
            
            if len(self.items) >= self.max_items:
                raise OverflowError("Cart is full! 📦")
            
            # ✨ Add to cart
            self.items[item_name] = {
                'price': float(price),
                'quantity': int(quantity),
                'emoji': self._get_item_emoji(item_name)
            }
            
            print(f"Added {quantity}x {item_name} to cart! {self._get_item_emoji(item_name)}")
            
        except TypeError as e:
            print(f"❌ Type Error: {e}")
        except ValueError as e:
            print(f"⚠️ Value Error: {e}")
        except OverflowError as e:
            print(f"🚫 Cart Error: {e}")
        except Exception as e:
            print(f"😱 Unexpected error: {e}")
    
    def _get_item_emoji(self, item_name):
        """Get emoji for items! 🎨"""
        emojis = {
            'apple': '🍎', 'banana': '🍌', 'coffee': '☕',
            'pizza': '🍕', 'book': '📚', 'laptop': '💻'
        }
        return emojis.get(item_name.lower(), '📦')
    
    def checkout(self):
        """Calculate total with error handling! 💰"""
        try:
            if not self.items:
                raise ValueError("Cart is empty! 🛒")
            
            total = sum(item['price'] * item['quantity'] 
                       for item in self.items.values())
            
            print(f"\n🧾 Your cart total: ${total:.2f}")
            return total
            
        except ValueError as e:
            print(f"⚠️ Checkout Error: {e}")
            return 0
        except Exception as e:
            print(f"💥 Checkout failed: {e}")
            return 0

# 🎮 Let's use our cart!
cart = ShoppingCart()

# ✅ Valid additions
cart.add_item("Apple", 1.99, 3)
cart.add_item("Coffee", 4.99, 1)

# ❌ Invalid additions (will be caught!)
cart.add_item(123, 2.99, 1)         # Wrong type
cart.add_item("Banana", -1.00, 2)   # Negative price
cart.add_item("Pizza", 9.99, 0)     # Zero quantity

# 💰 Checkout
cart.checkout()

🎯 Try it yourself: Add a remove_item method with its own exception handling!

🎮 Example 2: Game Save System

Let’s make it fun with a game save system:

import json
import os

# 🏆 Game save system with robust error handling
class GameSaveManager:
    def __init__(self, save_directory="game_saves"):
        self.save_dir = save_directory
        self._ensure_save_directory()
    
    def _ensure_save_directory(self):
        """Create save directory if needed! 📁"""
        try:
            os.makedirs(self.save_dir, exist_ok=True)
        except PermissionError:
            print("⚠️ No permission to create save directory!")
        except Exception as e:
            print(f"📁 Directory error: {e}")
    
    def save_game(self, player_name, game_data):
        """Save game with multiple error checks! 💾"""
        try:
            # 🔍 Validate player name
            if not player_name or not isinstance(player_name, str):
                raise ValueError("Invalid player name! 👤")
            
            # 🎮 Validate game data
            if not isinstance(game_data, dict):
                raise TypeError("Game data must be a dictionary! 📖")
            
            # 📝 Add metadata
            save_data = {
                'player': player_name,
                'level': game_data.get('level', 1),
                'score': game_data.get('score', 0),
                'achievements': game_data.get('achievements', []),
                'emoji': '🎮'
            }
            
            # 💾 Save to file
            filename = os.path.join(self.save_dir, f"{player_name}_save.json")
            with open(filename, 'w') as f:
                json.dump(save_data, f, indent=2)
            
            print(f"✅ Game saved for {player_name}! 🎮")
            return True
            
        except ValueError as e:
            print(f"❌ Invalid input: {e}")
        except TypeError as e:
            print(f"❌ Type error: {e}")
        except PermissionError:
            print("🚫 No permission to save file!")
        except IOError:
            print("💾 Disk error - could not save!")
        except Exception as e:
            print(f"😱 Unexpected save error: {e}")
        
        return False
    
    def load_game(self, player_name):
        """Load game with error recovery! 📂"""
        try:
            filename = os.path.join(self.save_dir, f"{player_name}_save.json")
            
            # 📖 Try to load the save
            with open(filename, 'r') as f:
                save_data = json.load(f)
            
            print(f"✅ Loaded save for {player_name}!")
            print(f"📊 Level: {save_data['level']}, Score: {save_data['score']}")
            return save_data
            
        except FileNotFoundError:
            print(f"🔍 No save found for {player_name}")
            return self._create_new_save(player_name)
        except json.JSONDecodeError:
            print("💥 Save file corrupted! Creating backup...")
            self._backup_corrupted_save(filename)
            return self._create_new_save(player_name)
        except PermissionError:
            print("🚫 No permission to read save file!")
        except Exception as e:
            print(f"😱 Load error: {e}")
        
        return None
    
    def _create_new_save(self, player_name):
        """Create a fresh save! 🌟"""
        return {
            'player': player_name,
            'level': 1,
            'score': 0,
            'achievements': ['🌟 First Steps'],
            'emoji': '🎮'
        }
    
    def _backup_corrupted_save(self, filename):
        """Backup corrupted saves! 🛡️"""
        try:
            backup_name = f"{filename}.corrupted"
            os.rename(filename, backup_name)
            print(f"📦 Corrupted save backed up to {backup_name}")
        except:
            pass  # Silently fail backup

# 🎮 Let's test our save system!
save_manager = GameSaveManager()

# ✅ Valid saves
save_manager.save_game("Alice", {'level': 5, 'score': 1000})
save_manager.save_game("Bob", {'level': 3, 'score': 500, 'achievements': ['🏆 First Boss']})

# ❌ Invalid saves (handled gracefully!)
save_manager.save_game("", {'level': 1})          # Empty name
save_manager.save_game("Charlie", "not a dict")   # Wrong type

# 📂 Load games
save_manager.load_game("Alice")      # Existing save
save_manager.load_game("NewPlayer")  # Non-existent save

🚀 Advanced Concepts

🧙‍♂️ Advanced Topic 1: Custom Exception Classes

When you’re ready to level up, create your own exceptions:

# 🎯 Custom exceptions for a banking app
class BankingError(Exception):
    """Base exception for banking operations 🏦"""
    pass

class InsufficientFundsError(BankingError):
    """Not enough money! 💸"""
    def __init__(self, balance, amount):
        self.balance = balance
        self.amount = amount
        super().__init__(f"Cannot withdraw ${amount} from balance ${balance}")

class AccountLockedError(BankingError):
    """Account is locked! 🔒"""
    pass

class InvalidTransactionError(BankingError):
    """Invalid transaction! ❌"""
    pass

# 🏦 Banking system using custom exceptions
class BankAccount:
    def __init__(self, account_number, initial_balance=0):
        self.account_number = account_number
        self.balance = initial_balance
        self.locked = False
        self.transactions = []
    
    def withdraw(self, amount):
        """Withdraw with custom exception handling! 💰"""
        try:
            # 🔒 Check if locked
            if self.locked:
                raise AccountLockedError("Account is locked! 🔒")
            
            # 💵 Check amount validity
            if amount <= 0:
                raise InvalidTransactionError("Amount must be positive! ➕")
            
            # 💸 Check sufficient funds
            if amount > self.balance:
                raise InsufficientFundsError(self.balance, amount)
            
            # ✅ Process withdrawal
            self.balance -= amount
            self.transactions.append(f"Withdrew ${amount} 💸")
            print(f"✅ Withdrew ${amount}. New balance: ${self.balance}")
            
        except AccountLockedError:
            print("🔒 Cannot withdraw - account is locked!")
        except InsufficientFundsError as e:
            print(f"💸 Insufficient funds! You have ${e.balance} but need ${e.amount}")
        except InvalidTransactionError as e:
            print(f"❌ Invalid transaction: {e}")
        except Exception as e:
            print(f"😱 Unexpected error: {e}")

# 🎮 Test our banking system!
account = BankAccount("123456", 100)

account.withdraw(50)    # ✅ Works!
account.withdraw(200)   # 💸 Insufficient funds!
account.withdraw(-10)   # ❌ Invalid amount!

account.locked = True
account.withdraw(10)    # 🔒 Account locked!

🏗️ Advanced Topic 2: Exception Chaining and Context

For the brave developers, let’s explore exception chaining:

# 🚀 Advanced exception chaining
class DataProcessor:
    def __init__(self):
        self.data = []
        self.processed = []
    
    def load_data(self, source):
        """Load data with exception chaining! 📊"""
        try:
            if source == "database":
                # 🗄️ Simulate database loading
                raise ConnectionError("Database unavailable! 🔌")
            elif source == "file":
                # 📁 Simulate file loading
                with open("data.txt", 'r') as f:
                    self.data = f.readlines()
            else:
                raise ValueError(f"Unknown source: {source}")
                
        except FileNotFoundError as e:
            # 🔗 Chain exceptions for context
            raise RuntimeError("Data loading failed! 📁") from e
        except ConnectionError as e:
            # 🔗 Provide alternative suggestion
            print(f"⚠️ {e} - Trying backup source...")
            try:
                self.load_data("file")  # Try alternative
            except Exception as backup_error:
                raise RuntimeError("All data sources failed! 😱") from backup_error
    
    def process_data(self):
        """Process with context managers! 🎨"""
        class ProcessingContext:
            def __enter__(self):
                print("🎬 Starting processing...")
                return self
            
            def __exit__(self, exc_type, exc_val, exc_tb):
                if exc_type is None:
                    print("✅ Processing completed successfully!")
                else:
                    print(f"❌ Processing failed: {exc_val}")
                    # Return False to propagate the exception
                return False
        
        try:
            with ProcessingContext():
                if not self.data:
                    raise ValueError("No data to process! 📊")
                
                # 🎨 Process each item
                for item in self.data:
                    if "error" in item.lower():
                        raise RuntimeError(f"Found error in data: {item.strip()}")
                    self.processed.append(item.upper())
                
        except ValueError as e:
            print(f"⚠️ Data validation error: {e}")
        except RuntimeError as e:
            print(f"💥 Processing error: {e}")
        except Exception as e:
            print(f"😱 Unexpected error: {e}")

# 🎮 Test advanced features!
processor = DataProcessor()

# Try different scenarios
try:
    processor.load_data("database")  # Will fail and try backup
except RuntimeError as e:
    print(f"Final error: {e}")
    print(f"Original cause: {e.__cause__}")

⚠️ Common Pitfalls and Solutions

😱 Pitfall 1: Catching Exceptions Too Broadly

# ❌ Wrong way - catches everything!
try:
    result = risky_operation()
except:  # 😰 This catches EVERYTHING including KeyboardInterrupt!
    print("Something went wrong")

# ✅ Correct way - be specific!
try:
    result = risky_operation()
except ValueError:
    print("Invalid value provided! 📝")
except IOError:
    print("File operation failed! 📁")
except Exception as e:  # 🛡️ Catch other exceptions but not system exits
    print(f"Unexpected error: {e}")

🤯 Pitfall 2: Wrong Exception Order

# ❌ Dangerous - specific exceptions never caught!
try:
    process_file("data.txt")
except Exception:  # 😱 This catches everything first!
    print("General error")
except FileNotFoundError:  # 💥 Never reached!
    print("File not found")

# ✅ Safe - specific exceptions first!
try:
    process_file("data.txt")
except FileNotFoundError:  # 🎯 Specific first
    print("File not found! 📁")
except PermissionError:    # 🔒 Then other specific
    print("No permission! 🚫")
except Exception as e:     # 🛡️ General last
    print(f"Other error: {e}")

🛠️ Best Practices

1. 🎯 Be Specific: Catch specific exceptions, not bare except:
2. 📝 Order Matters: Put specific exceptions before general ones
3. 🛡️ Always Have a Safety Net: Use Exception as last resort
4. 🎨 Create Custom Exceptions: For domain-specific errors
5. ✨ Provide Context: Give helpful error messages to users

🧪 Hands-On Exercise

🎯 Challenge: Build a File Processing System

Create a robust file processor that handles multiple error scenarios:

📋 Requirements:

• ✅ Read files with various formats (txt, json, csv)
• 🏷️ Handle file not found, permission, and format errors
• 👤 Parse and validate data from files
• 📊 Generate error reports for failures
• 🎨 Each operation needs specific error handling!

🚀 Bonus Points:

• Add retry logic for temporary failures
• Create custom exceptions for validation errors
• Implement logging for all errors

💡 Solution

import json
import csv
import time
from datetime import datetime

# 🎯 Custom exceptions for our file processor
class FileProcessingError(Exception):
    """Base exception for file processing 📁"""
    pass

class ValidationError(FileProcessingError):
    """Data validation failed! ❌"""
    pass

class UnsupportedFormatError(FileProcessingError):
    """File format not supported! 📄"""
    pass

# 📊 Our robust file processor!
class FileProcessor:
    def __init__(self):
        self.supported_formats = ['.txt', '.json', '.csv']
        self.processed_files = []
        self.error_log = []
    
    def process_file(self, filename, retry_count=3):
        """Process file with multiple error handlers! 🎯"""
        for attempt in range(retry_count):
            try:
                # 🔍 Check file extension
                if not any(filename.endswith(fmt) for fmt in self.supported_formats):
                    raise UnsupportedFormatError(f"Format not supported: {filename}")
                
                # 📖 Read and process based on type
                if filename.endswith('.json'):
                    data = self._process_json(filename)
                elif filename.endswith('.csv'):
                    data = self._process_csv(filename)
                else:
                    data = self._process_text(filename)
                
                # ✅ Validate data
                self._validate_data(data, filename)
                
                # 🎉 Success!
                self.processed_files.append({
                    'filename': filename,
                    'records': len(data) if isinstance(data, list) else 1,
                    'timestamp': datetime.now().isoformat(),
                    'status': '✅'
                })
                
                print(f"✅ Successfully processed {filename}!")
                return data
                
            except FileNotFoundError:
                self._log_error(filename, "File not found! 🔍")
                print(f"❌ File not found: {filename}")
                break  # Don't retry for missing files
                
            except PermissionError:
                self._log_error(filename, "Permission denied! 🔒")
                print(f"🚫 No permission to read: {filename}")
                break  # Don't retry for permission issues
                
            except json.JSONDecodeError as e:
                self._log_error(filename, f"Invalid JSON: {e} 📋")
                print(f"❌ JSON parsing error in {filename}")
                break  # Don't retry for format errors
                
            except UnsupportedFormatError as e:
                self._log_error(filename, str(e))
                print(f"📄 {e}")
                break
                
            except ValidationError as e:
                self._log_error(filename, f"Validation failed: {e} ⚠️")
                print(f"⚠️ Validation error in {filename}: {e}")
                break
                
            except IOError as e:
                self._log_error(filename, f"IO Error: {e} 💾")
                if attempt < retry_count - 1:
                    print(f"💾 IO Error, retrying in 1 second... (Attempt {attempt + 1}/{retry_count})")
                    time.sleep(1)
                else:
                    print(f"💥 Failed after {retry_count} attempts!")
                    
            except Exception as e:
                self._log_error(filename, f"Unexpected: {e} 😱")
                print(f"😱 Unexpected error processing {filename}: {e}")
                break
        
        return None
    
    def _process_json(self, filename):
        """Process JSON files! 📋"""
        with open(filename, 'r') as f:
            return json.load(f)
    
    def _process_csv(self, filename):
        """Process CSV files! 📊"""
        data = []
        with open(filename, 'r') as f:
            reader = csv.DictReader(f)
            for row in reader:
                data.append(row)
        return data
    
    def _process_text(self, filename):
        """Process text files! 📝"""
        with open(filename, 'r') as f:
            return f.readlines()
    
    def _validate_data(self, data, filename):
        """Validate processed data! 🔍"""
        if not data:
            raise ValidationError("File is empty!")
        
        if isinstance(data, list) and len(data) > 1000:
            raise ValidationError("File too large (>1000 records)!")
    
    def _log_error(self, filename, error_msg):
        """Log errors for reporting! 📝"""
        self.error_log.append({
            'filename': filename,
            'error': error_msg,
            'timestamp': datetime.now().isoformat()
        })
    
    def generate_report(self):
        """Generate processing report! 📊"""
        print("\n📊 File Processing Report")
        print("=" * 40)
        
        print(f"\n✅ Successfully processed: {len(self.processed_files)} files")
        for file_info in self.processed_files:
            print(f"  📁 {file_info['filename']} ({file_info['records']} records)")
        
        print(f"\n❌ Failed to process: {len(self.error_log)} files")
        for error_info in self.error_log:
            print(f"  ⚠️ {error_info['filename']}: {error_info['error']}")

# 🎮 Test our file processor!
processor = FileProcessor()

# Test various scenarios
test_files = [
    "data.json",       # May or may not exist
    "config.txt",      # May or may not exist
    "records.csv",     # May or may not exist
    "image.png",       # Unsupported format
    "protected.txt"    # May have permission issues
]

for filename in test_files:
    processor.process_file(filename)

# 📊 Generate final report
processor.generate_report()

🎓 Key Takeaways

You’ve learned so much! Here’s what you can now do:

• ✅ Handle multiple exceptions with confidence 💪
• ✅ Create specific error responses for different scenarios 🎯
• ✅ Build robust applications that don’t crash easily 🛡️
• ✅ Debug issues by understanding error types 🐛
• ✅ Write professional code with proper error handling! 🚀

Remember: Good error handling is like wearing a seatbelt - you hope you don’t need it, but you’ll be glad it’s there! 🚗

🤝 Next Steps

Congratulations! 🎉 You’ve mastered handling multiple exceptions in Python!

Here’s what to do next:

1. 💻 Practice with the exercises above
2. 🏗️ Add robust error handling to your existing projects
3. 📚 Move on to our next tutorial: Exception Chaining and Context
4. 🌟 Share your error-handling victories with others!

Remember: Every Python expert has encountered countless errors. The difference is they learned to handle them gracefully! Keep coding, keep learning, and most importantly, have fun! 🚀

Happy coding! 🎉🚀✨