Python学习--ZeroDivisionError 详解

def integer_division():    """整数除法中的除零错误"""    # 整数除法    try:        result = 10 // 0    except ZeroDivisionError as e:        print(f"整数除法错误: {e}")    # 普通除法    try:        result = 10 / 0    except ZeroDivisionError as e:        print(f"普通除法错误: {e}")    # 取模运算    try:        result = 10 % 0    except ZeroDivisionError as e:        print(f"取模运算错误: {e}")    # divmod 函数    try:        result = divmod(10, 0)    except ZeroDivisionError as e:        print(f"divmod 错误: {e}")integer_division()

def float_division():    """浮点数除法中的除零错误"""    # 浮点数除零也会报错    try:        result = 10.0 / 0.0    except ZeroDivisionError as e:        print(f"浮点数除法错误: {e}")    # 混合类型    try:        result = 10 / 0.0    except ZeroDivisionError as e:        print(f"混合类型除法错误: {e}")    # 注意：某些情况下浮点数除零会返回 inf 而不是报错    import numpy as np    # print(np.array([1.0]) / 0.0)  # numpy 会返回 inf，不是报错float_division()

def compound_operations():    """复合运算中的除零"""    # 赋值运算    x = 10    try:        x /= 0    except ZeroDivisionError as e:        print(f"赋值除法错误: {e}")    # 函数调用中的除法    def divide(a, b):        return a / b    try:        result = divide(10, 0)    except ZeroDivisionError as e:        print(f"函数调用错误: {e}")    # 列表推导式中的除法    try:        results = [10 / i for i in [2, 0, 4]]    except ZeroDivisionError as e:        print(f"列表推导式错误: {e}")compound_operations()

def average_calculation():    """计算平均值时的除零问题"""    def calculate_average(numbers):        """计算平均值（不安全的版本）"""        return sum(numbers) / len(numbers)    def safe_average(numbers):        """安全的平均值计算"""        if not numbers:            return 0  # 或 raise ValueError("列表为空")        return sum(numbers) / len(numbers)    # 空列表导致除零    empty_list = []    try:        result = calculate_average(empty_list)    except ZeroDivisionError as e:        print(f"空列表平均值错误: {e}")    # 安全版本    print(f"空列表安全平均值: {safe_average(empty_list)}")    print(f"正常列表平均值: {safe_average([10, 20, 30])}")average_calculation()

def ratio_calculation():    """比例计算中的除零问题"""    def calculate_ratio(part, total):        """计算比例"""        return part / total    def safe_ratio(part, total, default=0):        """安全的比例计算"""        if total == 0:            return default        return part / total    # 总数为0    try:        ratio = calculate_ratio(50, 0)    except ZeroDivisionError as e:        print(f"比例计算错误: {e}")    # 安全版本    print(f"安全比例: {safe_ratio(50, 0)}")    print(f"安全比例（自定义默认值）: {safe_ratio(50, 0, default=1)}")    print(f"正常比例: {safe_ratio(50, 100)}")ratio_calculation()

def normalization():    """数据归一化中的除零问题"""    def normalize(data):        """归一化数据（不安全的版本）"""        min_val = min(data)        max_val = max(data)        return [(x - min_val) / (max_val - min_val) for x in data]    def safe_normalize(data):        """安全的归一化"""        if not data:            return []        min_val = min(data)        max_val = max(data)        # 如果所有值相等，避免除零        if max_val == min_val:            return [0.5] * len(data)  # 或返回 [0] * len(data)        return [(x - min_val) / (max_val - min_val) for x in data]    # 所有值相同的情况    same_values = [5, 5, 5, 5]    try:        result = normalize(same_values)    except ZeroDivisionError as e:        print(f"归一化错误: {e}")    # 安全版本    print(f"安全归一化: {safe_normalize(same_values)}")    print(f"正常归一化: {safe_normalize([1, 2, 3, 4, 5])}")normalization()

