1. 什么是抽象类？为什么需要它？ #

1.1 生活中的例子 #

想象一下，你要设计一个"动物"系统。所有的动物都有一些共同的行为，比如"发出声音"和"移动"，但每种动物的具体实现都不同：

• 狗会"汪汪"叫，用四条腿跑
• 鸟会"啾啾"叫，用翅膀飞
• 鱼会"咕噜"叫，用鳍游泳

在编程中，我们希望定义一个"动物"类，规定所有动物都必须有"发出声音"和"移动"这两个方法，但不提供具体实现（因为不同动物实现不同）。这就是抽象类的概念。

1.2 抽象类的作用 #

抽象类就像一个"模板"或"契约"，它：

1. 定义接口：规定子类必须实现哪些方法
2. 防止遗漏：如果子类没有实现所有抽象方法，程序会报错
3. 提高代码质量：确保所有子类都遵循相同的接口规范

1.3 没有抽象类的问题 #

如果不使用抽象类，可能会出现这样的问题：

# 没有使用抽象类的情况
class Animal:
    def make_sound(self):
        pass  # 空实现，子类可能忘记重写

    def move(self):
        pass  # 空实现，子类可能忘记重写

class Dog(Animal):
    def make_sound(self):
        return "Woof!"
    # 忘记实现 move() 方法，但程序不会报错！

dog = Dog()
print(dog.make_sound())  # 可以运行
print(dog.move())        # 返回 None，但这不是我们想要的

使用抽象类后，如果子类忘记实现某个方法，程序会在创建对象时报错，这样我们就能及时发现问题。

2. 前置知识 #

在学习 abc 模块之前，我们需要了解一些 Python 基础知识。

2.1 面向对象基础 #

类（Class）是对象的模板，对象（Object）是类的实例。

# 定义一个类
class Dog:
    def __init__(self, name):
        # __init__ 是构造函数，创建对象时自动调用
        self.name = name

    def bark(self):
        # 这是一个方法（函数）
        return f"{self.name} says Woof!"

# 创建对象（实例化）
my_dog = Dog("旺财")
print(my_dog.bark())  # 输出：旺财 says Woof!

2.2 继承（Inheritance） #

继承允许一个类（子类）继承另一个类（父类）的属性和方法。

# 父类（基类）
class Animal:
    def __init__(self, name):
        self.name = name

    def eat(self):
        return f"{self.name} is eating"

# 子类（派生类）继承父类
class Dog(Animal):
    def bark(self):
        return f"{self.name} says Woof!"

# 子类可以使用父类的方法
my_dog = Dog("旺财")
print(my_dog.eat())   # 使用父类的方法
print(my_dog.bark())  # 使用子类自己的方法

2.3 装饰器（Decorator） #

装饰器是 Python 的一个特性，用于修改函数或类的行为。装饰器使用 @ 符号。

# 定义一个装饰器
def my_decorator(func):
    def wrapper():
        print("函数执行前")
        result = func()
        print("函数执行后")
        return result
    return wrapper

# 使用装饰器
@my_decorator
def say_hello():
    print("Hello!")

say_hello()
# 输出：
# 函数执行前
# Hello!
# 函数执行后

2.4 属性（Property） #

属性允许我们将方法当作属性来访问，使用 @property 装饰器。

class Circle:
    def __init__(self, radius):
        self._radius = radius  # 私有属性（约定用下划线开头）

    @property
    def area(self):
        # 将方法转换为属性，可以通过 circle.area 访问
        return 3.14159 * self._radius ** 2

circle = Circle(5)
print(circle.area)  # 像访问属性一样访问，不需要加括号

2.5 类方法和静态方法 #

类方法使用 @classmethod 装饰器，第一个参数是 cls（类本身）。

静态方法使用 @staticmethod 装饰器，不需要 self 或 cls 参数。

class MathUtils:
    # 类方法：可以通过类名或对象调用，第一个参数是 cls
    @classmethod
    def add(cls, a, b):
        return a + b

    # 静态方法：可以通过类名或对象调用，不需要 self 或 cls
    @staticmethod
    def multiply(a, b):
        return a * b

# 使用类方法
result1 = MathUtils.add(3, 5)  # 通过类名调用
print(result1)  # 输出：8

# 使用静态方法
result2 = MathUtils.multiply(3, 5)  # 通过类名调用
print(result2)  # 输出：15

3. 什么是 abc 模块？ #

