Python 抽象基类详解

抽象基类（Abstract Base Classes，简称 ABC）是 Python 中一种特殊的类，它不能被直接实例化，主要用于定义接口和规范子类的结构。通过抽象基类，我们可以创建更清晰的继承层次和更强的类型检查。

📚 学习目标

通过本章学习，你将能够：

理解抽象基类的概念和作用
掌握 abc 模块的使用方法
学会定义和实现抽象基类
了解抽象方法、抽象属性的使用
掌握虚拟子类的注册机制
在实际项目中应用抽象基类设计模式

🔍 抽象基类概述

什么是抽象基类

抽象基类是一种不能直接实例化的类，它的主要目的是：

定义接口：规定子类必须实现的方法和属性
强制实现：确保子类实现了所有必要的方法
类型检查：提供 isinstance()和类型注解的支持
代码规范：作为代码结构的规范和文档

from abc import ABC, abstractmethod

class Animal(ABC):
    """动物抽象基类"""
    
    @abstractmethod
    def make_sound(self):
        """发出声音的抽象方法"""
        pass
    
    @abstractmethod
    def move(self):
        """移动的抽象方法"""
        pass
    
#    # 可以包含具体方法
    def sleep(self):
        print(f"{self.__class__.__name__} is sleeping")

## 尝试实例化抽象基类会报错
## animal = Animal()  # TypeError: Can't instantiate abstract class

🏗️ abc 模块详解

核心组件

Python 的abc模块提供了创建抽象基类的工具：

ABC类：所有抽象基类的基类
abstractmethod：标记抽象方法的装饰器
abstractproperty：标记抽象属性（Python 3.11 后废弃）
abstractclassmethod：标记抽象类方法
abstractstaticmethod：标记抽象静态方法
ABCMeta：抽象基类的元类

基本使用方法

from abc import ABC, abstractmethod, abstractclassmethod, abstractstaticmethod

class Shape(ABC):
    """图形抽象基类"""
    
    def __init__(self, name):
        self.name = name
    
    @abstractmethod
    def area(self):
        """计算面积的抽象方法"""
        pass
    
    @abstractmethod
    def perimeter(self):
        """计算周长的抽象方法"""
        pass
    
    @abstractclassmethod
    def from_string(cls, shape_str):
        """从字符串创建图形的抽象类方法"""
        pass
    
    @abstractstaticmethod
    def validate_dimensions(*args):
        """验证尺寸的抽象静态方法"""
        pass
    
#    # 具体方法
    def describe(self):
        return f"{self.name}: 面积={self.area():.2f}, 周长={self.perimeter():.2f}"

🎯 实现抽象基类

完整的流接口示例

from abc import ABCMeta, abstractmethod

class IStream(metaclass=ABCMeta):
    """流接口抽象基类"""
    
    @abstractmethod
    def read(self, maxbytes=-1):
        """读取数据"""
        pass
    
    @abstractmethod
    def write(self, data):
        """写入数据"""
        pass

# 具体实现示例
class SocketStream(IStream):
    """Socket流实现"""
    
    def read(self, maxbytes=-1):
        print('从Socket读取数据')
        return b'socket_data'
    
    def write(self, data):
        print(f'向Socket写入数据: {data}')

# 类型检查示例函数
def serialize(obj, stream):
    """序列化对象到流"""
    if not isinstance(stream, IStream):
        raise TypeError('Expected an IStream')
    print('正在序列化对象...')
    stream.write(str(obj).encode())

# 使用示例
if __name__ == '__main__':
    # 尝试直接实例化抽象基类(会失败)
    try:
        a = IStream()
    except TypeError as e:
        print(f"抽象基类实例化失败: {e}")

    # 实例化具体实现
    socket_stream = SocketStream()
    socket_stream.read()
    socket_stream.write('测试数据')

    # 传递给类型检查函数
    serialize("Hello", socket_stream)

    # 尝试传递不兼容的对象(会失败)
    import sys
    try:
        serialize("Hello", sys.stdout)
    except TypeError as e:
        print(f"类型检查失败: {e}")

    # 注册已有类型作为虚拟子类
    import io
    IStream.register(io.IOBase)
    
    # 现在可以传递文件对象了
    serialize("Hello", sys.stdout)
    print(f"sys.stdout是IStream的实例: {isinstance(sys.stdout, IStream)}")

抽象类方法和静态方法

from abc import ABCMeta, abstractmethod

