如何用给定数量的元素初始化boost::python::list？

Question

我有 python 个用于执行二进制数据编码/解码的 C 库的包装器。其中一个包装函数将 python 列表作为参数，returns 是经过处理的 python 列表。

目前我是这样做的：

list pycf_cobs_decode(list data) {
    list decoded;
    uint32_t data_len = 0, worst_data_len = 0;
    uint8_t *cdata = NULL;
    uint8_t *cdata_dec = NULL;

    data_len = len( data );
    worst_data_len = COBS_WORST_LEN( data_len );

    // Clone the python list
    cdata = new uint8_t[ data_len ];
    for (int i=0; i<data_len; i++)
        cdata[ i ] = extract< uint8_t >( data[ i ] );

    // Decode it
    cdata_dec = new uint8_t[ worst_data_len ];
    cobs_decode( cdata, data_len, cdata_dec );

    for (int i=0; i<worst_data_len; i++)
        decoded.append( cdata_dec[ i ] );

    delete[] cdata_dec;
    delete[] cdata;
    return decoded;
}

然而，通过创建一个空列表，然后将所有字节一个一个地追加是远远不够高效的（导致大量的 realloc 调用）。

有没有办法将boost::python::list初始化为特定数量的元素？
一个想法是创建一个 std::vector 并将其转换为 python 列表 (std::vector to boost::python::list)，但发现大多数人建议无论如何都要手动附加所有元素。
另一个想法是复制输入列表，覆盖内容并只附加额外的字节。但到目前为止，我也没有找到任何功能来做到这一点。
也许如果我复制输入列表，删除所有元素（希望它不会在删除元素时重新分配）并将它们追加回去？

我一直试图从这些页面中找到有用的东西，但我真的不知道要找什么：

http://www.boost.org/doc/libs/1_57_0/libs/python/doc/v2/reference.html

http://www.boost.org/doc/libs/1_57_0/libs/python/doc/v2/list.html

谢谢

编辑： 意识到 std::string 也支持二进制数组并且 boost::python 自动将其转换为 python 字符串。使用 std::string，代码现在更短并且有望产生更好的性能。但是，这不能回答问题，因为它仅适用于字符数组。

std::string pycf_cobs_decode(const std::string &data) {
    uint32_t worst_len = COBS_WORST_LEN( data.size() );
    char *cdec = new char[ worst_len ];

    // Decode it
    cobs_decode( ( const uint8_t * ) data.c_str(), data.size(), 
        ( uint8_t * ) cdec );

    std::string decoded( cdec, worst_len );
    delete[] cdec;

    return decoded;
}

Answer 1

一次追加一项时，内部分配的数量可能没有预期的那么多。 documented，对于 list.append()，平均和摊销的最坏情况复杂度是常数。

Boost.Python 在允许用 C++ 编写 Python-ish 代码方面做得相当好。因此，可以使用 Python 惯用法，[None] * n 将列表分配给给定大小：

/// @brief Construct list with `n` elements.  each element is a copy 
///        of `value`.
/// @param n Iniitail container size.
/// @param item Item with which to fill the container.
boost::python::list make_list(
  const std::size_t n,
  boost::python::object item = boost::python::object() /* none */)
{
  namespace python = boost::python;
  // >>> [None] * n;
  python::list result;
  result.append(item);
  result *= n;
  return result;
}

我找不到明确说明此类操作的实现行为的文档，但该惯用语的表现通常优于追加。尽管如此，虽然 Boost.Python 并未公开所有 Python/C API 功能，但可以通过使用 PyList_New(len) 创建列表来保证单个分配，然后通过以下方式管理和操作它Boost.Python。如文档中所述，当 len 大于零时，在将列表对象暴露给 Python 代码之前，必须通过 PyList_SetItem() 将所有项目设置为真实对象，或者在这种情况下，一个boost::python::list 对象：

If len is greater than zero, the returned list object’s items are set to NULL. Thus you cannot use abstract API functions such as PySequence_SetItem() or expose the object to Python code before setting all items to a real object with PyList_SetItem().

辅助功能可能有助于隐藏这些细节。例如，可以使用具有类似填充行为的工厂函数：

