[转] C/C++ 调用Python

from :  https://cyendra.github.io/2018/07/10/pythoncpp/

目录

• 前言
• 官方文档
• 环境搭建
• 编译连接
• Demo
• 解释器
• 初始化
• GIL
• Object
• 一切皆对象
• 从Python代码中获取Object
• C/C++与Object转换
• 函数调用
• 引用计数
• 参考资料

前言

最近项目中遇到须要用C++调用python代码的状况，在网上搜索后发现中文资料比较少。所以借此机会一边学习一边整理成文档，方便后续查阅。

官方文档

教程：https://docs.python.org/2/extending/embedding.html API：https://docs.python.org/2/c-api/index.html

环境搭建

编译连接

使用python提供的C/C++接口，须要包含python安装目录下的头文件Python.h 编译、连接时须要指定头文件、python库的地址，不过不须要咱们本身操心，python提供了一个脚本，能够自动推荐编译、连接参数： Bash python-config –cflags python-config –ldflags

Demo

动过运行一个简单的demo，能够验证链路是否打通。 C++

#include <Python.h>
int main(int argc, char *argv[]) {
  Py_Initialize();
  PyRun_SimpleString("print('hello world')\n");
  Py_Finalize();
  return 0;
}
// g++ main.cpp -I$PYTHON_PATH/include/python2.7 -lpython2.7
// 输出 hello world

解释器

初始化

在调用python API时，首先须要初始化全局解释器，而且在使用完后销毁。在咱们的业务场景下，须要解释器常驻内存，所以Py_Initialize在系统初始化时调用，Py_Finalize在析构函数中调用。

C++

void Py_Initialize(void)
int Py_IsInitialized(void)
void Py_Finalize()

初始化Python后，能够经过int PyRun_SimpleString(const char *command)函数令解释器执行任意python代码。这种叫作高层接口。高层接口虽然方便，但很难与C/C++交换数据。因此对于复杂需求，应该使用低层接口。虽然须要多写不少C代码，但能够灵活的实现不少复杂功能。

从操做步骤上看，C++调用Python低层接口能够分为几个阶段

• 初始化Python解释器
• 从C++到Python转换数据
• 用转换后的数据作参数调用Python函数
• 把函数返回值转换为C++数据结构

GIL

在使用python解释器时，要注意GIL（全局解释锁）的工做原理以及对性能的影响。GIL保证在任意时刻只有一个线程在解释器中运行。在多线程环境中，python解释器工做原理以下： Plain Text

1. 设置GIL
2. 切换到一个线程去运行
3. 运行：
    a. 指定数量的字节码指令，或者
    b. 线程主动让出控制（能够调用time.sleep(0)）
4. 把线程设置为睡眠状态
5. 解锁GIL
6. 再次重复以上全部步骤

对性能的影响： 假若有一段两个线程的python代码，运行在一个两核CPU上。因为GIL的存在，两个线程没法真正并行执行，CPU占用率老是低于50%。

GIL是一个历史遗留问题，致使CPython多线程不能利用多个CPU内核的计算能力。为了利用多核，一般使用多进程的方法，或是经过Python调用C代码，由C来实现多线程。

