在 Python OOP 中处理异常的基础知识

异常处理是编写健壮的 Python 应用程序的一个关键方面，尤其是在面向对象编程 （OOP） 中。它允许您的程序优雅地响应各种错误和异常情况，而不会崩溃或产生不正确的结果。在本节中，我们将介绍在 Python OOP 中处理异常的基础知识，重点介绍 try-except-finally 语法。

了解 Python 中的异常

异常是在程序执行过程中发生的错误。Python 是一种动态语言，容易出现各种异常 — 从阻止程序运行的语法错误到程序执行时发生的运行时错误。

在 OOP 中，异常可能来自各种来源，例如对对象的方法调用、构造函数失败或资源管理问题。正确处理这些异常对于构建具有弹性且用户友好的应用程序至关重要。

try-except-finally块

Python 中异常处理的主要机制是 try-except-finally 块。此结构允许您捕获异常、正常处理异常并执行清理代码，而不管是否发生异常。

try块

try 块允许您测试代码块是否存在错误。这是您认为在执行过程中可能会引发异常的代码的位置。

try:
    # Code that might raise an exception
    result = 10 / 0
except Exception as e:
    # Code to handle the exception
    print(f"An error occurred: {e}")
finally:
    # Code that runs after the try and except blocks
    # This is optional and used for cleanup actions
    print("Execution completed.")

except块

except 块允许您处理异常。您可以指定要捕获的异常类型，从而允许对错误处理进行更精细的控制。如果 try 块中发生异常，则执行 except 块内的代码。

try:
    # Code that might raise an exception
    result = 10 / 0
except Exception as e:
    # Handling exception
    print(f"Division by zero is not allowed: {e}")

finally块

finally 块是可选的，无论是否捕获到异常，都会执行该块。它非常适合执行清理操作，例如关闭文件或释放资源。

try:
    # Code that might raise an exception
    file = open("example.txt", "r")
    data = file.read()
except Exception as e:
    # Handling exception related to I/O operations
    print(f"Failed to read file: {e}")
finally:
    # Cleanup action
    file.close()
    print("File closed.")

异常类型

Python 将异常分为几种类型，每种类型对应于不同的错误情况：

1. 语法错误：解释器在将源代码转换为字节码时检测到的错误。这些不是从 Exception 类派生的，因为它们不是传统意义上的异常。在程序实际运行之前检测到它们。
2. 内置异常： Python 提供了许多处理常见错误情况的内置异常，例如：

• ValueError 错误： 当函数收到正确类型的参数但值不合适时引发。
• TypeError 错误： 当操作或函数应用于不适当类型的对象时出现。
• IndexError：当序列下标超出范围时引发。
• KeyError： 在找不到字典键时发生。
• IOError： 当 I/O 操作因 I/O 相关原因失败时引发，例如，“找不到文件”或“磁盘已满”（在 Python 3.x 中，它称为 OSError）。

用户定义的异常： 用户可以定义自定义异常类来处理其程序中的特定错误情况。这些异常应派生自 Exception 类或其子类之一。

异常是 python 中的类

在 Python 中，异常作为类实现。这种面向对象的异常方法允许 Python 将错误处理与其其他面向对象的功能无缝集成。了解异常是类对于有效的异常处理至关重要，尤其是在定义自定义异常或需要在更复杂的程序中管理各种错误条件时。

了解异常类

Python 异常处理机制的核心是 Exception 类。它是所有其他异常类的基类，这意味着所有异常都直接或间接地从该类继承。此层次结构允许根据异常的特征对其进行分组和处理。

异常类的层次结构

Exception 类是更大的异常类层次结构的一部分，旨在对不同类型的错误进行分类：

• BaseException 的 异常层次结构的根。所有异常类都派生自此类。它包括 SystemExit、KeyboardInterrupt 和 GeneratorExit 等异常，大多数程序都不应捕获这些异常。
• 例外：所有内置的、非系统退出的异常都派生自此类。所有用户定义的异常也应从此类派生。

让我们深入研究一下 Python 中 BaseException 和 Exception 之间的区别：

BaseException的

