C语言调用【Python3】

最新推荐文章于 2024-06-10 19:55:22 发布
最新推荐文章于 2024-06-10 19:55:22 发布
阅读量1.1k 收藏 6
点赞数
分类专栏： Python思维导图 文章标签： c语言 开发语言 python linux 语言绑定 跨语言调用
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62140641/article/details/134427740
版权

一、搭建编译环境

  • 终端查询系统及软件版本
  • dpkg -l 列出所有已安装的软件包

二、C语言中调用Python

  • 使用 GCC编译并链接 Python 3.10 的共享库
  • 如何在C中获取和修改 sys.path

三、C语言调用无参python函数
四、C语言调用有参python函数

一、搭建编译环境

通过C语言调用Python代码，需要先安装libpython3的 dev依赖库（不同的ubuntu版本下，python版本可
能会有差异， 比如ubuntu 22.04里是libpython3.10-dev）。

libpython3 通常指的是 Python 3 的共享库文件（shared library）。在 Linux 系统上，这个库文件的名称可能会有所不同，通常是以 libpython3.x.so 的形式命名，其中 x 是 Python 3 的主版本号。

如果你希望在编译时链接 Python 3 的共享库，你需要确保已经安装了对应版本的 Python 3 开发包。这通常包括了 Python 3 的头文件和共享库文件。你可以使用系统的包管理工具来安装这些开发包。

以下是在一些流行的 Linux 发行版上安装 Python 3 开发包的示例：

  • 在 Ubuntu 或者 Debian 上：

    sudo apt-get update
sudo apt-get install python3-dev

  • 在 Fedora 上：

    sudo dnf install python3-devel

  • 在 CentOS 或者 RHEL 上：

    sudo yum install python3-devel

一旦你安装了 Python 3 的开发包，你就应该能够在系统中找到 libpython3.x.so 文件，其中 x 是你安装的 Python 3 的主版本号。这个文件通常位于 /usr/lib/ 或 /usr/lib64/ 目录下。

请注意，如果你在编译时使用 gcc 或其他编译器，你可能需要使用 -lpython3.x 标志来链接 Python 3 的共享库。例如：

gcc -o my_program my_program.c -I/usr/include/python3.x -lpython3.x

请替换 3.x 为你所使用的 Python 3 的版本号。

终端查询系统及软件版本

这些命令用于检查内核版本、系统信息、Python版本、GCC版本和Linux发行版信息。

以下是每个命令的简要说明：

  1. cat /proc/version： 显示Linux内核版本和系统信息。

  2. cat /etc/issue： 打印/etc/issue文件的内容，该文件通常包含有关Linux发行版的信息。

  3. uname -a： 打印系统信息，如内核名称、网络节点主机名、内核发布版本、内核版本、机器硬件名称和处理器类型。

  4. python --version： 显示Python解释器的版本。

  5. gcc -v： 显示GCC（GNU编译器集合）的版本。

  6. lsb_release -a： 打印LSB（Linux标准基础）和特定于发行版的信息。LSB是一组标准，旨在增加Linux发行版之间的兼容性。

您可以在终端中运行这些命令来查看有关您的Linux系统的相应信息。 请记住，这些命令的可用性和输出可能会有所不同，具体取决于您的特定 Linux 发行版和系统配置。

dpkg -l 列出所有已安装的软件包

这个命令用于列出已安装的与 Python 3 开发相关的库。具体来说，它使用 dpkg -l 列出所有已安装的软件包，然后使用 grep 过滤出包含 “libpython3” 和 “dev” 的行。

在 Ubuntu 或 Debian 等基于 Debian 的系统上，你可以运行以下命令：

dpkg -l | grep libpython3 | grep dev

如果你已经安装了 Python 3 的开发包，命令的输出应该包含与 Python 3 相关的开发库。如果没有安装，输出将为空。

请注意，这是一种查找已安装软件包的方法，确保你使用了适用于你的 Linux 发行版的包管理工具。

二、C语言中调用Python

在C语言中调用Python代码通常涉及到使用Python的C API。Python提供了一组C API，允许在C中调用Python函数、处理Python对象等。

