在 Python 中调用 C 语言（1） （测试可用）

在 Python 中调用 C 语言（1） 

在 Python 中调用 C 语言（2） 

https://docs.python.org/zh-cn/3.14/extending/extending.html

https://docs.python.org/zh-cn/3.14/c-api/

---

 

python C 扩展模块调用C语言

 

通义3-235B
 
已深度思考
嗯，用户想了解如何用Python的C扩展模块调用C语言代码。首先，我得回忆一下Python的C扩展机制。Python允许通过扩展模块来调用C代码，这样可以提高性能或者复用现有的C库。

用户可能已经知道Python的一些基础知识，现在想深入优化性能或者整合现有的C代码库。这时候，C扩展是一个很好的选择。不过，对于新手来说，这个过程可能有点复杂，需要详细解释步骤。

首先，我应该考虑Python的C API，比如如何定义模块和方法。用户需要编写一个C文件，里面包含初始化函数和方法定义。比如PyInit_模块名，以及方法表的结构。

然后，用户需要编写一个setup.py文件来编译扩展模块。使用distutils或者setuptools来构建，这样用户就可以通过python setup.py build_ext --inplace来生成.so文件。

接下来，示例代码很重要。我应该提供一个简单的例子，比如一个计算两个整数之和的函数。这样用户可以直观地看到如何将C函数暴露给Python。需要注意的是参数的转换，比如使用PyArg_ParseTuple来解析Python传来的参数，并检查类型是否正确。

另外，内存管理和错误处理也是关键点。用户可能在处理更复杂的结构时需要考虑这些方面，比如返回字符串或者处理异常。可能需要提醒用户注意引用计数，避免内存泄漏。

可能用户还会遇到编译环境的问题，比如需要安装Python开发头文件，或者在不同系统下的编译命令差异。这时候需要给出一些常见问题的解决方法，比如在Ubuntu上安装python3-dev，或者macOS上的依赖。

用户可能还想知道如何测试扩展模块，如何导入并调用其中的函数。所以在示例中给出Python代码的测试用例也是有帮助的。

此外，可能要考虑Python 2和Python 3的兼容性问题，但目前主流应该是Python 3，所以重点放在Python 3的API上。

用户可能没有提到的深层需求是希望将现有的C库集成到Python中，或者优化性能瓶颈。这时候，可能需要更复杂的例子，比如传递数组、结构体，或者处理更复杂的数据类型。不过作为入门指南，先从基础开始，再逐步深入。

总结步骤：编写C扩展代码，创建setup.py，编译安装，然后在Python中导入使用。同时注意错误处理和类型检查，确保安全性和稳定性。可能还需要提到其他工具如Cython，但用户明确问的是C扩展，所以可能不需要展开。

需要检查示例代码是否正确，比如函数名是否正确，模块名是否匹配，参数处理是否正确。比如，PyArg_ParseTuple的格式字符串是否正确，返回值是否正确处理，是否返回了正确的Python对象。

可能还需要解释PyLong_FromLong的作用，将C的long转换为Python的int对象。以及如何处理不同的返回类型。

最后，确保步骤清晰，用户能够一步步跟着操作，成功创建并运行示例模块。可能还需要提醒用户在编译时遇到的问题，比如编译器路径、权限问题等。

 

在 Python 中使用 C 扩展模块可以显著提高性能瓶颈，或者将现有的 C 代码库集成到 Python 中。以下是实现这一目标的详细步骤和最佳实践。

🧱 一、理解 Python C 扩展的基本结构

Python C 扩展模块本质上是一个用 C 编写的动态链接库（.so 文件在 Linux/macOS，.pyd 文件在 Windows），它实现了 Python 可以调用的函数和类。

1. 模块入口：PyInit_<模块名>

这是 Python 解释器加载模块时调用的初始化函数。它必须返回一个 PyModuleDef 结构体，定义模块的基本信息。

c

PyMODINIT_FUNC PyInit_myextension(void) {
    return PyModule_Create(&myextension_module);
}

 

2. 方法定义：PyMethodDef

每个可调用的 C 函数都需要在 PyMethodDef 数组中注册，指定函数名、处理函数、调用方式等。

c

static PyMethodDef MyMethods[] = {
    {"add",  add, METH_VARARGS, "Add two integers."},
    {NULL, NULL, 0, NULL}        /* Sentinel */
};

 

3. 模块结构：PyModuleDef

定义模块的名称、文档字符串、大小、方法表等。

c

