Python中`C/C++`扩展的编写：使用`CFFI`、`ctypes`和`pybind11`进行高性能计算。

Python扩展编写：CFFI, ctypes, 和 pybind11 实现高性能计算

各位同学，大家好！今天我们来深入探讨如何利用C/C++扩展来提升Python程序的性能，特别是针对计算密集型任务。我们将重点关注三种主流方法：CFFI、ctypes 和 pybind11。

Python作为一种高级动态语言，拥有易于学习、快速开发的优点。然而，解释执行的特性使其在处理大规模数据和复杂计算时，性能往往不如编译型语言C/C++。因此，将性能瓶颈部分用C/C++编写，再与Python代码集成，是一种常见的优化手段。

1. 为什么要使用C/C++扩展？

简单来说，使用C/C++扩展的主要目的是为了提升性能。但这并非唯一的原因。以下是一些具体的考虑因素：

• 性能优化： C/C++编译成机器码，执行效率远高于Python解释器逐行解释执行。
• 利用现有C/C++库： 很多成熟的科学计算、图像处理、音视频处理等库都是用C/C++编写的。
• 底层硬件访问： C/C++可以直接操作内存和硬件，可以实现一些Python无法完成的任务。
• 代码保护： 将核心算法用C/C++编写，编译成二进制文件，可以提高代码的安全性。

2. 三种扩展方式的比较

在选择合适的扩展方式之前，我们先对CFFI、ctypes 和 pybind11 进行一个简单的比较：

特性	CFFI	ctypes	pybind11
语言	C	C	C++
接口定义	ABI 或 API 模式，推荐 API 模式	Python	C++
易用性	相对复杂，需要编写接口描述	相对简单，直接在 Python 中定义类型和函数	简单，利用模板元编程自动生成绑定
性能	接近 C 的性能	性能损耗较大，需要类型转换	接近 C++ 的性能
依赖	需要 C 编译器和 CFFI 库	无额外依赖	需要 C++ 编译器和 pybind11 库
适用场景	需要高性能，对接口定义有一定要求的场景	快速原型验证，或者调用简单的 C 库	需要高性能，并且希望使用 C++ 特性的场景

3. CFFI (C Foreign Function Interface)

CFFI 是一个用于从 Python 调用 C 代码的外部函数接口。它支持两种模式：

• ABI (Application Binary Interface) 模式： 直接使用 C 编译器的二进制接口，不需要编译 C 代码，但依赖于特定的编译器和平台。
• API (Application Programming Interface) 模式： 需要编译 C 代码，但更加灵活，可以跨平台使用。CFFI 推荐使用 API 模式。

示例：使用 CFFI (API 模式) 计算两个数的和

Step 1: 编写 C 代码 (my_module.c)

// my_module.c
int add(int a, int b) {
  return a + b;
}

Step 2: 编写 Python 代码 (build.py) 生成 CFFI 模块

# build.py
from cffi import FFI

ffibuilder = FFI()

ffibuilder.cdef("""
    int add(int a, int b);
""")

ffibuilder.set_source(
    "_my_module",  # 模块名
    """
    #include "my_module.c"
    """,
    extra_compile_args=['-Werror'],  # 可选：添加编译参数
)

if __name__ == "__main__":
    ffibuilder.compile(verbose=True)

Step 3: 编译 C 代码生成 CFFI 模块

在命令行中运行：python build.py

这会在当前目录下生成 _my_module.c、_my_module.o (或其他平台的 object 文件) 和 _my_module.so (或 .dll 或 .dylib)。

Step 4: 编写 Python 代码 (main.py) 使用 CFFI 模块

# main.py
from cffi import FFI

ffi = FFI()
ffi.cdef("""
    int add(int a, int b);
""")
lib = ffi.dlopen("_my_module.so") # 或者 .dll, .dylib

result = lib.add(10, 20)
print(f"The sum is: {result}")

代码解释：