下面是一个简单的例子，展示了如何在C中调用Python代码：

  1. Python脚本： 编写一个简单的Python脚本，保存为 example.py。

    # example.py
def add_numbers(a, b):
    return a + b

  2. C代码： 编写一个C程序 invoke.c，调用Python中的函数。

    #include <Python.h>

int main() {
    // 初始化Python解释器
    Py_Initialize();

    // 导入Python模块
    PyObject* pModule = PyImport_ImportModule("example");

    if (pModule != NULL) {
        // 获取Python函数对象
        PyObject* pFunction = PyObject_GetAttrString(pModule, "add_numbers");

        if (pFunction != NULL) {
            // 调用Python函数
            PyObject* pArgs = PyTuple_Pack(2, PyLong_FromLong(3), PyLong_FromLong(5));
            PyObject* pResult = PyObject_CallObject(pFunction, pArgs);

            if (pResult != NULL) {
                // 处理Python函数的返回值
                printf("Result: %ld\n", PyLong_AsLong(pResult));
                Py_DECREF(pResult);
            } else {
                PyErr_Print(); // 打印Python错误信息
            }

            Py_DECREF(pFunction);
            Py_DECREF(pArgs);
        } else {
            PyErr_Print();
        }

        Py_DECREF(pModule);
    } else {
        PyErr_Print();
    }

    // 关闭Python解释器
    Py_Finalize();

    return 0;
}

  3. 编译： 使用合适的编译器将C代码编译成可执行文件。

    gcc invoke.c -o invoke -I /usr/include/python3.x -l python3.x
gcc -o simpledemo simpledemo.c -I /usr/include/python3.x -l python3.x

    请确保替换 3.x 为你所使用的Python版本号。

  4. 运行： 运行生成的可执行文件。

    ./invoke

这个例子中，C程序初始化了Python解释器，导入了一个Python模块，获取了Python模块中的一个函数，调用了这个函数，并处理了Python函数的返回值。这只是一个简单的例子，实际应用可能涉及更复杂的交互和数据传递。

使用 GCC编译并链接 Python 3.10 的共享库

这段命令和代码的作用是：

  1. ls /usr/include/python：列出 /usr/include/python 目录下的内容。通常，Python 的头文件（.h 文件）会在这个目录下。

  2. gcc invoke.c -o invoke -I /usr/include/python3.10 -lpython3.10：使用 GCC 编译 invoke.c 文件，并链接 Python 3.10 的共享库。其中，-I 选项指定了头文件所在的目录，-lpython3.10 用于链接 Python 3.10 的共享库。编译后的可执行文件名为 invoke。

  3. ./invoke：运行编译生成的 invoke 可执行文件。

这段命令和代码的目的可能是在 invoke.c 文件中调用了 Python 3.10 的一些函数，并通过 GCC 编译器将其与 Python 3.10 的共享库链接起来。在运行 invoke 可执行文件时，它可能会执行 invoke.c 中的 Python 相关代码。

请确保你的系统中已经安装了 Python 3.10 的开发包，以及 GCC 编译器。如果没有安装，你可以使用系统的包管理工具进行安装。

如何在C中获取和修改 sys.path

sys.path列表里储存了python默认库搜索路径

在Python中，sys.path 是一个包含模块搜索路径的列表。当你导入一个模块时，Python会在这些路径中查找模块文件。

在C语言中，你可以通过Python/C API来获取和操作 sys.path。以下是一个简单的例子，展示了如何在C中获取和修改 sys.path：

#include <Python.h>

