numpy的基本API（四）——拼接、拆分、添加、删除

numpy的基本拼接、拆分、添加、删除API

　　iwehdio的博客园：https://www.cnblogs.com/iwehdio/

1、np.concatenate((a, b), axis=0)　　np.concatenate方法沿现有的轴拼接一系列数组。输入数组(a、b、c)等要以元组形式输入，要求除了在所指定的拼接轴外形状一致。axis表示所指示的拼接轴，默认为0，为None时表示拼接前将所有输入数组展平。

>>> a = np.arange(8).reshape(4, 2)
>>> b = np.arange(12).reshape(4, 3)
>>> np.concatenate((a, b), axis=1)
array([[ 0,  1,  0,  1,  2],
       [ 2,  3,  3,  4,  5],
       [ 4,  5,  6,  7,  8],
       [ 6,  7,  9, 10, 11]])

2、np.stack((a, b), axis=0)　　np.stack方法按新轴进行拼接数组。输入数组要求为元组形式，并且必须具有完全相同的形状。。axis指定的是生成的新轴在shape中的索引。

>>> a = np.arange(8,20).reshape(4, 3)
>>> b = np.arange(12).reshape(4, 3)
>>> c = np.stack((a, b), axis=1)
>>> c
(4, 2, 3)
>>> c
array([[[ 8,  9, 10],
        [ 0,  1,  2]],
       [[11, 12, 13],
        [ 3,  4,  5]],
       [[14, 15, 16],
        [ 6,  7,  8]],
       [[17, 18, 19],
        [ 9, 10, 11]]])

3、np.column_stack((a, b))　　np.column_stack方法将输入数组作为列堆叠成二维数组，输入为元组形式，不一定必须为一维数组，但是必须形状相同。

>>> a = np.arange(8,11)
>>> b = np.arange(3)
>>> np.column_stack((a, b))
array([[ 8,  0],
       [ 9,  1],
       [10,  2]])