• build.py：定义了 C 代码的接口，并编译生成 CFFI 模块。
  • ffibuilder.cdef()：定义 C 函数的签名。
  • ffibuilder.set_source()：指定 C 源代码。
  • ffibuilder.compile()：编译 C 代码。
• main.py：加载 CFFI 模块，并调用 C 函数。
  • ffi.cdef()：再次定义 C 函数的签名 (需要与 build.py 中一致)。
  • ffi.dlopen()：加载 CFFI 模块 (动态链接库)。
  • lib.add()：调用 C 函数。

CFFI 的优点：

• 高性能： 接近 C 的执行效率。
• 灵活性： 可以调用任意 C 代码。
• 跨平台： API 模式可以跨平台使用。

CFFI 的缺点：

• 学习曲线较陡峭： 需要理解 CFFI 的 API 和 C 的类型系统。
• 代码量较大： 需要编写接口描述文件。

4. ctypes

ctypes 是 Python 内置的外部函数库，它允许 Python 代码调用 C 动态链接库中的函数。ctypes 的主要优点是无需编译 C 代码，可以直接在 Python 中定义 C 函数的类型和参数。

示例：使用 ctypes 计算两个数的和

Step 1: 编写 C 代码 (my_module.c)

// my_module.c
int add(int a, int b) {
  return a + b;
}

Step 2: 编译 C 代码生成动态链接库

在 Linux/macOS 上：gcc -shared -o my_module.so my_module.c

在 Windows 上：gcc -shared -o my_module.dll my_module.c

Step 3: 编写 Python 代码 (main.py) 使用 ctypes 模块

# main.py
import ctypes

# 加载动态链接库
lib = ctypes.CDLL("./my_module.so") # 或 my_module.dll

# 定义 C 函数的参数类型和返回类型
lib.add.argtypes = [ctypes.c_int, ctypes.c_int]
lib.add.restype = ctypes.c_int

# 调用 C 函数
result = lib.add(10, 20)
print(f"The sum is: {result}")

代码解释：

• ctypes.CDLL()：加载 C 动态链接库。
• lib.add.argtypes：定义 C 函数 add 的参数类型，使用 ctypes.c_int 表示 C 中的 int 类型。
• lib.add.restype：定义 C 函数 add 的返回类型。
• lib.add()：调用 C 函数。

ctypes 的优点：

• 简单易用： 无需编写接口描述文件，直接在 Python 中定义类型和函数。
• 无需额外依赖： Python 内置，无需安装额外的库。

ctypes 的缺点：

• 性能损耗较大： 需要进行类型转换，性能不如 CFFI 和 pybind11。
• 容易出错： 需要手动定义类型，容易出现类型不匹配的错误。
• 不支持 C++ 特性： 只能调用 C 函数，不支持 C++ 类和对象。

ctypes 类型映射表：

Python 类型	ctypes 类型	C 类型
int	ctypes.c_int	int
float	ctypes.c_float	float
double	ctypes.c_double	double
str	ctypes.c_char_p	char*
bytes	ctypes.c_char_p	char*
list/tuple	ctypes.c_array	array
None	ctypes.c_void_p	void*

5. pybind11

pybind11 是一个轻量级的头文件库，用于创建 Python 绑定。它允许你使用 C++ 编写高性能的 Python 模块，并且提供了简洁优雅的 API。pybind11 利用 C++ 的模板元编程技术，可以自动生成 Python 绑定代码，大大简化了扩展的编写过程。

示例：使用 pybind11 计算两个数的和

Step 1: 编写 C++ 代码 (my_module.cpp)

// my_module.cpp
#include <pybind11/pybind11.h>

int add(int a, int b) {
  return a + b;
}

namespace py = pybind11;

PYBIND11_MODULE(my_module, m) {
  m.doc() = "pybind11 example plugin"; // optional module docstring

  m.def("add", &add, "A function which adds two numbers");
}

Step 2: 编写 setup.py 文件