• BaseException 是 Python 中所有异常的基类。
• 这些异常与特殊情况有关，捕获它们几乎总是错误的做法。
• 错误地处理它们可能会阻止程序、线程或生成器/协程正常关闭。
• 直接从BaseException 继承的异常示例：
  -KeyboardInterrupt：当用户中断程序时引发（例如，按 Ctrl+C）
  - SystemExit：当程序正常退出时引发
  - GeneratorExit：当生成器或协程关闭时引发。

例外：

• Exception 是大多数与系统或解释器无关的用户定义和内置异常的基类。
• 所有用户定义的异常都应继承自 Exception。
• PEP 8 建议从 Exception 而不是 BaseException 派生异常。
• 从 Exception 派生的异常旨在由常规代码处理。
• 从 Exception 继承的异常示例：
  - ValueError：当操作收到不适当的值时引发。
  - TypeError：对不适当类型的对象执行操作时引发。
  - 开发人员在其代码中创建的自定义异常。

总之，对大多数自定义异常使用 Exception，并在捕获异常情况中保留从 BaseException 的直接继承，在这些情况下捕获它们几乎总是错误的方法。

ptyhon 中其他类型的基本异常包括：

异常 ArithmeticError

ArithmeticError 是针对 Python 中的不同算术错误引发的异常的基类。它充当其他几个专门处理算术运算的异常的父类，包括：

• OverflowError：当算术运算产生的结果太大而无法表示时，会发生这种情况。
• ZeroDivisionError 错误：当尝试以零作为分母进行除法或模运算时，会发生这种情况。
• FloatingPoint错误： 当浮点运算失败时会引发此错误，但并不常见，因为默认情况下 Python 倾向于更优雅地处理浮点错误。

作为基类，ArithmeticError 本身可用于异常处理以捕获上述任何错误，而无需单独指定它们。

异常 BufferError

当无法执行与缓冲区（直接指向包含原始数据的内存块的对象）相关的操作时，将引发 BufferError。在涉及缓冲区接口的低级操作的情况下，可能会发生此错误，其中 Python 由于内存或缓冲区约束而无法执行操作。可能引发 BufferError 的常见实例包括缓冲区操作期间的内存分配问题或尝试修改只读缓冲区。

异常 LookupError

LookupError 充当当指定的键或索引对给定数据结构（例如列表、元组、字典等）无效时发生的异常的基类。此类包括：

• IndexError：当尝试访问超出列表或元组边界的索引时，会引发此问题。
• KeyError：当字典（或类似的映射类型）中的查找失败时出现，因为在字典的键集中找不到键。

当您想要同时处理 IndexError 和 KeyError 而不区分它们时，LookupError 本身可以用于异常处理。这使得 LookupError 可用于编写更简洁、更全面的错误处理代码，以处理从各种容器类型访问元素。

这些基本异常有助于编写更灵活和通用的错误处理例程，允许程序员使用单个 except 子句捕获一系列错误。

python 中内置的特定异常

在 Python 中，异常是从基本异常派生的，因此这些异常由运行时直接引发以指示特定的错误条件。这些是直接从基类继承的异常实例，如 Exception，但旨在处理非常具体的方案。与它们的抽象基类（例如 ArithmeticError、LookupError）不同，具体异常对相关异常进行分组，提供有关程序中到底出了什么问题的详细上下文。

以下是 Python 中几个关键异常的摘要和解释：

零除法错误

• 说明：当除法或模运算的分母为零时，会引发此错误。它是 ArithmeticError 的直接实例。
• 示例：result = 1 / 0 触发 ZeroDivisionError。

FileNotFoundError

• 说明：请求文件或目录但不存在时引发。它在文件处理操作中特别有用。
• 示例：open（'nonexistentfile.txt'） 导致 FileNotFoundError。

ValueError

• 解释：当操作或函数收到正确类型的参数但值不适当时，会发生这种情况。
• 示例：int（'xyz'） 尝试将非数字字符串转换为整数，并引发 ValueError。

TypeError （类型错误）

• 说明：当操作或函数应用于不适当类型的对象时引发。关联的值是一个字符串，提供有关类型不匹配的详细信息。
• 示例：3 + '3' 会引发 TypeError，因为它试图添加一个整数和一个字符串。

