本文的目的是介绍M乘N形状的滑动窗口numpy.ndarray的详细情况，我们将通过专业的研究、有关数据的分析等多种方式，同时也不会遗漏关于NDArray与numpy.ndarray互相转换方式、Nu

本文的目的是介绍M乘N形状的滑动窗口numpy.ndarray的详细情况，我们将通过专业的研究、有关数据的分析等多种方式，同时也不会遗漏关于NDArray 与 numpy.ndarray 互相转换方式、NumPy - Ndarray 对象、NumPy Ndarray 对象、Numpy ndarray 形状参数的知识。

• M乘N形状的滑动窗口numpy.ndarray
• NDArray 与 numpy.ndarray 互相转换方式
• NumPy - Ndarray 对象
• NumPy Ndarray 对象
• Numpy ndarray 形状参数

M乘N形状的滑动窗口numpy.ndarray

我有一个形状为（6,2）的numpy数组

[[00,01], [10,11], [20,21], [30,31], [40,41], [50,51]]

我需要一个步长为1且窗口大小为3的滑动窗口，如下所示：

[[00,01,10,11,20,21], [10,11,20,21,30,31], [20,21,30,31,40,41], [30,31,40,41,50,51]]

我正在寻找一种解决方案。如果您的解决方案可以参数化原始数组的形状以及窗口大小和步长大小，那就太好了。

答案1

In [1]: import numpy as np

In [2]: a = np.array([[00,01], [10,11], [20,21], [30,31], [40,41], [50,51]])In [3]: w = np.hstack((a[:-2],a[1:-1],a[2:]))In [4]: wOut[4]: array([[ 0,  1, 10, 11, 20, 21],       [10, 11, 20, 21, 30, 31],       [20, 21, 30, 31, 40, 41],       [30, 31, 40, 41, 50, 51]])

您可以这样写：

def window_stack(a, stepsize=1, width=3):    n = a.shape[0]    return np.hstack( a[i:1+n+i-width:stepsize] for i in range(0,width) )

只要，这实际上并不取决于原始数组的形状a.ndim =2。请注意，在交互式版本中，我从不使用任何长度。形状的第二维无关紧要；每行可以根据需要设置。感谢@Jaime的建议，您完全不需要检查形状就可以做到：

def window_stack(a, stepsize=1, width=3):    return np.hstack( a[i:1+i-width or None:stepsize] for i in range(0,width) )

NDArray 与 numpy.ndarray 互相转换方式

NDArray与numpy.ndarray互相转换

import numpy as np
from mxnet import nd
# numpy.ndarray 变 mx.NDArray
np_val = np.array([1, 2, 3])   # 定义一个numpy.ndarray
nd_val = nd.array(np_val)   # 深复制 
# NDArray 变 numpy.ndarray
np_val_ = nd_val.asnumpy()

NumPy与ndarray简介

NumPy简介

NumPy的全名为Numeric Python，是一个开源的Python科学计算库，它包括：

• 一个强大的N维数组对象ndrray；
• 比较成熟的（广播）函数库；
• 用于整合C/C++和Fortran代码的工具包；
• 实用的线性代数、傅里叶变换和随机数生成函数

NumPy的优点：

• 对于同样的数值计算任务，使用NumPy要比直接编写Python代码便捷得多；
• NumPy中的数组的存储效率和输入输出性能均远远优于Python中等价的基本数据结构，且其能够提升的性能是与数组中的元素成比例的；
• NumPy的大部分代码都是用C语言写的，其底层算法在设计时就有着优异的性能，这使得NumPy比纯Python代码高效得多

当然，NumPy也有其不足之处，由于NumPy使用内存映射文件以达到最优的数据读写性能，而内存的大小限制了其对TB级大文件的处理；此外，NumPy数组的通用性不及Python提供的list容器。因此，在科学计算之外的领域，NumPy的优势也就不那么明显。

数组ndarray

NumPy最重要的一个特点就是其N维数组对象（即ndarray）,该对象是一个快速而灵活的大数据集容器，该对象由两部分组成：

• 实际的数据；
• 描述这些数据的元数据；

