numpy-数组变换

数组变换

目录

• 数组变换
• 数组变换
  • 维度变换
  • 展成一维
  • ravel()和flatten()
  • 增加维度
  • np.expand_dims()
  • 删除维度
  • np.squeeze(arr)
• 翻转数组
• 拼接数组
  • concatenate()
• 数组分割
• 元素添加和删除

数组变换

	函数	描述
	array.shape=(2,3)	数组形状、修改数组
	array.reshape((2,3))	修改形状
展开	array.flatten(array)	展开数组，压缩为一维数组，会进行拷贝
展开	np.ravel(array)	展开数组，压缩为一维数组，不进行拷贝
降维	np.squeeze()	删除维度，只有数组长度在该维度上为1，该维度才可以被删除
扩展	np.newaxis	np.newaxis其实就是None的别名, 扩展维度
扩展	np.expand_dims()	扩展维度

维度变换

shape、reshape()

a1 = np.array([1, 2, 3, 4, 5, 6])
print(a1.shape)
a1.shape = (2, 3)
print(a1)

a2 = np.array([1, 2, 3, 4, 5, 6]).reshape((2, 3))
print(a2)
# ------------------------------------------
(6,)
[[1 2 3]
 [4 5 6]]
[[1 2 3]
 [4 5 6]]

reshape()  # 可以用来提升或者降低维度

arr1 = np.array([[1, 1], [2, 2]])
arr2=arr1.reshape((1,2,2))
arr3=np.reshape(arr2,(2,2))
print(arr2)
print(arr3)
# ------------------------------------------------
[[[1 1]
  [2 2]]]
[[1 1]
 [2 2]]

展成一维

ravel()和flatten()

arr1 = np.arange(20)
arr2 = arr1.reshape((4,5))
arr3 = arr2.ravel()
arr4 = arr2.flatten()
print(arr1)
print(arr2)
print(arr3)
print(arr4)
# -----------------------------------------------------------------
[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]]
[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]
[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]

ravel 和 flatten 区别

• 共同点： 都可将多维数组降为一维数组
• 区别：
  ①拷贝copy:强调的是数据–使用flatten返回的是一份拷贝，类似深拷贝
  ②视图view:侧重的是数据的展现，而不是数据的本身–使用ravel返回的是一份视图，类似浅拷贝

增加维度

np.newaxis

arr = np.array([[1, 2, 3], [2, 3, 4]])
arr = np.array([[1, 2, 3], [2, 3, 4]])
arr1=arr[None,:]
arr2=arr[:,:,None]
arr3=arr[np.newaxis,:]   #  np.newaxis 等价于 None
print(arr.shape)
print(arr1.shape)
print(arr2.shape)
print(arr3.shape)
# ------------------------------------------
(2, 3)
(1, 2, 3)
(2, 3, 1)
(1, 2, 3)

np.expand_dims()

arr = np.array([[1, 2, 3], [2, 3, 4]])

print(arr.shape)  # (2, 3)
(2, 3)

# 很好理解
print(np.expand_dims(arr, 0).shape)  # (1, 2, 3)
print(np.expand_dims(arr, 1).shape)  # (2, 1, 3)
print(np.expand_dims(arr, 2).shape)  # (2, 3, 1)

删除维度

np.squeeze(arr)

arr = np.array([[[1, 2, 3], [2, 3, 4]]])
# 只有数组长度在该维度上为1，那么该维度才可以被删除
arr1=np,squeeze(arr)
print(arr.shape)
print(arr1.shape) 
# (1,2,3)
# (2,3)

翻转数组

	函数	描述
	np.transpose(arr, axes)	对换数组的维度
	ndarray.T	和 self.transpose() 相同
	rollaxis(arr,axis,start)	向后滚动指定的轴
	swapaxes()	对换数组的两个轴

arr=np.arange(12).reshape((3,4))

print(arr)
arr1=arr.transpose(0,1)  # 相当于没有 维度变换
# arr 有三个维度，编号对应为(0,1,2)
print(arr1)
arr2=arr.transpose(1,0)
print(arr2)
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]

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

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

arr=np.arange(12).reshape((1,3,4))