int main() {
    // 初始化Python解释器
    Py_Initialize();

    // 获取sys.path对象
    PyObject* sysPath = PySys_GetObject("path");

    // 打印原始sys.path
    printf("Original sys.path:\n");
    for (Py_ssize_t i = 0; i < PyList_Size(sysPath); ++i) {
        PyObject* pathItem = PyList_GetItem(sysPath, i);
        const char* pathStr = PyUnicode_AsUTF8(pathItem);
        printf("%s\n", pathStr);
    }

    // 添加新路径到sys.path
    PyList_Append(sysPath, PyUnicode_DecodeFSDefault("/path/to/your/directory"));

    // 打印修改后的sys.path
    printf("\nModified sys.path:\n");
    for (Py_ssize_t i = 0; i < PyList_Size(sysPath); ++i) {
        PyObject* pathItem = PyList_GetItem(sysPath, i);
        const char* pathStr = PyUnicode_AsUTF8(pathItem);
        printf("%s\n", pathStr);
    }

    // 关闭Python解释器
    Py_Finalize();

    return 0;
}

这个例子中，我们使用 PySys_GetObject("path") 获取了 sys.path 对象，并使用 PyList_Append 将新的路径添加到列表中。在实际应用中，你可能会根据你的需求添加不同的路径。请注意，在真实的应用中，你可能需要更加谨慎地处理路径，以确保不会破坏系统的正常运行。

#!/usr/bin/python3

import sys

print(sys.path)

在这里插入图片描述

三、C语言调用无参python函数

C语言中调用无参Python函数的步骤

1、包含Python.h头文件，以便使用Python API。

2、使用void Py_Initialize()初始化Python解释器，

3、使用PyObject *PyImport_ImportModule(const char *name)和PyObject *PyObject_GetAttrString(PyObject *o, const char *attr_name)
获取sys.path对象，并利用int PyList_Append(PyObject *list, PyObject *item)将当前路径.添加到sys.path中，
以便加载当前的Python模块(Python文件即python模块)。

4、使用PyObject *PyImport_ImportModule(const char *name)函数导入Python模块，并检查是否有错误。

5、使用PyObject *PyObject_GetAttrString(PyObject *o, const char *attr_name)函数获取Python函数对象，并检查是否可调用。

6、使用PyObject *PyObject_CallObject(PyObject *callable, PyObject *args)函数调用Python函数，并获取返回值。

7、使用void Py_DECREF(PyObject *o)函数释放所有引用的Python对象。

8、结束时调用void Py_Finalize()函数关闭Python解释器。

相关的函数参数说明参考网站（网站左上角输入函数名即可开始搜索）：
3.10 Documentation » Python/C API 参考手册 » 工具 » 导入模块

#include <Python.h>

int main() {
    // 1. 初始化Python解释器
    Py_Initialize();

    // 2. 获取sys.path对象，并将当前路径添加到sys.path中
    PyObject* sysPath = PySys_GetObject("path");
    PyList_Append(sysPath, PyUnicode_DecodeFSDefault("."));

    // 3. 导入Python模块
    PyObject* pModule = PyImport_ImportModule("your_module_name");

    if (pModule != NULL) {
        // 4. 获取Python函数对象
        PyObject* pFunction = PyObject_GetAttrString(pModule, "your_function_name");

        if (pFunction != NULL && PyCallable_Check(pFunction)) {
            // 5. 调用Python函数（这里是无参数调用）
            PyObject* pArgs = PyTuple_New(0);  // 传递空参数元组
            PyObject* pResult = PyObject_CallObject(pFunction, pArgs);

            if (pResult != NULL) {
                // 6. 处理返回值，可以在这里进行你的操作
                Py_DECREF(pResult);
            } else {
                // 打印Python错误信息
                PyErr_Print();
            }

            // 释放Python函数对象和参数
            Py_DECREF(pFunction);
            Py_DECREF(pArgs);
        } else {
            // 打印Python错误信息
            PyErr_Print();
        }

        // 释放Python模块对象
        Py_DECREF(pModule);
    } else {
        // 打印Python错误信息
        PyErr_Print();
    }

    // 7. 关闭Python解释器
    Py_Finalize();

    return 0;
}

请确保替换 “your_module_name” 和 “your_function_name” 为你实际使用的Python模块和函数的名称。
这段代码演示了如何在C中调用一个无参数的Python函数。

根据上面的流程写出的示例代码如下：

# nopara.py文件
# !/usr/bin/python3

def say_funny():
  print('funny')

#include <Python.h>