class A(metaclass=ABCMeta):
    """包含各种抽象成员的示例类"""
    
    @property
    @abstractmethod
    def name(self):
        """抽象属性"""
        pass

    @name.setter
    @abstractmethod
    def name(self, value):
        """抽象属性的setter"""
        pass

    @classmethod
    @abstractmethod
    def method1(cls):
        """抽象类方法"""
        pass

    @staticmethod
    @abstractmethod
    def method2():
        """抽象静态方法"""
        pass

class ConcreteA(A):
    """A的具体实现"""
    
    def __init__(self):
        self._name = "默认名称"
    
    @property
    def name(self):
        return self._name
    
    @name.setter
    def name(self, value):
        self._name = value
    
    @classmethod
    def method1(cls):
        return f"类方法被{cls.__name__}调用"
    
    @staticmethod
    def method2():
        return "静态方法被调用"

# 使用示例
concrete = ConcreteA()
print(concrete.name)              # 默认名称
concrete.name = "新名称"
print(concrete.name)              # 新名称
print(ConcreteA.method1())        # 类方法被ConcreteA调用
print(ConcreteA.method2())        # 静态方法被调用

插件系统设计模式

import abc

class PluginBase(object):
    """插件基类 - 定义插件接口"""
    __metaclass__ = abc.ABCMeta

    @abc.abstractmethod
    def load(self, input):
        """从输入源检索数据并返回对象"""
        return

    @abc.abstractmethod
    def save(self, output, data):
        """将数据对象保存到输出"""
        return

# 方法1: 通过注册实现插件
class RegisteredImplementation(object):
    """通过注册机制实现的插件"""
    
    def load(self, input):
        return input.read()

    def save(self, output, data):
        return output.write(data)

# 注册为PluginBase的虚拟子类
PluginBase.register(RegisteredImplementation)

# 方法2: 通过继承实现插件
class SubclassImplementation(PluginBase):
    """通过继承实现的插件"""
    
    def load(self, input):
        return input.read()

    def save(self, output, data):
        return output.write(data)

# 测试两种实现方式
if __name__ == '__main__':
    print('注册方式实现:')
    print('  是子类:', issubclass(RegisteredImplementation, PluginBase))
    print('  是实例:', isinstance(RegisteredImplementation(), PluginBase))
    
    print('\n继承方式实现:')
    print('  是子类:', issubclass(SubclassImplementation, PluginBase))
    print('  是实例:', isinstance(SubclassImplementation(), PluginBase))
    
    # 查看子类列表的区别
    print(f'\n注册子类在subclasses中: {RegisteredImplementation in PluginBase.__subclasses__()}')
    print(f'继承子类在subclasses中: {SubclassImplementation in PluginBase.__subclasses__()}')

抽象方法的具体实现

抽象类中的抽象方法也可以提供通用逻辑实现，具体类可以通过super()重用：

import abc
from io import StringIO

class ABCWithConcreteImplementation(object):
    """包含具体实现的抽象基类"""
    __metaclass__ = abc.ABCMeta
    
    @abc.abstractmethod
    def retrieve_values(self, input):
        """检索值的抽象方法 - 提供基础实现"""
        print('基类正在读取数据')
        return input.read()

class ConcreteOverride(ABCWithConcreteImplementation):
    """重写抽象方法但复用基类逻辑"""
    
    def retrieve_values(self, input):
        # 调用父类的抽象方法实现
        base_data = super(ConcreteOverride, self).retrieve_values(input)
        print('子类正在排序数据')
        response = sorted(base_data.splitlines())
        return response

# 使用示例
input_data = StringIO("""line one
line two
line three
""")

reader = ConcreteOverride()
result = reader.retrieve_values(input_data)
print('最终结果:', result)

具体子类实现

import math

class Rectangle(Shape):
    """矩形类"""
    
    def __init__(self, width, height):
        super().__init__("矩形")
        self.width = width
        self.height = height
    
    def area(self):
        return self.width * self.height
    
    def perimeter(self):
        return 2 * (self.width + self.height)
    
    @classmethod
    def from_string(cls, shape_str):
#        # 解析字符串 "rectangle:width,height"
        parts = shape_str.split(':')
        if parts[0] != 'rectangle':
            raise ValueError("不是矩形字符串")
        width, height = map(float, parts[1].split(','))
        return cls(width, height)
    
    @staticmethod
    def validate_dimensions(width, height):
        return width > 0 and height > 0

class Circle(Shape):
    """圆形类"""
    
    def __init__(self, radius):
        super().__init__("圆形")
        self.radius = radius
    
    def area(self):
        return math.pi * self.radius ** 2
    
    def perimeter(self):
        return 2 * math.pi * self.radius
    
    @classmethod
    def from_string(cls, shape_str):
