复制C+的最佳方式+；Python缓冲区 < P>使用Python处理C扩展时，从C++数组或“代码>矢量< /代码>中移动数据到 pyObjs >代码> pyList< /Cord>是什么最好的方法，所以它可以返回到Python？

我现在使用的方法似乎有点笨拙。我循环遍历每个元素并调用

Py\u BuildValue

将值附加到

PyList

---

是否有类似于

memcpy

？

在将每个元素添加到序列之前，必须从每个元素构造一个

PyObject

因此，您必须逐个添加它们，或者将它们全部转换，然后从

PyObject[]

传递给构造函数

---

我想第二种方法速度稍快，因为它不必在每次添加后调整序列的成员变量。

在将每个元素添加到序列之前，必须从每个元素构造一个

PyObject

因此，您必须逐个添加它们，或者将它们全部转换，然后从

PyObject[]

传递给构造函数

---

我想第二种方法速度稍快，因为它不必在每次添加后调整序列的成员变量。

在将每个元素添加到序列之前，必须从每个元素构造一个

PyObject

因此，您必须逐个添加它们，或者将它们全部转换，然后从

PyObject[]

传递给构造函数

---

我想第二种方法速度稍快，因为它不必在每次添加后调整序列的成员变量。

在将每个元素添加到序列之前，必须从每个元素构造一个

PyObject

因此，您必须逐个添加它们，或者将它们全部转换，然后从

PyObject[]

传递给构造函数

---

我想第二种方法速度稍快，因为它不必在每次添加后调整序列的成员变量。

如果可以将Boost作为依赖项安装，那么可以利用

Boost:：python:：list

类自动进行转换。要将

std:：vector

转换为

python:：list

如果可以将Boost作为依赖项安装，则可以利用

Boost:：python:：list

类自动进行转换。要将

std:：vector

转换为

python:：list

如果可以将Boost作为依赖项安装，则可以利用

Boost:：python:：list

类自动进行转换。要将

std:：vector

转换为

python:：list

如果可以将Boost作为依赖项安装，则可以利用

Boost:：python:：list

类自动进行转换。要将

std:：vector

转换为

python:：list

如果向量包含同质数字数据，最好创建一个将值传输到python的函数

与列表不同，数组在内部将其值存储为本机C值的连续数组，但在其他方面提供类似python列表的接口。它最大限度地减少了内存占用，使您能够实际使用单个

memcpy

调用来高效地传输数据。以下是一个例子：

PyObject *
vec_to_array(std::vector<double>& vec)
{
    static PyObject *single_array;
    if (!single_array) {
        PyObject *array_module = PyImport_ImportModule("array");
        if (!array_module)
            return NULL;
        PyObject *array_type = PyObject_GetAttrString(array_module, "array");
        Py_DECREF(array_module);
        if (!array_type)
            return NULL;
        // array.array('d', [0.0])
        single_array = PyObject_CallFunction(array_type, "c[d]", 'd', 0.0);
        Py_DECREF(array_type);
        if (!single_array)
            return NULL;
    }

    // extra-fast way to create an empty array of count elements:
    //   array = single_element_array * count
    PyObject *pysize = PyLong_FromSsize_t(vec.size());
    if (!pysize)
        return NULL;
    PyObject *array = PyNumber_Multiply(single_array, pysize);
    Py_DECREF(pysize);
    if (!array)
        return NULL;

    // now, obtain the address of the array's buffer
    PyObject *buffer_info = PyObject_CallMethod(array, "buffer_info", "");
    if (!buffer_info) {
        Py_DECREF(array);
        return NULL;
    }
    PyObject *pyaddr = PyTuple_GetItem(buffer_info, 0);
    void *addr = PyLong_AsVoidPtr(pyaddr);

    // and, finally, copy the data.
    if (vec.size())
        memcpy(addr, &vec[0], vec.size() * sizeof(double));

    return array;
}