int main()
{
  // 1. 初始化Python解释器
  Py_Initialize();
    
  // 2. 获取sys.path对象，并将当前路径添加到sys.path中
  PyObject *sys = PyImport_ImportModule("sys");
  PyObject *path = PyObject_GetAttrString(sys, "path");
  PyList_Append(path, PyUnicode_FromString(".")); // PyUnicode_FromString将c字符串转换成Python字符串
  
  // 3. 导入Python模块
  PyObject *pModule = PyImport_ImportModule("nopara");
  
  if (!pModule) {
    PyErr_Print();
    printf("ERROR: failed to load nopara.py\n");
    
    return 1;
  }
  
  // 4. 获取Python函数对象say_funny
  PyObject *pFunc = PyObject_GetAttrString(pModule, "say_funny");
  
  if (!pFunc || !PyCallable_Check(pFunc)) {
    PyErr_Print();
    printf("ERROR: function say_funny not found or not callable\n");
    
    return 1;
  }

  // 5. 调用Python函数,调用say_funny函数并获取返回值
  PyObject *pValue = PyObject_CallObject(pFunc, NULL);
  
  if (!pValue ) {
    PyErr_Print();
    printf("ERROR: function call failed\n");
    
    return 1;
  }
  
  // 释放所有引用的Python对象
  Py_DECREF(pValue);
  Py_DECREF(pFunc);
  Py_DECREF(pModule);
  
  // 关闭Python解释器
  Py_Finalize();
  
  return 0;
}

编译和运行这个程序，可以使用以下命令（假设使用的是gcc编译器和Python 3.10版本）：

gcc -o nopara nopara.c -I /usr/include/python3.10/ -l python3.10
./nopara

在这里插入图片描述

四、C语言调用有参python函数

C语言中调用有参Python函数的步骤

1、包含Python.h头文件，以便使用Python API。

2、使用void Py_Initialize()初始化Python解释器，

3、使用PyObject *PyImport_ImportModule(const char *name)和PyObject *PyObject_GetAttrString(PyObject *o, const char *attr_name)
获取sys.path对象，并利用int PyList_Append(PyObject *list, PyObject *item)将当前路径.添加到sys.path中，
以便加载当前的Python模块(Python文件即python模块)。

4、使用PyObject *PyImport_ImportModule(const char *name)函数导入Python模块，并检查是否有错误。

5、使用PyObject *PyObject_GetAttrString(PyObject *o, const char *attr_name)函数获取Python函数对象，并检查是否可调用。

6、使用PyObject *Py_BuildValue(const char *format, …)函数将C类型的数据结构转换成Python对象，
作为Python函数的参数,没有参数不需要调用

7、使用PyObject *PyObject_CallObject(PyObject *callable, PyObject *args)函数调用Python函数，并获取返回值。

8、使用int PyArg_Parse(PyObject *args, const char *format, …)函数将返回值转换为C类型，
并检查是否有错误,没有返回值时不需要调用。

9、使用void Py_DECREF(PyObject *o)函数释放所有引用的Python对象。

10、结束时调用void Py_Finalize()函数关闭Python解释器。

相关的函数参数说明参考网站（网站左上角输入函数名即可开始搜索）：
3.12.0 Documentation » Python/C API 参考手册 » 工具 » 导入模块

在C语言中调用有参Python函数的步骤。这里是整理后的步骤：

#include <Python.h>