print(arr)
arr1=arr.transpose(0,1,2)
print(arr1.shape)
arr2=arr.transpose(2,0,1)
print(arr2.shape)
# #-----------------------------------------------------------------
myMat=np.mat([[1,2,3],[4,5,6]])
print(myMat)
print(myMat.T)

# matrix([[1.,2.,3.]
#         [4.,5.,6.]])

# matrix([[1,4]，
#         [2,5],
#         [3,6]])

# #-----------------------------------------------------------------
arr=np.arange(16).reshape((2,2,4))
print(arr)
arr1=arr.swapaxes(1,2)  # 将1，2维度对换
print(arr1)
[[[ 0  1  2  3]
  [ 4  5  6  7]]
 [[ 8  9 10 11]
  [12 13 14 15]]]

[[[ 0  4]
  [ 1  5]
  [ 2  6]
  [ 3  7]]
 [[ 8 12]
  [ 9 13]
  [10 14]
  [11 15]]]

拼接数组

	函数	描述
	np.stack()	沿着新的轴加入一系列数组
	np.hstack(arr1,arr2)	水平堆叠序列中的数组（列方向）
	np.vstack(arr1,arr2)	竖直堆叠序列中的数组（行方向）
推荐	np.concatenate((arr1, arr2), axis=1)	连接沿现有轴的数组序列

hstack() vstack()

一维数组

arr1 = np.arange(1, 6, 2)  # [1 3 5]
arr2 = np.arange(7, 12, 2)  # [ 7  9 11]
arr3 = np.hstack((arr1, arr2))  # 横行拼接
arr4 = np.vstack((arr1, arr2))  # 纵向拼接
print(arr3)  
print(arr4)
# #-----------------------------------------------------------------
[ 1  3  5  7  9 11]
[[ 1  3  5]
 [ 7  9 11]]

二维数组

arr1 = np.array([[1, 2, 3], [4, 5, 6]])
arr2 = np.array([[7, 8, 9], [10, 11, 12]])
arr3 = np.hstack((arr1, arr2))  # 横行拼接
arr4 = np.vstack((arr1, arr2))  # 纵向拼接
print(arr3)  
print(arr4)
# #-----------------------------------------------------------------
[[ 1  2  3  7  8  9]
 [ 4  5  6 10 11 12]]
[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]

concatenate()

import numpy as np

arr1 = np.array([[1, 1], [2, 2]])
arr2 = np.array([[3, 3], [4, 4]])
print(arr1.shape)
print(arr2.shape)

print("="*30)
arr3=np.concatenate((arr1, arr2), axis=0)  # 和vstack效果相同
arr4=np.concatenate((arr1, arr2), axis=1) # 和hstack效果相同
print(arr3.shape)
print(arr3)
print("="*30)
print(arr4.shape)
print(arr4)

# #-----------------------------------------------------------------
(2, 2)
(2, 2)
==============================
(4, 2)
[[1 1]
 [2 2]
 [3 3]
 [4 4]]
==============================
(2, 4)
[[1 1 3 3]
 [2 2 4 4]]

数组分割

	函数	数组及操作
推荐	np.split(arr,indices_or_sections,axis)	将一个数组分割为多个子数组，指定维度 返回 [arr1,arr2..]
	np.array_split(arr,indic,axis)	和np.split 类似 不平均分割
	hsplit(arr,indices_or_sections)	将数组水平分割为多个子数组（按列）返回[arr1,arr2..]
	np.vsplit(arr,indices_or_sections)	将数组垂直分割为多个子数组（按行）返回[arr1,arr2..]

np.split(arr,indices_or_sections,axis)

• arr 需要切割的数组
• indices_or_sections 需要分割的份数
• axis 指定切割的维度

import numpy as np
x = np.arange(12).reshape((3,4))
xsp =np.split(x, 3)
xsp2 =np.split(x, 4,axis=1)
print(x)
print(xsp)
print(xsp2)
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]])]
[array([[0],[4],[8]]), 
 array([[1],[5],[9]]), 
 array([[ 2],[ 6],[10]]), 
 array([[ 3],[ 7],[11]])]

x = np.arange(8.0)
np.split(x, [3, 5, 6, 10])
[array([ 0.,  1.,  2.]), array([ 3.,  4.]), array([ 5.]), array([ 6.,  7.]), array([], dtype=float64)]