IndexError

• 说明：尝试访问超出序列范围的索引（如列表或元组）时触发。
• 示例：访问三项列表的第五个元素，如 lst[4] 中所示，将引发 IndexError。

KeyError 错误

• 解释：找不到字典键时引发。这是 LookupError 下的一个特定情况。
• 示例： dict = {'a'： 1}; dict['b'] 会引发 KeyError，因为 'b' 不是字典中的键。

属性错误

• 解释：当属性引用或赋值失败时出现。
• 示例： x = 10;x.append（5） 引发 AttributeError，因为 'int' 对象没有 'append' 方法。

NotImplementedError 错误

• 解释：此异常是由需要子类提供实现的抽象方法或函数引发的。如果他们没有，并且调用了该方法，则会引发 NotImplementedError。
• 示例：调用本应由任何子类实现但尚未实现的类中的方法将引发此错误。

MemoryError （内存错误）

• 解释：当操作内存不足但情况仍可挽救时引发（与导致解释器退出的其他致命错误不同）。
• 示例：这可能发生在超出可用内存的大型数据处理任务中。

OverflowError （溢出错误）

• 解释：当算术运算太大而无法表示时触发。
• 示例：在 Python 中极为罕见的整数，因为 Python 整数是任意精度的，但也可能发生在浮点运算（如指数计算）中。

这些异常对于 Python 中的稳健错误处理至关重要，因为它们允许开发人员以可预测且优雅的方式管理错误。了解这些有助于调试，并通过有效地捕获和处理错误来提高软件的可靠性。

这是 python 中完整的内置异常层次结构：

BaseException
 ├── BaseExceptionGroup
 ├── GeneratorExit
 ├── KeyboardInterrupt
 ├── SystemExit
 └── Exception
      ├── ArithmeticError
      │    ├── FloatingPointError
      │    ├── OverflowError
      │    └── ZeroDivisionError
      ├── AssertionError
      ├── AttributeError
      ├── BufferError
      ├── EOFError
      ├── ExceptionGroup [BaseExceptionGroup]
      ├── ImportError
      │    └── ModuleNotFoundError
      ├── LookupError
      │    ├── IndexError
      │    └── KeyError
      ├── MemoryError
      ├── NameError
      │    └── UnboundLocalError
      ├── OSError
      │    ├── BlockingIOError
      │    ├── ChildProcessError
      │    ├── ConnectionError
      │    │    ├── BrokenPipeError
      │    │    ├── ConnectionAbortedError
      │    │    ├── ConnectionRefusedError
      │    │    └── ConnectionResetError
      │    ├── FileExistsError
      │    ├── FileNotFoundError
      │    ├── InterruptedError
      │    ├── IsADirectoryError
      │    ├── NotADirectoryError
      │    ├── PermissionError
      │    ├── ProcessLookupError
      │    └── TimeoutError
      ├── ReferenceError
      ├── RuntimeError
      │    ├── NotImplementedError
      │    └── RecursionError
      ├── StopAsyncIteration
      ├── StopIteration
      ├── SyntaxError
      │    └── IndentationError
      │         └── TabError
      ├── SystemError
      ├── TypeError
      ├── ValueError
      │    └── UnicodeError
      │         ├── UnicodeDecodeError
      │         ├── UnicodeEncodeError
      │         └── UnicodeTranslateError
      └── Warning
           ├── BytesWarning
           ├── DeprecationWarning
           ├── EncodingWarning
           ├── FutureWarning
           ├── ImportWarning
           ├── PendingDeprecationWarning
           ├── ResourceWarning
           ├── RuntimeWarning
           ├── SyntaxWarning
           ├── UnicodeWarning
           └── UserWarning

Python 中的自定义异常

Python 的灵活性允许您根据应用程序的特定需求定义自定义异常。这些自定义异常可以提供更清晰、更有意义的错误处理，使您的代码更具可读性和可维护性。通过从内置的 Exception 类或其子类之一继承，您可以创建自己的异常层次结构，从而封装特定于应用程序域的各种错误条件。

为什么要定义自定义异常？

自定义异常很有用，原因如下：