#        # 解析字符串 "circle:radius"
        parts = shape_str.split(':')
        if parts[0] != 'circle':
            raise ValueError("不是圆形字符串")
        radius = float(parts[1])
        return cls(radius)
    
    @staticmethod
    def validate_dimensions(radius):
        return radius > 0

## 使用示例
rect = Rectangle(5, 3)
circle = Circle(4)

print(rect.describe())  # 矩形: 面积=15.00, 周长=16.00
print(circle.describe())  # 圆形: 面积=50.27, 周长=25.13

## 从字符串创建
rect2 = Rectangle.from_string("rectangle:10,6")
print(rect2.describe())  # 矩形: 面积=60.00, 周长=32.00

🔧 抽象特性(Abstract Properties)

基础抽象属性

如果API规范中包括属性，可以使用@abstractproperty来定义：

import abc

class Base(object):
    """包含抽象属性的基类"""
    __metaclass__ = abc.ABCMeta

    @abc.abstractproperty
    def value(self):
        """抽象属性 - 只读"""
        return 'Should never get here'

class Implementation(Base):
    """实现抽象属性的具体类"""
    
    @property
    def value(self):
        return 'concrete property'

# 测试
try:
    b = Base()
    print('Base.value:', b.value)
except Exception as err:
    print('错误:', str(err))

i = Implementation()
print('Implementation.value:', i.value)

读写抽象属性

定义同时具有getter和setter的抽象属性：

import abc

class Base(object):
    """包含读写抽象属性的基类"""
    __metaclass__ = abc.ABCMeta
    
    def value_getter(self):
        return 'Should never see this'
    
    def value_setter(self, newvalue):
        return
    
    # 使用函数形式定义抽象属性
    value = abc.abstractproperty(value_getter, value_setter)

class PartialImplementation(Base):
    """只实现了getter的不完整实现"""
    
    @abc.abstractproperty
    def value(self):
        return 'Read-only'

class Implementation(Base):
    """完整实现读写属性"""
    
    def __init__(self):
        self._value = 'Default value'
    
    def value_getter(self):
        return self._value
    
    def value_setter(self, newvalue):
        self._value = newvalue
    
    # 定义具体类的property时必须与抽象类的abstract property相同
    value = property(value_getter, value_setter)

# 测试各种实现
try:
    b = Base()
    print('Base.value:', b.value)
except Exception as err:
    print('Base实例化错误:', str(err))

try:
    p = PartialImplementation()
    print('PartialImplementation.value:', p.value)
except Exception as err:
    print('PartialImplementation实例化错误:', str(err))

i = Implementation()
print('Implementation.value:', i.value)
i.value = 'New value'
print('修改后的值:', i.value)

使用装饰器实现读写抽象属性

使用装饰器语法实现读写抽象属性，读和写的方法名必须相同：

import abc

class Base(object):
    """使用装饰器语法的抽象属性"""
    __metaclass__ = abc.ABCMeta
    
    @abc.abstractproperty
    def value(self):
        """抽象属性的getter"""
        return 'Should never see this'
    
    @value.setter
    def value(self, newvalue):
        """抽象属性的setter"""
        return

class Implementation(Base):
    """使用装饰器语法实现抽象属性"""
    
    def __init__(self):
        self._value = 'Default value'
    
    @property
    def value(self):
        return self._value
    
    @value.setter
    def value(self, newvalue):
        self._value = newvalue

# 使用示例
i = Implementation()
print('Implementation.value:', i.value)
i.value = 'New value'
print('修改后的值:', i.value)

💡 为什么使用ABC？

Abstract Base Classes提供了比hasattr()更严格的接口检查机制。通过定义抽象基类，可以：

为一组子类定义通用API: 确保所有实现都遵循相同的接口规范
支持第三方插件开发: 第三方开发者可以基于抽象基类为应用提供插件
改善大型项目的可维护性: 在大型团队或代码库中，抽象基类帮助维护清晰的类层次结构
提供更好的类型检查: 支持isinstance()检查和类型注解
强制实现关键方法: 确保子类实现所有必需的抽象方法

ABC的工作原理

abc模块通过以下方式工作：

在基类中将方法标记为抽象方法
注册具体类作为抽象基类的实现
提供运行时类型检查和验证机制

这种设计模式特别适用于：

框架设计中的接口定义
插件系统的接口规范
大型项目中的模块解耦
API设计和第三方集成