std:：vector to boost:：python:：list 我有一个C++方法，从Python调用，需要返回Python列表对象。

我已经创建了这个方法，它连接到一个公开的类，现在可以从python调用。。。（它返回void）

所以问题是，如何从以下内容创建python列表：

std:：向量结果

我不太理解此文档中的构造函数是如何工作的：


还有。。。我真的不想返回某种包装向量。。。我只想用向量中的字符串值创建一个新的python列表

如果这是重复的，我很抱歉。。。我发现了很多列表到向量的问题，但是我找不到任何关于创建新python列表的问题

我可以将这个问题扩展到其他一些问题，如：

从：
std:：map
等创建新的python字典。
boost:：python
已经包含了包装向量和映射的功能。下面是向量的示例代码，您可以看到传递列表和返回列表都非常简单：

// C++ code
typedef std::vector<std::string> MyList;
class MyClass {
  MyList myFuncGet();
  void myFuncSet(const Mylist& list);
  //       stuff
};

// Wrapper code

#include <boost/python/suite/indexing/vector_indexing_suite.hpp>

using namespace boost::python;


BOOST_PYTHON_MODULE(mymodule)
{
    class_<MyList>("MyList")
        .def(vector_indexing_suite<MyList>() );

    class_<MyClass>("MyClass")
        .def("myFuncGet", &MyClass::myFuncGet)
        .def("myFuncSet", &MyClass::myFuncSet)
        ;
}

<代码> /C++代码
typedef std：：向量MyList；
类MyClass{
MyList myFuncGet（）；
void myFuncSet（常量Mylist&list）；
//东西
};
//包装代码
#包括
使用名称空间boost:：python；
BOOST_PYTHON_模块（mymodule）
{
类（“MyList”）
.def（向量索引套件（））；
类别（MyClass）
.def（“myFuncGet”，&MyClass:：myFuncGet）
.def（“myFuncSet”，&MyClass:：myFuncSet）
;
}

地图与矢量非常相似，本文对此进行了描述：

---

不幸的是，

boost:：python

目前没有包装列表的功能。您可以手动创建包装器，但我没有时间回答这个问题。我可以今天或明天寄。我希望能有一个关于这个特殊问题的新问题，因为答案将非常广泛，可能超出了本文的范围。我只是避免使用列表，而是使用向量

如果您只想手动创建python列表（并让函数返回py:：list而不是vector），请执行以下操作：

/* using namespace std; namespace py=boost::python;
   #define FOREACH BOOST_FOREACH
*/
vector<string> ss;
py::list ret;
FOREACH(const string& s, ss) ret.append(s);
return s;

/*使用名称空间std；名称空间py=boost:：python；
#定义FOREACH BOOST\u FOREACH
*/
矢量ss；
py：：列表ret；
FOREACH（const string&s，ss）ret.append（s）；
返回s；

自动转换，将Python列表中的向量转换器定义为C++，从C++到Python列表——我在回复的第二部分写了这个。这样，您就得到了真正的python列表

---

自动转换的另一种可能性（我没有经验）是使用indexing_suite，正如一位同事在这里提到的那样，它将

vector

包装为python中的一个特殊类。

我使用迭代器将

std:：vector

转换为

py:：list

：

namespace py = boost::python;

template<class T>
py::list std_vector_to_py_list(const std::vector<T>& v)
{
    py::object get_iter = py::iterator<std::vector<T> >();
    py::object iter = get_iter(v);
    py::list l(iter);
    return l;
}

namespace py=boost:：python；
模板
py:：list std_vector_to_py_list（const std:：vector&v）
{
py:：object get_iter=py:：iterator（）；
py:：object iter=get_iter（v）；
py：：列表l（iter）；
返回l；
}

FWIW，这里有一个与eudoxos解决方案相同的模板函数：

namespace py = boost::python;

template<class T>
py::list std_vector_to_py_list(const std::vector<T>& v)
{
  py::list l;
  typename std::vector<T>::const_iterator it;
  for (it = v.begin(); it != v.end(); ++it)
    l.append(*it);   
  return l;  
}

