Python 抽象基类 ABC ：从实践到优雅-51CTO.COM

今天我们来聊聊 Python 中的抽象基类（Abstract Base Class，简称 ABC）。虽然这个概念在 Python 中已经存在很久了，但在日常开发中，很多人可能用得并不多，或者用得不够优雅。

让我们从一个实际场景开始：假设你正在开发一个文件处理系统，需要支持不同格式的文件读写，比如 JSON、CSV、XML 等。

初始版本：简单但不够严谨

我们先来看看最简单的实现方式：

class FileHandler:
    def read(self, filename):
        pass
    
    def write(self, filename, data):
        pass

class JsonHandler(FileHandler):
    def read(self, filename):
        import json
        with open(filename, 'r') as f:
            return json.load(f)
    
    def write(self, filename, data):
        import json
        with open(filename, 'w') as f:
            json.dump(data, f)

class CsvHandler(FileHandler):
    def read(self, filename):
        import csv
        with open(filename, 'r') as f:
            return list(csv.reader(f))1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.

这个实现看起来没什么问题，但实际上存在几个隐患：

无法强制子类实现所有必要的方法
基类方法的签名（参数列表）可能与子类不一致
没有明确的接口契约

改进版本：使用抽象基类

让我们引入 abc.ABC 来改进这个设计：

from abc import ABC, abstractmethod

class FileHandler(ABC):
    @abstractmethod
    def read(self, filename: str):
        """读取文件内容"""
        pass
    
    @abstractmethod
    def write(self, filename: str, data: any):
        """写入文件内容"""
        pass

class JsonHandler(FileHandler):
    def read(self, filename: str):
        import json
        with open(filename, 'r') as f:
            return json.load(f)
    
    def write(self, filename: str, data: any):
        import json
        with open(filename, 'w') as f:
            json.dump(data, f)1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.

这个版本引入了两个重要的改进：

使用 ABC 将 FileHandler 声明为抽象基类
使用 @abstractmethod 装饰器标记抽象方法

现在，如果我们尝试实例化一个没有实现所有抽象方法的子类，Python 会抛出异常：

# 这个类缺少 write 方法的实现
class BrokenHandler(FileHandler):
    def read(self, filename: str):
        return "some data"

# 这行代码会抛出 TypeError
handler = BrokenHandler()  # TypeError: Can't instantiate abstract class BrokenHandler with abstract method write1.
2.
3.
4.
5.
6.
7.

进一步优化：添加类型提示和接口约束

让我们再进一步，添加类型提示和更严格的接口约束：

from abc import ABC, abstractmethod
from typing import Any, List, Dict, Union

class FileHandler(ABC):
    @abstractmethod
    def read(self, filename: str) -> Union[Dict, List]:
        """读取文件内容并返回解析后的数据结构"""
        pass
    
    @abstractmethod
    def write(self, filename: str, data: Union[Dict, List]) -> None:
        """将数据结构写入文件"""
        pass
    
    @property
    @abstractmethod
    def supported_extensions(self) -> List[str]:
        """返回支持的文件扩展名列表"""
        pass

class JsonHandler(FileHandler):
    def read(self, filename: str) -> Dict:
        import json
        with open(filename, 'r') as f:
            return json.load(f)
    
    def write(self, filename: str, data: Dict) -> None:
        import json
        with open(filename, 'w') as f:
            json.dump(data, f)
    
    @property
    def supported_extensions(self) -> List[str]:
        return ['.json']

# 使用示例
def process_file(handler: FileHandler, filename: str) -> None:
    if any(filename.endswith(ext) for ext in handler.supported_extensions):
        data = handler.read(filename)
        # 处理数据...
        handler.write(f'processed_{filename}', data)
    else:
        raise ValueError(f"Unsupported file extension for {filename}")1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.

这个最终版本的改进包括：

添加了类型提示，提高代码的可读性和可维护性
引入了抽象属性（supported_extensions），使接口更完整
通过 Union 类型提供了更灵活的数据类型支持
提供了清晰的文档字符串

使用抽象基类的好处

接口契约：抽象基类提供了明确的接口定义，任何违反契约的实现都会在运行前被发现。
代码可读性：通过抽象方法清晰地表明了子类需要实现的功能。
类型安全：结合类型提示，我们可以在开发时就发现潜在的类型错误。
设计模式支持：抽象基类非常适合实现诸如工厂模式、策略模式等设计模式。

NotImplementedError 还是 ABC？

很多 Python 开发者会使用 NotImplementedError 来标记需要子类实现的方法：

