Numpy 数组修改形状/连接/分割/元素的添加与删除

修改数组形状

就是将一个已有数组按照要求改变其形状后新生成一个数组，新数组的所有元素都来自于原数组，并且元素数量也保持不变，变的只有形状。

reshape 不改变数据的条件下修改形状
flat 数组元素迭代器
flatten 返回一份数组拷贝，对拷贝所做的修改不会影响原始数组
ravel 返回展开数组

reshape(…) 返回一个给定shape的数组的副本，不共用同一个视图

np. reshape(a, newshape, order='C ’）

a 是原数组，
newshape 是接收用元组表达的新数组的形状

a = np.arange(10)
print(a)
b = a.reshape(2, 5)
print(b)
c = np.reshape(a, (2,5))
print(c)
输出：
[0 1 2 3 4 5 6 7 8 9]
[[0 1 2 3 4]
 [5 6 7 8 9]]
[[0 1 2 3 4]
 [5 6 7 8 9]]

numpy.ndarray.flat()

numpy.ndarray.flat 是一个数组元素迭代器


import numpy as np
 
a = np.arange(9).reshape(3,3) 
print ('原始数组：')
for row in a:
    print (row)
 
#对数组中每个元素都进行处理，可以使用flat属性，该属性是一个数组元素迭代器：
print ('迭代后的数组：')
for element in a.flat:
    print (element)

输出：

原始数组：
[0 1 2]
[3 4 5]
[6 7 8]
迭代后的数组：
0
1
2
3
4
5
6
7
8

flatten()/ravel() 将多维度的数组变成一个一维数组

flatten()将多维度的数组变成一个一维数组，相对原数组不在同一个视图
ravel() 将多维度的数组变成一个一维数组，和原数组公用一个视图

ndarray.flatten(order='C')
numpy.ravel(a, order='C')

order：'C' -- 按行，'F' -- 按列，'A' -- 原顺序，'K' -- 元素在内存中的出现顺序。

a = np.arange(10).reshape(2, 5)
print(a)
b = a.flatten()
print(b)
c = a.ravel()
print(c)
输出：
[[0 1 2 3 4]
 [5 6 7 8 9]]
[0 1 2 3 4 5 6 7 8 9]
[0 1 2 3 4 5 6 7 8 9]

组合与分割

水平组合/垂直组合/深度组合

numpy.hstack(tup) 水平(按列顺序)把数组给堆叠起来
numpy.vstack(tup) 垂直（按照行顺序）的把数组给堆叠起来
numpy.stack(arrays, axis=0) 将一堆数组的数据按照指定的维度进行堆叠
numpy.dstack((a, b)) 堆栈数组按顺序深入（沿第三维）深度组合
numpy.concatenate((a1, a2, ...), axis=0) 根据指定的维度，对一个元组、列表中的list或者ndarray进行连接，前面的几个函数其实都可以用concatenate()函数来进行等价操作

numpy.hstack（tup）

实现水平组合功能的函数形式是 numpy.hstack（其中参数 tup 是一个元组，包含即将被组合在一起的几个数组。下面的示例假设是二维数组，要求其 0 轴方向的形状一样，而1 轴方向的形状可以不同。

等价于np.concatenate（tup,axis=1）

a= np.arange(9).reshape(3,3)
b = np.arange(12).reshape(3, 4)
c = np.arange(15).reshape(3, 5)
print(a)
print(b)
print(c)
print('**************')
d = np.hstack((a, b))
print(d)
print('******************')
e = np.hstack((a, b, c))
print(e)
输出：
[[0 1 2]
 [3 4 5]
 [6 7 8]]
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]]
**************
[[ 0  1  2  0  1  2  3]
 [ 3  4  5  4  5  6  7]
 [ 6  7  8  8  9 10 11]]
******************
[[ 0  1  2  0  1  2  3  0  1  2  3  4]
 [ 3  4  5  4  5  6  7  5  6  7  8  9]
 [ 6  7  8  8  9 10 11 10 11 12 13 14]]

numpy.vstack(tup)

前面的水平组合是沿着 1 轴组合（对于二维数组而言如此，对于多维数组也是如此），那么这里的垂直组合，则是沿着与 1 轴垂直的方向）组合。

**等价于：np.concatenate(tup,axis=0) **

a= np.arange(9).reshape(3,3)
b = np.arange(12).reshape(4, 3)
c = np.arange(15).reshape(5, 3)
print(a)
print(b)
print(c)
print('**************')
d = np.vstack((a, b))
print(d)
print('******************')
e = np.vstack((a, b, c))
print(e)
输出：
[[0 1 2]
 [3 4 5]
 [6 7 8]]
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]
 [12 13 14]]