注意，当在C/C++建立的线程中调用Python时，GIL须要经过函数PyGILState_Ensure()和PyGILState_Release(）手动获取、释放。 C++

PyGILState_STATE gstate;
gstate = PyGILState_Ensure();

/* Perform Python actions here. */
result = CallSomeFunction();
/* evaluate result or handle exception */

/* Release the thread. No Python API allowed beyond this point. */
PyGILState_Release(gstate);

Object

###一切皆对象 在python中有一句话叫作“一切皆对象”，这句话能够结合源码更好的进行理解。在python里，一切变量、函数、类等，在解释器中执行时，都会在在堆中新建一个对象，并将名字绑定在对象上。 Python

i = 1              -----新建一个PyIntObject对象,而后绑定到i上
s = "abcde"        -----新建一个PyStringObject对象，绑定到s上
def foo(): pass    -----新建一个PyFunctionObject对象， 绑定到foo上
class C(object): pass    -----新建一个类对象，绑定到C上
instance = C()           -----新建一个实例对象，绑定到instance上
l = [1,2]                -----新建一个PyListObject对象，绑定到l上
t = (1,2)                -----新建一个PyTupleObject对象，绑定到t上

在Python/C API中，使用指向堆中对象的指针PyObject*对这些对象进行进行管理。所以，python中的大多数语句，均可以经过对PyObject指针调用各类函数来实现。

从Python代码中获取Object

如上一节所述，既然一切皆对象，那咱们就能够在C/C++中获取到python代码中的对象。

C++

// Python内建函数import，导入一个Python模块。
PyObject* PyImport_ImportModule(char *name) 

// Python语句o.attr_name，返回对象o中检索attr_name属性或方法。
PyObject* PyObject_GetAttrString(PyObject *o, char*attr_name)

C/C++与Object转换

能够经过调用Py_BuildValue，经过传递格式字符串和变长参数，将C/C++变量构造为变量或元组。 C

PyObject* Py_BuildValue(const char *format, ...)
// 更多参数查阅参考官方文档
// s 将C字符串转换为Python字符串对象。
// i 将C int转换为Python整数对象。
// d 将C double转换为Python浮点数。

此外也能够直接调用下面一系列函数，显式将C/C++变量转换为python变量。 C++

// 基本变量
PyObject* PyLong_FromLong(long v)
PyObject* PyBool_FromLong(long v)
PyObject* PyFloat_FromDouble(double v)

// python元组
PyObject* PyTuple_New(Py_ssize_t len)
int PyTuple_SetItem(PyObject *p, Py_ssize_t pos, PyObject *o)

使用例 C++

// 经过set item的方式构造tuple
PyObject* args = PyTuple_New(3);
PyObject* arg1 = Py_BuildValue("i", 100); // 整数参数
PyObject* arg2 = Py_BuildValue("f", 3.14); // 浮点数参数
PyObject* arg3 = Py_BuildValue("s", "hello"); // 字符串参数
PyTuple_SetItem(args, 0, arg1);
PyTuple_SetItem(args, 1, arg2);
PyTuple_SetItem(args, 2, arg3);

// 经过buildvalue直接构造tuple
PyObject* args = Py_BuildValue("(ifs)", 100, 3.14, "hello");
PyObject* args = Py_BuildValue("()"); // 无参函数

PyObject也能够转换为C++变量 C++

// 使用一系列库函数转换基本变量
long PyLong_AsLong(PyObject *obj)
long PyInt_AsLong(PyObject *obj)
double PyFloat_AsDouble(PyObject *obj)
string PyString_AsString(PyObject *obj)

// 元组
Py_ssize_t PyTuple_Size(PyObject *p)
PyObject* PyTuple_GetItem(PyObject *p, Py_ssize_t pos)

函数调用

因为Python中一切皆对象，所以函数、方法等调用均可以经过PyObject_Call系列函数完成。 C++

// callable(*args, **kwargs)
PyObject* PyObject_Call(PyObject *callable, PyObject *args, PyObject *kwargs)
PyObject* PyObject_CallObject(PyObject *callable, PyObject *args)

// callable(arg1, arg2, ...)
PyObject* PyObject_CallFunction(PyObject *callable, const char *format, ...)
PyObject* PyObject_CallFunctionObjArgs(PyObject *callable, ..., NULL)

// obj.name(arg1, arg2, ...)
PyObject* PyObject_CallMethod(PyObject *obj, const char *name, const char *format, ...)
PyObject* PyObject_CallMethodObjArgs(PyObject *obj, PyObject *name, ..., NULL)

能够发现，函数参数一般有两种类型，一种是直接传递tuple、map两类PyObject，另外一种是经过格式字符串与变长参数，直接将C/C++变量解析成参数。

还用一种结合两种参数的方法，经过PyArg_ParseTuple()、PyArg_ParseTupleAndKeywords()和PyArg_Parse()三个函数，能够用格式字符串将C/C++变量构造为Python元组、字典或变量，以便后续函数调用。

引用计数

内存管理

Python使用引用计数与垃圾回收来管理内存。对于每一个对象，能够理解为有一个对象实体以及若干对该实体的引用（指向对象的指针）。引用计数经过记录对象被引用的次数来管理对象，增长对对象的引用会使引用计数加一，减小对对象的引用使引用计数减一，当一个对象引用计数为0时释放该对象占用的内存。因为引用计数没法处理循环引用的状况，还会有垃圾回收机制来处理循环引用的对象。能够认为Python解释器会周期的调用垃圾回收。 全部的python对象，PyObject都有对象类型和引用计数。对象类型肯定它是什么样的对象 (如，整数、列表或用户定义的函数)。对于每一个已知类型，都有一个宏来检查对象是否属于该类型。例如，若是指向的对象是 Python 列表, 则 PyList_Check (a) 为 true。

Python/C API 中的引用计数

API中使用两个宏Py_INCREF(x) 和 Py_DECREF(x)来处理引用计数的增长和减小。当计数达到零时，Py_DECREF() 会释放对象。若是是列表等复合对象类型，Py_DECREF还会递减对象中包含的其余对象的引用计数。若是忘记减小引用计数将会形成内存泄漏。 有一个概念叫作引用的全部权，拥有全部权表明该引用不使用时须要调用Py_DECREF。全部权能够被传递，得到全部权的新引用也须要在不使用时调用Py_DECREF。 此外还有一个概念叫作“借用(borrow)”的引用，相似C++中std::weak_ptr。借用的引用不能长期持有对象，没有全部权。对象原持有者释放对象后，借用引用再访问被释放的内存会有风险。借用的引用能够经过调用Py_INCREF()改成真正持有引用。 全部权传递常发生在函数调用：

• 做为返回值：当函数返回一个引用给调用方时，分为两种状况：调用方得到引用全部权或借用了引用而没有得到全部权。
  • 以 PyObject_、PyNumber_、PySequence_ 或 PyMapping_ 开头的函数老是传递全部权，新增它们返回的对象的引用计数，调用方要在使用完后调用Py_DECREF ()。
  • 而PyTuple_GetItem ()、PyList_GetItem ()、PyDict_GetItem () 和 PyDict_GetItemString () 都返回从元组、列表或字典中借用的引用。
• 做为参数：当引用做为参数传递给函数时，有两种状况：函数窃取引用或没有窃取。窃取引用表明调用方不须要再处理该引用。
  • 不多有函数窃取引用，经常使用的是PyList_SetItem()和PyTuple_SetItem()。
  • 而PyObject_SetItem()、PyDict_SetItem()不窃取引用。

用一个例子来讲明全部权传递问题，分别用PyList_GetItem()、 PySequence_GetItem()实现对list中全部数字求和： C++

long
sum_list(PyObject *list)
{
    Py_ssize_t i, n;
    long total = 0, value;
    PyObject *item;

    n = PyList_Size(list);
    if (n < 0)
        return -1; /* Not a list */
    for (i = 0; i < n; i++) {
        item = PyList_GetItem(list, i); /* Can't fail */
        if (!PyLong_Check(item)) continue; /* Skip non-integers */
        value = PyLong_AsLong(item);
        if (value == -1 && PyErr_Occurred())
            /* Integer too big to fit in a C long, bail out */
            return -1;
        total += value;
    }
    return total;
}
C++
long
sum_sequence(PyObject *sequence)
{
    Py_ssize_t i, n;
    long total = 0, value;
    PyObject *item;
    n = PySequence_Length(sequence);
    if (n < 0)
        return -1; /* Has no length */
    for (i = 0; i < n; i++) {
        item = PySequence_GetItem(sequence, i);
        if (item == NULL)
            return -1; /* Not a sequence, or other failure */
        if (PyLong_Check(item)) {
            value = PyLong_AsLong(item);
            Py_DECREF(item);
            if (value == -1 && PyErr_Occurred())
                /* Integer too big to fit in a C long, bail out */
                return -1;
            total += value;
        }
        else {
            Py_DECREF(item); /* Discard reference ownership */
        }
    }
    return total;
}

参考资料

• 嵌套python解释器
• 浅析 C++ 调用 Python 模块
• C/C++与python互相调用
• python 一切皆对象
• 深刻理解 GIL：如何写出高性能及线程安全的 Python 代码
• Python高级特性：全局解释器锁GIL基本概念
• python引用计数和gc垃圾回收