abc 是 Python 标准库中的一个模块，全称是 Abstract Base Classes（抽象基类）。

3.1 abc 模块的作用 #

abc 模块提供了定义抽象类的功能，它使用装饰器和元类来实现抽象方法，强制子类实现特定的接口。

3.2 核心组件 #

abc 模块主要有两个核心组件：

1. ABC 类：所有抽象基类的基类，继承自 ABC 的类可以包含抽象方法
2. abstractmethod 装饰器：用于标记抽象方法，子类必须实现这些方法

3.3 导入 abc 模块 #

# 导入 abc 模块的核心组件
from abc import ABC, abstractmethod

4. 基本用法 #

4.1 最简单的抽象类示例 #

下面是一个最简单的抽象类示例，展示了如何使用 abc 模块：

# 导入必要的模块
from abc import ABC, abstractmethod

# 定义抽象基类，继承自 ABC
class Animal(ABC):
    # 使用 @abstractmethod 装饰器标记抽象方法
    # 子类必须实现这个方法
    @abstractmethod
    def make_sound(self):
        """发出声音（抽象方法，子类必须实现）"""
        pass

    # 另一个抽象方法
    @abstractmethod
    def move(self):
        """移动（抽象方法，子类必须实现）"""
        pass

# 正确实现：实现了所有抽象方法
class Dog(Animal):
    def make_sound(self):
        return "Woof!"

    def move(self):
        return "Running on four legs"

# 错误实现：只实现了部分抽象方法
class Bird(Animal):
    def make_sound(self):
        return "Chirp!"
    # 缺少 move() 方法，会报错

# 测试代码
if __name__ == "__main__":
    # 正确：Dog 实现了所有抽象方法，可以实例化
    dog = Dog()
    print(f"狗的声音: {dog.make_sound()}")
    print(f"狗的行动: {dog.move()}")

    # 错误：Bird 没有实现所有抽象方法，无法实例化
    try:
        bird = Bird()  # 这里会报错
    except TypeError as e:
        print(f"错误: {e}")
        # 输出：Can't instantiate abstract class Bird with abstract method move

4.2 抽象类的工作原理 #

1. 当类继承自 ABC 并使用 @abstractmethod 装饰器时，这个类就变成了抽象类
2. 抽象类不能直接实例化（不能创建对象）
3. 子类必须实现所有抽象方法，才能实例化
4. 如果子类没有实现所有抽象方法，尝试创建对象时会抛出 TypeError

5. 抽象方法详解 #

5.1 什么是抽象方法？ #

抽象方法是只有声明、没有实现的方法。它使用 @abstractmethod 装饰器标记，子类必须提供具体实现。

5.2 抽象方法的特点 #

1. 必须使用装饰器：使用 @abstractmethod 装饰器
2. 可以有文档字符串：可以添加说明文档
3. 通常使用 pass：方法体通常只有 pass，表示空实现
4. 子类必须实现：子类必须重写这个方法，否则无法实例化

5.3 完整示例：图形计算系统 #

下面是一个完整的示例，展示如何使用抽象方法定义一个图形计算系统：

# 导入必要的模块
from abc import ABC, abstractmethod
import math

# 定义抽象基类：图形
class Shape(ABC):
    # 抽象方法：计算面积（所有图形都必须实现）
    @abstractmethod
    def area(self):
        """计算图形的面积"""
        pass

    # 抽象方法：计算周长（所有图形都必须实现）
    @abstractmethod
    def perimeter(self):
        """计算图形的周长"""
        pass

    # 普通方法：可以被子类直接使用
    def describe(self):
        """描述图形（有默认实现，子类可以重写）"""
        return f"这是一个图形，面积是 {self.area():.2f}"

# 矩形类：实现抽象方法
class Rectangle(Shape):
    def __init__(self, width, height):
        # 初始化矩形的宽和高
        self.width = width
        self.height = height

    def area(self):
        # 实现抽象方法：计算矩形面积
        return self.width * self.height

    def perimeter(self):
        # 实现抽象方法：计算矩形周长
        return 2 * (self.width + self.height)

# 圆形类：实现抽象方法
class Circle(Shape):
    def __init__(self, radius):
        # 初始化圆的半径
        self.radius = radius

    def area(self):
        # 实现抽象方法：计算圆形面积
        return math.pi * self.radius ** 2

    def perimeter(self):
        # 实现抽象方法：计算圆形周长（即周长）
        return 2 * math.pi * self.radius