int main() {
    // 1. 初始化Python解释器
    Py_Initialize();

    // 2. 获取sys.path对象，并将当前路径添加到sys.path中
    PyObject* sysPath = PySys_GetObject("path");
    PyList_Append(sysPath, PyUnicode_DecodeFSDefault("."));

    // 3. 导入Python模块
    PyObject* pModule = PyImport_ImportModule("your_module_name");

    if (pModule != NULL) {
        // 4. 获取Python函数对象
        PyObject* pFunction = PyObject_GetAttrString(pModule, "your_function_name");

        if (pFunction != NULL && PyCallable_Check(pFunction)) {
            // 5. 构建Python函数的参数
            PyObject* pArgs = Py_BuildValue("(ii)", 42, 17);  // 传递两个整数参数

            if (pArgs != NULL) {
                // 6. 调用Python函数
                PyObject* pResult = PyObject_CallObject(pFunction, pArgs);

                if (pResult != NULL) {
                    // 7. 处理返回值，可以在这里进行你的操作

                    // 8. 将返回值转换为C类型
                    int resultValue;
                    if (PyArg_Parse(pResult, "i", &resultValue)) {
                        // 处理resultValue
                    } else {
                        // 转换错误
                        PyErr_Print();
                    }

                    Py_DECREF(pResult);
                } else {
                    // 打印Python错误信息
                    PyErr_Print();
                }

                // 释放Python函数对象和参数
                Py_DECREF(pFunction);
                Py_DECREF(pArgs);
            } else {
                // 参数构建错误
                PyErr_Print();
            }
        } else {
            // 打印Python错误信息
            PyErr_Print();
        }

        // 释放Python模块对象
        Py_DECREF(pModule);
    } else {
        // 打印Python错误信息
        PyErr_Print();
    }

    // 9. 关闭Python解释器
    Py_Finalize();

    return 0;
}

请确保替换 “your_module_name” 和 “your_function_name” 为你实际使用的Python模块和函数的名称，并根据你的函数参数类型调整 Py_BuildValue 和 PyArg_Parse 的格式字符串。

第六步传参

6、使用PyObject *Py_BuildValue(const char *format, …)函数创建一个Python元组或者对象，
作为Python函数的参数,没有参数势不需要调用

这里要注意的是，Py_BuildValue的第一个参数是类型转换：C对应的Python的数据类型转换对应的格式如下：
在这里插入图片描述

Py_BuildValue 函数用于将C中的数据转换为Python对象。它的第一个参数是一个格式字符串，指定了如何构建Python对象。以下是一些常见的格式码及其对应的C数据类型：

  • 's'：字符串
    • C类型：const char*
  • 'i'：整数
    • C类型：int
  • 'l'：长整数
    • C类型：long
  • 'f'：浮点数
    • C类型：double
  • 'd'：双精度浮点数
    • C类型：double
  • 'O'：任意Python对象
    • C类型：PyObject*

例如，如果你想构建一个Python元组，其中包含一个整数和一个字符串，可以使用以下格式字符串：

PyObject* result = Py_BuildValue("(is)", 42, "hello");

这将构建一个包含一个整数和一个字符串的元组。第一个参数 42 对应 i 表示整数，第二个参数 "hello" 对应 s 表示字符串。

以下是一些常用的格式码：

  • '()'：元组
  • '[]'：列表
  • '{}'：字典
  • 's'：字符串
  • 'i'：整数
  • 'l'：长整数
  • 'f'：浮点数
  • 'd'：双精度浮点数
  • 'O'：任意Python对象

你可以根据实际需要选择合适的格式码，并使用相应的C数据类型提供参数。
确保在使用 Py_BuildValue 时，提供的参数数量和格式码匹配，以避免运行时错误。

格式码C数据类型示例
's'const char*Py_BuildValue("s", "hello")
'i'intPy_BuildValue("i", 42)
'l'longPy_BuildValue("l", 123456789L)
'f'floatPy_BuildValue("f", 3.14f)
'd'doublePy_BuildValue("d", 2.71828)
'O'PyObject*Py_BuildValue("O", somePyObject)
'()'TuplePy_BuildValue("(is)", 42, "hello")
'[]'ListPy_BuildValue("[i]", 1)
'{}'DictionaryPy_BuildValue("{s:i}", "key", 42)
## 第八步返回值的处理 8、使用int PyArg_Parse(PyObject *args, const char *format, ...)函数将返回值转换为C类型， 并检查是否有错误,**没有返回值时不需要调用**。

PyArg_Parse 是 Python/C API 中用于将 Python 对象参数转换为 C 数据类型的函数。它通常用于解析从 Python 调用的函数传递的参数。以下是 PyArg_Parse 的基本用法：

int PyArg_Parse(PyObject *args, const char *format, ...);
  • args: 一个包含传递给函数的参数的元组。
  • format: 包含格式化指令的字符串，指定了如何解析参数。
  • ...: 用于接收解析后的参数值的变量。

