Numpy学习笔记——数组形状

数组堆叠的stack可能是我无法理解的痛……

改变数组形状

需要注意ndarry.T 转置，ndarray.reshape()数组相同更改尺寸，ndarray.resize()都是生成新的数组开辟新的内存区域，而非直接更改原有数组，而ndarray.shape是更改原有数组。

ar1=np.arange(9)
ar2=np.zeros((2,5),dtype=np.int)
print(ar1)
print(ar2)
print('\n-------')

#T 转置 一位数组转置结果不变
print(ar1.T)
print(ar2.T)
print('\n-------')

#reshape只能变成元素数相同的不同尺寸矩阵
print(ar1.reshape(3,3))#已有数组改变形状
print(np.arange(8).reshape(2,4))#生成数组同时改变形状
print(np.reshape(np.arange(8),(2,4)))
print('\n-------')

#resize 在元素不够时会进行排序来生成新矩阵
print(np.resize(ar1,(3,3)))
print(np.resize(ar1,(3,4)))

#shape也可以用来修改数组
ar=np.arange(30)
ar.shape=2,-1,3#-1表示按照其他维数确定该项
print(ar.shape)
print(ar)
ar.shape=-1,5,6
print(ar.shape)
print(ar)
'''

[0 1 2 3 4 5 6 7 8]
[[0 0 0 0 0]
 [0 0 0 0 0]]

-------
[0 1 2 3 4 5 6 7 8]
[[0 0]
 [0 0]
 [0 0]
 [0 0]
 [0 0]]

-------
[[0 1 2]
 [3 4 5]
 [6 7 8]]
[[0 1 2 3]
 [4 5 6 7]]
[[0 1 2 3]
 [4 5 6 7]]

-------
[[0 1 2]
 [3 4 5]
 [6 7 8]]
[[0 1 2 3]
 [4 5 6 7]
 [8 0 1 2]]
(2, 5, 3)
[[[ 0  1  2]
  [ 3  4  5]
  [ 6  7  8]
  [ 9 10 11]
  [12 13 14]]

 [[15 16 17]
  [18 19 20]
  [21 22 23]
  [24 25 26]
  [27 28 29]]]
(1, 5, 6)
[[[ 0  1  2  3  4  5]
  [ 6  7  8  9 10 11]
  [12 13 14 15 16 17]
  [18 19 20 21 22 23]
  [24 25 26 27 28 29]]]
'''

数组复制copy

# 数组的复制
ar1 = np.arange(10)
ar2 = ar1
print(ar2 is ar1)
ar1[2] = 9
print(ar1,ar2)
# ar1和ar2指向同一个值，所以ar1改变，ar2一起改变

ar3 = ar1.copy()
print(ar3 is ar1)
ar1[0] = 9
print(ar1,ar3)
# copy方法生成新数组及其数据的完整拷贝
#copy方法常与切片一起使用，删除原数组后新数组仍被保留
ar4=ar1[:5].copy()
del ar1
print(ar4)
'''
True
[0 1 9 3 4 5 6 7 8 9] [0 1 9 3 4 5 6 7 8 9]
False
[9 1 9 3 4 5 6 7 8 9] [0 1 9 3 4 5 6 7 8 9]
[9 1 9 3 4]
'''

数据类型转换 ndarray.astype

ar1=np.arange(3,dtype=float)
ar2=ar1.astype(np.int32)
print(ar1,ar1.dtype)
print(ar2,ar2.dtype)
'''
[0. 1. 2.] float64
[0 1 2] int32
'''

数组堆叠

np.hstack vstack

np.hstack(tup)水平方向堆叠，一维数组和二维数组而言增加数组的列宽，三维数组增加的是第二维数。进行堆叠的两个数组除第二维数，其他维数应相同。如shape(2,3)的数组可以与形状为(2,5)的数组堆叠，但不能与(3,3)堆叠。

##hstack 除第二维数其他维数应相同  叠加第二维数
#一维数组
ar1=np.array([1,2])
ar2=np.array(list('abc'))
print(ar1)
print(ar2)
ar=np.hstack((ar1,ar2))
print(ar,ar.shape)
print('\n------')
# 二维数组
ar1=np.arange(2).reshape(2,1)
ar2=np.random.randint(1,10,size=(2,3))
print(ar1)
print(ar2)
ar=np.hstack((ar1,ar2))
print(ar,ar.shape)
print('\n------')
# 三维数组
a=np.arange(12).reshape((2,2,3))
b=np.random.randint(1,10,size=(2,4,3))
print(a)
print(b)
x=np.hstack((a,b))
print(x)
print(x.shape)
'''

[1 2]
['a' 'b' 'c']
['1' '2' 'a' 'b' 'c'] (5,)

------
[[0]
 [1]]
[[1 3 2]
 [1 8 1]]
[[0 1 3 2]
 [1 1 8 1]] (2, 4)

------
[[[ 0  1  2]
  [ 3  4  5]]

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

 [[6 1 1]
  [4 1 5]
  [9 6 8]
  [3 6 6]]]
[[[ 0  1  2]
  [ 3  4  5]
  [ 3  9  1]
  [ 5  6  4]
  [ 5  9  8]
  [ 8  3  6]]

 [[ 6  7  8]
  [ 9 10 11]
  [ 6  1  1]
  [ 4  1  5]
  [ 9  6  8]
  [ 3  6  6]]]
(2, 6, 3)
'''