# 测试代码
if __name__ == "__main__":
    # 创建矩形对象
    rect = Rectangle(5, 3)
    print(f"矩形面积: {rect.area()}")
    print(f"矩形周长: {rect.perimeter()}")
    print(f"描述: {rect.describe()}")

    print("-" * 40)

    # 创建圆形对象
    circle = Circle(5)
    print(f"圆形面积: {circle.area():.2f}")
    print(f"圆形周长: {circle.perimeter():.2f}")
    print(f"描述: {circle.describe()}")

6. 抽象属性 #

6.1 什么是抽象属性？ #

抽象属性是使用 @property 和 @abstractmethod 组合定义的属性。子类必须实现这个属性。

6.2 如何定义抽象属性？ #

定义抽象属性需要两个装饰器：

1. @property：将方法转换为属性
2. @abstractmethod：标记为抽象方法

注意：装饰器的顺序很重要，@property 必须在 @abstractmethod 之前。

6.3 完整示例：抽象属性 #

# 导入必要的模块
from abc import ABC, abstractmethod

# 定义抽象基类：车辆
class Vehicle(ABC):
    # 定义抽象属性：品牌
    # 注意：@property 必须在 @abstractmethod 之前
    @property
    @abstractmethod
    def brand(self):
        """车辆品牌（抽象属性，子类必须实现）"""
        pass

    # 定义抽象属性：速度
    @property
    @abstractmethod
    def max_speed(self):
        """最大速度（抽象属性，子类必须实现）"""
        pass

    # 普通方法：使用抽象属性
    def info(self):
        """显示车辆信息"""
        return f"{self.brand} 的最大速度是 {self.max_speed} km/h"

# 汽车类：实现抽象属性
class Car(Vehicle):
    def __init__(self, brand, max_speed):
        # 初始化汽车的品牌和最大速度
        self._brand = brand
        self._max_speed = max_speed

    @property
    def brand(self):
        # 实现抽象属性：返回品牌
        return self._brand

    @property
    def max_speed(self):
        # 实现抽象属性：返回最大速度
        return self._max_speed

# 自行车类：实现抽象属性
class Bicycle(Vehicle):
    def __init__(self, brand, max_speed):
        # 初始化自行车的品牌和最大速度
        self._brand = brand
        self._max_speed = max_speed

    @property
    def brand(self):
        # 实现抽象属性：返回品牌
        return self._brand

    @property
    def max_speed(self):
        # 实现抽象属性：返回最大速度
        return self._max_speed

# 测试代码
if __name__ == "__main__":
    # 创建汽车对象
    car = Car("特斯拉", 200)
    print(f"汽车品牌: {car.brand}")
    print(f"最大速度: {car.max_speed} km/h")
    print(f"信息: {car.info()}")

    print("-" * 40)

    # 创建自行车对象
    bike = Bicycle("永久", 30)
    print(f"自行车品牌: {bike.brand}")
    print(f"最大速度: {bike.max_speed} km/h")
    print(f"信息: {bike.info()}")

7. 抽象类方法和静态方法 #

7.1 抽象类方法 #

抽象类方法使用 @abstractclassmethod 装饰器（或 @classmethod + @abstractmethod）定义。子类必须实现这个类方法。

7.2 抽象静态方法 #

抽象静态方法使用 @abstractstaticmethod 装饰器（或 @staticmethod + @abstractmethod）定义。子类必须实现这个静态方法。

7.3 完整示例：数据库连接系统 #

# 导入必要的模块
from abc import ABC, abstractmethod, abstractclassmethod, abstractstaticmethod

# 定义抽象基类：数据库
class Database(ABC):
    # 抽象类方法：建立数据库连接
    # 注意：@classmethod 必须在 @abstractmethod 之前
    @classmethod
    @abstractmethod
    def connect(cls, connection_string):
        """类方法：建立数据库连接（子类必须实现）"""
        pass

    # 抽象静态方法：验证配置
    # 注意：@staticmethod 必须在 @abstractmethod 之前
    @staticmethod
    @abstractmethod
    def validate_config(config):
        """静态方法：验证配置（子类必须实现）"""
        pass

    # 抽象实例方法：执行查询
    @abstractmethod
    def query(self, sql):
        """实例方法：执行查询（子类必须实现）"""
        pass

