C++数组和python数组相互转换（pybind11 numpy和指针数据转换） tcy

最新推荐文章于 2024-01-08 20:32:14 发布
最新推荐文章于 2024-01-08 20:32:14 发布
阅读量7.7k 收藏 22
点赞数 8
分类专栏： pybind11 C/C++ python 文章标签： python c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tcy23456/article/details/119998548
版权
本文详细介绍了如何使用C++模板将指针转换为一维、二维和三维的numpy数组，并提供了针对一维、二维和三维numpy数组的相加函数示例。通过实例演示了如何在C++和Python交互中实现数组运算。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1.实例：指针-->numpy

#include <iostream>
#include<pybind11/pybind11.h>

#undef max//放在<pybind11/numpy.h>之前（#define NOMINMAX有时不起作用）
#include<pybind11/numpy.h>

namespace py = pybind11;
using namespace py::literals; 
//*指针-->numpy 1D
template<typename T>
py::array_t<T> _ptr_to_arrays_1d(T* data, py::ssize_t col) {
    auto result = py::array_t<T>(col);//申请空间
    py::buffer_info buf = result.request();
    T* ptr = (T*)buf.ptr;

    for (auto i = 0; i < col; i++) 
        ptr[i] = data[i];
    
    return result;
}


//*指针-->numpy 1D
template<typename T>
py::array_t<T> ptr_to_arrays_1d(T* data, py::ssize_t col) {
    py::array_t<double> out = py::array_t<double>(col);
    auto r3 = out.mutable_unchecked<1>();

    for (int i = 0; i < col; i++)
        r3(i) = data[i];

    return out;
}
//*指针-->numpy 2D
template<typename T>
py::array_t<T> _ptr_to_arrays_2d(T* data, py::ssize_t row,py::ssize_t col) {
    auto result = _ptr_to_arrays_1d(data, row * col);
    result.resize({ row,col });//转换为2d矩阵
    return result;
}
//*指针-->numpy 2D
template<typename T>
py::array_t<T> ptr_to_arrays_2d(T* data, py::ssize_t row, py::ssize_t col) {
    py::array_t<T> out = ptr_to_arrays_1d(data,row * col);
    out.resize({ row,col});
   
    return out;
}
//*指针-->numpy 3D
template<typename T>
py::array_t<T> _ptr_to_arrays_3d(T* data, py::ssize_t chunk, py::ssize_t row, py::ssize_t col) {
    auto result = _ptr_to_arrays_1d(data, chunk * row * col);
    result.resize({ chunk,row,col });//转换为2d矩阵
    return result;
} 
//*指针-->numpy 3D
template<typename T>
py::array_t<T> ptr_to_arrays_3d(T* data, py::ssize_t chunk, py::ssize_t row, py::ssize_t col) {
    py::array_t<T> out = ptr_to_arrays_1d(data, chunk * row * col);
    out.resize({ chunk,row,col });

    return out;
}
2.实例：测试-numpy数组相加
//*1d numpy数组相加
py::array_t<double> _add_arrays_1d(py::array_t<double>& arr1, py::array_t<double>& arr2) {
    py::buffer_info buf1 = arr1.request();// 获取arr1, arr2的信息
    py::buffer_info buf2 = arr2.request();

    if (buf1.ndim != 1 || buf2.ndim != 1)
        throw std::runtime_error("Number of dimensions must be one");
    if (buf1.size != buf2.size)
        throw std::runtime_error("Input shape must match");

    auto result = py::array_t<double>(buf1.size);//申请空间
    py::buffer_info buf3 = result.request();

    double* ptr1 = (double*)buf1.ptr;       //获取numpy.ndarray 数据指针
    double* ptr2 = (double*)buf2.ptr;
    double* ptr3 = (double*)buf3.ptr;

    for (int i = 0; i < buf1.shape[0]; i++){//指针访问numpy.ndarray
        ptr3[i] = ptr1[i] + ptr2[i];}

    return result;
}
//*1d numpy数组相加
py::array_t<double> add_arrays_1d(py::array_t<double>& arr1, py::array_t<double>& arr2) {
    auto r1 = arr1.unchecked<1>();
    auto r2 = arr2.unchecked<1>();

    py::array_t<double> out = py::array_t<double>(arr1.size());
    auto r3 = out.mutable_unchecked<1>();

    for (int i = 0; i < arr1.shape()[0]; i++) 
       r3(i) = r1(i) + r2(i);//下标索引访问 numpy.ndarray
        
    return out;
}
//*2d numpy数组相加
py::array_t<double> _add_arrays_2d(py::array_t<double>& arr1, py::array_t<double>& arr2) {
    py::buffer_info buf1 = arr1.request();
    py::buffer_info buf2 = arr2.request();

    if (buf1.ndim != 2 || buf2.ndim != 2)
        throw std::runtime_error("numpy.ndarray dims must be 2!");
    if ((buf1.shape[0] != buf2.shape[0]) || (buf1.shape[1] != buf2.shape[1]))
        throw std::runtime_error("two array shape must be match!");
  
    auto result = py::array_t<double>(buf1.size);//申请内存
    result.resize({ buf1.shape[0],buf1.shape[1] });//转换为2d矩阵
    py::buffer_info buf_result = result.request();

    double* ptr1 = (double*)buf1.ptr;//指针访问读写 numpy.ndarray
    double* ptr2 = (double*)buf2.ptr;
    double* ptr_result = (double*)buf_result.ptr;

    for (int i = 0; i < buf1.shape[0]; i++){
        for (int j = 0; j < buf1.shape[1]; j++){
            auto value1 = ptr1[i*buf1.shape[1] + j];
            auto value2 = ptr2[i*buf2.shape[1] + j];
            ptr_result[i*buf_result.shape[1] + j] = value1 + value2;
        }
    }

    return result;
} 
//*2d numpy数组相加
py::array_t<double> add_arrays_2d_(py::array_t<double>& arr1, py::array_t<double>& arr2) {
    auto r1 = arr1.unchecked<2>();
    auto r2 = arr2.unchecked<2>();

    py::array_t<double> out = py::array_t<double>(arr1.size());
    out.resize({ arr1.shape()[0],arr1.shape()[1] });
    auto r3 = out.mutable_unchecked<2>();

    for (int i = 0; i < arr1.shape()[0]; i++) {
        for (int j = 0; j < arr1.shape()[1]; j++) {
            r3(i,j) = r1(i,j) + r2(i,j);//下标索引访问 numpy.ndarray
        } 
    }
    return out;
}
 