/// @brief Construct list with `n` elements.  each element is a copy 
///        of `value`.
/// @param n Iniitail container size.
/// @param item Item with which to fill the container.
boost::python::list make_list(
  const std::size_t n,
  boost::python::object item = boost::python::object() /* none */)
{
  namespace python = boost::python;
  python::handle<> list_handle(PyList_New(n));
  for (std::size_t i=0; i < n; ++i)
  {
    // PyList_SetItem will steal the item reference.  As Boost.Python is
    // managing the item, explicitly increment the item's reference count
    // so that the stolen reference remains alive when this Boost.Python
    // object's scope ends.
    Py_XINCREF(item.ptr());

    PyList_SetItem(list_handle.get(), i, item.ptr());
  }
  return python::list{list_handle};
}

或者在范围内工作的工厂函数：

/// @brief Construct a list from a given range of [first,last).  The
///        copied range includes all elements between `first` to `last`,
///        including `first`.
/// @param first Input iterator to the initial item to copy.
/// @param last Input iterator to one after the final item to be copied.
template <typename Iterator>
boost::python::list make_list(Iterator first, Iterator last)
{
  namespace python = boost::python;
  const auto size = std::distance(first, last);
  python::handle<> list_handle{PyList_New(size)};
  for (auto i=0; i < size; ++i, ++first)
  {
    python::object item{*first};

    // PyList_SetItem will steal the item reference.  As Boost.Python is
    // managing the item, explicitly increment the item's reference count
    // so that the stolen reference remains alive when this Boost.Python
    // object's scope ends.
    Py_XINCREF(item.ptr());

    PyList_SetItem(list_handle.get(), i, item.ptr());
  }
  return boost::python::list{list_handle};
}

这是一个完整的示例 demonstrating，其中模拟了 COBS_WORST_LEN() 和 cobs_decode() 函数，这些函数通过累积对进行解码。由于在构造返回的列表时解码值是已知的，因此我选择使用范围工厂函数来防止必须遍历列表并将值设置两次：

#include <boost/python.hpp>

#include <iostream>
#include <vector>

#include <boost/python/stl_iterator.hpp>

/// Mockup that halves the list, rounding up.
std::size_t COBS_WORST_LEN(const std::size_t len)
{
  return (len / 2) + (len % 2);
}

/// Mockup that just adds adjacent elements together.
void cobs_decode(
  const boost::uint8_t* input,
  const std::size_t size,
  boost::uint8_t* output)
{
  for (std::size_t i=0; i < size; ++i, ++input)
  {
    if (i % 2 == 0)
    {
      *output = *input;
    }
    else
    {
      *output += *input;
      ++output;
    }
  }
}

/// @brief Construct a list from a given range of [first,last).  The
///        copied range includes all elements between `first` to `last`,
///        including `first`.
/// @param first Input iterator to the initial value to copy.
/// @param last Input iterator to one after the final element to be copied.
template <typename Iterator>
boost::python::list make_list(Iterator first, Iterator last)
{
  namespace python = boost::python;
  const auto size = std::distance(first, last);
  python::handle<> list_handle{PyList_New(size)};
  for (auto i=0; i < size; ++i, ++first)
  {
    python::object item{*first};

    // PyList_SetItem will steal the item reference.  As Boost.Python is
    // managing the item, explicitly increment the item's reference count
    // so that the stolen reference remains alive when this Boost.Python
    // object's scope ends.
    Py_XINCREF(item.ptr());

    PyList_SetItem(list_handle.get(), i, item.ptr());
  }
  return boost::python::list{list_handle};
}

/// @brief Decode a list, returning the aggregation of paired items.
boost::python::list decode(boost::python::list py_data)
{
  namespace python = boost::python;

  // Clone the list.
  std::vector<boost::uint8_t> data(len(py_data));
  std::copy(
    python::stl_input_iterator<boost::uint8_t>{py_data},
    python::stl_input_iterator<boost::uint8_t>{},
    begin(data));

  // Decode the list.
  std::vector<boost::uint8_t> decoded(COBS_WORST_LEN(data.size()));
  cobs_decode(&data[0], data.size(), &decoded[0]);

  return make_list(begin(decoded), end(decoded));
}

BOOST_PYTHON_MODULE(example)
{
  namespace python = boost::python;
  python::def("decode", &decode);
}

交互使用：

>>> import example
>>> assert(example.decode([1,2,3,4]) == [3,7])

此外，由于 Boost.Python 可能会抛出异常，因此可能值得考虑使用内存管理容器，例如 std::vector 或智能指针，而不是原始动态数组。

如何用给定数量的元素初始化boost::python::list？

How to initialize boost::python::list with a given number of elements?

c++

boost-python