>>> a = np.arange(8,12).reshape(2, 2)
>>> b = np.arange(4).reshape(2, 2)
>>> np.column_stack((a, b))
array([[ 8,  9,  0,  1],
       [10, 11,  2,  3]]

4、np.dstack((a, b))　　np.dstack方法沿深度方向（第三轴，索引为2）按顺序拼接数组。输入数组同样要求为元组形式，且形状只在第三轴上不同。如果输入为形状为(M,N)的二维数组则等效为(M,N,1)，如果输入为形状为(N,)的一维数组，则等效为(1,N,1)。

>>> a = np.arange(3).reshape(3)
>>> b = np.arange(3,6).reshape(1,3)
>>> c = np.dstack((a, b))
>>> c
array([[[0, 3],
        [1, 4],
        [2, 5]]])
>>> c.shape
(1, 3, 2)

5、np.hstack((a, b))　　np.hstack方法沿列方向（第二轴，索引为1）按顺序拼接数组。输入数组同样要求为元组形式，且形状只在第二轴上不同。但是如果输入为形状为(N,)的一维数组，则在第一轴（索引为0）上将数组展平后拼接，生成形状为(n*N,)的一维数组。可以用来拼接列。

>>> a = np.arange(3).reshape(3)
>>> b = np.arange(3,6).reshape(3)
>>> np.hstack((a, b)).shape
(6,)

>>> a = np.arange(3).reshape(3,1)
>>> b = np.arange(3,6).reshape(3,1)
>>> np.hstack((a, b)).shape
(3, 2)

6、np.vstack((a ,b))　　np.vstack方法沿列方向（第一轴，索引为0）按顺序拼接数组。输入数组同样要求为元组形式，且形状只在第一轴上不同。但是如果输入为形状为(N,)的一维数组，则在第一轴（索引为0）上拼接，生成形状为(n,N)的二维数组。可以用来拼接行。

>>> a = np.arange(3).reshape(3,1)
>>> b = np.arange(3,6).reshape(3,1)
>>> np.vstack((a, b)).shape
(6, 1)

>>> a = np.arange(3).reshape(3)
>>> b = np.arange(3,6).reshape(3)
>>> np.vstack((a, b)).shape
(2, 3)

7、np.block([ a, b ])　　np.block方法将数组作为块输入，从块的嵌套列表中拼接一个数组。从输入的块的最后一个维度向前拼接，直到到达最外边的列表。可以用来创建块矩阵，也可以实现vstack和hstack的功能。如输入为[ a, b ]时相当于hstack((a,b))，输入为[[a],[b]]时相当于vstack((a,b))。

>>> A = np.eye(2) * 2
>>> B = np.eye(3) * 3
>>> np.block([
        [A,               np.zeros((2, 3))],
        [np.ones((3, 2)), B               ]])
array([[2., 0., 0., 0., 0.],
       [0., 2., 0., 0., 0.],
       [1., 1., 3., 0., 0.],
       [1., 1., 0., 3., 0.],
       [1., 1., 0., 0., 3.]])

>>> a = np.array([1, 2, 3])
>>> b = np.array([2, 3, 4])
>>> np.block([a, b])　　# hstack
array([ 1,  2,  3,  2,  3,  4])

>>> np.block([[a], [b]])　　# vstack
array([[1, 2, 3],
       [2, 3, 4]])

8、np.r_[ ]　　np.r_方法可以自定义的完成以上所有拼接功能，具体可见numpy的基本API（三）。

9、np.split(x, a， axis=0)　　np.split方法可以将输入数组x进行拆分。如果a是一个整数且可整除数组长度，则将x拆分为a个数组，如果a是列表，则按列表中索引的位置进行拆分，超出值返回空列表。axis表示所要拆分的轴，默认为0。返回值为列表形式。

>>> x = np.arange(15)
>>> np.split(x,3)
[array([0, 1, 2, 3, 4]), array([5, 6, 7, 8, 9]), array([10, 11, 12, 13, 14])]

>>> np.split(x, [0, 2, 5, 8, 13, 16])
[array([], dtype=int32),
 array([0, 1]),
 array([2, 3, 4]),
 array([5, 6, 7]),
 array([ 8,  9, 10, 11, 12]),
 array([13, 14]),
 array([], dtype=int32)]

>>> x = x.reshape(3,5)
>>> np.split(x,[0,1,2],axis=1)
[array([], shape=(3, 0), dtype=int32), 
 array([[ 0],
        [ 5],
        [10]]), 
 array([[ 1],
        [ 6],
        [11]]), 
 array([[ 2,  3,  4],
        [ 7,  8,  9],
        [12, 13, 14]])]

10、np.dsplit(x,a)　　np.dsplit方法相当于np.split方法中axis=2。

11、np.hsplit(x,a)　　np.hsplit方法相当于np.split方法中axis=1。

12、np.vsplit(x,a)　　np.vsplit方法相当于np.split方法中axis=0。

　　以上三个方法是和np.dstack、 np.hstack、 np.vstack相对应的。

13、np.repeat(x, a)　　np.repeat方法重复输入数组x，重复次数为a，a可以为形状与x对应的数组。

>>> np.repeat(3, 4)
array([3, 3, 3, 3])
>>> x = np.array([[1,2],[3,4]])
>>> np.repeat(x, 2)
array([1, 1, 2, 2, 3, 3, 4, 4])
>>> np.repeat(x, 3, axis=1)
array([[1, 1, 1, 2, 2, 2],
       [3, 3, 3, 4, 4, 4]])
>>> np.repeat(x, [1, 2], axis=0)
array([[1, 2],
       [3, 4],
       [3, 4]])

14、np.delet(x, a, axis=None)　　np.delet方法对输入数组x进行删除操作，a为删除的数组的索引，可以为列表，axis表示索引的轴，默认为展平数组。

>>> arr = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])
>>> arr
array([[ 1,  2,  3,  4],
       [ 5,  6,  7,  8],
       [ 9, 10, 11, 12]])
>>> np.delete(arr, [0,1], 0)
array([[ 9, 10, 11, 12]])