PyArg_Parse 的格式化指令可以是以下之一：

  • 'i': 整数
  • 'f': 浮点数
  • 's': 字符串
  • 'O': 任意对象

以下是一些示例：

  1. 解析一个整数参数：

    int value;
if (!PyArg_Parse(args, "i", &value)) {
    // 处理解析错误
    return NULL;
}

  2. 解析一个浮点数参数：

    double value;
if (!PyArg_Parse(args, "f", &value)) {
    // 处理解析错误
    return NULL;
}

  3. 解析一个字符串参数：

    const char *text;
if (!PyArg_Parse(args, "s", &text)) {
    // 处理解析错误
    return NULL;
}

  4. 解析一个任意对象参数：

    PyObject *obj;
if (!PyArg_Parse(args, "O", &obj)) {
    // 处理解析错误
    return NULL;
}

PyArg_Parse 还支持更复杂的格式化字符串，允许你指定多个参数以及它们的类型。例如：

int x, y;
if (!PyArg_Parse(args, "(ii)", &x, &y)) {
    // 处理解析错误
    return NULL;
}

在这个例子中，期望参数是一个包含两个整数的元组。

注意：PyArg_Parse 在解析参数时会自动增加引用计数，但在解析失败时需要手动处理错误。如果解析失败，它会返回 0，并且你应该在错误处理中返回 NULL 或适当的错误信息。

示例代码如下：

# para.py文件
# !/usr/bin/python3

def say_funny(category):
  print(category)
  return category    

#if 0
1、包含Python.h头文件，以便使用Python API。

2、使用void Py_Initialize()初始化Python解释器，

3、使用PyObject *PyImport_ImportModule(const char *name)和PyObject *PyObject_GetAttrString(PyObject *o, const char *attr_name)
获取sys.path对象，并利用int PyList_Append(PyObject *list, PyObject *item)将当前路径.添加到sys.path中，
以便加载当前的Python模块(Python文件即python模块)。

4、使用PyObject *PyImport_ImportModule(const char *name)函数导入Python模块，并检查是否有错误。

5、使用PyObject *PyObject_GetAttrString(PyObject *o, const char *attr_name)函数获取Python函数对象，并检查是否可调用。

6、使用PyObject *Py_BuildValue(const char *format, ...)函数将C类型的数据结构转换成Python对象，
作为Python函数的参数,没有参数不需要调用。

7、使用PyObject *PyObject_CallObject(PyObject *callable, PyObject *args)函数调用Python函数，并获取返回值。

8、使用int PyArg_Parse(PyObject *args, const char *format, ...)函数将返回值转换为C类型，
并检查是否有错误,没有返回值时不需要调用。

9、使用void Py_DECREF(PyObject *o)函数释放所有引用的Python对象。

10、结束时调用void Py_Finalize()函数关闭Python解释器。

相关的函数参数说明参考网站（网站左上角输入函数名即可开始搜索）：
https://docs.python.org/zh-cn/3/c-api/import.html
#endif

#include <Python.h>

int main()
{
  // 初始化Python解释器
  Py_Initialize();
    
  // 获取sys.path对象，并将当前路径添加到sys.path中
  PyObject *sys = PyImport_ImportModule("sys");
  PyObject *path = PyObject_GetAttrString(sys, "path");
  PyList_Append(path, PyUnicode_FromString(".")); // PyUnicode_FromString将c字符串转换成Python字符串
  
  // 导入Python模块
  PyObject *pModule = PyImport_ImportModule("para");
  
  if (!pModule ) {
    PyErr_Print();
    printf("ERROR: failed to load para.py\n");
    
  }
  
  // 获取Python函数对象say_funny
  PyObject *pFunc = PyObject_GetAttrString(pModule, "say_funny");
  
  if (!pFunc || !PyCallable_Check(pFunc)) {
    PyErr_Print();
    printf("ERROR: function say_funny not found or not callable\n");
    
    return 1;
  }

  //创建一个字符串作为参数
  char *category = "comedy";
  PyObject *pArgs = Py_BuildValue("(s)", category);
  
  // 调用Python函数,调用say_funny函数并获取返回值
  PyObject *pValue = PyObject_CallObject(pFunc, pArgs);
  
  if (!pValue) {
    PyErr_Print();
    printf("ERROR: function call failed\n");
  }
  
  //将返回值转换为C类型
  char *result = NULL;
  
  if (!PyArg_Parse(pValue, "s", &result)) {
    PyErr_Print();
    printf("Error: parse failed\n");
  }
  
  //打印返回值
  printf("pValue=%s\n", result);  
  
  // 释放所有引用的Python对象
  Py_DECREF(pValue);
  Py_DECREF(pFunc);
  Py_DECREF(pModule);
  
  // 关闭Python解释器
  Py_Finalize();
  
  return 0;
}