# setup.py
from setuptools import setup, Extension
from pybind11.setup_helpers import Pybind11Extension, build_ext

ext_modules = [
    Pybind11Extension(
        "my_module",  # 模块名
        ["my_module.cpp"],  # 源文件列表
        # Example: passing in the version to the compiled code
        define_macros=[("VERSION_INFO", "1.0")],
    ),
]

setup(
    name="my_module",
    version="1.0",
    author="Your Name",
    author_email="[email protected]",
    description="A test project using pybind11",
    long_description="",
    ext_modules=ext_modules,
    cmdclass={"build_ext": build_ext},
    zip_safe=False,
)

Step 3: 编译 C++ 代码生成 Python 模块

在命令行中运行：python setup.py install

这会将编译后的 my_module.so (或其他平台的动态链接库) 安装到 Python 的 site-packages 目录下。

Step 4: 编写 Python 代码 (main.py) 使用 pybind11 模块

# main.py
import my_module

result = my_module.add(10, 20)
print(f"The sum is: {result}")

代码解释：

• my_module.cpp：包含 C++ 代码和 pybind11 绑定代码。
  • #include <pybind11/pybind11.h>：包含 pybind11 头文件。
  • PYBIND11_MODULE(my_module, m)：定义 Python 模块。
    • m.def("add", &add, "A function which adds two numbers")：将 C++ 函数 add 绑定到 Python 模块 my_module 中，并指定函数的文档字符串。
• setup.py：使用 setuptools 和 pybind11.setup_helpers 编译 C++ 代码并生成 Python 模块。
• main.py：导入 pybind11 模块，并调用 C++ 函数。

pybind11 的优点：

• 简单易用： 利用 C++ 模板元编程自动生成绑定代码，大大简化了扩展的编写过程。
• 高性能： 接近 C++ 的执行效率。
• 支持 C++ 特性： 可以绑定 C++ 类、对象、函数重载、模板等。
• 良好的类型转换： pybind11 提供了自动的类型转换机制，可以方便地在 Python 和 C++ 之间传递数据。

pybind11 的缺点：

• 需要 C++ 编译器： 需要安装 C++ 编译器，例如 g++ 或 clang++。
• 学习曲线较陡峭： 需要理解 C++ 模板元编程和 pybind11 的 API。

6. 如何选择合适的扩展方式？

选择哪种扩展方式取决于你的具体需求和技术背景。以下是一些建议：

• 如果需要快速原型验证，或者调用简单的 C 库： 可以选择 ctypes，因为它简单易用，无需额外依赖。
• 如果需要高性能，并且对接口定义有一定要求的场景： 可以选择 CFFI，它可以提供接近 C 的性能，并且支持跨平台。
• 如果需要高性能，并且希望使用 C++ 特性的场景： 可以选择 pybind11，它可以方便地绑定 C++ 类、对象和函数，并且提供了良好的类型转换机制。

总的来说，pybind11 是一个更加现代和强大的扩展方式，它提供了更好的性能、更简洁的 API 和更丰富的功能。但是，它的学习曲线也相对较陡峭。

7. 性能优化注意事项

无论选择哪种扩展方式，以下是一些性能优化方面的注意事项：

• 减少数据在 Python 和 C/C++ 之间的传递： 数据传递的开销很大，尽量在 C/C++ 中完成尽可能多的计算。
• 使用高效的数据结构和算法： C/C++ 提供了更多的数据结构和算法选择，可以根据实际情况选择最合适的。
• 利用编译器优化： 开启编译器的优化选项，例如 -O3，可以提高代码的执行效率。
• 使用多线程或多进程： C/C++ 可以方便地使用多线程或多进程来并行计算，提高程序的吞吐量。
• 避免内存泄漏： C/C++ 需要手动管理内存，需要注意避免内存泄漏。

8. 案例分析：使用 pybind11 加速 NumPy 数组计算