//*2d numpy数组相加
py::array_t<double> add_arrays_2d(py::array_t<double>& arr1, py::array_t<double>& arr2) {
    auto row = arr1.shape()[0], col = arr1.shape()[1];
    py::array_t<double> arr1_ = arr1,arr2_ = arr2;
    arr1_.resize({ row * col });
    arr2_.resize({ row * col });

    auto out = add_arrays_1d(arr1_,arr2_);
    py::array_t<double> out1 = py::array_t<double>(arr1.size());
    out1 = out;
    out1.resize({ row,col });
    
    return out1;
}
//*3d numpy数组相加
py::array_t<double> _add_arrays_3d(py::array_t<double>& arr1, py::array_t<double>& arr2) {
    py::buffer_info buf1 = arr1.request();
    py::buffer_info buf2 = arr2.request();

    if (buf1.ndim != 3 || buf2.ndim != 3)
        throw std::runtime_error("numpy array dim must is 3!");

    for (int i = 0; i < buf1.ndim; i++) {
        if (buf1.shape[i] != buf2.shape[i])
            throw std::runtime_error("inputs shape must match!");
    }

    auto result = py::array_t<double>(buf1.size);
    result.resize({ buf1.shape[0], buf1.shape[1], buf1.shape[2] });
    py::buffer_info buf_result = result.request();

    double* ptr1 = (double*)buf1.ptr;
    double* ptr2 = (double*)buf2.ptr;
    double* ptr_result = (double*)buf_result.ptr;

    auto chunks = buf1.shape[0];
    auto rows = buf1.shape[1];
    auto cols = buf1.shape[2];
    py::ssize_t idx = 0;
    for (int i = 0; i < buf1.shape[0]; i++) {
        for (int j = 0; j < buf1.shape[1]; j++) {
            for (int k = 0; k < buf1.shape[2]; k++) {
                idx = i * rows * cols + j * cols + k;
                ptr_result[idx] = ptr1[idx]+ptr2[idx];
            }
        }
    }
    return result;
} 
//*3d numpy数组相加
py::array_t<double> add_arrays_3d(py::array_t<double>& arr1, py::array_t<double>& arr2) {

    //unchecked<N>          can be non-writeable
    //mutable_unchecked<N>  can be writeable
    auto r1 = arr1.unchecked<3>();
    auto r2 = arr2.unchecked<3>();

    py::array_t<double> out = py::array_t<double>(arr1.size());
    out.resize({ arr1.shape()[0], arr1.shape()[1], arr1.shape()[2] });
    auto r3 = out.mutable_unchecked<3>();

    for (int i = 0; i < arr1.shape()[0]; i++){
        for (int j = 0; j < arr1.shape()[1]; j++){
            for (int k = 0; k < arr1.shape()[2]; k++){
                double value1 = r1(i, j, k);
                double value2 = r2(i, j, k);
                r3(i, j, k) = value1 + value2;//下标索引访问 numpy.ndarray
            }
        }
    }
    return out;
} 
3.c++中测试：