编译和运行这个程序，可以使用以下命令（假设使用的是gcc编译器和Python 3.10版本）：

gcc para.c -o para -I /usr/include/python3.10 -l python3.10
./para

在这里插入图片描述

咖喱年糕
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
ubuntu 安装python3.10和对应版本的pip
nayanminxing的专栏
03-26 1万+
sudo add-apt-repository ppa:deadsnakes/ppa sudo apt-get install --reinstall python3.10-distutils sudo apt-get install --reinstall python3.10-dev sudo apt-get install --reinstall python3.10-distutils curl -sS https://bootstrap.pypa.io/get-pip.py | pyt..
C语言调用Python函数
天牛虫
01-17 1904
1、Python脚本源码 from googletrans import Translator translator = Translator(service_urls=[ 'translate.google.cn', ]) def trans(str): print(translator.translate(str, dest='zh-CN').text) ...
C语言调用Python代码的方法
08-18
主要介绍了C语言调用Python代码的方法，文中讲解非常细致，代码帮助大家更好的理解和学习，感兴趣的朋友可以了解下
Python 调用 C 和 C 调用 Python 方法
最新发布
Pika
06-10 884
python/c 的相互调用
C语言调用Python脚本
weixin_45066336的博客
04-13 9495
一、头文件 #include <python3.6/Python.h> 或者使用其他版本的python也可以。 二、使用步骤 1.初始化python模块 void Py_Initialize(); 初始化完成后，可以调用函数Py_IsInitialized()来判断初始化是否成功。 /* Return true (nonzero) when the Python interpreter has been initialized, false (zero) if not..
C调用python
zhangdell的专栏
12-01 6405
1：调用Python中的类 #include <python3.6m/Python.h> int main(int argc,char **argv) { PyObject *pModule, *pDict, *pFRCNN, *pFrcnn; PyObject *result, *result1; //初始化python Py_Initialize(); if (!Py_IsInitialized()) { printf("
C语言调用Python
weixin_58198422的博客
04-07 2297
C语言调用python需要我们已经安装好了libpython3的dev依赖库，如果还没安装的可以看我之前的文档。
C程序中直接调用Python函数（Linux）
SunSachin的博客
12-05 1777
C程序中调用Python函数
C++调用Python的方法
热门推荐
ZONGXP的博客
04-15 3万+
0 背景 在《Python调用C++程序的几种方法》中，我们介绍了 python 调用 c++ 的一些方法，实际项目中，有时会遇到 c++ 调用 python 的需求，比如实现代码加密等功能，因此本文对相关方法做一个整理记录。 1 https://cyendra.github.io/2018/07/10/pythoncpp/ https://cloud.tencent.com/developer/article/1174629 https://docs.python.org/3.8/extend.
python调用C语言
weixin_34409703的博客
05-13 646
python由于在实现多线程的情况下，由于GIL（全局解释器锁）的存在，只能实现伪线程，要想真正实现多线程，可以调用第三方的扩展，使用C语言编写一些需要实现多线程的业务逻辑。 最常用的调用C函数的方式，分别是c extension，Cython和ctypes。 c extension 介绍 python标准库包含了很多使用C开发的扩展模块，比如对性能要求很高的json库。开发者同样可以使用...
c语言调用python脚本
07-28
在C语言中调用Python脚本可以通过以下步骤进行： 安装Python解释器：首先需要确保系统中安装了Python解释器，可以从Python官方网站下载并安装。 编写Python脚本：创建一个包含所需功能的Python脚本文件。例如，...
python 调用c语言函数的实例讲解
09-21
下面小编就为大家带来一篇python 调用c语言函数的实例讲解。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
C++调用Python（混合编程）函数整理总结
jindayue的博客
12-05 1万+
python是一种非常强大的胶水语言，可以灵活的嵌入到c++和java等主流语言中。python提供了一套C的API库，是的开发者能够很方便的从C、C++的程序中调用python中的各个功能模块。c++ 调用 python ，本质上是在 c++ 中启动了一个 python 解释器，由解释器对 python 相关的代码进行执行，执行完毕后释放资源，达到调用目的。从操作步骤上看，C++调用Python低层接口可以分为几个阶段：和环境相关的接口如下： 2.调用python脚本的两种方式 第一种方法示例： 第一种
C调用Python的函数
weixin_34178244的博客
07-22 254
Python是简单的，Python又是强大的。刚接触Python的人都会有这么一个疑问：Python到底有什么用。不过要知道它能做什么，还得先学会使用它。Python的语法相当简单，这里有一个教程：http://woodpecker.org.cn/abyteofpython_cn/chinese/，相信你一两天就能对Python轻车熟路。我的大部分时间都是用C开发的，所以，在C中调用Python是...
c++中导入python
lengyuyan007的专栏
10-12 4359
大体参照这个详细的 博客，https://www.jianshu.com/p/74dfdf130bf7 具体有一个不同，就是python文件要放在exe目录，而不是cpp目录, 道理应该都可以的，还没弄清楚 例子 调用python变量：https://blog.csdn.net/tobacco5648/article/details/50890106 不用安装python的方法：就是搞一个裁...
C 语言调用python
whs_123_123的博客
04-05 379
环境ubuntu16.04。
c语言如何调用python代码_C语言调用Python代码的方法
weixin_39962770的博客
11-24 241
问题你想在C中安全的执行某个Python调用并返回结果给C。 例如，你想在C语言中使用某个Python函数作为一个回调。解决方案在C语言中调用Python非常简单，不过涉及到一些小窍门。 下面的C代码告诉你怎样安全的调用：#include /* Execute func(x,y) in the Python interpreter. Thearguments and return result o...
C语言调用python代码
xzlAwin的博客
01-01 680
【代码】C语言调用python代码。
c语言调用python程序
08-28
C语言是一种高级编程语言，而Python也是一种高级编程语言。在C语言中调用Python程序可以通过使用Python的解释器来实现。要在C语言中调用Python程序，首先需要在C中包含Python的头文件，以便可以使用Python的函数和数据结构。 在C代码中，可以使用Py_Initialize()函数来初始化Python解释器。然后可以使用PyRun_SimpleString()函数或PyRun_SimpleFile()函数来执行Python代码。这样可以将C语言中的数据传递给Python程序进行处理，并获取Python的返回结果。 此外，还可以使用PyImport_ImportModule()函数来导入Python模块，并使用PyObject_CallObject()函数来调用Python函数。通过这些函数的使用，可以在C语言中直接调用Python函数。 在调用Python程序之前，需要先确保Python解释器已经安装在计算机上，并且路径已正确配置好。可以通过设置环境变量或在代码中指定Python解释器的路径来实现。 需要注意的是，在调用Python程序时，C语言和Python存储数据的方式是不同的。所以在C语言和Python之间传递数据时，需要进行数据类型的转换。可以使用PyArg_ParseTuple()函数来将C语言的数据类型转换为Python的数据类型，或使用Py_BuildValue()函数将Python的数据类型转换为C语言的数据类型。 总之，通过上述方法，我们可以在C语言中调用Python程序，实现C语言和Python的互操作。这样可以充分利用C语言的性能和Python的灵活性，来开发更加复杂和强大的应用程序。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

咖喱年糕

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值