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

继承是面向对象编程的核心机制之一，允许子类复用父类的属性和方法，同时支持扩展与重写。Python通过class ChildClass(ParentClass):语法实现单继承，通过多继承（class ChildClass(Parent1, Parent2):）支持更灵活的组合。

1.1 方法重写与扩展

子类可通过重写父类方法实现定制化逻辑。例如：

class Animal:
    def speak(self):
        print("Animal makes a sound")
class Dog(Animal):
    def speak(self):
        print("Dog barks: Woof!")
dog = Dog()
dog.speak()  # 输出: Dog barks: Woof!

子类可通过super()调用父类方法，实现扩展而非完全重写：

class Cat(Animal):
    def speak(self):
        super().speak()
        print("Cat meows: Meow!")
cat = Cat()
cat.speak()  # 输出: Animal makes a sound \n Cat meows: Meow!

1.2 多继承与MRO机制

Python通过C3算法解析方法调用顺序（MRO），可通过__mro__属性查看：

class A: pass
class B(A): pass
class C(A): pass
class D(B, C): pass
print(D.__mro__)  # 输出: (<class 'D'>, <class 'B'>, <class 'C'>, <class 'A'>, <class 'object'>)

实践建议：多继承易导致代码复杂化，建议优先使用组合模式或接口抽象。

二、多态：同一接口的不同实现

多态允许不同类对同一方法提供差异化实现，增强代码灵活性。Python通过鸭子类型（Duck Typing）实现动态多态，无需显式接口声明。

2.1 鸭子类型示例

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

关键点：Python不检查对象类型，只关心对象是否具有所需方法或属性。

2.2 @abstractmethod实现抽象基类

通过abc模块强制子类实现特定方法：

from abc import ABC, abstractmethod
class Shape(ABC):
    @abstractmethod
    def area(self):
        pass
class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
    def area(self):
        return 3.14 * self.radius ** 2
# circle = Shape()  # 报错: Cannot instantiate abstract class
circle = Circle(5)
print(circle.area())  # 输出: 78.5

应用场景：框架开发中定义接口规范，确保子类必须实现关键方法。

三、私有化：数据封装与安全控制

Python通过命名约定（_单下划线、__双下划线）实现属性与方法的私有化，控制访问权限。

3.1 单下划线_：约定私有

单下划线表示“内部使用”，仅作为约定，仍可被外部访问：

class MyClass:
    def __init__(self):
        self._internal_var = 42
obj = MyClass()
print(obj._internal_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.__private_var)  # 报错: AttributeError
print(obj.get_private())  # 输出: 42
print(obj._MyClass__private_var)  # 输出: 42（不推荐强制访问）

最佳实践：优先使用属性装饰器（@property）实现可控访问：

class Temperature:
    def __init__(self, celsius):
        self._celsius = celsius
    @property
    def celsius(self):
        return self._celsius
    @celsius.setter
    def celsius(self, value):
        if value < -273.15:
            raise ValueError("Temperature below absolute zero!")
        self._celsius = value
temp = Temperature(25)
temp.celsius = 30  # 通过setter验证

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

Python通过try-except-finally块处理异常，避免程序因意外错误终止。

4.1 基础异常处理

try:
    result = 10 / 0
except ZeroDivisionError as e:
    print(f"Error: {e}")  # 输出: Error: division by zero

4.2 自定义异常类

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

class InvalidAgeError(Exception):
    pass
def set_age(age):
    if age < 0:
        raise InvalidAgeError("Age cannot be negative!")
    return age
try:
    set_age(-5)
except InvalidAgeError as e:
    print(e)  # 输出: Age cannot be negative!

4.3 else与finally的合理使用

try:
    file = open("data.txt", "r")
except FileNotFoundError:
    print("File not found!")
else:
    print("File opened successfully")
    file.close()
finally:
    print("Cleanup completed")  # 无论是否异常都会执行

建议：避免捕获通用Exception，应明确处理特定异常类型。

五、类属性与类方法：共享数据与功能

类属性为所有实例共享，类方法通过@classmethod装饰器定义，操作类级别数据。

5.1 类属性 vs 实例属性

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

5.2 类方法与静态方法

class Pizza:
    def __init__(self, ingredients):
        self.ingredients = ingredients
    @classmethod
    def margherita(cls):
        return cls(["tomato", "mozzarella"])
    @staticmethod
    def calculate_area(radius):
        return 3.14 * radius ** 2
pizza = Pizza.margherita()  # 通过类方法创建实例
print(pizza.ingredients)  # 输出: ['tomato', 'mozzarella']
print(Pizza.calculate_area(5))  # 输出: 78.5

应用场景：

• 类方法：替代构造函数或操作类属性
• 静态方法：工具函数，与类逻辑相关但无需访问类/实例

六、综合实践：设计一个健壮的账户系统

class AccountError(Exception):
    pass
class InsufficientBalanceError(AccountError):
    pass
class Account:
    min_balance = 0  # 类属性
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.__balance = balance  # 私有属性
    @property
    def balance(self):
        return self.__balance
    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("Deposit amount must be positive")
        self.__balance += amount
    def withdraw(self, amount):
        if amount > self.__balance:
            raise InsufficientBalanceError("Insufficient balance")
        self.__balance -= amount
    @classmethod
    def create_account(cls, owner):
        return cls(owner)
# 使用示例
try:
    acc = Account.create_account("Alice")
    acc.deposit(1000)
    acc.withdraw(500)
    print(f"{acc.owner}'s balance: {acc.balance}")  # 输出: Alice's balance: 500
    acc.withdraw(600)  # 触发异常
except InsufficientBalanceError as e:
    print(f"Error: {e}")

总结与建议

1. 继承：优先使用组合而非多继承，避免“菱形继承”问题。
2. 多态：利用鸭子类型提升灵活性，必要时使用抽象基类规范接口。
3. 私有化：通过@property实现可控访问，而非直接暴露私有变量。
4. 异常处理：明确捕获特定异常，避免“吞掉”关键错误。
5. 类属性与方法：合理区分类级别与实例级别操作，保持代码清晰。

通过掌握这些进阶特性，开发者能够编写出更模块化、可维护且健壮的Python代码。