# MySQL 数据库类：实现所有抽象方法
class MySQLDatabase(Database):
    def __init__(self, connection_string):
        # 初始化数据库连接字符串
        self.connection_string = connection_string

    @classmethod
    def connect(cls, connection_string):
        # 实现抽象类方法：建立 MySQL 连接
        print(f"正在连接到 MySQL: {connection_string}")
        return cls(connection_string)

    @staticmethod
    def validate_config(config):
        # 实现抽象静态方法：验证 MySQL 配置
        # 检查配置中是否包含必要的字段
        required_fields = ['host', 'port', 'user', 'password']
        return all(field in config for field in required_fields)

    def query(self, sql):
        # 实现抽象实例方法：执行 MySQL 查询
        return f"执行 MySQL 查询: {sql}"

# SQLite 数据库类：实现所有抽象方法
class SQLiteDatabase(Database):
    def __init__(self, db_path):
        # 初始化数据库路径
        self.db_path = db_path

    @classmethod
    def connect(cls, db_path):
        # 实现抽象类方法：建立 SQLite 连接
        print(f"正在连接到 SQLite: {db_path}")
        return cls(db_path)

    @staticmethod
    def validate_config(config):
        # 实现抽象静态方法：验证 SQLite 配置
        # SQLite 只需要数据库路径
        return 'db_path' in config

    def query(self, sql):
        # 实现抽象实例方法：执行 SQLite 查询
        return f"执行 SQLite 查询: {sql}"

# 测试代码
if __name__ == "__main__":
    # 测试 MySQL
    print("=" * 50)
    print("测试 MySQL 数据库")
    print("=" * 50)

    # 验证配置
    mysql_config = {'host': 'localhost', 'port': 3306, 'user': 'root', 'password': '123456'}
    is_valid = MySQLDatabase.validate_config(mysql_config)
    print(f"MySQL 配置验证: {is_valid}")

    # 建立连接
    mysql_db = MySQLDatabase.connect("mysql://localhost:3306")

    # 执行查询
    result = mysql_db.query("SELECT * FROM users")
    print(result)

    print("\n" + "=" * 50)
    print("测试 SQLite 数据库")
    print("=" * 50)

    # 验证配置
    sqlite_config = {'db_path': '/path/to/database.db'}
    is_valid = SQLiteDatabase.validate_config(sqlite_config)
    print(f"SQLite 配置验证: {is_valid}")

    # 建立连接
    sqlite_db = SQLiteDatabase.connect("/path/to/database.db")

    # 执行查询
    result = sqlite_db.query("SELECT * FROM users")
    print(result)

8. 实际应用场景 #

8.1 场景一：支付系统（策略模式） #

在实际开发中，抽象类常用于实现设计模式。下面是一个支付系统的示例：

# 导入必要的模块
from abc import ABC, abstractmethod

# 定义抽象基类：支付策略
class PaymentStrategy(ABC):
    @abstractmethod
    def pay(self, amount):
        """支付方法（子类必须实现）"""
        pass

# 信用卡支付类：实现支付策略
class CreditCardPayment(PaymentStrategy):
    def __init__(self, card_number, cvv):
        # 初始化信用卡号和 CVV
        self.card_number = card_number
        self.cvv = cvv

    def pay(self, amount):
        # 实现支付方法：使用信用卡支付
        print(f"使用信用卡 {self.card_number[-4:]} 支付 ${amount}")
        return True

# 支付宝支付类：实现支付策略
class AlipayPayment(PaymentStrategy):
    def __init__(self, account):
        # 初始化支付宝账号
        self.account = account

    def pay(self, amount):
        # 实现支付方法：使用支付宝支付
        print(f"使用支付宝 {self.account} 支付 ${amount}")
        return True

# 微信支付类：实现支付策略
class WeChatPayment(PaymentStrategy):
    def __init__(self, openid):
        # 初始化微信 openid
        self.openid = openid

    def pay(self, amount):
        # 实现支付方法：使用微信支付
        print(f"使用微信支付 {self.openid} 支付 ${amount}")
        return True

# 购物车类：使用支付策略
class ShoppingCart:
    def __init__(self):
        # 初始化购物车，存储商品列表
        self.items = []
        # 初始化支付策略为 None
        self.payment_strategy = None

    def add_item(self, item_name, price):
        # 添加商品到购物车
        self.items.append({'name': item_name, 'price': price})
        print(f"已添加 {item_name}，价格 ${price}")

    def set_payment_strategy(self, strategy):
        # 设置支付策略
        self.payment_strategy = strategy

    def checkout(self):
        # 结算：计算总价并使用支付策略支付
        if not self.items:
            print("购物车为空，无法结算")
            return False

        # 计算总价
        total = sum(item['price'] for item in self.items)
        print(f"\n购物车商品:")
        for item in self.items:
            print(f"  - {item['name']}: ${item['price']}")
        print(f"总计: ${total}")

        # 检查是否设置了支付策略
        if self.payment_strategy is None:
            print("错误：未设置支付方式")
            return False

        # 使用支付策略支付
        return self.payment_strategy.pay(total)