static struct PyModuleDef myextension_module = {
    PyModuleDef_HEAD_INIT,
    "myextension",   /* name of module */
    NULL,            /* module documentation, may be NULL */
    -1,              /* size of per-interpreter state of the module, or -1 if the module is not per-interpreter state. */
    MyMethods
};

 

🧩 二、编写一个简单的 C 扩展模块

示例：实现一个 add(a, b) 函数

1. 编写 C 文件：myextension.c

c

#include <Python.h>

static PyObject* add(PyObject* self, PyObject* args) {
    int a, b;
    if (!PyArg_ParseTuple(args, "ii", &a, &b)) {
        return NULL;  // 参数解析失败
    }
    return PyLong_FromLong(a + b);
}

static PyMethodDef MyMethods[] = {
    {"add", (PyCFunction)add, METH_VARARGS, "Add two integers."},
    {NULL, NULL, 0, NULL}
};

static struct PyModuleDef myextension_module = {
    PyModuleDef_HEAD_INIT,
    "myextension",
    NULL,
    -1,
    MyMethods
};

PyMODINIT_FUNC PyInit_myextension(void) {
    return PyModule_Create(&myextension_module);
}

 

2. 编写 setup.py 构建脚本

python

from setuptools import setup, Extension

module = Extension('myextension', sources=['myextension.c'])

setup(
    name='myextension',
    version='1.0',
    description='My C Extension',
    ext_modules=[module],
)

 

3. 编译模块

bash

python3 setup.py build_ext --inplace

 

这将生成 myextension.cpython-3x-x86_64-linux-gnu.so（Linux）或 .pyd（Windows）文件。

4. 在 Python 中使用

python

import myextension

result = myextension.add(3, 4)
print(result)  # 输出: 7

 

⚙️ 三、参数与返回值处理

1. 参数解析：PyArg_ParseTuple

用于将 Python 的参数转换为 C 类型。常用格式符包括：

• "i": int
• "l": long
• "d": double
• "s": char*
• "O": PyObject*

示例：

c

 

int a, b;
PyArg_ParseTuple(args, "ii", &a, &b);

2. 返回值：PyLong_FromLong, Py_BuildValue, Py_RETURN_NONE 等

• PyLong_FromLong: 返回整数
• Py_BuildValue("i", 42): 返回任意类型
• Py_RETURN_NONE: 返回 None

📦 四、集成现有 C 库

如果你已有 C 库，可以通过以下方式集成：

1. 将 C 库编译为静态库或动态库
2. 在 setup.py 中指定库路径和链接选项

python

Extension(
    'myextension',
    sources=['myextension.c'],
    libraries=['mylib'],
    library_dirs=['/path/to/lib'],
    include_dirs=['/path/to/include']
)

 

🧪 五、调试与错误处理

1. 异常处理

在 C 中抛出异常：

c

PyErr_SetString(PyExc_ValueError, "Invalid input");
return NULL;

 

2. 内存管理

注意引用计数，避免内存泄漏。使用 Py_INCREF, Py_DECREF 管理对象引用。

3. 使用 gdb 调试 C 扩展

在 Python 中使用 gdb 调试时，可以附加到 Python 进程，或使用 faulthandler 模块捕获崩溃。

🧰 六、常见问题与解决方案

问题	解决方案
编译失败	确保安装了 Python 开发包（如 python3-dev）
找不到模块	确保 build_ext --inplace 生成的 .so 文件在当前目录
参数类型错误	使用 PyArg_ParseTuple 检查参数类型
内存泄漏	使用 valgrind 检查内存使用
性能瓶颈	使用 perf 或 cProfile 分析瓶颈

📚 七、进阶主题（可选）

• 多线程支持：使用 Py_BEGIN_ALLOW_THREADS 和 Py_END_ALLOW_THREADS
• 结构体和数组传递：使用 PyArrayObject（NumPy）或自定义类型
• C++ 支持：使用 extern "C" 包裹函数，避免名称修饰
• Cython：作为 Python 和 C 的中间层，简化开发（非 C 扩展，但值得了解）

✅ 总结

通过 Python 的 C 扩展模块，你可以：

• 提升关键代码的性能
• 复用现有的 C 库
• 与底层系统交互
• 构建高性能的 Python 模块

掌握这一技能可以让你在 Python 与 C 的世界之间自由穿梭，构建更高效、更灵活的应用。

---

 

 

python 使用c扩展调用c语言并用C语言打印hello word

 

DeepSeek-R1最新版
 
已深度思考
我们将使用Python的C扩展来调用C函数，该C函数会打印"Hello World"。
步骤：

