try:
    # 可能引發(fā)異常的代碼
    result = 10 / int(input("請(qǐng)輸入一個(gè)除數(shù): "))
except ValueError:
    # 處理值錯(cuò)誤（例如輸入的不是數(shù)字）
    print("錯(cuò)誤：請(qǐng)輸入一個(gè)有效的整數(shù)！")
except ZeroDivisionError:
    # 處理除零錯(cuò)誤
    print("錯(cuò)誤：除數(shù)不能為零！")
else:
    # 如果沒(méi)有異常發(fā)生，執(zhí)行這里的代碼
    print(f"計(jì)算結(jié)果為: {result}")
finally:
    # 無(wú)論是否發(fā)生異常，都會(huì)執(zhí)行的代碼（常用于清理資源）
    print("程序執(zhí)行完畢。")

BaseException
 ├── SystemExit
 ├── KeyboardInterrupt
 ├── GeneratorExit
 └── Exception
      ├── ArithmeticError
      │    ├── ZeroDivisionError
      │    └── FloatingPointError
      ├── LookupError
      │    ├── IndexError
      │    └── KeyError
      ├── OSError
      │    ├── FileNotFoundError
      │    └── PermissionError
      ├── ValueError
      ├── TypeError
      └── ... # 許多其他內(nèi)置異常

class MyCustomError(Exception):
    """我的自定義異常"""
    pass

# 使用
def example_function():
    raise MyCustomError("發(fā)生了自定義錯(cuò)誤")

try:
    example_function()
except MyCustomError as e:
    print(f"捕獲到自定義異常: {e}")

class ValidationError(Exception):
    """數(shù)據(jù)驗(yàn)證失敗的異常"""
    
    def __init__(self, message, field_name=None, value=None):
        self.message = message
        self.field_name = field_name  # 哪個(gè)字段驗(yàn)證失敗
        self.value = value            # 失敗時(shí)的值是什么
        # 構(gòu)造完整的錯(cuò)誤信息
        full_message = message
        if field_name:
            full_message += f" (字段: {field_name})"
        if value is not None:
            full_message += f" (值: {value})"
        super().__init__(full_message)
    
    def get_field_name(self):
        """獲取字段名的輔助方法"""
        return self.field_name

# 使用
def validate_age(age):
    if not isinstance(age, int):
        raise ValidationError("年齡必須是整數(shù)", "age", age)
    if age < 0:
        raise ValidationError("年齡不能為負(fù)數(shù)", "age", age)
    if age > 150:
        raise ValidationError("年齡不能超過(guò)150歲", "age", age)

try:
    validate_age(-5)
except ValidationError as e:
    print(f"驗(yàn)證錯(cuò)誤: {e}")
    print(f"錯(cuò)誤字段: {e.get_field_name()}")
    print(f"錯(cuò)誤值: {e.value}")

# 基礎(chǔ)應(yīng)用異常
class AppError(Exception):
    """所有應(yīng)用異常的基類"""
    pass

# 業(yè)務(wù)邏輯異常
class BusinessError(AppError):
    """業(yè)務(wù)邏輯異常的基類"""
    pass

class PaymentError(BusinessError):
    """支付相關(guān)異常的基類"""
    pass

class InsufficientFundsError(PaymentError):
    """余額不足異常"""
    def __init__(self, balance, amount):
        self.balance = balance
        self.amount = amount
        super().__init__(f"余額不足。當(dāng)前余額: {balance}, 所需金額: {amount}")

class PaymentProcessingError(PaymentError):
    """支付處理失敗異常"""
    pass

# 數(shù)據(jù)驗(yàn)證異常
class ValidationError(AppError):
    """數(shù)據(jù)驗(yàn)證異常的基類"""
    pass

# 使用層次化的異常
def process_payment(user_balance, amount):
    if user_balance < amount:
        raise InsufficientFundsError(user_balance, amount)
    # 模擬其他支付錯(cuò)誤
    if amount == 0:
        raise PaymentProcessingError("支付金額不能為零")
    return True

try:
    process_payment(100, 150)
except InsufficientFundsError as e:
    print(f"需要處理余額不足: {e}")
except PaymentError as e:
    print(f"其他支付錯(cuò)誤: {e}")
except BusinessError as e:
    print(f"其他業(yè)務(wù)錯(cuò)誤: {e}")

class DataProcessingError(Exception):
    """數(shù)據(jù)處理錯(cuò)誤"""
    pass

def process_data(data):
    try:
        # 可能引發(fā)多種底層異常
        result = complex_operation(data)
        return result
    except (ValueError, TypeError) as e:
        # 使用 from 關(guān)鍵字鏈?zhǔn)疆惓?
        raise DataProcessingError(f"處理數(shù)據(jù)時(shí)發(fā)生錯(cuò)誤: {data}") from e

def complex_operation(data):
    if not isinstance(data, dict):
        raise TypeError("需要字典類型數(shù)據(jù)")
    if "value" not in data:
        raise ValueError("數(shù)據(jù)中缺少'value'字段")
    return data["value"] * 2

try:
    process_data("invalid")