namespace py=boost:：python；
模板
py:：list std_vector_to_py_list（const std:：vector&v）
{
py：：列表l；
typename std:：vector:：const_迭代器it；
for（it=v.begin（）；it！=v.end（）；+it）
l、 附加（*它）；
返回l；
}

来自：

<代码> //将C++向量转换为Python列表 模板 boost:：python:：list toPythonList（std:：vector）{ typename std:：vector:：iterator iter； boost:：python:：list； 对于（iter=vector.begin（）；iter！=vector.end（）；++iter）{ 列表。附加（*iter）； } 退货清单； }

---

我使用以下实用程序函数从stl容器转换到stl容器。平凡和函数说明了如何使用它们。此外，我还发现了以下开源软件包，其中包含许多转换实用程序：

#包括
#包括
#包括
#包括
名称空间bpy=boost:：python；
名称空间fm{
模板
bpy:：列表stl2py（const容器和vec）{
typedef typename容器：：value_type T；
列表lst；
std:：for_each（vec.begin（）、vec.end（）、[&]（const T&T）{lst.append（T）；}）；
返回lst；
}
模板
void py2stl（const bpy:：list&lst、Container&vec）{
typedef typename容器：：value_type T；
stl_输入_迭代器beg（lst），结束；
std:：for_each（beg，end，[&]（const T&T）{vec.push_back（T）；}）；
}
bpy:：列表和（常量bpy:：列表和左侧、常量bpy:：列表和右侧）{
std：：载体lhsv；
py2stl（lhs，lhsv）；
std：：载体rhsv；
py2stl（rhs，rhsv）；
std：：向量结果（lhsv.size（），0.0）；
对于（int i=0；i

我看到了这个问题：但这是关于返回一个包装向量的问题。。。我只想创建一个新的python对象并返回它。可能重复：hello@Aleksey，我想我有一个相关的问题要问你。顺便问一下，这个方法的开销大吗？对不起，我是C++和BooSt.python中的新手，可以分享对应的代码：<代码> Vector TrimeLangSuppu。这意味着可以直接访问

std:：vector

。这基本上是你能期望的最低开销。这是链接：。这不是一个巨大的开销吗？这是一个问题，我在这个例子中得到了一个例外：<代码> Py::ItITER＝GETIITER（V）<代码> >没有To-Python（按值）转换器，对于C++类型：STD:：向量作为Boost 1.51，同样“没有TyPython（按值）转换器为C++类型找到：STD:：vector’，Boost 1.48同样错误：没有ToPython（按值）为C++类型找到的转换器：STD:：Voice这里有同样的错误：<代码>没有ToyPython（按值）转换

// Converts a C++ vector to a python list
template <class T>
boost::python::list toPythonList(std::vector<T> vector) {
    typename std::vector<T>::iterator iter;
    boost::python::list list;
    for (iter = vector.begin(); iter != vector.end(); ++iter) {
        list.append(*iter);
    }
    return list;
}

#include <vector>
#include <boost/python.hpp>
#include <boost/python/object.hpp>
#include <boost/python/stl_iterator.hpp>

namespace bpy = boost::python;

namespace fm {

template <typename Container>
bpy::list stl2py(const Container& vec) {
  typedef typename Container::value_type T;
  bpy::list lst;
  std::for_each(vec.begin(), vec.end(), [&](const T& t) { lst.append(t); });
  return lst;
}

template <typename Container>
void py2stl(const bpy::list& lst, Container& vec) {
  typedef typename Container::value_type T;
  bpy::stl_input_iterator<T> beg(lst), end;
  std::for_each(beg, end, [&](const T& t) { vec.push_back(t); });
}

bpy::list sum(const bpy::list& lhs, const bpy::list& rhs) {
  std::vector<double> lhsv;
  py2stl(lhs, lhsv);

  std::vector<double> rhsv;
  py2stl(rhs, rhsv);

  std::vector<double> result(lhsv.size(), 0.0);
  for (int i = 0; i < lhsv.size(); ++i) {
    result[i] = lhsv[i] + rhsv[i];
  }
  return stl2py(result);
}

} // namespace fm

BOOST_PYTHON_MODULE(fm)
{
  bpy::def("sum", &fm::sum);
}