创建一个C源文件（例如hello.c），其中包含我们的C函数和必要的Python扩展代码。
编写setup.py脚本，用于构建扩展。
构建并安装扩展。
在Python中导入并调用该扩展。
注意：这里我们不会真正安装到系统，而是使用setup.py构建后在当前目录使用。

在C扩展中，我们通常不会直接使用printf，因为Python有自己的输出缓冲机制，而且我们希望在Python环境中正确输出。
但是，为了演示，我们可以使用printf，但更规范的做法是使用Python的API（如PySys_WriteStdout）来输出。

不过，题目要求用C语言打印hello world，我们可以使用printf。

但是，需要注意的是，在多线程环境或嵌入Python时，直接使用printf可能不会立即刷新缓冲区，或者与Python的输出混合。
因此，我们也可以考虑使用PySys_WriteStdout，但这里我们先按照题目要求使用printf。

 

我们将创建一个模块hello，其中包含一个函数say_hello，该函数调用printf打印"Hello World"。

以下是hello.c的内容：

要在 Python 中使用 C 扩展调用 C 函数并打印 "Hello World"，可以按照以下步骤操作：

1. 创建 C 源文件（如 hello.c）

c

#include <Python.h>

// C 函数，打印 "Hello World"
static PyObject* say_hello(PyObject* self, PyObject* args) {
    printf("Hello World\n");  // 调用 C 的 printf
    return Py_None;  // 返回 Python 的 None 对象
}

// 方法定义
static PyMethodDef HelloMethods[] = {
    {"say_hello", say_hello, METH_NOARGS, "打印 Hello World"},
    {NULL, NULL, 0, NULL}  // 结束标志
};

// 模块定义
static struct PyModuleDef hellomodule = {
    PyModuleDef_HEAD_INIT,
    "hello",  // 模块名
    NULL,
    -1,
    HelloMethods
};

// 初始化函数
PyMODINIT_FUNC PyInit_hello(void) {
    return PyModule_Create(&hellomodule);
}

 

 

2. 创建 setup.py 编译脚本

python

from distutils.core import setup, Extension

# 定义 C 扩展模块
module = Extension('hello', sources=['hello.c'])

# 编译设置
setup(
    name='hello',
    version='1.0',
    description='Python C Extension Example',
    ext_modules=[module]
)

 

3. 编译并安装扩展

在终端执行以下命令：

bash

python setup.py build_ext --inplace

 这会生成 hello.so（Linux/Mac）或 hello.pyd（Windows）文件。

4. 在 Python 中调用

python 

import hello
hello.say_hello()  # 输出: Hello World

关键点说明

1. 头文件引入：#include <Python.h> 包含 Python C API 的必要定义。
2. 函数规范：
   • C 函数需返回 PyObject*，参数为 PyObject* self 和 PyObject* args。
   • 使用 Py_None 作为返回值时需用 Py_RETURN_NONE 宏（但此处直接返回已引用的 Py_None 也可）。
3. 模块初始化：
   • 方法表 PyMethodDef 定义模块中的函数映射。
   • 模块结构体 PyModuleDef 定义模块元信息。
   • 初始化函数命名必须为 PyInit_<模块名>。

修正代码（推荐写法）

c

#include <Python.h>

static PyObject* say_hello(PyObject* self, PyObject* args) {
    printf("Hello World\n");
    Py_RETURN_NONE;  // 更规范的返回值写法
}

static PyMethodDef HelloMethods[] = {
    {"say_hello", say_hello, METH_NOARGS, "Print Hello World"},
    {NULL, NULL, 0, NULL}
};

static struct PyModuleDef hellomodule = {
    PyModuleDef_HEAD_INIT,
    "hello",
    NULL,
    -1,
    HelloMethods
};

PyMODINIT_FUNC PyInit_hello(void) {
    return PyModule_Create(&hellomodule);
}

输出结果

执行 Python 脚本后，控制台会直接打印：

text

Hello World

 

通过这种方式，Python 成功调用了 C 语言的 printf 函数实现输出。

 

---

在 Python 中调用 C 语言代码是常见的需求，尤其在需要高性能计算、访问底层系统功能或复用已有 C 代码时。Python 提供了多种方式来实现与 C 语言的交互，主要包括以下几种主流方法：

---

📌 总结对比

方法	优点	缺点	适用场景
ctypes	简单，无需编译	类型声明繁琐	调用已有 C 动态库
C 扩展（已测试）	性能最佳，完全控制	学习成本高	高性能模块开发
Cython	易于编写，性能好	需要编译	渐进式优化 Python
subprocess	简单易用	性能差	调用外部程序

 