def slope_calculation():    """计算斜率时的除零问题"""    def calculate_slope(x1, y1, x2, y2):        """计算两点间的斜率"""        return (y2 - y1) / (x2 - x1)    def safe_slope(x1, y1, x2, y2, default=None):        """安全的斜率计算"""        dx = x2 - x1        if dx == 0:            if default is not None:                return default            raise ValueError("垂直线，斜率无限大")        return (y2 - y1) / dx    # 垂直线（x 坐标相同）    try:        slope = calculate_slope(5, 1, 5, 10)    except ZeroDivisionError as e:        print(f"斜率计算错误: {e}")    # 安全版本    print(f"安全斜率: {safe_slope(5, 1, 5, 10, default=float('inf'))}")    try:        print(f"安全斜率（无默认值）: {safe_slope(5, 1, 5, 10)}")    except ValueError as e:        print(f"错误: {e}")slope_calculation()

def conditional_check():    """使用条件判断避免除零"""    def safe_divide(a, b):        """使用条件判断的安全除法"""        if b == 0:            return None  # 或返回其他默认值        return a / b    # 测试    print(safe_divide(10, 2))   # 5.0    print(safe_divide(10, 0))   # None    def divide_with_default(a, b, default=0):        """带默认值的除法"""        return a / b if b != 0 else default    print(divide_with_default(10, 2, 0))    # 5.0    print(divide_with_default(10, 0, 0))    # 0    print(divide_with_default(10, 0, float('inf')))  # infconditional_check()

def try_except_handling():    """使用异常处理捕获除零错误"""    def safe_divide(a, b):        """使用异常处理的安全除法"""        try:            return a / b        except ZeroDivisionError:            return None    def divide_with_fallback(a, b, fallback_func=None):        """带回退函数的除法"""        try:            return a / b        except ZeroDivisionError:            if fallback_func:                return fallback_func(a, b)            return None    def alternative_calculation(a, b):        """替代计算方法"""        return f"无法计算 {a}/{b}，使用替代方案"    # 测试    print(safe_divide(10, 2))   # 5.0    print(safe_divide(10, 0))   # None    result = divide_with_fallback(10, 0, alternative_calculation)    print(result)  # 无法计算 10/0，使用替代方案try_except_handling()

from contextlib import contextmanagerdef context_manager():    """使用上下文管理器处理除零"""    @contextmanager    def ignore_zero_division(default=None):        """忽略除零错误的上下文管理器"""        try:            yield        except ZeroDivisionError:            return default    # 使用    with ignore_zero_division(0) as result:        result = 10 / 0    print(f"结果: {result}")  # 0    # 在循环中使用    values = [(10, 2), (10, 0), (20, 4), (30, 0)]    results = []    for a, b in values:        with ignore_zero_division(None) as result:            result = a / b        results.append(result)    print(f"批量除法结果: {results}")context_manager()

def zero_division_handler(default_value=None):    """处理除零错误的装饰器"""    def decorator(func):        def wrapper(*args, **kwargs):            try:                return func(*args, **kwargs)            except ZeroDivisionError:                return default_value        return wrapper    return decoratordef use_decorator():    """使用装饰器处理除零"""    @zero_division_handler(default_value=0)    def divide(a, b):        return a / b    @zero_division_handler(default_value=float('inf'))    def slope(x1, y1, x2, y2):        return (y2 - y1) / (x2 - x1)    # 测试    print(divide(10, 2))    # 5.0    print(divide(10, 0))    # 0    print(slope(1, 1, 1, 5))   # inf（垂直线）    print(slope(1, 1, 5, 5))   # 1.0use_decorator()

def floating_point_precision():    """浮点数精度导致的除零问题"""    # 浮点数精度可能导致看似为0的值实际不为0    x = 0.1 + 0.1 + 0.1 - 0.3    print(f"x = {x}")  # 非常接近0，但不等于0    # 直接比较可能导致问题    try:        result = 10 / x  # x 非常小但不为0，不会抛出异常        print(f"结果: {result}")  # 非常大的数    except ZeroDivisionError:        print("除零错误")    # 解决方案：使用容差比较    EPSILON = 1e-10    if abs(x) < EPSILON:        print("x 被视为0")        result = float('inf')    else:        result = 10 / x    print(f"安全结果: {result}")floating_point_precision()