# #-----------------------------------------------------------------
#array_split
x = np.arange(8.0)
xspt =np.array_split(x, 3)   #  不平均分割
print(xspt)
[array([ 0.,  1.,  2.]), array([ 3.,  4.,  5.]), array([ 6.,  7.])]

# #-----------------------------------------------------------------
#hsplit
harr = np.floor(10 * np.random.random((2, 6)))
print(harr)
print(np.hsplit(harr, 3))   # 水平 方向分割
[[9. 1. 9. 1. 9. 2.]
 [0. 8. 7. 5. 9. 1.]]
[array([[9., 1.],[0., 8.]]), 
 array([[9., 1.],[7., 5.]]), 
 array([[9., 2.],[9., 1.]])]    

# #-----------------------------------------------------------------
#vsplit
harr = np.floor(10 * np.random.random((2, 6)))
print(harr)
print(np.vsplit(harr,2 ))   # 垂直 方向分割
[[9. 3. 8. 0. 1. 7.]
 [4. 9. 7. 0. 6. 4.]]
[array([[9., 3., 8., 0., 1., 7.]]), array([[4., 9., 7., 0., 6., 4.]])]

元素添加和删除

	函数	元素及描述
	resize(shape)	返回指定形状的新数组
推荐	np.append(arr, values, axis)	将值添加到数组末尾
	np.insert(arr, obj, values)	沿指定轴将值插入到指定下标之前
	np.delete(arr,obj)	删掉某个轴的子数组，并返回删除后的新数组
	np.unique(b,return_index=True)	查找数组内的唯一元素

• resize 和 reshape 区别
• resize会对原值进行修改并且返回是None，reshape不会对原值进行修改，返回是修改后结果

# resize会对原值进行修改并且返回是None，reshape不会对原值进行修改，返回是修改后结果
x=np.arange(12)
x_resize=x.resize(2,3,2)  
print(x)          # 原地修改
print(x_resize)   # 返回是 None

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

#-----------------------------------------------------------------
#append()    
#values 为数组，values 数组列维度与 arr 数组列维度相同
a = np.array(np.arange(12).reshape(3,4))
print(a)
np.append(a,[[1,1,1,1]],axis=0)
print(a)

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

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

#-----------------------------------------------------------------
#insert    
#values值可为单元素或values数组，并且 values 数组行维度与arr数组列维度相同

# 未提供 axis 值，在插入之前输入数组会被展开
arr = np.array([[1,2,3,4], [5,6,7,8]])
arr1=np.insert(arr,4,[9, 10,11,12])
print(arr1)
[ 1  2  3  4  9 10 11 12  5  6  7  8]

arr2=np.insert(arr, 2, [9], axis=0)   # 广播
print(arr2)
[[1 2 3 4]
 [5 6 7 8]
 [9 9 9 9]]

arr3=np.insert(arr, 2, [9,10,11,12], axis=0)
print(arr3)
[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]

#-----------------------------------------------------------------
#delete 返回从输入数组中删除指定子数组的新数组
#与 insert() 函数的情况一样，如果未提供轴参数，则输入数组将展开

arr = np.arange(16).reshape(4,4)
print(arr)

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]

print (np.delete(arr,[6,9,12]))   #删除arr数组中索引为6，9，12的元素
print(arr)
[ 0  1  2  3  4  5  7  8 10 11 13 14 15]

print(np.delete(arr, 2, axis=1))
[[ 0  1  3]
 [ 4  5  7]
 [ 8  9 11]
 [12 13 15]]

print(np.delete(arr, 1, axis=0))　　
[[ 0  1  2  3]
 [ 8  9 10 11]
 [12 13 14 15]]

print(np.delete(arr, np.s_[::2]))
[ 1  3  5  7  9 11 13 15]

#-----------------------------------------------------------------
A = [1, 2, 2, 5,3, 4, 3]
a = np.unique(A)
[1 2 3 4 5]

#  return_index=True 返回新列表元素在旧列表中的位置
a, s= np.unique(A, return_index=True) 
print(a)
print(s)
# [1 2 3 4 5]
# [0 1 4 5 3]