class FileHandler:
    def read(self, filename: str) -> Dict:
        raise NotImplementedError("Subclass must implement read method")
    
    def write(self, filename: str, data: Dict) -> None:
        raise NotImplementedError("Subclass must implement write method")1.
2.
3.
4.
5.
6.

这种方式看起来也能达到目的，但与 ABC 相比有几个明显的劣势：

延迟检查：使用 NotImplementedError 只能在运行时发现问题，而 ABC 在实例化时就会检查。

# 使用 NotImplementedError 的情况
class BadHandler(FileHandler):
    pass

handler = BadHandler()  # 这行代码可以执行
handler.read("test.txt")  # 直到这里才会报错

# 使用 ABC 的情况
class BadHandler(FileHandler):  # FileHandler 是 ABC
    pass

handler = BadHandler()  # 直接在这里就会报错1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.

缺乏语义：NotImplementedError 本质上是一个异常，而不是一个接口契约。
IDE 支持：现代 IDE 对 ABC 的支持更好，能提供更准确的代码提示和检查。

不过，NotImplementedError 在某些场景下仍然有其价值：

当你想在基类中提供部分实现，但某些方法必须由子类覆盖时：

from abc import ABC, abstractmethod

class FileHandler(ABC):
    @abstractmethod
    def read(self, filename: str) -> Dict:
        pass
    
    def process(self, filename: str) -> Dict:
        data = self.read(filename)
        if not self._validate(data):
            raise ValueError("Invalid data format")
        return self._transform(data)
    
    def _validate(self, data: Dict) -> bool:
        raise NotImplementedError("Subclass should implement validation")
    
    def _transform(self, data: Dict) -> Dict:
        # 默认实现
        return data1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.

这里，_validate 使用 NotImplementedError 而不是 @abstractmethod，表明它是一个可选的扩展点，而不是必须实现的接口。

代码检查工具的配合

主流的 Python 代码检查工具（pylint、flake8）都对抽象基类提供了良好的支持。

Pylint

Pylint 可以检测到未实现的抽象方法：

# pylint: disable=missing-module-docstring
from abc import ABC, abstractmethod

class Base(ABC):
    @abstractmethod
    def foo(self):
        pass

class Derived(Base):  # pylint: error: Abstract method 'foo' not implemented
    pass1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

你可以在 .pylintrc 中配置相关规则：

[MESSAGES CONTROL]
# 启用抽象类检查
enable=abstract-method1.
2.
3.

Flake8

Flake8 本身不直接检查抽象方法实现，但可以通过插件增强这个能力：

pip install flake8-abstract-base-class1.

配置 .flake8：

[flake8]
max-complexity = 10
extend-ignore = ABC0011.
2.
3.

metaclass=ABCMeta vs ABC

在 Python 中，有两种方式定义抽象基类：

# 方式 1：直接继承 ABC
from abc import ABC, abstractmethod

class FileHandler(ABC):
    @abstractmethod
    def read(self):
        pass

# 方式 2：使用 metaclass
from abc import ABCMeta, abstractmethod

class FileHandler(metaclass=ABCMeta):
    @abstractmethod
    def read(self):
        pass1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.

这两种方式在功能上是等价的，因为 ABC 类本身就是用 ABCMeta 作为元类定义的：

class ABC(metaclass=ABCMeta):
    """Helper class that provides a standard way to create an ABC using
    inheritance.
    """
    pass1.
2.
3.
4.
5.

选择建议：

推荐使用 ABC：

代码更简洁
更符合 Python 的简单直观原则
是 Python 3.4+ 后推荐的方式

使用 metaclass=ABCMeta 的场景：

当你的类已经有其他元类时
需要自定义元类行为时

例如，当你需要组合多个元类的功能时：

class MyMeta(type):
    def __new__(cls, name, bases, namespace):
        # 自定义的元类行为
        return super().__new__(cls, name, bases, namespace)

class CombinedMeta(ABCMeta, MyMeta):
    pass

class MyHandler(metaclass=CombinedMeta):
    @abstractmethod
    def handle(self):
        pass1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.

实践建议

当你需要确保一组类遵循相同的接口时，使用抽象基类。
优先使用类型提示，它们能帮助开发者更好地理解代码。
适当使用抽象属性（@property + @abstractmethod），它们也是接口的重要组成部分。
在文档字符串中清晰地说明方法的预期行为和返回值。

通过这个实例，我们可以看到抽象基类如何帮助我们写出更加健壮和优雅的 Python 代码。它不仅能够捕获接口违规，还能提供更好的代码提示和文档支持。在下一个项目中，不妨试试用抽象基类来设计你的接口！