• 特 异性：它们可以比 Python 的内置异常更精确地表示特定的错误条件。
• 清晰： 自定义异常可以使您的代码更具可读性和自文档性。当其他人（或未来的您）阅读您的代码时，异常将清楚地指示您预期的错误情况类型。
• 控制： 它们允许您以不同的方式捕获和处理非常具体的异常，从而让您更好地控制程序的流。

定义自定义异常

要定义自定义异常，首先要创建一个继承自 Exception 类或其子类之一的新类。新类可以根据需要简单或复杂，您可以添加方法和属性以提供有关错误的其他功能或信息。

在应用程序中设计有效的 Pythonic 异常处理有两个基本方面：

1. 从 Exception 类继承

Python 异常处理机制的核心是异常类的层次结构，所有这些类都继承自基类 Exception 。此设计允许以结构化和可扩展的方式处理 Python 程序中的错误和异常情况。

• 继承要求：要使自定义异常与 Python 的内置错误处理机制无缝集成，它们必须是此异常类层次结构的一部分。这意味着您定义的任何自定义异常都应该继承自 Exception 类或其更具体的子类之一。这种继承至关重要，因为它使你的自定义异常能够被 except 块捕获，这些块希望捕获 Exception 类型或更具体类型的异常。

class MyCustomError(Exception):
    """Base class for other custom exceptions"""
    pass

这个简单的自定义异常 MyCustomError 现在的行为与 Python 中的任何其他异常一样，能够被引发、捕获和处理。从这里，您可以开始定制和自定义您的错误处理。

2. 利用 Python 的异常处理功能

通过在定义自定义异常时遵循 Python 的异常层次结构，您可以解锁自定义错误的全套 Python 异常处理功能。这包括能够：

• 精确捕获特定异常，使您的错误处理代码更加精细和信息丰富。
• 将异常向上传播到调用堆栈中，直到它们被适当的处理程序捕获，从而允许在更高级别的函数或方法中进行集中错误处理。
• 通过自定义属性或方法将其他信息附加到异常，从而增强错误报告和处理能力。
• 实施复杂的错误处理逻辑，以区分各种类型的错误，每个错误都有自己的响应策略。

使用自定义例外

您还可以将初始化参数添加到自定义异常中，以传递有关错误的其他信息：

class ValidationError(Exception):
    """Exception raised for errors in the input validation.
    
    Attributes:
        message -- explanation of the error
        value -- input value which caused the error
    """
    def __init__(self, message, value):
        self.message = message
        self.value = value
        super().__init__(message)

定义后，您可以使用 raise 语句在代码中引发自定义异常，就像使用内置异常一样：

def validate_age(age):
    if age < 0:
        raise ValidationError("Age cannot be negative", age)
    elif age < 18:
        raise ValidationError("You must be at least 18 years old", age)
    else:
        print("Age is valid")

# Example usage
try:
    validate_age(-1)
except ValidationError as e:
    print(f"Error: {e.message} - Invalid Value: {e.value}")

Python 中的 raise 语句用于在程序执行过程中触发异常。当遇到 raise 语句时，Python 会停止执行程序的正常流程，并转移到最近的封闭 try 块来处理引发的异常。如果不存在这样的 try 块，则程序终止，并且 Python 会向控制台打印回溯，提供有关未处理异常的详细信息。

在 validate_age 函数的上下文中，当不满足有关 age 参数的某些条件时，使用 raise 函数引发 ValidationError。

异常处理中raise的目的

• 自定义错误报告： 通过将 raise 与自定义异常（如 ValidationError）一起使用，您可以提供有关程序中出错之处的清晰、具体的反馈。这比允许 Python 引发 ValueError 或 TypeError 等内置异常更具信息量，后者可能无法完全传达错误的上下文。
• 控制流： 它允许您在面对不正确或意外的输入时控制程序的流程。您可以立即停止执行并发出发生错误的信号，而不是继续处理无效数据。
• 封装：将错误条件封装在异常中可以使代码更简洁，并将普通逻辑与错误处理逻辑分开。它还允许传递错误，直到它们到达程序中准备处理错误的一部分。