# 测试代码
if __name__ == "__main__":
    # 创建购物车
    cart = ShoppingCart()

    # 添加商品
    cart.add_item("Python 编程书", 59.99)
    cart.add_item("鼠标", 29.99)
    cart.add_item("键盘", 79.99)

    # 使用信用卡支付
    print("\n" + "=" * 50)
    print("使用信用卡支付")
    print("=" * 50)
    credit_card = CreditCardPayment("1234567890123456", "123")
    cart.set_payment_strategy(credit_card)
    cart.checkout()

    # 使用支付宝支付
    print("\n" + "=" * 50)
    print("使用支付宝支付")
    print("=" * 50)
    cart2 = ShoppingCart()
    cart2.add_item("Python 编程书", 59.99)
    alipay = AlipayPayment("user@example.com")
    cart2.set_payment_strategy(alipay)
    cart2.checkout()

8.2 场景二：数据格式化插件系统 #

下面是一个数据格式化插件系统的示例：

# 导入必要的模块
from abc import ABC, abstractmethod
import json
import csv
import io

# 定义抽象基类：数据格式化插件
class DataFormatter(ABC):
    # 抽象属性：插件名称
    @property
    @abstractmethod
    def name(self):
        """插件名称（子类必须实现）"""
        pass

    # 抽象方法：格式化数据
    @abstractmethod
    def format(self, data):
        """格式化数据（子类必须实现）"""
        pass

# JSON 格式化插件：实现数据格式化
class JSONFormatter(DataFormatter):
    @property
    def name(self):
        # 实现抽象属性：返回插件名称
        return "JSON Formatter"

    def format(self, data):
        # 实现抽象方法：将数据格式化为 JSON
        return json.dumps(data, indent=2, ensure_ascii=False)

# CSV 格式化插件：实现数据格式化
class CSVFormatter(DataFormatter):
    @property
    def name(self):
        # 实现抽象属性：返回插件名称
        return "CSV Formatter"

    def format(self, data):
        # 实现抽象方法：将数据格式化为 CSV
        # 假设 data 是一个列表，每个元素是一个字典
        if not data:
            return ""

        # 创建字符串缓冲区
        output = io.StringIO()
        # 获取所有键作为 CSV 的列名
        fieldnames = data[0].keys()
        # 创建 CSV 写入器
        writer = csv.DictWriter(output, fieldnames=fieldnames)
        # 写入表头
        writer.writeheader()
        # 写入数据
        writer.writerows(data)
        # 返回格式化后的字符串
        return output.getvalue()

# 格式化管理器：管理所有格式化插件
class FormatManager:
    def __init__(self):
        # 初始化格式化器列表
        self.formatters = []

    def register(self, formatter):
        # 注册格式化插件
        if not isinstance(formatter, DataFormatter):
            raise TypeError("格式化器必须继承自 DataFormatter")
        self.formatters.append(formatter)
        print(f"已注册格式化器: {formatter.name}")

    def format_with(self, formatter_name, data):
        # 使用指定的格式化器格式化数据
        for formatter in self.formatters:
            if formatter.name == formatter_name:
                return formatter.format(data)
        raise ValueError(f"未找到格式化器: {formatter_name}")

    def list_formatters(self):
        # 列出所有已注册的格式化器
        return [f.name for f in self.formatters]

# 测试代码
if __name__ == "__main__":
    # 准备测试数据
    test_data = [
        {"name": "张三", "age": 25, "city": "北京"},
        {"name": "李四", "age": 30, "city": "上海"},
        {"name": "王五", "age": 28, "city": "广州"}
    ]

    # 创建格式化管理器
    manager = FormatManager()

    # 注册格式化插件
    manager.register(JSONFormatter())
    manager.register(CSVFormatter())

    # 使用 JSON 格式化
    print("=" * 50)
    print("JSON 格式化结果:")
    print("=" * 50)
    json_result = manager.format_with("JSON Formatter", test_data)
    print(json_result)

    # 使用 CSV 格式化
    print("\n" + "=" * 50)
    print("CSV 格式化结果:")
    print("=" * 50)
    csv_result = manager.format_with("CSV Formatter", test_data)
    print(csv_result)

    # 列出所有格式化器
    print("\n" + "=" * 50)
    print("已注册的格式化器:")
    print("=" * 50)
    for name in manager.list_formatters():
        print(f"  - {name}")