---

 

✅ 1. 使用 ctypes 模块（无需编译 Python 扩展）

适用场景：

• 快速调用已有的 C 动态库（如 .dll、.so、.dylib）
• 无需编写额外的 Python 扩展模块

步骤：

1. 编写 C 函数并编译为共享库

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

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

 

编译为共享库（Linux/macOS）： bash 

gcc -shared -fPIC -o libexample.so example.c

 

（Windows）： bash 

gcc -shared -o example.dll example.c

 

---

2. 在 Python 中调用

python 

import ctypes

# 加载共享库（注意路径和后缀）
lib = ctypes.CDLL('./libexample.so')  # Windows: './example.dll'

# 声明参数和返回值类型
lib.add.argtypes = [ctypes.c_int, ctypes.c_int]
lib.add.restype = ctypes.c_int

# 调用 C 函数
result = lib.add(3, 4)
print(result)  # 输出 7

优点：

• 简单易用，无需编译 Python 扩展
• 适合调用已有 C 动态库

缺点：

• 类型声明繁琐
• 性能略低于 C 扩展
• 不支持复杂结构体或回调函数

---

 

✅ 2. 编写 C 扩展模块（Python C API）

适用场景：

• 需要高性能的 C 代码嵌入 Python
• 构建可导入的 Python 模块

步骤：

1. 编写 C 扩展代码

c 

// examplemodule.c
#include <Python.h>

static PyObject* example_add(PyObject* self, PyObject* args) {
    int a, b;
    if (!PyArg_ParseTuple(args, "ii", &a, &b)) {
        return NULL;
    }
    return Py_BuildValue("i", a + b);
}

static PyMethodDef ExampleMethods[] = {
    {"add", example_add, METH_VARARGS, "Add two integers"},
    {NULL, NULL, 0, NULL}
};

static struct PyModuleDef examplemodule = {
    PyModuleDef_HEAD_INIT,
    "example",
    NULL,
    -1,
    ExampleMethods
};

PyMODINIT_FUNC PyInit_example(void) {
    return PyModule_Create(&examplemodule);
}

 

2. 编写 setup.py 编译模块

python

# setup.py
from setuptools import setup, Extension

module = Extension('example', sources=['examplemodule.c'])

setup(
    name='example',
    version='1.0',
    description='Example C Extension',
    ext_modules=[module]
)

 

3. 安装并使用模块

bash

 //win终端安装
pip show setuptools
pip install setuptools
python setup.py build_ext --inplace

python

import example
print(example.add(3, 4))  # 输出 7

编译和执行需在同一个打开的终端 

>>> %Run setup.py build_ext --inplace
running build_ext
copying build\lib.win-amd64-cpython-314\example.cp314-win_amd64.pyd -> 
>>> import example  
>>> print(example.add(3, 4))  # 输出 7
7
>>> 
>>> print(example.hello_world())
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: module 'example' has no attribute 'hello_world'
>>> 

 

优点：

• 性能最佳
• 可以完全控制 C 与 Python 的交互
• 可以与 Python 对象交互（如列表、字典）

缺点：

• 编写复杂，需要熟悉 Python C API
• 容易出错（如引用计数、类型检查）
• //-TODO 需要编译

---

 

✅ 3. 使用 Cython（Python 与 C 的混合编程）

适用场景：

• 需要将 Python 代码编译为 C 代码以提升性能
• 渐进式优化 Python 代码

步骤：

1. 编写 .pyx 文件

cython

 

# example.pyx
def add(int a, int b):
    return a + b

 

2. 编写 setup.py 编译为 C 扩展

python

 

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

setup(
    ext_modules=cythonize("example.pyx")
)

 

3. 编译并使用

bash

 

python setup.py build_ext --inplace

python

 

import example
print(example.add(3, 4))  # 输出 7

 

优点：

• 语法接近 Python，学习曲线低
• 支持类型注解，可生成高性能 C 代码
• 可以直接调用 C 函数和结构体

缺点：

• 仍需编译过程
• 对复杂 C 接口支持不如纯 C 扩展

---

 

✅ 4. 使用 subprocess 调用外部 C 程序（非函数级）

适用场景：

• 调用独立的 C 程序（如命令行工具）
• 无需函数级集成

python

 

import subprocess

result = subprocess.run(['./my_c_program', '3', '4'], capture_output=True, text=True)
print(result.stdout)

 

优点：

• 简单，适合脚本调用

缺点：

• 性能差
• 无法直接传递复杂数据结构
• 不适合频繁调用

 