总之，raise 语句是 Python 中的一个强大工具，用于管理程序流、发出错误信号并确保程序即使在特殊情况下也能以可预测的方式运行。

自定义异常的好处

• 清晰度和可维护性：使用定义完善的异常层次结构可以使您的代码更清晰、更易于维护。其他开发人员（或将来的您）可以快速了解您的代码可能引发的错误类型以及它们之间的关系。
• 鲁棒性：它允许您以不同的方式捕获和处理特定错误，从而对不同的故障条件提供更精确的反应，从而实现更强大的错误处理。
• 最佳实践：此方法符合 Python 的异常处理理念和最佳实践，确保您的代码是惯用的和 Pythonic的。

自定义异常是 Python 中的一项强大功能，可以大大提高应用程序错误处理的可读性、可维护性和健壮性。通过定义自己的异常，您可以创建更直观、更精细的错误处理机制，该机制针对应用程序的特定要求进行定制。请记住从 Exception 类或其子类之一继承，并充分利用 Python 的异常处理功能的潜力。

场景：机器学习模型的数据验证

假设您正在为预测房价的机器学习模型准备数据。该数据集包括卧室数量、平方英尺和房屋建造年份等特征。在训练模型之前，您需要验证数据是否满足某些条件，例如：

• 卧室数必须为正整数。
• 平方英尺必须在合理范围内。
• 房子的建造年份不能是将来的年份。

要处理违反这些条件的情况，您需要定义自定义异常。

步骤 1：定义自定义例外

class DataValidationError(Exception):
    """Base class for exceptions in data validation."""
    pass

class BedroomCountError(DataValidationError):
    """Exception raised for errors in the number of bedrooms."""
    pass

class SquareFootageError(DataValidationError):
    """Exception raised for errors in the square footage."""
    pass

class YearBuiltError(DataValidationError):
    """Exception raised for errors in the year the house was built."""
    pass

第 2 步：实现数据验证功能

接下来，让我们实现一个函数，该函数根据这些条件验证单个数据条目，如果违反任何条件，则引发相应的自定义异常。

def validate_house_data(house):
    if not isinstance(house['bedrooms'], int) or house['bedrooms'] <= 0:
        raise BedroomCountError(f"Invalid number of bedrooms: {house['bedrooms']}")
    
    if house['square_footage'] < 100 or house['square_footage'] > 10000:
        raise SquareFootageError(f"Square footage out of range: {house['square_footage']}")
    
    from datetime import datetime
    if house['year_built'] > datetime.now().year:
        raise YearBuiltError(f"Year built is in the future: {house['year_built']}")
    
    print("House data is valid.")

步骤 3：验证数据

最后，我们可以使用此函数来验证数据，捕获和处理引发的任何自定义异常。

house_data = {
    'bedrooms': 3,
    'square_footage': 2500,
    'year_built': 2025  # This will cause a validation error
}

try:
    validate_house_data(house_data)
except DataValidationError as e:
    print(f"Data validation error: {e}")

在此示例中，自定义异常（BedroomCountError、SquareFootageError、YearBuiltError）允许在数据验证过程中进行清晰具体的错误处理。通过定义这些自定义异常，我们可以根据数据科学项目的需求定制的方式捕获和处理数据验证错误。这种方法增强了代码的可读性和可维护性，从而更容易管理数据科学工作流中可能出现的复杂错误场景。

在 Python 中处理异常层次结构

Python 的异常系统是围绕异常类的层次结构构建的，使开发人员能够处理不同特异性级别的错误。此层次结构还引入了复杂性，例如父异常和子异常之间的关系。了解如何驾驭这些关系对于编写清晰有效的异常处理代码至关重要。

了解异常层次结构

正如我们之前看到的，在 Python 中，所有异常都继承自基类 BaseException。Exception 类是 BaseException 的直接子类，几乎用作所有其他异常的基类。这种分层结构允许根据异常的功能或来源对异常进行分组。例如，IOError 和 ValueError 都是 Exception 类的子类，但适用于不同的错误场景。

try-except块中异常顺序的重要性

