Python与C/C++互操作：如何使用`ctypes`、`cffi`和`pybind11`实现高性能的计算密集型模块。 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

Python与C/C++互操作：高性能计算模块的构建

大家好，今天我们来探讨一个重要的主题：Python与C/C++的互操作，以及如何利用这种互操作性构建高性能的计算密集型模块。Python以其易用性和丰富的库生态系统著称，但在处理需要极高计算性能的任务时，往往力不从心。C/C++则以其运行效率和底层控制能力成为理想的选择。将两者结合，既能享受Python的开发效率，又能获得C/C++的运行性能。

我们将重点介绍三种主流的互操作方案：ctypes、cffi和pybind11，并分析它们各自的特点、适用场景和具体用法。

1. ctypes：Python标准库中的利器

ctypes是Python标准库的一部分，它提供了一种直接调用动态链接库（DLL或SO）中C/C++函数的能力。无需额外的编译步骤，即可实现Python与C/C++代码的交互。

优势：

无需编译：直接加载动态链接库。
Python标准库：无需安装额外依赖。
简单易用：基本类型映射方便。

劣势：

手动类型转换：需要显式定义和转换数据类型。
错误处理：需要手动处理C/C++函数的错误。
性能损耗：类型转换和函数调用存在一定的性能开销。

使用示例：

假设我们有一个名为my_library.c的C代码文件，其中包含一个简单的加法函数：

// my_library.c
#include <stdio.h>

int add(int a, int b) {
    printf("Calling C add function with a = %d, b = %dn", a, b);
    return a + b;
}

首先，我们需要将其编译成动态链接库。在Linux系统中，可以使用以下命令：

gcc -shared -o my_library.so my_library.c

在Windows系统中，可以使用以下命令（需要安装MinGW或Visual Studio）：

gcc -shared -o my_library.dll my_library.c

接下来，我们可以在Python中使用ctypes来调用这个加法函数：

# example.py
import ctypes

# 加载动态链接库
my_lib = ctypes.CDLL('./my_library.so') # Linux
# my_lib = ctypes.CDLL('./my_library.dll') # Windows

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

# 调用C函数
result = my_lib.add(10, 20)
print(f"Result from C add function: {result}")

解释：

ctypes.CDLL('./my_library.so') 加载动态链接库。
my_lib.add.argtypes = [ctypes.c_int, ctypes.c_int] 定义add函数的参数类型为两个C语言的int类型。
my_lib.add.restype = ctypes.c_int 定义add函数的返回类型为C语言的int类型。
result = my_lib.add(10, 20) 调用C函数，并将结果存储在result变量中。

复杂数据类型的处理：

对于更复杂的数据类型，例如结构体和数组，ctypes也提供了相应的支持。

// my_library.c
#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int x;
    int y;
} Point;

Point* create_point(int x, int y) {
    Point* p = (Point*)malloc(sizeof(Point));
    if (p != NULL) {
        p->x = x;
        p->y = y;
    }
    return p;
}

int get_x(Point* p) {
    if (p != NULL) {
        return p->x;
    } else {
        return -1; // Or handle the error in a different way
    }
}

void free_point(Point* p) {
    if (p != NULL) {
        free(p);
    }
}

编译成动态链接库：

gcc -shared -o my_library.so my_library.c

Python代码：

# example.py
import ctypes

# 加载动态链接库
my_lib = ctypes.CDLL('./my_library.so')

# 定义结构体类型
class Point(ctypes.Structure):
    _fields_ = [("x", ctypes.c_int), ("y", ctypes.c_int)]

# 定义函数参数类型和返回类型
my_lib.create_point.argtypes = [ctypes.c_int, ctypes.c_int]
my_lib.create_point.restype = ctypes.POINTER(Point)

my_lib.get_x.argtypes = [ctypes.POINTER(Point)]
my_lib.get_x.restype = ctypes.c_int

my_lib.free_point.argtypes = [ctypes.POINTER(Point)]
my_lib.free_point.restype = None

# 调用C函数
point = my_lib.create_point(10, 20)
print(f"Point address: {point}")
x = my_lib.get_x(point)
print(f"X coordinate: {x}")

my_lib.free_point(point)

解释：

class Point(ctypes.Structure): 定义了一个Python类Point，它继承自ctypes.Structure，用于表示C语言的Point结构体。
_fields_ = [("x", ctypes.c_int), ("y", ctypes.c_int)] 定义了Point结构体的成员变量，包括x和y，它们的类型都是ctypes.c_int。
ctypes.POINTER(Point) 表示指向Point结构体的指针。
需要注意内存管理，create_point 在C代码中分配了内存，需要在Python中通过 free_point 函数释放。

2. cffi：更灵活的互操作方案