int main() {
    py::scoped_interpreter guard{};//python初始化 
	
	//*测试1D
    double data1[] = {1.1,2.2,3.3,4.4};
    py::array_t<double> _arr1 = _ptr_to_arrays_1d(data1, 4);
    py::array_t<double> _arr2 = _ptr_to_arrays_1d(data1, 4);
    py::array_t<double> arr1 = ptr_to_arrays_1d(data1, 4);
    py::array_t<double> arr2 = ptr_to_arrays_1d(data1, 4);

    py::print("1.1.add_1d=");
    py::print(_add_arrays_1d(_arr1, _arr2));
   
    py::print("1.2.add_1d=");
    py::print(add_arrays_1d(arr1, arr2));

	//*测试2D
    double data2[] = { 1.1,1.2,1.3,2.1,2.2,2.3 };
    _arr1 = _ptr_to_arrays_2d(data2, 2, 3);
    _arr2 = _ptr_to_arrays_2d(data2, 2, 3);
    arr1 = ptr_to_arrays_2d(data2, 2, 3);
    arr2 = ptr_to_arrays_2d(data2, 2, 3);

    py::print("2.1.add_2d=");
    py::print(_add_arrays_2d(_arr1, _arr2));
    
    py::print("2.2.add_2d=");
    py::print(add_arrays_2d(arr1, arr2));

	//*测试3D
    double data3[] = { 
        11.1,11.2,11.3,12.1,12.2,12.3 ,
        21.1,21.2,21.3,22.1,22.2,22.3 };
    _arr1 = _ptr_to_arrays_3d(data3,2, 2, 3);
    _arr2 = _ptr_to_arrays_3d(data3,2, 2, 3);
    arr1 = ptr_to_arrays_3d(data3, 2, 2, 3);
    arr2 = ptr_to_arrays_3d(data3, 2, 2, 3);

    py::print("3.1.add_3d=");
    py::print(_add_arrays_3d(_arr1, _arr2));
    
    py::print("3.4.add_3d=");
    py::print(add_arrays_3d(arr1, arr2));  
}
4.python中测试：

PYBIND11_MODULE(py_numpy, m) {
   m.doc() = "Simple demo using numpy!";

   m.def("_add_arrays_1d", &_add_arrays_1d);
   m.def("_add_arrays_2d", &_add_arrays_2d);
   m.def("_add_arrays_3d", &_add_arrays_3d);
   
   m.def("add_arrays_1d", &add_arrays_1d);
   m.def("add_arrays_2d", &add_arrays_2d);
   m.def("add_arrays_3d", &add_arrays_3d);
}