在处理异常时，Python 允许您在单个 try-except 语句中指定多个 except 块，每个块捕获不同类型的异常。由于异常层次结构的性质，这些 except 块的顺序非常重要。由于多态性原理，用于捕获父异常的块也将捕获其所有子异常。

首先捕获子异常

为了有效地区分层次结构中的异常，

必须将 CHILD EXCEPTIONS 的 EXCEPT 块放在 PARENT EXCEPTIONS 的 EXCEPT 块之前。

这种安排可确保由最具体的处理程序捕获和处理异常。请考虑以下示例：

try:
    # Code that might raise an exception
    pass
except ValueError:
    # Handle ValueError
    pass
except Exception:
    # Handle any exception
    pass

在此结构中，ValueError （Exception 的子异常） 由第一个 except 块捕获。如果顺序相反，则 ValueError 将被 except Exception 块捕获，从而阻止更具体的 ValueError 处理程序执行。

为什么这很重要

首先捕获更具体的异常的做法不仅仅是遵守最佳实践。它对您的应用程序具有实际意义：

• 清晰：在最具体的级别处理异常可以使您的错误处理逻辑更清晰、更可预测。其他开发人员更容易了解哪个数据块处理哪个错误情况。
• 自定义响应：不同的异常通常需要不同的处理策略。通过首先捕获子异常，您可以根据特定错误定制响应，从而提高应用程序的可靠性和用户友好性。
• 防止屏蔽错误： 宽泛的异常处理程序可能会无意中捕获和屏蔽您不打算在该级别处理的错误，这可能会导致难以诊断的错误。

示例场景：数据加载和预处理

在数据科学领域，由于涉及从数据加载和预处理到模型训练和评估的各种操作，因此有效处理异常层次结构可能尤为重要。这些操作可能会引发各种异常，适当处理这些异常可确保数据科学管道的稳健性。

让我们考虑一个涉及数据科学项目中数据加载和预处理的实际示例。在此方案中，我们将演示如何处理可能出现的不同异常，例如与文件相关的错误和数据处理错误。

假设您正在编写一个 Python 脚本，用于从文件加载数据集，然后在这些数据用于训练机器学习模型之前对其进行预处理。在此过程中，可能会出现以下几点问题：

1. 该文件可能不存在或无法访问（引发 FileNotFoundError 或 PermissionError）。
2. 文件中的数据可能不是预期的格式，从而导致 ValueError。
3. 在处理过程中可能会发生泛型错误，我们将这些错误捕获为 Exception。

使用分层方法处理异常

为了处理这些异常，我们将使用 try-except 块，首先捕获最具体的异常，然后再捕获更通用的异常。

import pandas as pd

def load_and_preprocess_data(filepath):
    try:
        # Attempt to load the data file
        data = pd.read_csv(filepath)
        
        # Perform some preprocessing on the data
        # This might include operations that could raise a ValueError
        # For example, converting a column to numeric, where the operation might fail
        data['price'] = pd.to_numeric(data['price'], errors='raise')
        
        # Return the preprocessed data
        return data

    except FileNotFoundError:
        print(f"Error: The file {filepath} was not found.")
    except PermissionError:
        print(f"Error: Permission denied when trying to read {filepath}.")
    except ValueError as e:
        print(f"Error processing file {filepath}: {e}")
    except Exception as e:
        print(f"An unexpected error occurred: {e}")

• FileNotFoundError 和 PermissionError 中：这些异常特定于文件操作。首先捕获它们可以确保我们在考虑更常见的错误之前处理文件访问问题。这种区别对于调试和向用户或日志提供明确的反馈非常重要。
• ValueError 错误：如果数据格式存在问题，例如由于数据包含非数值而将列转换为数值类型失败，则会引发此异常。单独处理此消息可让我们提供有关数据处理问题的特定消息。
• 例外：这是以前未捕获的任何其他异常的 catch-all。它放在最后，以确保特定异常不会被这个更通用的处理程序屏蔽。

此示例说明了如何在数据科学上下文中管理异常层次结构，确保数据加载和预处理阶段的每个步骤都能够抵御潜在错误。通过首先捕获更具体的异常，我们可以针对不同的错误情况提供有针对性的响应，从而提高数据科学管道的可靠性和用户友好性。