cffi (C Foreign Function Interface) 提供了一种更灵活的方式来调用C代码。它允许你使用C语法来描述C接口，并自动生成必要的代码来实现Python和C之间的交互。

优势：

C语法描述：使用C语法描述C接口，更自然。
自动代码生成：自动生成Python和C之间的桥接代码。
支持多种调用方式：支持ABI和API两种调用方式。
安全性：在API模式下，可以进行类型检查，提高安全性。

劣势：

需要安装：需要安装cffi库。
学习曲线：相比ctypes，学习曲线稍陡峭。

使用示例：

我们仍然使用上面的my_library.c文件。

首先，需要安装cffi库：

pip install cffi

然后，创建example.py文件：

# example.py
from cffi import FFI

# 创建FFI对象
ffi = FFI()

# 声明C接口
ffi.cdef("""
    int add(int a, int b);
""")

# 加载动态链接库
lib = ffi.dlopen('./my_library.so') # Linux
# lib = ffi.dlopen('./my_library.dll') # Windows

# 调用C函数
result = lib.add(10, 20)
print(f"Result from C add function: {result}")

解释：

ffi = FFI() 创建一个FFI对象。
ffi.cdef("""...""") 使用C语法声明C接口。
lib = ffi.dlopen('./my_library.so') 加载动态链接库。
result = lib.add(10, 20) 调用C函数。

API模式：

cffi还支持API模式，它需要在编译时将C代码编译成一个模块，并在运行时加载该模块。这种模式可以提供更好的类型检查和安全性。

# build.py
from cffi import FFI

ffi = FFI()

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

ffi.set_source("_my_library",
"""
    #include "my_library.h"
""",
    sources=['my_library.c'],
    include_dirs=['.'],  # Include current directory for my_library.h
    extra_compile_args=['-Werror'] # Optional: Treat warnings as errors
)

if __name__ == "__main__":
    ffi.compile()

首先，我们需要创建一个头文件my_library.h，其中包含add函数的声明：

// my_library.h
#ifndef MY_LIBRARY_H
#define MY_LIBRARY_H

int add(int a, int b);

#endif

然后，运行build.py脚本来编译C代码：

python build.py

这会生成一个名为_my_library.so（或_my_library.pyd在Windows上）的模块。

最后，可以在Python中使用该模块：

# example.py
from _my_library import ffi, lib

# 调用C函数
result = lib.add(10, 20)
print(f"Result from C add function: {result}")

复杂数据类型的处理：

cffi处理复杂数据类型也比ctypes更加方便。

// my_library.c
#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int x;
    int y;
} Point;

Point* create_point(int x, int y) {
    Point* p = (Point*)malloc(sizeof(Point));
    if (p != NULL) {
        p->x = x;
        p->y = y;
    }
    return p;
}

int get_x(Point* p) {
    if (p != NULL) {
        return p->x;
    } else {
        return -1; // Or handle the error in a different way
    }
}

void free_point(Point* p) {
    if (p != NULL) {
        free(p);
    }
}

// my_library.h
#ifndef MY_LIBRARY_H
#define MY_LIBRARY_H

typedef struct {
    int x;
    int y;
} Point;

Point* create_point(int x, int y);
int get_x(Point* p);
void free_point(Point* p);

#endif

# build.py
from cffi import FFI

ffi = FFI()

ffi.cdef("""
    typedef struct {
        int x;
        int y;
    } Point;

    Point* create_point(int x, int y);
    int get_x(Point* p);
    void free_point(Point* p);
""")

ffi.set_source("_my_library",
"""
    #include "my_library.h"
""",
    sources=['my_library.c'],
    include_dirs=['.'],
    extra_compile_args=['-Werror']
)

if __name__ == "__main__":
    ffi.compile()

# example.py
from _my_library import ffi, lib

# 调用C函数
point = lib.create_point(10, 20)
print(f"Point address: {point}")
x = lib.get_x(point)
print(f"X coordinate: {x}")

lib.free_point(point)

解释：

在ffi.cdef中，我们定义了Point结构体和相关的函数声明。
通过lib.create_point创建的point变量，可以直接传递给lib.get_x和lib.free_point函数。
需要注意内存管理，create_point 在C代码中分配了内存，需要在Python中通过 free_point 函数释放。

3. pybind11：面向C++的完美桥梁

pybind11是一个轻量级的头文件库，用于创建Python绑定。它可以让你直接在C++代码中定义Python模块，并提供了一种简单而优雅的方式来暴露C++类和函数给Python。

优势：

现代C++：使用现代C++特性，代码简洁易懂。
自动类型转换：自动进行Python和C++类型之间的转换。
异常处理：支持C++异常到Python异常的转换。
高性能：高效的Python绑定生成器。

劣势：