except DataProcessingError as e:
    print(f"捕獲到處理錯(cuò)誤: {e}")
    print(f"根本原因: {e.__cause__}")  # 訪問(wèn)鏈?zhǔn)疆惓?

import sys
import logging

def global_exception_handler(exc_type, exc_value, exc_traceback):
    """全局異常處理器"""
    # 忽略KeyboardInterrupt，讓用戶正常退出
    if issubclass(exc_type, KeyboardInterrupt):
        sys.__excepthook__(exc_type, exc_value, exc_traceback)
        return
    
    logging.error(
        "未捕獲的異常",
        exc_info=(exc_type, exc_value, exc_traceback)
    )
    
    # 可以在這里添加其他處理邏輯，如發(fā)送郵件、重啟服務(wù)等
    print(f"緊急：發(fā)生未處理異常 {exc_type.__name__}: {exc_value}")

# 設(shè)置全局異常鉤子
sys.excepthook = global_exception_handler

# 測(cè)試
def cause_unhandled_error():
    raise ValueError("這是一個(gè)未處理的錯(cuò)誤")

# 這個(gè)異常不會(huì)被try/except捕獲，但會(huì)被我們的全局鉤子處理
cause_unhandled_error()

user_management/
├── __init__.py
├── exceptions.py    # 異常定義
├── models.py        # 數(shù)據(jù)模型
├── validators.py    # 驗(yàn)證器
└── main.py          # 主程序

# exceptions.py
"""
用戶管理系統(tǒng)的異常定義模塊
"""

class UserManagementError(Exception):
    """所有用戶管理系統(tǒng)異常的基類"""
    default_message = "用戶管理錯(cuò)誤"
    
    def __init__(self, message=None, **kwargs):
        self.message = message or self.default_message
        self.context = kwargs  # 額外的上下文信息
        super().__init__(self.message)
    
    def __str__(self):
        if self.context:
            return f"{self.message} [上下文: {self.context}]"
        return self.message

class ValidationError(UserManagementError):
    """數(shù)據(jù)驗(yàn)證錯(cuò)誤基類"""
    default_message = "數(shù)據(jù)驗(yàn)證失敗"

class UserValidationError(ValidationError):
    """用戶數(shù)據(jù)驗(yàn)證錯(cuò)誤"""
    default_message = "用戶數(shù)據(jù)驗(yàn)證失敗"

class EmailValidationError(UserValidationError):
    """郵箱格式錯(cuò)誤"""
    default_message = "郵箱格式無(wú)效"

class PasswordValidationError(UserValidationError):
    """密碼強(qiáng)度不足錯(cuò)誤"""
    default_message = "密碼強(qiáng)度不足"

class DatabaseError(UserManagementError):
    """數(shù)據(jù)庫(kù)操作錯(cuò)誤基類"""
    default_message = "數(shù)據(jù)庫(kù)操作失敗"

class UserNotFoundError(DatabaseError):
    """用戶未找到錯(cuò)誤"""
    default_message = "用戶不存在"

class DuplicateUserError(DatabaseError):
    """重復(fù)用戶錯(cuò)誤"""
    default_message = "用戶已存在"

class AuthenticationError(UserManagementError):
    """認(rèn)證錯(cuò)誤基類"""
    default_message = "認(rèn)證失敗"

class InvalidCredentialsError(AuthenticationError):
    """無(wú)效憑證錯(cuò)誤"""
    default_message = "用戶名或密碼錯(cuò)誤"

class AccountLockedError(AuthenticationError):
    """賬戶鎖定錯(cuò)誤"""
    default_message = "賬戶已被鎖定"

class PermissionError(UserManagementError):
    """權(quán)限錯(cuò)誤"""
    default_message = "權(quán)限不足"

# models.py
from dataclasses import dataclass
from typing import Optional

@dataclass
class User:
    id: Optional[int] = None
    username: str = ""
    email: str = ""
    password_hash: str = ""
    is_locked: bool = False

# validators.py
import re
from .exceptions import EmailValidationError, PasswordValidationError

def validate_email(email):
    """驗(yàn)證郵箱格式"""
    pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
    if not re.match(pattern, email):
        raise EmailValidationError(
            f"郵箱格式無(wú)效: {email}",
            email=email,
            pattern=pattern
        )
    return True

def validate_password(password):
    """驗(yàn)證密碼強(qiáng)度"""
    if len(password) < 8:
        raise PasswordValidationError(
            "密碼至少需要8個(gè)字符",
            password_length=len(password),
            requirement="min_length_8"
        )
    
    if not any(char.isdigit() for char in password):
        raise PasswordValidationError(
            "密碼必須包含至少一個(gè)數(shù)字",
            requirement="contains_digit"
        )
    
    if not any(char.isupper() for char in password):
        raise PasswordValidationError(
            "密碼必須包含至少一個(gè)大寫(xiě)字母",
            requirement="contains_uppercase"
        )
    
    return True

# user_service.py
from typing import List, Optional
from .exceptions import (
    UserNotFoundError, DuplicateUserError, InvalidCredentialsError,
    AccountLockedError, PermissionError
)
from .models import User
from .validators import validate_email, validate_password