//python测试代码
import py_numpy as cnp
import numpy as np

data1 = np.array([1, 3, 5, 7, 9])
data2 = np.array([2, 4, 6, 8, 10])
var1 = cnp._add_arrays_1d(data1,data2)
print('var1=', var1)

data1 = np.array(range(0, 16)).reshape([4, 4])
data2 = np.array(range(20, 36)).reshape([4, 4])
var2 = cnp._add_arrays_2d(data1,data2)
print('var2', var2)

data1 = np.array(range(0, 48)).reshape([4, 4, 3])
data2 = np.array(range(50, 50 + 48)).reshape([4, 4, 3])
var3 = cnp.add_arrays_3d(data1,data2)
print('var3', var3)

参考：https ://www.jianshu.com/p/c912a0a59af9

Python C++ 扩展教程：使用 PyBind11 填充 NumPy 数组
.
03-29 657
当我们需要在 Python 程序中使用 C++ 实现的函数时，可以通过 PyBind11 库来实现 Python 与 C++ 的交互。在这篇教程中，我们将深入了解如何使用 PyBind11 填充 NumPy 数组。接下来，在 Python 中定义一个包装器函数，该函数可用于调用 C++ 函数，并将输入和输出数组转换为 NumPy 数组。接下来，我们定义一个 C++ 函数，该函数使用输入数组中的值来修改输出数组中的值。函数来修改一个输入数组，并获得一个输出数组。
pybind11和numpy进行交互
aakwnam6338的博客
07-04 1827
使用一个遵循buffer protocol的对象就可以和numpy交互了. 这个buffer_protocol要有哪些东西呢? 要有如下接口: struct buffer_info { void *ptr; ssize_t itemsize; std::string format; ssize_t ndim; ...
Python调用C++函数（SWIG，VS2013使用numpy.i完成Numpy与C++数组转换）
ustczhang的博客
10-01 5078
最近尝试使用Python调用C++函数，发现网上都是一些简单的例子，涉及到Python Numpy数组与C++数组转换的例子比较少，所以花费了一些时间，搞懂了SWIG使用numpy.i接口文件完成Numpy与C++数组转换。相比于其它几种方式，使用SWIG接口文件编写比较简单，编译也很方便，主要是不太好调试，因为是编译成.dll或者.so才能在Python中调用。 1.安装SWIG window
pybind11：numpy 2D转c++的Eigen
原来也有北瓜
03-09 500
CMakeLists.txt文件 cmake_minimum_required(VERSION 2.8.12) project(shp) # Eigen include_directories("/usr/include/eigen3") add_subdirectory(pybind11) pybind11_add_module(shp shape_detection.cpp) cpp文件 #include <pybind11/pybind11.h> #include <pybin
pybind11使用教程笔记__5.2_python C++ interface__numpy
weixin_41521681的博客
05-25 3380
NumPy1. Buffer protocolSee also2. Arrays3. Structured types4. Vectorizing functionsNoteSee also5. Direct accessSee also6. Ellipsis 1. Buffer protocol python支持 非常通用和方便地与plugin libraries交换数据。types可以expose a buffer view [1], 提供 fast direct access to the raw i
pybind11实现numpy和OpenCV Mat的数据交互
mjlsuccess的专栏
01-08 1458
使用pybind11相比ctypes方法ctypes实现python和c之间的数据交互-CSDN博客，更加简单、易用。但ctypes的优势在于不用额外配置库，python内置了。
pybind11 | 绑定CGAL几何算法（numpy数据交换）
MSTIFIY的博客
12-30 1734
pybind11 | 绑定CGAL几何算法（numpy数据交换）
pybind11和numpy进行交互的方法
09-19
总结起来，Pybind11通过buffer protocol实现了与NumPy数组的高效交互，允许在C++扩展中直接访问和操作数组内存，同时也支持与其他C++库如Eigen的无缝结合，为Python提供了更强大的数值计算能力。在编写Python扩展...
类似c++数组的python包
最新发布
11-23
本专题将介绍如何使用Python来处理类似C++中数组的数据结构，尤其是二维数组和三维数组的创建和操作。 首先，我们需要了解Python中list的特性。List是Python的一种数据类型，是一种可变的序列类型。它可以包含任意...
Python快速转换numpy数组中Nan和Inf的方法实例说明
09-19
总结来说，当处理numpy数组时，如果需要处理`NaN`和`Inf`，可以利用numpy提供的`numpy.nan_to_num()`来转换特殊值，以及`numpy.isinf()`, `numpy.isnan()`, `numpy.isneginf()`, `numpy.isposinf()`, 和 `numpy.is...
python调用c++传递数组的实例
09-19
今天小编就为大家分享一篇python调用c++传递数组的实例，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
Python numpy实现二维数组和一维数组拼接的方法
01-20
撰写时间：2017.5.23 ...注意（3，）和（3,1）的数组是不一样的，前者是一维数组，后者是二维数组。 拼接 3.numpy有很多的拼接函数。比如hstack和vstack等。网上又很多这样的总结帖子。但是两个数组能拼接的
python 调用 c numpy 数组_快速转换C / C ++向量到Numpy数组
weixin_39864682的博客
12-21 342
I'm using SWIG to glue together some C++ code to Python (2.6), and part of that glue includes a piece of code that converts large fields of data (millions of values) from the C++ side to a Numpy array...
python笔记（一）【C++向python转移】
han_hhh的博客
09-03 1333
1、原始字符串：在字符串前边加一个r即可，这样就不会在使用print时将字符串中的反斜杠当成转义符 2、数据类型 type():打印数据类型 ininstance（a,type):判断a是否为type类型 3、python除法 单斜杠"/"除法商不一定是整数 双斜杠“//"除法商一定是整数 4、逻辑操作符 and or not ：与或非 ...
史上最全-小白教程-使用pybind11实现C++语言与python语言相互调用
baidu_30594023的博客
08-22 2944
3.1 在C++中写入测试代码，准备example.py测试文件，如图10所示。2.2 C++代码，运行后生成dll文件，供python调用，配置如图5所示。特别注意，如图11所示，箭头处的名称必须一致（函数名称和文件名称）。2.3 找到程序运行生成的目录中，找到生成的dll文件，并将其名称修改为。2.4 还有一个坑：如图8所示，3处名字必须一致，否则提示找不到。1.2 在VC++目录属性中，选择“包含目录”进行如下图1配置。1.3 在VC++目录属性中，选择“库目录”进行如下图2配置。
pybind11 C++ STL和python数据类型的转换
u012483097的博客
09-27 1696
https://pybind11.readthedocs.io/en/stable/advanced/cast/stl.html
c++调用python传array数据类型
zuoanhuahai的博客
05-26 464
vs2015调用python传array
python 调用dll中c或c++语言的带指针方法，
weixin_30379911的博客
11-15 611
在项目开发中遇到了，python需要去调用一个动态链接库dll中的c++方法。这个方法的参数为一个指针类型的参数,一个bool类型参数， 在python中并未对数字类型进行区分。 int LP_Agc ( double * a, bool b= true ) 所以在调用这个方法之前， 第一步要将python中的类型转换为c语言类型。 ...
c调用python第三方库_Python实例浅谈之三Python与C/C++相互调用
weixin_39636696的博客
11-21 580
#include #include#includeint fac(intn){if (n < 2) return(1); /*0! == 1! == 1*/return (n)*fac(n-1); /*n! == n*(n-1)!*/}char *reverse(char *s){registerchar t, /*tmp*/*p = s, ...
Python Numpy数组和类型全面介绍
资源摘要信息:"本资源是一系列关于Python编程语言中使用Numpy库的笔记。...- 03.04-array-数组类型.ipynb：介绍不同Numpy数组类型及其转换方法，展示了如何根据数据特点选择合适的数据类型，以提高性能和效率。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值