NumPy 是 Python 中用于科学计算的核心库，它提供了高效的多维数组对象。但是，对于一些复杂的数组计算，NumPy 的性能仍然可能不足。这时，可以使用 pybind11 来加速 NumPy 数组的计算。

示例：使用 pybind11 计算 NumPy 数组的平均值

Step 1: 编写 C++ 代码 (numpy_example.cpp)

// numpy_example.cpp
#include <pybind11/pybind11.h>
#include <pybind11/numpy.h>

namespace py = pybind11;

double average(py::array_t<double> arr) {
  py::buffer_info buf = arr.request();
  double *ptr = (double *) buf.ptr;
  int size = buf.size;

  double sum = 0;
  for (int i = 0; i < size; i++) {
    sum += ptr[i];
  }

  return sum / size;
}

PYBIND11_MODULE(numpy_example, m) {
  m.def("average", &average, "Calculates the average of a NumPy array");
}

Step 2: 编写 setup.py 文件

# setup.py
from setuptools import setup, Extension
from pybind11.setup_helpers import Pybind11Extension, build_ext
import os

ext_modules = [
    Pybind11Extension(
        "numpy_example",  # 模块名
        ["numpy_example.cpp"],  # 源文件列表
        # Example: passing in the version to the compiled code
        define_macros=[("VERSION_INFO", "1.0")],
        include_dirs=[os.path.dirname(__file__)] # 添加当前目录到include路径
    ),
]

setup(
    name="numpy_example",
    version="1.0",
    author="Your Name",
    author_email="[email protected]",
    description="A test project using pybind11 and NumPy",
    long_description="",
    ext_modules=ext_modules,
    cmdclass={"build_ext": build_ext},
    zip_safe=False,
)

Step 3: 编译 C++ 代码生成 Python 模块

在命令行中运行：python setup.py install

Step 4: 编写 Python 代码 (main.py) 使用 pybind11 模块

# main.py
import numpy as np
import numpy_example
import time

# 创建一个大的 NumPy 数组
arr = np.random.rand(1000000)

# 使用 pybind11 计算平均值
start_time = time.time()
avg_cpp = numpy_example.average(arr)
end_time = time.time()
print(f"Average (C++): {avg_cpp}, Time: {end_time - start_time:.4f} seconds")

# 使用 NumPy 计算平均值
start_time = time.time()
avg_numpy = np.mean(arr)
end_time = time.time()
print(f"Average (NumPy): {avg_numpy}, Time: {end_time - start_time:.4f} seconds")

代码解释：

• numpy_example.cpp：包含 C++ 代码和 pybind11 绑定代码。
  • #include <pybind11/numpy.h>：包含 pybind11 NumPy 头文件，用于处理 NumPy 数组。
  • py::array_t<double> arr：表示一个双精度浮点数类型的 NumPy 数组。
  • arr.request()：获取 NumPy 数组的缓冲区信息，包括指针、大小等。
• main.py：比较使用 pybind11 和 NumPy 计算平均值的性能。

通过运行这个示例，你会发现使用 pybind11 计算 NumPy 数组的平均值比使用 NumPy 本身更快。这是因为 C++ 代码可以直接访问 NumPy 数组的底层数据，避免了 Python 解释器的开销。

9. 深入理解扩展机制，选择合适的工具

今天我们探讨了使用 CFFI, ctypes, 和 pybind11 编写 Python 扩展的方法，并对比了各自的优缺点和适用场景。理解这些扩展机制，可以帮助我们更好地利用 C/C++ 的性能优势，提升 Python 程序的效率。

10. 优化代码，避免不必要的性能损失

无论选择哪种扩展方式，都要注意代码的优化，避免不必要的数据拷贝和类型转换，才能充分发挥 C/C++ 的性能。

11. 持续学习和实践，掌握更多高级技巧

Python 扩展的编写是一个复杂而有趣的话题，希望大家通过今天的学习，能够掌握一些基本的技巧，并在实践中不断探索和学习，掌握更多高级的扩展技术。 谢谢大家！