大部分的数组操作仅仅是修改元数据部分，而不改变其底层的实际数据。数组的维数称为秩，简单来说就是如果你需要获取数组中一个特定元素所需的坐标数，如a是一个2×3×4的矩阵，你索引其中的一个元素必须给定三个坐标a[x,y,z]，故它的维数就是3。而轴可以理解为一种对数组空间的分割，以数组a为例，如果我们以0为轴，那么a可以看成是一个由两个元素构成的数组，其中每个元素都是一个3×4的数组。

我们可以直接将数组看作一种新的数据类型，就像list、tuple、dict一样，但数组中所有元素的类型必须是一致的，Python支持的数据类型有整型、浮点型以及复数型，但这些类型不足以满足科学计算的需求，因此NumPy中添加了许多其他的数据类型，如bool、inti、int64、float32、complex64等。同时，它也有许多其特有的属性和方法。

常用ndarray属性：

dtype 描述数组元素的类型

shape 以tuple表示的数组形状

ndim 数组的维度

size 数组中元素的个数

itemsize 数组中的元素在内存所占字节数

T 数组的转置

flat 返回一个数组的迭代器，对flat赋值将导致整个数组的元素被覆盖

real/imag 给出复数数组的实部/虚部

nbytes 数组占用的存储空间

常用ndarray方法：

以上为个人经验，希望能给大家一个参考，也希望大家多多支持。

NumPy - Ndarray 对象

NumPy 中定义的最重要的对象是称为 ndarray 的 N 维数组类型。 它描述相同类型的元素集合。 可以使用基于零的索引访问集合中的项目。ndarray中的每个元素在内存中使用相同大小的块。 ndarray中的每个元素是数据类型对象的对象(称为 dtype)。

从ndarray对象提取的任何元素(通过切片)由一个数组标量类型的 Python 对象表示。 下图显示了ndarray，数据类型对象(dtype)和数组标量类型之间的关系。

　基本的ndarray是使用 NumPy 中的数组函数创建的，如下所示：

　numpy.array

　它从任何暴露数组接口的对象，或从返回数组的任何方法创建一个ndarray。

1 numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)

View Code

　　参数：

　　　　object 任何暴露数组接口方法的对象都会返回一个数组或任何(嵌套)序列。

　　　　dtype 数组的所需数据类型，可选。

　　　　copy 可选，默认为true，对象是否被复制。

　　　　order C(按行)、F(按列)或A(任意，默认)。

　　　　subok 默认情况下，返回的数组被强制为基类数组。 如果为true，则返回子类。

　　　　ndimin 指定返回数组的最小维数。

 示例：

NumPy Ndarray 对象

NumPy 最重要的一个特点是其 N 维数组对象 ndarray，它是一系列同类型数据的集合，以 0 下标为开始进行集合中元素的索引。
ndarray 对象是用于存放同类型元素的多维数组。
ndarray 中的每个元素在内存中都有相同存储大小的区域。
ndarray 内部由以下内容组成：
一个指向数据（内存或内存映射文件中的一块数据）的指针。
数据类型或 dtype，描述在数组中的固定大小值的格子。
一个表示数组形状（shape）的元组，表示各维度大小的元组。
一个跨度元组（stride），其中的整数指的是为了前进到当前维度下一个元素需要"跨过"的字节数。
跨度可以是负数，这样会使数组在内存中后向移动，切片中 obj[::-1] 或 obj[:,::-1] 就是如此。
创建一个 ndarray 只需调用 NumPy 的 array 函数即可：
numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
参数说明：
object      数组或嵌套的数列
dtype       数组元素的数据类型，可选
copy        对象是否需要复制，可选
order       创建数组的样式，C为行方向，F为列方向，A为任意方向（默认）
subok      默认返回一个与基类类型一致的数组
ndmin      指定生成数组的最小维度
实例 1

import numpy as np
a = np.array([1,2,3])  
print (a)
[python@master test]$ python3 a.py
[1 2 3]

实例2

# 多于一个维度  
import numpy as np
a = np.array([[1,2],  [3,4]])  
print (a)
[python@master test]$ python3 b.py
[[1 2]
 [3 4]]

实例3

# 最小维度  
import numpy as np
a = np.array([1,2,3,4,5], ndmin = 2)  
print (a)
[python@master test]$ python3 c.py
[[1 2 3 4 5]]