def integer_division_trap():    """整数除法的陷阱"""    # Python 2 中的整数除法不同    # Python 3 中 / 总是返回浮点数    # 注意：整数除法 //    try:        result = 10 // 0    except ZeroDivisionError as e:        print(f"整数除法错误: {e}")    # 混合类型    try:        result = 10 // 0.0    except ZeroDivisionError as e:        print(f"混合类型整数除法错误: {e}")integer_division_trap()

def data_structure_trap():    """数据结构中的除零问题"""    # 字典中的值可能为0    data = {'a': 10, 'b': 20, 'c': 0}    # 错误的方式    def process_bad(data):        results = {}        for key, value in data.items():            results[key] = 100 / value        return results    # 正确的方式    def process_good(data, default=None):        results = {}        for key, value in data.items():            try:                results[key] = 100 / value            except ZeroDivisionError:                results[key] = default        return results    try:        result = process_bad(data)    except ZeroDivisionError as e:        print(f"错误: {e}")    print(process_good(data, default=float('inf')))data_structure_trap()

def best_practice_check():    """最佳实践：始终检查除数"""    def safe_division(a, b):        """安全的除法"""        # 1. 检查 None        if a is None or b is None:            raise ValueError("参数不能为 None")        # 2. 检查类型        if not isinstance(a, (int, float)) or not isinstance(b, (int, float)):            raise TypeError("参数必须是数字")        # 3. 检查除数        if b == 0:            return float('inf') if a > 0 else float('-inf') if a < 0 else float('nan')        return a / b    # 测试    print(safe_division(10, 2))    # 5.0    print(safe_division(10, 0))    # inf    print(safe_division(-10, 0))   # -inf    print(safe_division(0, 0))     # nanbest_practice_check()

def best_practice_math():    """使用数学库的安全函数"""    import math    class SafeMath:        """安全的数学函数"""        @staticmethod        def div(a, b):            """安全除法"""            if b == 0:                return float('inf') if a > 0 else float('-inf') if a < 0 else float('nan')            return a / b        @staticmethod        def percentage(part, whole):            """计算百分比"""            if whole == 0:                return float('inf') if part > 0 else float('-inf') if part < 0 else float('nan')            return (part / whole) * 100        @staticmethod        def ratio(a, b):            """计算比率"""            if b == 0:                return float('inf')            return a / b        @staticmethod        def safe_mean(data, default=0):            """安全的平均值"""            if not data:                return default            return sum(data) / len(data)    math_safe = SafeMath()    print(math_safe.div(10, 2))           # 5.0    print(math_safe.percentage(50, 200))  # 25.0    print(math_safe.ratio(5, 0))          # inf    print(math_safe.safe_mean([]))        # 0best_practice_math()

from typing import Union, Optionalfrom decimal import Decimal, DivisionByZerodef best_practice_type_hints():    """使用类型注解和验证"""    class SafeCalculator:        """类型安全的计算器"""        @staticmethod        def divide(a: Union[int, float, Decimal],                    b: Union[int, float, Decimal],                   default: Optional[Union[int, float, Decimal]] = None) -> Union[int, float, Decimal, None]:            """            安全除法            """            # 验证参数类型            if not isinstance(a, (int, float, Decimal)):                raise TypeError(f"a 必须是数字类型，得到 {type(a).__name__}")            if not isinstance(b, (int, float, Decimal)):                raise TypeError(f"b 必须是数字类型，得到 {type(b).__name__}")            # 处理 Decimal 类型            if isinstance(b, Decimal):                try:                    return a / b                except DivisionByZero:                    return default            # 处理普通数字            try:                return a / b            except ZeroDivisionError:                return default    calc = SafeCalculator()    print(calc.divide(10, 2))          # 5.0    print(calc.divide(10, 0, 0))       # 0    print(calc.divide(10, 0, float('inf')))  # infbest_practice_type_hints()