Python自定义异常详解 - 继承Exception创建业务异常

# 最简单的自定义异常
class MyCustomError(Exception):
    """自定义异常基类"""
    pass

# 使用自定义异常
def check_value(value):
    if value < 0:
        raise MyCustomError("值不能为负数")
    return value * 2

try:
    check_value(-5)
except MyCustomError as e:
    print(f"捕获到异常：{e}")

class APIError(Exception):
    """API调用异常，携带错误码和详情"""
    
    def __init__(self, error_code, message, details=None):
        self.error_code = error_code
        self.message = message
        self.details = details
        super().__init__(self.message)
    
    def __str__(self):
        return f"[{self.error_code}] {self.message}"
    
    def __repr__(self):
        return f"{self.__class__.__name__}(error_code={self.error_code!r}, message={self.message!r})"

# 使用
def call_api(endpoint):
    if endpoint == "/users":
        raise APIError(404, "用户接口未找到", {"path": "/users"})
    return {"data": "success"}

try:
    call_api("/users")
except APIError as e:
    print(f"错误码：{e.error_code}")
    print(f"错误信息：{e.message}")
    print(f"详细信息：{e.details}")
    print(f"异常字符串：{e}")

# 自定义异常层级设计
class AppError(Exception):
    """应用程序异常基类"""
    def __init__(self, message, error_code=None):
        self.error_code = error_code
        super().__init__(message)

class ValidationError(AppError):
    """数据验证异常"""
    pass

class DatabaseError(AppError):
    """数据库操作异常"""
    def __init__(self, message, query=None):
        self.query = query
        super().__init__(message, error_code="DB_ERR")

class AuthenticationError(AppError):
    """认证异常"""
    pass

class PermissionDeniedError(AuthenticationError):
    """权限不足异常"""
    pass

# 使用示例
def process_payment(amount, user_role):
    if amount <= 0:
        raise ValidationError("金额必须大于0", error_code="VAL_001")
    if user_role != "admin":
        raise PermissionDeniedError("只有管理员可以处理付款", error_code="AUTH_003")

try:
    process_payment(-100, "user")
except ValidationError as e:
    print(f"验证失败：{e}，错误码：{e.error_code}")
except AppError as e:
    print(f"应用异常：{e}")

class OrderError(Exception):
    """订单异常基类"""
    def __init__(self, message, order_id=None):
        self.order_id = order_id
        super().__init__(message)

class InventoryError(OrderError):
    """库存不足异常"""
    def __init__(self, message, product_id=None, available=None):
        self.product_id = product_id
        self.available = available
        super().__init__(message)

class PaymentError(OrderError):
    """支付异常"""
    def __init__(self, message, amount=None, method=None):
        self.amount = amount
        self.method = method
        super().__init__(message)

def place_order(product_id, quantity, user_balance):
    stock = get_stock(product_id)
    if quantity > stock:
        raise InventoryError(
            f"商品{product_id}库存不足",
            product_id=product_id,
            available=stock
        )
    
    price = get_price(product_id) * quantity
    if user_balance < price:
        raise PaymentError(
            f"余额不足，需要{price}元",
            amount=price,
            method="balance"
        )
    
    return {"status": "success", "order_id": "ORD001"}

def get_stock(pid): return 5
def get_price(pid): return 100

# 测试
try:
    place_order("P001", 10, 500)
except InventoryError as e:
    print(f"库存问题：{e}，当前库存：{e.available}")
except PaymentError as e:
    print(f"支付问题：{e}，需要金额：{e.amount}")
except OrderError as e:
    print(f"订单异常：{e}")

class RetryableError(Exception):
    """可重试的错误"""
    def __init__(self, message, retry_after=None):
        self.retry_after = retry_after
        super().__init__(message)

def retry(func, max_retries=3):
    """带重试的函数执行器"""
    for attempt in range(max_retries):
        try:
            return func()
        except RetryableError as e:
            print(f"第{attempt + 1}次失败：{e}")
            if attempt == max_retries - 1:
                raise
    return None

# 模拟网络请求
request_count = 0
def mock_api_call():
    global request_count
    request_count += 1
    if request_count < 3:
        raise RetryableError("服务暂时不可用", retry_after=1)
    return "success"

result = retry(mock_api_call, max_retries=3)
print(f"最终结果：{result}")