一、继承：代码复用的基石

继承是面向对象编程的核心机制之一，允许子类继承父类的属性和方法，实现代码复用。Python通过class ChildClass(ParentClass):语法实现继承。

1.1 单继承与多继承

• 单继承：子类仅继承一个父类，结构清晰，易于维护。例如：
  ```python
  class Animal:
  def speak(self):

    pass

class Dog(Animal):
def speak(self):
return “Woof!”

- **多继承**：子类可继承多个父类，需谨慎处理命名冲突（通过MRO顺序解决）。例如：
```python
class A:
    def method(self):
        return "A"
class B(A):
    def method(self):
        return "B" + super().method()
class C(A):
    def method(self):
        return "C" + super().method()
class D(B, C):
    pass
d = D()
print(d.method())  # 输出: "BA C A"（MRO顺序为D→B→C→A）

1.2 方法重写与super()

子类可重写父类方法，并通过super()调用父类方法，避免重复代码。例如：

class Parent:
    def __init__(self, value):
        self.value = value
class Child(Parent):
    def __init__(self, value, extra):
        super().__init__(value)  # 调用父类__init__
        self.extra = extra

二、多态：接口统一与行为差异

多态允许不同类对同一方法做出不同响应，提升代码灵活性。Python通过鸭子类型（Duck Typing）实现多态，无需显式接口声明。

2.1 鸭子类型示例

class Duck:
    def quack(self):
        return "Quack!"
class Person:
    def quack(self):
        return "I'm pretending to be a duck!"
def make_quack(thing):
    print(thing.quack())
duck = Duck()
person = Person()
make_quack(duck)   # 输出: "Quack!"
make_quack(person) # 输出: "I'm pretending to be a duck!"

2.2 多态的实际应用

多态常用于框架设计，如Web框架中的请求处理：

class RequestHandler:
    def handle(self, request):
        raise NotImplementedError
class JSONHandler(RequestHandler):
    def handle(self, request):
        return {"data": request.json()}
class XMLHandler(RequestHandler):
    def handle(self, request):
        return "<data>" + request.text + "</data>"

三、私有化：封装与数据保护

Python通过命名约定（_前缀表示受保护，__前缀表示私有）实现封装，限制外部直接访问。

3.1 受保护成员（_前缀）

约定俗成，提示开发者“谨慎修改”：

class MyClass:
    def __init__(self):
        self._protected_var = 42

3.2 私有成员（__前缀）

名称重整（Name Mangling）机制防止外部访问：

class MyClass:
    def __init__(self):
        self.__private_var = 42
    def get_private(self):
        return self.__private_var
obj = MyClass()
print(obj.get_private())  # 输出: 42
print(obj.__private_var)  # 报错: AttributeError

四、异常捕获：健壮性保障

异常处理机制（try/except/finally）确保程序在错误发生时优雅退出或恢复。

4.1 基础异常捕获

try:
    result = 10 / 0
except ZeroDivisionError:
    print("Cannot divide by zero!")

4.2 多异常处理与else/finally

try:
    file = open("data.txt", "r")
except FileNotFoundError:
    print("File not found.")
except IOError as e:
    print(f"IO error: {e}")
else:
    print("File opened successfully.")
    data = file.read()
finally:
    file.close()  # 确保资源释放

4.3 自定义异常

通过继承Exception类定义业务异常：

class InvalidInputError(Exception):
    pass
def validate_input(value):
    if value < 0:
        raise InvalidInputError("Value must be positive.")

五、类属性与类方法：静态成员管理

类属性属于类本身，而非实例；类方法通过@classmethod装饰器定义，第一个参数为类本身（cls）。

5.1 类属性示例

class MyClass:
    class_var = 0  # 类属性
    def __init__(self):
        self.instance_var = 1  # 实例属性
obj1 = MyClass()
obj2 = MyClass()
MyClass.class_var = 10  # 修改类属性
print(obj1.class_var)   # 输出: 10
print(obj2.class_var)   # 输出: 10

5.2 类方法与静态方法

• 类方法：操作类属性或返回新实例。
  ```python
  class Pizza:
  def init(self, ingredients):

    self.ingredients = ingredients

  @classmethod
  def margherita(cls):

    return cls(["tomato", "mozzarella"])

  @classmethod
  def prosciutto(cls):

    return cls(["tomato", "mozzarella", "ham"])

p1 = Pizza.margherita()
p2 = Pizza.prosciutto()

- **静态方法**：与类无关的工具函数，通过`@staticmethod`装饰。
```python
class MathUtils:
    @staticmethod
    def add(a, b):
        return a + b

六、综合应用案例

以下案例整合继承、多态、异常处理等特性：

class DatabaseConnection:
    def __init__(self, config):
        self.config = config
        self.connection = None
    def connect(self):
        try:
            # 模拟连接逻辑
            self.connection = "Connected to " + self.config["host"]
        except KeyError:
            raise ValueError("Missing 'host' in config.")
    def disconnect(self):
        self.connection = None
class MySQLConnection(DatabaseConnection):
    def connect(self):
        super().connect()
        self.connection += " (MySQL)"
class PostgreSQLConnection(DatabaseConnection):
    def connect(self):
        super().connect()
        self.connection += " (PostgreSQL)"
def main():
    try:
        db = MySQLConnection({"host": "localhost"})
        db.connect()
        print(db.connection)  # 输出: "Connected to localhost (MySQL)"
    except ValueError as e:
        print(f"Error: {e}")
    finally:
        if hasattr(db, "connection"):
            db.disconnect()
if __name__ == "__main__":
    main()

七、进阶建议

1. 优先使用组合而非继承：遵循“组合优于继承”原则，降低耦合度。
2. 明确私有化边界：通过__前缀保护关键数据，但避免过度封装。
3. 精细化异常处理：捕获具体异常而非通用Exception。
4. 合理使用类方法：工厂模式或替代构造函数时优先选择类方法。

通过掌握继承、多态、私有化、异常捕获及类属性/方法，开发者可编写出更灵活、可维护的Python代码。