---

 

---

🚨 常见问题与注意事项

• 类型声明不匹配：如 ctypes 中未正确设置 argtypes 和 restype，可能导致崩溃。
• 引用计数管理：在 C 扩展中，忘记 Py_INCREF 或 Py_DECREF 可能导致内存泄漏或崩溃。
• 编译环境依赖：C 扩展和 Cython 需要安装 C 编译器（如 GCC 或 MSVC）。
• 跨平台兼容性：不同系统下共享库的后缀不同（.so / .dll / .dylib），需注意路径问题。

✅ 推荐选择

• 快速调用已有 C 库 → 使用 ctypes
• 高性能 C 扩展模块 → 使用 Python C API
• 渐进式性能优化 → 使用 Cython
• 调用外部 C 程序 → 使用 subprocess

根据你的具体需求选择合适的方法即可。

---

setuptools

setuptools

Python和C语言混合编程可以通过以下方式实现：

目录

 

1、实现方式

2、通过setuptools编译.c文件的实现

---

 

1、实现方式

使用Python的C扩展：Python提供了C扩展的功能，允许我们在Python中调用C语言代码。我们可以编写C语言扩展模块，并将其编译为共享库或动态链接库，然后在Python程序中导入并使用。这种方式需要我们熟悉C语言和Python的C API，并且需要手动编写和维护C扩展代码。

使用Cython：Cython是Python的一个扩展，它可以将Python代码转换为C代码，并编译成可执行文件。使用Cython，我们可以将Python代码中的某些部分替换为C语言代码，从而提高程序的执行效率。Cython的使用相对简单，只需要在Python代码中添加一些注释即可。

使用ctypes库：ctypes是Python的标准库之一，它提供了调用C语言共享库或动态链接库的功能。我们可以编写C语言共享库或动态链接库，并在Python程序中使用ctypes库来调用其中的函数。这种方式不需要我们熟悉C语言和Python的C API，但是需要手动编写和维护C语言代码。

使用SWIG工具：SWIG是一个开源的工具，它可以将C语言代码转换为Python扩展模块。使用SWIG，我们可以将C语言代码封装为Python可调用的函数或类。SWIG的使用需要一定的学习和工作量，但是它可以自动生成Python扩展代码，减少了手动编写和维护的工作量。

2、通过setuptools编译.c文件的实现

当使用Python和C混合编程时，可以通过使用setuptools模块来编译C语言扩展。下面是一个具体的示例，演示如何使用setuptools编译.c文件：

创建一个名为example.c的C语言源文件，其中包含要编译的C代码。例如：

#include <Python.h>
 
static PyObject* hello_world(PyObject* self) {
return PyUnicode_FromFormat("Hello, World!");
}
 
static PyMethodDef ExampleMethods[] = {
{"hello_world", hello_world, METH_NOARGS, "Print 'Hello, World!'"},
{NULL, NULL, 0, NULL}
};
 
static struct PyModuleDef examplemodule = {
PyModuleDef_HEAD_INIT, "example", NULL, -1, ExampleMethods
};
 
PyMODINIT_FUNC PyInit_example(void) {
return PyModule_Create(&examplemodule);
}

 

创建一个名为setup.py的Python脚本，用于编译C语言扩展。例如：

from setuptools import setup, Extension
 
module = Extension('example', sources=['example.c'])
 
setup(name='Example',
version='1.0',
description='This is a demo package',
ext_modules=[module])

 

python

from setuptools import setup, Extension
import os
 
# 将C编译器路径添加到系统环境变量中
os.environ["CC"] = "gcc"
 
# 定义C语言扩展模块
module = Extension('example', sources=['example.c'])
 
# 设置编译选项
setup(name='Example',
version='1.0',
description='This is a demo package',
ext_modules=[module],
include_dirs=[os.path.join(os.getcwd(), 'include')], # 添加头文件目录
)

python

 

在这个示例中，我们将要编译的.c文件命名为example.c，并将它列在sources列表中。

在终端中运行以下命令来编译C语言扩展：

python setup.py build_ext --inplace

 

python

这个命令将会编译example.c文件，并生成一个名为example的Python模块。如果编译成功，您可以在Python程序中导入并使用这个模块。例如：

import example
 
print(example.hello_world()) # 输出 "Hello, World!"

 python

请确保在运行setup.py之前已经安装了setuptools模块，并且您的系统中已经安装了C编译器。如果使用的是Linux操作系统，可以使用以下命令安装gcc编译器：

sudo apt-get install build-essential

 

python