9. 常见错误和注意事项 #

9.1 常见错误 #

9.1.1 错误 1：忘记实现抽象方法 #

# 导入必要的模块
from abc import ABC, abstractmethod

# 定义抽象基类
class Animal(ABC):
    @abstractmethod
    def make_sound(self):
        pass

# 错误：子类没有实现抽象方法
class Dog(Animal):
    pass  # 忘记实现 make_sound() 方法

# 测试代码
if __name__ == "__main__":
    try:
        # 尝试创建对象会报错
        dog = Dog()
    except TypeError as e:
        print(f"错误: {e}")
        # 输出：Can't instantiate abstract class Dog with abstract method make_sound

9.1.2 错误 2：装饰器顺序错误 #

# 导入必要的模块
from abc import ABC, abstractmethod

# 定义抽象基类
class Shape(ABC):
    # 错误：装饰器顺序错误
    # @abstractmethod 必须在 @property 之后
    @abstractmethod
    @property
    def area(self):
        pass

# 正确的方式应该是：
class CorrectShape(ABC):
    @property
    @abstractmethod
    def area(self):
        pass

9.1.3 错误 3：直接实例化抽象类 #

# 导入必要的模块
from abc import ABC, abstractmethod

# 定义抽象基类
class Animal(ABC):
    @abstractmethod
    def make_sound(self):
        pass

# 测试代码
if __name__ == "__main__":
    try:
        # 错误：尝试直接实例化抽象类
        animal = Animal()
    except TypeError as e:
        print(f"错误: {e}")
        # 输出：Can't instantiate abstract class Animal with abstract method make_sound

9.2 最佳实践 #

9.2.1 实践 1：最小化抽象方法 #

只将真正必须实现的方法设为抽象方法，可选的方法提供默认实现。

# 导入必要的模块
from abc import ABC, abstractmethod

# 好的设计：只有关键方法设为抽象
class Animal(ABC):
    # 必须实现的方法：设为抽象
    @abstractmethod
    def make_sound(self):
        pass

    # 可选的方法：提供默认实现
    def sleep(self):
        return "正在睡觉..."

# 子类只需要实现抽象方法
class Dog(Animal):
    def make_sound(self):
        return "Woof!"

# 测试代码
if __name__ == "__main__":
    dog = Dog()
    print(dog.make_sound())  # 使用子类实现的方法
    print(dog.sleep())       # 使用父类的默认实现

9.2.2 实践 2：提供清晰的文档 #

为抽象方法添加清晰的文档字符串，说明子类应该如何实现。

# 导入必要的模块
from abc import ABC, abstractmethod

# 好的设计：提供清晰的文档
class Calculator(ABC):
    @abstractmethod
    def calculate(self, a, b):
        """
        执行计算操作

        参数:
            a: 第一个操作数
            b: 第二个操作数

        返回:
            计算结果
        """
        pass

# 子类实现时可以参考文档
class Adder(Calculator):
    def calculate(self, a, b):
        # 根据文档实现
        return a + b

9.2.3 实践 3：合理使用抽象类 #

抽象类适合用于：

• 定义接口契约
• 框架开发
• 插件系统
• 需要强制实现的 API

不适合用于：

• 简单的继承关系（普通继承即可）
• 不需要强制实现的情况

10. 总结 #

10.1 abc 模块的核心价值 #

1. 强制接口实现：确保子类实现必要的方法，避免遗漏
2. 提高代码质量：明确标出哪些方法必须实现，提高代码可读性
3. 设计契约：定义清晰的类层次结构，便于团队协作
4. 类型检查：配合 isinstance() 和 issubclass() 使用，进行类型检查

10.2 关键要点 #

1. 导入方式：from abc import ABC, abstractmethod
2. 定义抽象类：继承自 ABC
3. 定义抽象方法：使用 @abstractmethod 装饰器
4. 定义抽象属性：使用 @property + @abstractmethod（注意顺序）
5. 子类必须实现：所有抽象方法都必须实现，否则无法实例化