class UserService:
    def __init__(self):
        # 模擬數(shù)據(jù)庫(kù)
        self.users: List[User] = []
        self.next_id = 1
    
    def create_user(self, username: str, email: str, password: str) -> User:
        """創(chuàng)建新用戶"""
        try:
            # 驗(yàn)證輸入
            validate_email(email)
            validate_password(password)
            
            # 檢查是否已存在
            if any(u.username == username for u in self.users):
                raise DuplicateUserError(
                    f"用戶名已存在: {username}",
                    username=username
                )
            
            if any(u.email == email for u in self.users):
                raise DuplicateUserError(
                    f"郵箱已存在: {email}",
                    email=email
                )
            
            # 創(chuàng)建用戶（實(shí)際項(xiàng)目中應(yīng)該哈希密碼）
            user = User(
                id=self.next_id,
                username=username,
                email=email,
                password_hash=password,  # 簡(jiǎn)化處理，實(shí)際應(yīng)使用哈希
                is_locked=False
            )
            
            self.users.append(user)
            self.next_id += 1
            return user
            
        except Exception as e:
            # 重新拋出已知的異常類型
            if isinstance(e, (DuplicateUserError, EmailValidationError, PasswordValidationError)):
                raise
            # 將未知異常包裝為系統(tǒng)異常
            raise UserManagementError("創(chuàng)建用戶時(shí)發(fā)生意外錯(cuò)誤") from e
    
    def authenticate(self, username: str, password: str) -> User:
        """用戶認(rèn)證"""
        user = self.find_by_username(username)
        if not user:
            raise InvalidCredentialsError(
                "用戶名或密碼錯(cuò)誤",
                username=username
            )
        
        if user.is_locked:
            raise AccountLockedError(
                "賬戶已被鎖定，請(qǐng)聯(lián)系管理員",
                user_id=user.id,
                username=username
            )
        
        # 簡(jiǎn)化密碼驗(yàn)證（實(shí)際應(yīng)使用哈希比較）
        if user.password_hash != password:
            raise InvalidCredentialsError(
                "用戶名或密碼錯(cuò)誤",
                username=username
            )
        
        return user
    
    def find_by_username(self, username: str) -> Optional[User]:
        """根據(jù)用戶名查找用戶"""
        for user in self.users:
            if user.username == username:
                return user
        return None
    
    def get_user(self, user_id: int) -> User:
        """獲取用戶詳情"""
        for user in self.users:
            if user.id == user_id:
                return user
        
        raise UserNotFoundError(
            f"用戶ID不存在: {user_id}",
            user_id=user_id
        )
    
    def delete_user(self, current_user: User, target_user_id: int) -> bool:
        """刪除用戶（需要權(quán)限）"""
        # 檢查權(quán)限（簡(jiǎn)化版）
        if not current_user or current_user.id != 1:  # 假設(shè)ID=1是管理員
            raise PermissionError(
                "需要管理員權(quán)限才能刪除用戶",
                current_user_id=current_user.id if current_user else None,
                required_permission="admin"
            )
        
        target_user = self.get_user(target_user_id)
        self.users = [u for u in self.users if u.id != target_user_id]
        return True

# main.py
from .exceptions import (
    UserManagementError, ValidationError, DatabaseError, 
    AuthenticationError, PermissionError
)
from .user_service import UserService

def main():
    service = UserService()
    
    # 演示各種異常情況
    test_cases = [
        # 正常創(chuàng)建用戶
        lambda: service.create_user("alice", "alice@example.com", "Secure123"),
        # 郵箱格式錯(cuò)誤
        lambda: service.create_user("bob", "invalid-email", "Password1"),
        # 密碼強(qiáng)度不足
        lambda: service.create_user("charlie", "charlie@example.com", "weak"),
        # 重復(fù)用戶名
        lambda: service.create_user("alice", "alice2@example.com", "Another123"),
        # 認(rèn)證測(cè)試
        lambda: service.authenticate("alice", "Secure123"),
        lambda: service.authenticate("alice", "WrongPassword"),
        lambda: service.authenticate("nonexistent", "Password1"),
        # 權(quán)限測(cè)試
        lambda: service.delete_user(service.get_user(2), 1)  # 非管理員刪除用戶
    ]
    
    for i, test_case in enumerate(test_cases):
        print(f"\n=== 測(cè)試用例 {i + 1} ===")
        try:
            result = test_case()
            print(f"? 成功: {result}")
        except PermissionError as e:
            print(f"? 權(quán)限錯(cuò)誤: {e}")
        except AuthenticationError as e:
            print(f"? 認(rèn)證錯(cuò)誤: {e}")
        except ValidationError as e:
            print(f"? 驗(yàn)證錯(cuò)誤: {e}")
        except DatabaseError as e:
            print(f"? 數(shù)據(jù)庫(kù)錯(cuò)誤: {e}")
        except UserManagementError as e:
            print(f"? 用戶管理錯(cuò)誤: {e}")
        except Exception as e:
            print(f"? 未預(yù)期的錯(cuò)誤: {e}")

if __name__ == "__main__":
    main()