实例4

# dtype 参数  
import numpy as np
a = np.array([1,2,3], dtype = complex)  
print (a)
[python@master test]$ python3 d.py
[1.+0.j 2.+0.j 3.+0.j]

实例5

>>> import numpy as np
>>> c = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
>>> c
array([[ 1,  2,  3,  4],
       [ 5,  6,  7,  8],
       [ 9, 10, 11, 12]])
>>> c.shape
(3, 4)              #两个数字表示二维数组，第0轴长度为3，第1轴长度为4
>>> c.shape = 4,3   #将数组改为4行3列
>>> c               #注意不是对数组转置，只是改变每个轴的大小，数组元素在内存中的位置并没有改变
array([[ 1,  2,  3],
       [ 4,  5,  6],
       [ 7,  8,  9],
       [10, 11, 12]])
>>> c.shape
(4, 3)
>>> c.shape = 2,-1  #第二个参数设置为-1系统会自动计算第二个参数
>>> c
array([[ 1,  2,  3,  4,  5,  6],
       [ 7,  8,  9, 10, 11, 12]])

以上介绍的数组创建的方法都是先创建序列，在使用array()函数转化为数组，下面介绍使用专门的函数创建数组：

1.arange(开始值, 终值, 步长)：类似Python的range()，注意不包括终值：

>>> np.arange(0, 1, 0.1)
array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9])

2. linspace(开始值, 终值, 元素个数): 默认包括终值，可以使用endpoint设置是否包括终值

>>> np.linspace(0, 1, 8)
array([0.        , 0.14285714, 0.28571429, 0.42857143, 0.57142857,
       0.71428571, 0.85714286, 1.        ])

3. logspace(开始值, 终值, 元素个数): 创建等比数列，下面的例子产生1(10^0)到100(10^2)、有10个元素的等比数列:

>>> np.logspace(0, 2, 10)
array([  1.        ,   1.66810054,   2.7825594 ,   4.64158883,
         7.74263683,  12.91549665,  21.5443469 ,  35.93813664,
        59.94842503, 100.        ])

4.fromstring(字符串, dtype=?)：从字节创建数组

>>> s = "mytestfromstring"
>>> np.fromstring(s, dtype=np.int8)
__main__:1: DeprecationWarning: The binary mode of fromstring is deprecated, as it behaves surprisingly on unicode inputs. Use frombuffer instead
array([109, 121, 116, 101, 115, 116, 102, 114, 111, 109, 115, 116, 114,
       105, 110, 103], dtype=int8)

5.fromfunction(计算每个数组元素的函数, 数组大小即shape)

>>> def func1(i):
...  return i%4+1
... 
>>> np.fromfunction(func1, (10,))   #第二个参数必须是一个序列，本例中用(10,)创建一个10元素的一维数组
array([1., 2., 3., 4., 1., 2., 3., 4., 1., 2.]) 
#创建一个二维数组表示九九乘法表
>>> def func2(i, j):
...  return (i+1) * (j+1)
... 
>>> np.fromfunction(func2, (9, 9))
array([[ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.],
       [ 2.,  4.,  6.,  8., 10., 12., 14., 16., 18.],
       [ 3.,  6.,  9., 12., 15., 18., 21., 24., 27.],
       [ 4.,  8., 12., 16., 20., 24., 28., 32., 36.],
       [ 5., 10., 15., 20., 25., 30., 35., 40., 45.],
       [ 6., 12., 18., 24., 30., 36., 42., 48., 54.],
       [ 7., 14., 21., 28., 35., 42., 49., 56., 63.],
       [ 8., 16., 24., 32., 40., 48., 56., 64., 72.],
       [ 9., 18., 27., 36., 45., 54., 63., 72., 81.]])

ndarray 对象由计算机内存的连续一维部分组成，并结合索引模式，将每个元素映射到内存块中的一个位置。内存块以行顺序(C样式)或列顺序(FORTRAN或MatLab风格，即前述的F样式)来保存元素。

Numpy ndarray 形状参数

import numpy as np

zone = np.array([[[221,529]],[[156,850]],[[374,858]],[[452,537]]])

print(zone.shape)