PyObject*
向量到向量阵列（标准：：向量和向量）
{
静态PyObject*单_数组；
如果（！单_数组）{
PyObject*array_module=PyImport_ImportModule（“数组”）；
if（！数组_模块）
返回NULL；
PyObject*array_type=PyObject_GetAttrString（数组模块，“数组”）；
Py_DECREF（阵列_模块）；
如果（！数组类型）
返回NULL；
//array.array（'d'，[0.0]）
单个数组=PyObject调用函数（数组类型，“c[d]”，'d'，0.0）；
Py_DECREF（数组类型）；
如果（！单_数组）
返回NULL；
}
//创建计数元素空数组的超快速方法：
//数组=单个元素数组*计数
PyObject*pysize=PyLong_fromsize_t（vec.size（））；
如果（！pysize）
返回NULL；
PyObject*数组=PyNumber\u乘法（单数组，pysize）；
Py_DECREF（pysize）；
if（！数组）
返回NULL；
//现在，获取数组缓冲区的地址
PyObject*buffer_info=PyObject_CallMethod（数组，“buffer_info”，“”）；
如果（！缓冲区信息）{
Py_DECREF（数组）；
返回NULL；
}
PyObject*pyaddr=PyTuple\u GetItem（buffer\u info，0）；
void*addr=PyLong_AsVoidPtr（pyaddr）；
//最后，复制数据。
if（向量大小（））
memcpy（addr，&vec[0]，vec.size（）*sizeof（double））；
返回数组；
}

---

读者可以通过模板专门化来增强这一点，以支持其他基本类型。

如果向量包含同质数字数据，那么最好创建一个将值传输到Python的模板

与列表不同，数组在内部将其值存储为本机C值的连续数组，但在其他方面提供类似python列表的接口。它最大限度地减少了内存占用，使您能够实际使用单个

memcpy

调用来高效地传输数据。以下是一个例子：

PyObject *
vec_to_array(std::vector<double>& vec)
{
    static PyObject *single_array;
    if (!single_array) {
        PyObject *array_module = PyImport_ImportModule("array");
        if (!array_module)
            return NULL;
        PyObject *array_type = PyObject_GetAttrString(array_module, "array");
        Py_DECREF(array_module);
        if (!array_type)
            return NULL;
        // array.array('d', [0.0])
        single_array = PyObject_CallFunction(array_type, "c[d]", 'd', 0.0);
        Py_DECREF(array_type);
        if (!single_array)
            return NULL;
    }

    // extra-fast way to create an empty array of count elements:
    //   array = single_element_array * count
    PyObject *pysize = PyLong_FromSsize_t(vec.size());
    if (!pysize)
        return NULL;
    PyObject *array = PyNumber_Multiply(single_array, pysize);
    Py_DECREF(pysize);
    if (!array)
        return NULL;

    // now, obtain the address of the array's buffer
    PyObject *buffer_info = PyObject_CallMethod(array, "buffer_info", "");
    if (!buffer_info) {
        Py_DECREF(array);
        return NULL;
    }
    PyObject *pyaddr = PyTuple_GetItem(buffer_info, 0);
    void *addr = PyLong_AsVoidPtr(pyaddr);

    // and, finally, copy the data.
    if (vec.size())
        memcpy(addr, &vec[0], vec.size() * sizeof(double));

    return array;
}

PyObject*
向量到向量阵列（标准：：向量和向量）
{
静态PyObject*单_数组；
如果（！单_数组）{
PyObject*array_module=PyImport_ImportModule（“数组”）；
if（！数组_模块）
返回NULL；
PyObject*array_type=PyObject_GetAttrString（数组模块，“数组”）；
Py_DECREF（阵列_模块）；
如果（！数组类型）
返回NULL；
//array.array（'d'，[0.0]）
单个数组=PyObject调用函数（数组类型，“c[d]”，'d'，0.0）；
Py_DECREF（数组类型）；
如果（！单_数组）
返回NULL；
}
//创建计数元素空数组的超快速方法：
//数组=单个元素数组*计数
PyObject