我要评论引言
python作为一门高级编程语言，以其简洁的语法和丰富的库生态赢得了开发者的青睐。然而，在计算密集型任务中，python的性能往往无法满足要求。python调用c/c++函数库成为提升应用性能的关键技术路径，通过将底层计算逻辑用c/c++实现，再通过适当的接口与python交互，可以在保持开发效率的同时获得接近系统语言的执行性能。本文将深入探讨python调用c/c++函数库的多种方法，包括它们的工作原理、实现步骤、优缺点及适用场景，帮助开发者根据具体需求选择最适合的集成方案。
一、主流调用方法及其基本原理
python调用c/c++函数库主要有五种主流方法，各有其独特的实现机制和适用范围：
ctypes是python标准库的一部分，提供了一种直接与c语言兼容的数据类型和函数调用方式。它通过动态加载共享库（.so或.dll）并在内存中创建对应的函数指针来实现调用，无需任何预编译步骤。ctypes的工作原理类似于windows平台上的dll调用或linux平台上的动态链接库加载，通过函数指针和参数类型转换直接调用c函数。
swig（simplifiedwrapper and interface generator）是一个开源的软件接口生成器，能够自动生成c/c++与python之间的接口代码。swig通过解析c/c++头文件和接口描述文件（.i），生成特定语言的包装代码，这些代码负责在python和c/c++之间进行参数转换和内存管理。swig支持多种语言和复杂的c++特性，如类、继承、模板等，是处理大型c++项目时的常用工具。
cffi（c foreign function interface）是另一个python库，用于调用c语言函数。与ctypes不同，cffi采用声明式接口，开发者可以使用接近c语法的声明来定义函数和数据结构。cffi的优势在于其可读性和维护性，同时它还支持与pypy解释器的兼容，这在某些高性能场景中非常有价值。
python/c api是python官方提供的扩展接口，允许开发者用c/c++编写python模块。这种方法需要开发者深入理解python对象模型和内存管理机制，通过一系列宏和函数（如pymod初始化、pymethoddef定义等）手动创建python可调用的对象和方法。python/c api提供了最大的灵活性，但开发复杂度也最高。
pybind11是一个现代的c++库，旨在简化c++与python之间的绑定过程。它通过c++模板和编译时类型推导，将c++代码无缝暴露给python，无需手动编写大量包装代码。pybind11支持c++11及更高版本的特性，如智能指针、移动语义等，是当前推荐的c++与python集成方案。
二、实现步骤与代码示例
1. ctypes方法
ctypes是最简单的调用方式，适合快速原型开发和简单函数调用。实现步骤如下：
编写c/c++函数并导出为共享库：
// add.c
#include <stdio.h>
int add_int(int a, int b) {
printf("adding %d and %d\n", a, b);
return a + b;
}
float add_float(float a, float b) {
printf("adding %f and %f\n", a, b);
return a + b;
}编译为共享库：
gcc -shared -wl,-soname,adder -o adder.so -fpic add.c
python调用代码：
import ctypes
# 加载共享库
adder = ctypes.cdll('./adder.so')
# 设置函数参数类型和返回值类型
adder.add_int.argtypes = [ctypes.c_int, ctypes.c_int]
adder.add_int.restype = ctypes.c_int
adder.add_float.argtypes = [ctypes.c_float, ctypes.c_float]
adder.add_float支柱 = ctypes.c_float
# 调用函数
result_int = adder.add_int(4, 5)
print(f"4 + 5 = {result_int}")
a = ctypes.c_float(5.5)
b = ctypes.c_float(4.1)
result_float = adder.add_float(a, b)
print(f"5.5 + 4.1 = {result_float}")c++类调用：由于c++支持函数重载，编译器会修改函数名，ctypes无法直接调用。解决方法是在c++代码中使用extern “c”声明：
// testlib.cpp
#include <iostream>
extern "c" {
class testlib {
public:
void display() {
std::cout << "first display" << std::endl;
}
void display(int a) {
std::cout << "second display:" << a << std::endl;
}
};
testlib global_obj;
void display() {
global_obj.display();
}
void display_int(int a) {
global_obj.display(a);
}
}编译命令：
g++ -shared -fpic testlib.cpp -o libtestlib.so
python调用：
import ctypes
lib = ctypes.cdll('./libtestlib.so')
lib.display()
lib.display_int(100)2. cffi方法
cffi提供了更接近c语法的接口定义，适合需要在python中嵌入c代码的场景。实现步骤如下：
编写c/c++函数并导出为共享库：
// ffi_test.cpp
extern "c" {
int add(int a, int b) {
return a + b;
}
}编译命令：
g++ffi_test.cpp -fpic -shared -o libffi_test.so
python调用代码：
from cffi import ffi
ffi = ffi()
# 声明c函数接口
ffi.cdef(
"""int add(int a, int b);"""
)
# 加载共享库
lib = ffi.dlopen('libffi_test.so')
# 调用函数
print(f"3 + 4 = {lib.add(3, 4)}")python代码中嵌入c代码（无需编译为共享库）：
from cffi import ffi
ffi = ffi()
# 声明c函数接口
ffi.cdef(
"""int add(int a, int b);"""
)
# 定义并编译c代码
lib =ffi.verify(
"""
int add(int a, int b) {
return a + b;
}
"""
)
print(f"3 + 4 = {lib.add(3, 4)}")3. swig方法
swig适合处理复杂的c++项目，能够自动处理类、继承、模板等特性。实现步骤如下：
编写c++类和接口文件：
// testlib.h
#include <iostream>
class testlib {
public:
testlib();
~testlib();
void display();
void display(int a);
int add(int a, int b);
float add(float a, float b);
};
// testlib.cpp
#include "testlib.h"
testlib::testlib() {
std::cout << "testlib created" << std::endl;
}
testlib::~testlib() {
std::cout << "testlib destroyed" << std::endl;
}
void testlib::display() {
std::cout << "first display" << std::endl;
}
void testlib::display(int a) {
std::cout << "second display:" << a << std::endl;
}
int testlib::add(int a, int b) {
return a + b;
}
float testlib::add(float a, float b) {
return a + b;
}
// testlib.i
%module testlib
%{
#include "testlib.h"
%}
// 声明c++类
class testlib {
public:
testlib();
~testlib();
void display();
void display(int a);
int add(int a, int b);
float add(float a, float b);
};编译swig接口：
swig -c++ -python testlib.i g++ -fpic -c testlib.cpp g++ -fpic -c testlib wrap.cpp g++ -shared testlib.o testlib wrap.o -o _testlib.so
python调用代码：
import testlib
# 创建c++对象
obj = testlib.testlib()
# 调用成员函数
obj.display()
obj.display(100)
# 调用重载函数
print(f"5 + 3 = {obj.add(5, 3)}")
print(f"2.5 + 3.1 = {obj.add(2.5, 3.1)}")4. python/c api方法
python/c api提供了最大的灵活性，但开发复杂度也最高。实现步骤如下：
编写c++扩展模块：
// module.cpp
#include <python.h>
#include <iostream>
// c++类
class testlib {
public:
void display() {
std::cout << "first display" << std::endl;
}
void display(int a) {
std::cout << "second display:" << a << std::endl;
}
int add(int a, int b) {
return a + b;
}
float add(float a, float b) {
return a + b;
}
};
// python类型定义
static pytypeobject testlibtype = {
pyvarobjecthead_init
"testlib",
sizeof(testlib),
0,
// 方法表
.tpmethods = methods,
};
// 方法定义
static pymethoddef methods[] = {
{"display", (pycfunction)display, meth_varargs, "display message"},
{"display_int", (pycfunction)display_int, meth_varargs, "display integer"},
{"add", (pycfunction)add, meth_varargs, "add two numbers"},
{null, null, 0, null}
};
// 模块初始化函数
static struct pymoduledef moduledef = {
pymoduledefhead_init
"module",
null,
0,
.mmethods = null,
.mmoduleinit = pymodinit_module
};
pymodinit_t pymodinit_module() {
// 初始化python解释器
py_initialize();
// 创建模块
pythonmodule* module = pymoduledefinit(&moduledef);
// 创建类型
if (pytype_ready(&testlibtype) < 0)
return null;
// 将类型添加到模块
pymoduledictsetitemstr(module-> ob_type, "testlib", (pyobject*) &testlibtype);
return module;
}编写setup.py：
from setuptools import setup, extension
module = extension('module',
sources=['module.cpp'])
setup(name='module',
version='1.0',
description='python c++ extension',
ext_modules=[module])编译扩展模块：
python setup.py build_ext --inplace
python调用代码：
import module
# 创建c++对象
obj = module.testlib()
# 调用成员函数
obj.display()
obj.display_int(100)
# 调用函数
print(f"5 + 3 = {obj.add(5, 3)}")
print(f"2.5 + 3.1 = {obj.add(2.5, 3.1)}")5. pybind11方法
pybind11是目前推荐的现代c++与python集成方案，实现步骤如下：
编写c++代码和绑定：
// example.cpp
#include <pybind11/pybind11.h>
using namespace pybind11;
class testlib {
public:
void display() {
std::cout << "first display" << std::endl;
}
void display(int a) {
std::cout << "second display:" << a << std::endl;
}
int add(int a, int b) {
return a + b;
}
float add(float a, float b) {
return a + b;
}
};
pybind11_module(example, m) {
// 绑定c++类到python
m.def("add_int", &testlib::add, "add two integers");
m.def("add_float", &testlib::add, "add two floats");
// 绑定类到python
py::class_<testlib>(m, "testlib")
.def py::init<>())
.def("display", &testlib::display)
.def("display_int", &testlib::display_int);
}编译扩展模块：
c++ -o3 -wall -shared -std=c++11 -fpic $(python3 -m pybind11 --includes) example.cpp -o example$(python3-config --extension-suffix)
python调用代码：
import example
# 创建c++对象
obj = example.testlib()
# 调用成员函数
obj.display()
obj.display_int(100)
# 调用函数
print(f"5 + 3 = {example.add_int(5, 3)}")
print(f"2.5 + 3.1 = {example.add_float(2.5, 3.1)}")三、不同方法的优缺点与适用场景
下表对五种主流方法进行了系统性比较：
| 方法 | 开发复杂度 | 性能 | 语言支持 | 维护性 | 适用场景 |
| ctypes | 低 | 中 | c函数 | 低 | 快速原型开发、简单函数调用 |
| cffi | 中 | 高 | c函数 | 中 | 需要pypy兼容、轻量级c调用 |
| swig | 中高 | 高 | c++类、继承、模板 | 中 | 大型c++项目、复杂接口 |
| python/c api | 高 | 最高 | c++类、继承、模板 | 低 | 需要深度定制、高性能需求 |
| pybind11 | 中 | 高 | c++11及以上 | 高 | 现代c++项目、简洁接口 |
ctypes的优势在于简单易用，无需额外编译步骤，适合快速验证c函数调用。但其缺点也很明显：不支持c++类和重载，需要手动处理参数类型和内存管理，难以处理复杂数据结构。
cffi相比ctypes提供了更好的可读性和维护性，支持更接近c语法的声明方式，同时兼容pypy解释器。这对于需要在不同python实现上运行的程序非常有价值。然而，cffi同样不支持c++类和重载，需要通过c接口间接调用c++功能。
swig是处理复杂c++项目的强大工具，能够自动生成python绑定代码，支持类、继承、模板等高级特性。swig的灵活性使其成为许多大型项目的首选。然而，swig的学习曲线较陡，需要编写接口描述文件，并且对于某些c++语法（如非常规类型声明）的支持有限。
python/c api提供了最大的灵活性和控制权，允许开发者完全定制python与c/c++之间的交互。这对于需要深度集成或特殊性能优化的场景非常有价值。然而，python/c api的开发复杂度最高，需要深入理解python对象模型和内存管理机制，维护成本也相应较高。
pybind11是目前推荐的现代c++与python集成方案，它结合了swig的灵活性和python/c api的性能优势，同时简化了开发流程。pybind11支持c++11及以上版本的特性，如智能指针、移动语义等，使得c++代码可以保持现代风格。此外，pybind11还提供了丰富的文档和示例，降低了学习曲线。然而，pybind11需要c++11及以上版本的编译器支持，这对于某些遗留系统可能构成限制。
四、性能比较与选择建议
在实际应用中，性能是选择调用方法的重要考量因素。根据多个测试案例，不同方法的性能表现如下：
ctypes的调用开销约为纯c函数的1.5-2倍，适合简单的函数调用和快速原型开发。对于需要频繁调用的函数，ctypes的性能可能无法满足要求。
cffi在性能上与ctypes相当，但在代码可读性和维护性方面有所优势。此外，cffi在pypy解释器上的表现通常优于ctypes，这对于需要高性能且与pypy兼容的场景非常有价值。
swig生成的绑定代码在性能上接近原生c/c++调用，但需要额外的编译步骤。对于复杂的c++项目，swig的性能开销通常可以忽略不计。
python/c api提供了最高的性能，几乎与纯c/c++调用相当，适合对性能要求极高的场景。然而，其开发复杂度也最高，需要开发者深入理解python内部机制。
pybind11在性能上与python/c api相当，但开发复杂度显著降低。这对于大多数现代c++项目来说是一个理想的选择，可以在保持高性能的同时减少开发和维护成本。
基于上述分析，以下是针对不同场景的调用方法选择建议：
对于简单函数调用和快速原型开发，ctypes是最佳选择，其简单易用的特性可以快速验证c函数调用。
对于需要pypy兼容或轻量级c调用的场景，cffi是一个更好的选择，它提供了更好的可读性和维护性。
对于大型c++项目或复杂接口，swig是首选工具，它能够自动生成python绑定代码，支持类、继承、模板等高级特性。
对于需要深度定制或特殊性能优化的场景，python/c api提供了最大的灵活性，但需要开发者具备深入的python和c/c++知识。
对于现代c++项目，pybind11是当前推荐的方案，它结合了swig的灵活性和python/c api的性能优势，同时简化了开发流程，支持c++11及以上版本的特性。
五、实际应用案例与最佳实践
科学计算与数据分析：在rplidar数据通讯和解析项目中，使用c++编写数据解析模块，将运算结果写入共享内存块，再通过python进行数据处理和可视化。这种方法将c++的高性能与python的易用性相结合，显著提升了程序的执行效率。
机器学习与深度学习：在cgal（计算几何算法库）的python绑定中，使用swig自动生成python接口，同时保留c++的模板特性和高性能。这种方法使得复杂的几何计算可以在python环境中高效执行，同时保持代码的可维护性和扩展性。
web开发与系统集成：在flask框架下集成模拟 机接口（如rinsim平台的dataport.dll），使用pybind11对c++函数进行封装，生成python模块。这种方法使得复杂的工业控制逻辑可以在python web应用中高效调用，同时保持代码的简洁性和可读性。
最佳实践：
- 明确需求：在选择调用方法之前，明确项目的具体需求，包括性能要求、复杂度、维护周期等。
- 简化接口：无论使用哪种方法，都应尽量简化c/c++与python之间的接口，减少跨语言调用的开销。
- 处理内存管理：跨语言调用需要特别注意内存管理，避免内存泄漏或无效指针访问。
- 利用现代c++特性：在使用pybind11等现代工具时，充分利用c++11及以上版本的特性，如智能指针、移动语义等，简化代码并提高安全性。
- 测试与验证：在实际应用中，充分测试跨语言调用的性能和稳定性，确保接口的正确性和可靠性。
六、未来发展趋势与技术展望
随着python和c++生态的不断发展，python调用c/c++函数库的技术也在持续演进：
类型系统增强：现代工具如pybind11和swig正在不断改进对c++类型系统的支持，使得c++的复杂数据结构可以在python中更自然地表示和操作。
编译器支持改进：c++编译器（如gcc、clang）对python绑定的支持也在不断提升，使得c++代码与python的集成更加无缝。
多解释器兼容：随着pypy等替代python解释器的普及，cffi等工具对多解释器的兼容性变得越来越重要，未来可能会有更多工具支持这一特性。
自动化绑定生成：随着ai技术的发展，可能会出现更智能的绑定生成工具，能够自动分析c/c++代码并生成python接口，进一步降低开发复杂度。
跨平台支持：python应用通常需要跨平台运行，未来工具可能会更好地支持windows、linux、macos等不同平台的c/c++库调用。
性能优化：随着计算需求的不断提升，工具可能会提供更精细的性能优化选项，如缓存机制、并行计算支持等。
结论：python调用c/c++函数库是提升应用性能的重要技术路径。根据项目需求、开发复杂度、性能要求和维护周期等因素，可以选择合适的调用方法。对于大多数现代c++项目，pybind11是当前推荐的方案，它结合了swig的灵活性和python/c api的性能优势，同时简化了开发流程。而对于简单的函数调用和快速原型开发，ctypes或cffi可能是更好的选择。无论选择哪种方法，都应遵循最佳实践，确保接口的正确性和可靠性，同时充分利用现代c++和python特性，提升代码质量和性能。
以上就是python调用c/c++函数库的多种方法与实践指南的详细内容，更多关于python调用c/c++函数库的资料请关注代码网其它相关文章！
发表评论