15、np.insert(a, index, value, axis=None)　　np.insert方法在数组的指定位置插入数据。a为输入的原数组，index为插入的索引，可以为元组、列表和slice()索引。value为所要插入的数据，形状应与指定的轴对应，为数字时代表全部填充这个数。axis为选定的轴，默认为展平数组。需要注意的是index为多个时，numpy会按索引值从大到小插入数据，而且每次插入的数组都是完成上一个数据插入后返回的新数组。

>>> a = np.array([[1, 1], [2, 2], [3, 3]])
>>> a
array([[1, 1],
       [2, 2],
       [3, 3]]
>>> np.insert(a, 1, 5, axis=1)
array([[1, 5, 1],
       [2, 5, 2],
       [3, 5, 3]])

>>> np.insert(a, [1], [[1],[2],[3]], axis=1)
array([[1, 1, 1],
       [2, 2, 2],
       [3, 3, 3]])

>>> b = a.flatten()
>>> np.insert(b, [2, 1, 0], [5, 3, 4])
array([4, 1, 3, 1, 5, 2, 2, 3, 3])

16、np.append(a, b, axis=None)　　np.append方法将值b拼接到数组a的末端，axis表示拼接的轴，默认为展平。

>>> np.append([[1, 2, 3], [4, 5, 6]], [[7, 8, 9]], axis=0)
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])

17、np.resize(a, shape)　　resize方法改变输入数组a的形状。与reshape不同的是，resize直接更改了输入a的shape，而reshape是将更改后的数组作为返回值，数组a的shape没有改变。

18、np.trim_zeros(a, trim=''fb)　　np.trim_zeros删除一维数组中头部或尾部的0。a为输入数组，trim为‘fb’表示删除头尾的0，为‘f'表示删除头部的0，为‘b'表示删除尾部的0。

>>> a = np.array((0, 0, 0, 1, 2, 3, 0, 2, 1, 0))
>>> np.trim_zeros(a)
array([1, 2, 3, 0, 2, 1])

19、np.unique(a, return_index=False, return_inverse=False, return_counts=False, axis=None)　　np.unique方法用于查找数组中的唯一元素，返回排序好的数组中的元素，可以理解为数组a转换为集合。a为输入数组，axis为查找的最小元组，默认为展平即数字元素，如取0则查找唯一列。return_index表示返回数组a的唯一值的索引，数组中有多个相同值则返回最小的索引；return_inverse表示按数组a中的顺序，返回数组a中唯一值的索引，可以用于数组重建。return_counts表示返回数组a唯一值在原数组中出现的的个数。

可以同时使用多个return，但是无论输入顺序如何，输出顺序都是按 [唯一值、index、inverse、counts] 排列。

>>> a = np.array([[1, 0, 0], [1, 0, 0], [2, 3, 4]])
>>> np.unique(a, axis=0)
array([[1, 0, 0], [2, 3, 4]])

>>> a = np.array(['a', 'b', 'b', 'c', 'a'])
>>> u, indices = np.unique(a, return_index=True)
>>> u
array(['a', 'b', 'c'])
>>> indices
array([0, 1, 3])
>>> a[indices]
array(['a', 'b', 'c'])

>>> a = np.array([1, 2, 6, 4, 2, 3, 2])
>>> u, indices = np.unique(a, return_inverse=True)
>>> u
array([1, 2, 3, 4, 6])
>>> indices
array([0, 1, 4, 3, 1, 2, 1])
>>> u[indices]
array([1, 2, 6, 4, 2, 3, 2])

>>> u, indices = np.unique(a, return_counts=True)
>>> u
array([1, 3, 1, 1, 1])

>>> u,i,o = np.unique(a,return_counts=True,return_index=True, )
>>> u,i,o
(array([1, 2, 3, 4, 6]),
 array([0, 1, 5, 3, 2]),
 array([1, 3, 1, 1, 1])

参考：numpy中文文档：https://www.numpy.org.cn/reference/

　　　numpy英文文档：https://numpy.org/doc/1.17/reference/index.html

iwehdio的博客园：https://www.cnblogs.com/iwehdio/