需要编译：需要编译C++代码。
C++依赖：只能用于C++代码。
需要安装：需要安装pybind11。

使用示例：

首先，需要安装pybind11。如果使用conda，可以通过以下命令安装：

conda install -c conda-forge pybind11

或者使用pip:

pip install pybind11

然后，创建一个名为my_module.cpp的C++代码文件：

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

namespace py = pybind11;

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

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

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

解释：

#include <pybind11/pybind11.h> 引入pybind11头文件。
namespace py = pybind11; 使用pybind11命名空间。
PYBIND11_MODULE(my_module, m) 定义一个Python模块，名为my_module。
m.def("add", &add, "A function that adds two numbers"); 将C++函数add暴露给Python，并指定函数名和文档字符串。

接下来，我们需要编译C++代码。可以使用以下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",
    ext_modules=ext_modules,
    cmdclass={"build_ext": build_ext},
    zip_safe=False,
)

运行以下命令来编译和安装模块：

python setup.py install

最后，可以在Python中使用该模块：

# example.py
import my_module

# 调用C++函数
result = my_module.add(10, 20)
print(f"Result from C++ add function: {result}")

复杂数据类型的处理：

pybind11处理复杂数据类型非常方便。

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

namespace py = pybind11;

struct Point {
    int x;
    int y;
};

PYBIND11_MODULE(my_module, m) {
    py::class_<Point>(m, "Point")
        .def(py::init<>())
        .def_readwrite("x", &Point::x)
        .def_readwrite("y", &Point::y);

    m.def("create_point", []() { return Point{10, 20}; }, "Creates a point");
}

# example.py
import my_module

# 创建Point对象
point = my_module.Point()
point.x = 10
point.y = 20
print(f"Point x: {point.x}, y: {point.y}")

point2 = my_module.create_point()
print(f"Point2 x: {point2.x}, y: {point2.y}")

解释：

py::class_<Point>(m, "Point") 将C++结构体Point暴露给Python，并命名为Point。
.def(py::init<>()) 定义默认构造函数。
.def_readwrite("x", &Point::x) 将x成员变量暴露给Python，并允许读取和写入。
m.def("create_point", []() { return Point{10, 20}; }, "Creates a point"); 定义一个创建Point对象的函数。

不同工具的对比

下表总结了ctypes、cffi和pybind11的特点和适用场景：

特性	ctypes	cffi	pybind11
依赖	Python标准库	需要安装`cffi`库	需要安装`pybind11`库
语言	Python	C语法	C++
编译	无需编译	需要编译 (API模式)	需要编译
易用性	简单	较简单	较简单
性能	较低	较高	高
安全性	较低	较高 (API模式)	较高
适用场景	简单、无需编译的场景	需要更灵活的C接口描述的场景	需要将C++类和函数暴露给Python的场景
数据类型处理	手动类型转换，较为繁琐	较为方便，使用C语法描述	自动类型转换，非常方便

性能优化策略

无论选择哪种互操作方案，都需要注意性能优化。以下是一些常用的策略：

减少跨语言调用次数： 尽量将计算密集型任务放在C/C++代码中完成，减少Python和C/C++之间的频繁调用。
使用高效的数据结构： 选择合适的数据结构，例如使用NumPy数组代替Python列表。
避免不必要的内存拷贝： 尽量避免在Python和C/C++之间进行数据拷贝，可以使用指针或引用来传递数据。
并行计算： 利用多线程或多进程来加速计算。
编译器优化： 使用编译器优化选项，例如-O3，来提高C/C++代码的运行效率。

选择合适的工具

选择哪种互操作方案取决于具体的应用场景和需求。

如果只需要调用一些简单的C函数，并且不需要额外的编译步骤，那么ctypes是一个不错的选择。
如果需要更灵活地描述C接口，并且希望获得更好的类型检查和安全性，那么cffi是一个更好的选择。
如果需要将C++类和函数暴露给Python，并且希望使用现代C++特性，那么pybind11是最佳选择。

三种方案各有优劣，需要根据实际情况权衡选择。在实际项目中，可以根据不同的模块选择不同的方案，以达到最佳的性能和开发效率。

总结来说

我们学习了 ctypes、cffi 和 pybind11 三种 Python 与 C/C++ 互操作的方法。 ctypes 简单易用，但性能较低；cffi 更加灵活，支持 C 语法描述 C 接口；pybind11 面向 C++，提供高效的 Python 绑定。选择哪种方法取决于项目的具体需求和场景。

Python与C/C++互操作：高性能计算模块的构建

1. ctypes：Python标准库中的利器

2. cffi：更灵活的互操作方案

3. pybind11：面向C++的完美桥梁

不同工具的对比

性能优化策略

选择合适的工具

总结来说

发表回复 取消回复

发表回复取消回复