**************
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]
******************
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]
 [ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]
 [12 13 14]]

numpy.stack(arrays, axis=0)被组合的数组的要求形状相同

import numpy as np

a = np.arange(9).reshape(3, 3)
b = np.arange(12).reshape(3, 4)
c = np.arange(15) . reshape(3, 5)
m = a * 3

print(np.stack((a, m), axis=1))
输出：
[[[ 0  1  2]
  [ 0  3  6]]

 [[ 3  4  5]
  [ 9 12 15]]

 [[ 6  7  8]
  [18 21 24]]]

numpy.dstack((a, b)) 堆栈数组按顺序深入（沿第三维）深度组合

等价于：np.concatenate(tup,axis=2)

a = np.arange(9).reshape(3,3)
b = 3 * a
print(a)
print(b)

#深度组合
c = np.dstack((a, b))
print(c)
输出:
[[0 1 2]
 [3 4 5]
 [6 7 8]]
[[ 0  3  6]
 [ 9 12 15]
 [18 21 24]]
[[[ 0  0]
  [ 1  3]
  [ 2  6]]

 [[ 3  9]
  [ 4 12]
  [ 5 15]]

 [[ 6 18]
  [ 7 21]
  [ 8 24]]]

numpy.concatenate((a1, a2, ...), axis=0)

最全能的concatenate()函数，前面的几个函数其实都可以用concatenate()函数来进行等价操作

a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6]])
print(np.concatenate((a, b), axis=0))
print(np.concatenate((a, b.T), axis=1))
输出：
array([[1, 2],
       [3, 4],
       [5, 6]])

array([[1, 2, 5],
       [3, 4, 6]])

数组的分割

np.split()是一个比较通用的分割方法

其函数形式是:

np.split(ary， indices_or_ sections, axis=0）

a = np.arange(24).reshape(4 , 6)
print(a)

c = np.split(a, 2, axis=1)
print(c)
输出：
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]
[array([[ 0,  1,  2],
       [ 6,  7,  8],
       [12, 13, 14],
       [18, 19, 20]]), array([[ 3,  4,  5],
       [ 9, 10, 11],
       [15, 16, 17],
       [21, 22, 23]])]

元素的添加与删除

numpy.append(arr,values,axis=None) 在末尾添加元素
numpy.insert(arr,obj,value,axis=None) 在指定位置添加元素
numpy.delete(arr,obj,axis=None) 移除指定元素

np.append()函数用法

np.append(arr,values,axis=None)

将values插入到目标arr的最后。注意，这里values跟arr应该为相同维度的向量

axis是可选参数。如果不设置axis，则np.append()返回的结果返回将arr和values展平再进行拼接。

a = np.array([[1, 2, 3], [4, 5, 6]])
b = np.array([[7, 8, 9]])
print(a)
r = np.append(a, b)
print(r)
r = np.append(a, b, axis=0)
print(r)
输出：
[[1 2 3]
 [4 5 6]]
[1 2 3 4 5 6 7 8 9]
[[1 2 3]
 [4 5 6]
 [7 8 9]]

np.insert()函数用法

numpy.insert(arr,obj,value,axis=None)

arr:为目标向量
obj:为目标位置
value:为想要插入的数值
axis:为插入的维度

a = np.array(np.arange(12).reshape(3, 4))
    print(a) 
    print(np.insert(a, 1, [1, 1, 1, 1], 0))  #第一行添加数组[1 ,1 ,1 ,1]

	
输出：
[[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]]

[[0  1  2  3]
 [1  1  1  1]
 [4  5  6  7]
 [8  9 10 11]]

np.delete()

numpy.delete(arr,obj,axis=None)

按照axis和obj对arr进行元素删除的功能。如果没有设置axis,则对arr进行flatten之后再删除

arr:输入向量
obj:表明哪一个子向量应该被移除。可以为整数或一个int型的向量
axis:表明删除哪个轴的子向量，若默认，则返回一个被拉平的向量

a = np.array(np.arange(12).reshape(3, 4))
print(a) 
print(np.delete(a,1,0))  #删除第一行数据 
print(np.delete(a,1,1))  #删除第一列数据
print(np.delete(a,[0,1],1)) #删除0和1列数据 
    
输出：
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]

[[ 0  1  2  3]
 [ 8  9 10 11]]

[[ 0  2  3]
 [ 4  6  7]
 [ 8 10 11]]

[[ 2  3]
 [ 6  7]
 [10 11]]

来源：oschina

链接：https://my.oschina.net/u/3696975/blog/3207648

标签

numpy

Apache Axis

Numpy 数组 修改形状/连接/分割/元素的添加与删除