np.vstack(tup)垂直方向堆叠，对一维数组和二维数组堆叠增加数组的行宽，对三维数组增加第一维数。堆叠的两个数组除第一维数维数均应相同，即二维数组列应相同。

#vstack 除第一维数其他维数应相同  叠加第一维数
#一维数组
ar1=np.array([[1,2,3],[4,5,6]])
ar2=np.array(list('abc'))
print(ar1)
print(ar2)
ar=np.vstack((ar1,ar2))
print(ar,ar.shape)
print('\n------')
# 二维数组
ar1=np.arange(3).reshape(1,3)
ar2=np.random.randint(1,10,size=(2,3))
print(ar1)
print(ar2)
ar=np.vstack((ar1,ar2))
print(ar,ar.shape)
print('\n------')
# 三维数组
a=np.arange(8).reshape((2,2,2))
b=np.random.randint(1,10,size=(1,2,2))
print(a,a.shape)
print(b,b.shape)
x=np.vstack((a,b))
print(x)
print(x.shape)
'''

[[1 2 3]
 [4 5 6]]
['a' 'b' 'c']
[['1' '2' '3']
 ['4' '5' '6']
 ['a' 'b' 'c']] (3, 3)

------
[[0 1 2]]
[[5 1 5]
 [4 9 4]]
[[0 1 2]
 [5 1 5]
 [4 9 4]] (3, 3)

------
[[[0 1]
  [2 3]]

 [[4 5]
  [6 7]]] (2, 2, 2)
[[[6 9]
  [9 1]]] (1, 2, 2)
[[[0 1]
  [2 3]]

 [[4 5]
  [6 7]]

 [[6 9]
  [9 1]]]
(3, 2, 2)
'''

stack

这个我看了好多还是懵，大概理解为根据axis参数，在不同的轴上进行堆叠。
np.stack(arrays, axis=0, out=None)

• 两个数组必须相同shape
• if axis=0 it will be the first dimension and if axis=-1 it will be the last dimension.
• If provided, the destination to place the result

#jupyter函数说明中的例子，axis对shape的影响
>>> arrays = [np.random.randn(3, 4) for _ in range(10)]
>>> np.stack(arrays, axis=0).shape
(10, 3, 4)
>>> np.stack(arrays, axis=1).shape
(3, 10, 4)
>>> np.stack(arrays, axis=2).shape
(3, 4, 10)
#对一维数组使用stack
#stack一维数组
a = np.array([1, 2, 3])
b = np.array(['a', 'b', 'c'])
print(a)
print(b)

s0=np.stack((a,b))#默认0axis=0纵向 
s1=np.stack((a,b),axis=1)
#axis0 直接纵向堆在一起，增加行的维数
print('stack axis=0:size %s  shape %s'%(s0.size,s0.shape))
print(s0)
# axis1 横着切开 竖着堆叠，相当于都转置后增加列的维数
print('stack axis=1:size %s  shape %s'%(s1.size,s1.shape))
print(s1)
'''
[1 2 3]
['a' 'b' 'c']
stack axis=0:size 6  shape (2, 3)
[['1' '2' '3']
 ['a' 'b' 'c']]
stack axis=1:size 6  shape (3, 2)
[['1' 'a']
 ['2' 'b']
 ['3' 'c']]
'''

数组拆分

np.hsplit(ary, indices_or_sections)

• 水平拆分（按行）返回list，在第一维数上拆分，第二参数必须是能均等拆分的值。
• 可以根据索引返回list，标号从0开始。
  np.vsplit(ary, indices_or_sections)
• 竖直拆分（按列）返回list，第二维数上拆分，必须能等分
• 可以通过索引返回list

# 数组拆分
ar=np.random.randint(1,10,size=(4,4))
print(ar)
print('水平（按列）拆分hsplit')
hs=np.hsplit(ar,2)
print(hs,type(hs))#返回list
print('水平拆分hsplit取第一个拆分值')
print(np.hsplit(ar,2)[0])#横向拆分
print('垂直（按行）拆分vsplit')
print(np.vsplit(ar,2))#纵向拆分
'''
[[9 2 7 1]
 [3 8 6 9]
 [6 5 5 4]
 [7 9 8 7]]
水平（按列）拆分hsplit
[array([[9, 2],
       [3, 8],
       [6, 5],
       [7, 9]]), array([[7, 1],
       [6, 9],
       [5, 4],
       [8, 7]])] <class 'list'>
水平拆分hsplit取第一个拆分值
[[9 2]
 [3 8]
 [6 5]
 [7 9]]
垂直（按行）拆分vsplit
[array([[9, 2, 7, 1],
       [3, 8, 6, 9]]), array([[6, 5, 5, 4],
       [7, 9, 8, 7]])]
'''