numpy-数组变换
数组变换
目录
数组变换
| 函数 | 描述 | |
|---|---|---|
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]
浙公网安备 33010602011771号