C 代码#

// fast_sum.c
#include <stdint.h>

long long c_sum(int *arr, int n) {
    long long total = 0;
    for (int i = 0; i < n; i++) {
        total += arr[i];
    }
    return total;
}

编译成共享库：

# Linux/macOS
gcc -O2 -shared -fPIC -o fast_sum.so fast_sum.c

# Windows（MinGW）
gcc -O2 -shared -o fast_sum.dll fast_sum.c

Python 调用#

import ctypes
import os

# 加载共享库
lib = ctypes.CDLL(os.path.join(os.path.dirname(__file__), "fast_sum.so"))

# 声明函数签名（必须，否则类型不对）
lib.c_sum.argtypes = [ctypes.POINTER(ctypes.c_int), ctypes.c_int]
lib.c_sum.restype = ctypes.c_longlong

def ctypes_sum(arr):
    # 把 Python list 转成 C 数组
    c_arr = (ctypes.c_int * len(arr))(*arr)
    return lib.c_sum(c_arr, len(arr))

性能对比#

优点：不用编译 Python 扩展，会 C 就会用，适合快速集成。
缺点：类型声明繁琐，传 NumPy 数组需要额外处理（用 arr.ctypes.data_as()），不适合频繁调用的热点路径。

Cython 代码#

# fast_sum.pyx
def cy_sum(list arr):
    cdef long long total = 0
    cdef int i
    cdef int n = len(arr)
    for i in range(n):
        total += arr[i]
    return total

关键是 cdef——声明了 C 类型，循环里就不走 Python 对象系统了，直接变成 C 的整数运算。

编译配置#

# setup.py
from setuptools import setup
from Cython.Build import cythonize

setup(
    ext_modules=cythonize("fast_sum.pyx", compiler_directives={"language_level": "3"})
)

python setup.py build_ext --inplace

编译完会生成 fast_sum.cpython-xxx.so，直接 import fast_sum 就能用。

NumPy 加速示例（Cython 真正的杀手锏）#

# numpy_sum.pyx
import numpy as np
cimport numpy as np

def cy_numpy_sum(np.ndarray[np.int32_t, ndim=1] arr):
    cdef long long total = 0
    cdef int i
    cdef int n = arr.shape[0]
    for i in range(n):
        total += arr[i]
    return total

cimport numpy 让 Cython 直接访问 NumPy 数组的 C 指针，绕过 Python 对象层，性能接近纯 C。

优点：渐进式优化，只改热点函数，其余代码不动；NumPy 生态集成最好。
缺点：需要编译环境，发布时要带 .so；调试比纯 Python 麻烦。

C 代码#

// fast_sum_ext.c
#define PY_SSIZE_T_CLEAN
#include <Python.h>

// 实际的求和函数
static PyObject* ext_sum(PyObject *self, PyObject *args) {
    PyObject *list_obj;
    
    // 解析 Python 传入的参数
    if (!PyArg_ParseTuple(args, "O!", &PyList_Type, &list_obj)) {
        return NULL;
    }
    
    Py_ssize_t n = PyList_Size(list_obj);
    long long total = 0;
    
    for (Py_ssize_t i = 0; i < n; i++) {
        PyObject *item = PyList_GetItem(list_obj, i);  // 借用引用，不需要 Decref
        total += PyLong_AsLongLong(item);
    }
    
    return PyLong_FromLongLong(total);  // 返回 Python int 对象
}

// 模块方法表
static PyMethodDef FastSumMethods[] = {
    {"ext_sum", ext_sum, METH_VARARGS, "Sum a list of integers in C"},
    {NULL, NULL, 0, NULL}  // 哨兵
};

// 模块定义
static struct PyModuleDef fast_sum_module = {
    PyModuleDef_HEAD_INIT, "fast_sum_ext", NULL, -1, FastSumMethods
};

// 模块初始化函数（名字必须是 PyInit_<模块名>）
PyMODINIT_FUNC PyInit_fast_sum_ext(void) {
    return PyModule_Create(&fast_sum_module);
}

编译#

# setup.py
from setuptools import setup, Extension

module = Extension(
    "fast_sum_ext",
    sources=["fast_sum_ext.c"],
    extra_compile_args=["-O2"],
)

setup(name="fast_sum_ext", ext_modules=[module])

python setup.py build_ext --inplace

Python 调用#

import fast_sum_ext
result = fast_sum_ext.ext_sum([1, 2, 3, 4, 5])

优点：零中间层，完全控制对象生命周期，可以做任何 Python 扩展能做的事。
缺点：引用计数管理全靠手动（忘了 Py_DECREF 就内存泄漏），代码冗长，平均写一个简单函数要 50 行 C。不适合日常业务开发，适合造轮子。

C++ 代码#

// fast_sum_bind.cpp
#include <pybind11/pybind11.h>
#include <pybind11/stl.h>   // 自动转换 std::vector ↔ Python list
#include <vector>
#include <numeric>

namespace py = pybind11;

// 纯 C++ 函数，不需要任何 Python 相关代码
long long pb_sum(const std::vector<int>& arr) {
    return std::accumulate(arr.begin(), arr.end(), 0LL);
}

// 绑定模块
PYBIND11_MODULE(fast_sum_bind, m) {
    m.doc() = "pybind11 example";
    m.def("pb_sum", &pb_sum, "Sum a list of integers",
          py::arg("arr"));  // 支持关键字参数
}

编译#

# setup.py
from setuptools import setup, Extension
import pybind11

ext = Extension(
    "fast_sum_bind",
    sources=["fast_sum_bind.cpp"],
    include_dirs=[pybind11.get_include()],
    extra_compile_args=["-O2", "-std=c++14"],
    language="c++",
)

setup(name="fast_sum_bind", ext_modules=[ext])

pip install pybind11
python setup.py build_ext --inplace

Python 调用#

import fast_sum_bind
result = fast_sum_bind.pb_sum([1, 2, 3, 4, 5])
# 也可以用关键字参数
result = fast_sum_bind.pb_sum(arr=[1, 2, 3, 4, 5])

pybind11 还能直接绑定 C++ 类：

// 绑定一个 C++ 类到 Python
class Counter {
public:
    int count = 0;
    void increment() { count++; }
    int get() { return count; }
};

PYBIND11_MODULE(counter_module, m) {
    py::class_<Counter>(m, "Counter")
        .def(py::init<>())          // 构造函数
        .def("increment", &Counter::increment)
        .def("get", &Counter::get)
        .def_readwrite("count", &Counter::count);  // 直接暴露成员变量
}

Python 里直接当普通类用：

from counter_module import Counter
c = Counter()
c.increment()
print(c.get())   # 1
print(c.count)   # 1

优点：代码最简洁，自动处理类型转换，支持类/异常/回调的完整绑定，现代 C++ 项目首选。
缺点：依赖 pybind11 头文件，编译时间比 ctypes/Cython 长；纯 C 项目用不上（需要 C++11）。