https://www.runoob.com/numpy/numpy-indexing-and-slicing.html
https://blog.csdn.net/weixin_44385465/article/details/115050077
ndarray对象属性获取ndarray 内部结构
import numpy as np # 秩 np.ndim # 即轴的数量或维度的数量 #形状 np.shape # 数组的维度，对于矩阵，n 行 m 列 #大小 np.size # 数组元素的总个数，相当于 .shape 中 n*m 的值 #元素数据类型 np.dtype # np 对象的元素类型 #元素占用空间大小 np.itemsize # np 对象中每个元素的大小，以字节为单位 #对象内存布局 np.flags # np 对象的内存信息 #实部 np.real # np元素的实部 #虚部 np.imag # np 元素的虚部 #内存地址 np.data #包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性。数组
常见数组创建
#创建空矩阵 numpy.empty(shape, dtype = float, order = 'C') # 创建 0 矩阵 numpy.zeros(shape, dtype = float, order = 'C') # 创建 1 矩阵 numpy.ones(shape, dtype = None, order = 'C') # 创建指定形状的数组，数组元素以 1 来填充 #创建对角矩阵 np.eye(5) 创建5行5列的二维对角阵 numpy.eye(N, M=None, k=0, dtype=, order='C') #已有列表、元组创建 numpy.asarray(a, dtype = None, order = None) # x = [1,2,3] or x = (1,2,3) # a = np.asarray(x)
创建序列数组
# 根据 start 与 stop 指定的范围以及 step 设定的步长，生成一个 ndarray numpy.arange(start, stop, step, dtype) # 创建一个一维等差数列数组，范围是[start,stop],元素个数num。linspace翻译成线性空间？ np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None) # 创建一个一维等比数列数组 np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None) np.arange(0,12).reshape(3,4) # 创建序列数组并转换成3行4列矩阵
创建概率分布的数组
#创建shape形状的高斯（正态）分布数组 np.random.randn(shape) #a = np.random.randn(10) #创建均值为loc，标准差为scale，形状为size的高斯（正态）分布 np.random.normal(loc, scale, size) #b = np.random.normal(0, 1, (2,4)) 均值为0，标准差为1，形状为（2，4）的二维数组 #创建shape形状的均匀分布数组 np.random.rand(shape) #c = np.random.rand(2,3) 生成一个形状为（2，3）的均匀分布二维数组 #创建一个从[low, high)中随即采样的，样本数量为size的均匀分布 np.random.uniform(low, high, size) #d = np.random.uniform(-1,1,10)切片
索引的图示理解
高维切片
…用来表示高维情况下，选中该维度的所有数据，并与其他维度选取结果取交集
import numpy as np a = np.array([[1,2,3],[3,4,5],[4,5,6]]) print (a[...,1]) # 第2列元素 print (a[1,...]) # 第2行元素 print (a[...,1:]) # 第2列及剩下所有元素 嵌套的切片 1：由第二个元素开始到最后一个元素，步距默认为1 # 切片 ":" 或 "..." 与索引数组组合 b = a[1:3, 1:3] # 位于第2，3行且第2,3列部分的元素 c = a[1:3,[1,2]] # 同上
输出结果展示：
[2 4 5] [3 4 5] [[2 3] [4 5] [5 6]]索引
a = np.arange(10) # [0 1 2 3 4 5 6 7 8 9] b = a[5] print(b) # 5 获取数组中第6个位置的元素 x = np.array([[1, 2], [3, 4], [5, 6]]) y = x[[0,1,2], [0,1,0]] # 索引结果1维 print(y) # [1 4 5] 获取数组中(0,0)，(1,1)和(2,0)位置处的元素 # 获取 4X3 矩阵中的四个角的元素 x = np.array([[ 0, 1, 2],[ 3, 4, 5],[ 6, 7, 8],[ 9, 10, 11]]) rows = np.array([[0,0],[3,3]]) cols = np.array([[0,2],[0,2]]) y = x[rows,cols] # 索引结果2维 print(y) #获取数组中 (0,0),(0,2),(3,0),(3,2) 位置处的元素 # array([[ 0, 2],[ 9, 11]])
布尔索引
x = np.array([[ 0, 1, 2],[ 3, 4, 5],[ 6, 7, 8],[ 9, 10, 11]]) x[x > 5]# array([ 6, 7, 8, 9, 10, 11]) # 使用"~" 过滤NaN 数据丢失 浮点型 a = np.array([np.nan, 1,2,np.nan,3,4,5]) a[~np.isnan(a)] # array([1., 2., 3., 4., 5.]) # 筛选复数 浮点型 a = np.array([1, 2+6j, 5, 3.5+5j]) a[np.iscomplex(a)] # array([2. +6.j, 3.5+5.j])
花式索引
x=np.arange(32).reshape((8,4)) x[[4,2,1,7]] # 原矩阵的第4,2,1,7行构成的新矩阵（第0行起计） x[[-4,-2,-1,-7]] # 原矩阵的倒数第4,2,1,7行构成的新矩阵（第1行起计） x[np.ix_([1,5,7,2],[0,3,1,2])] print(x) print(x.shape) print(x[[4,2,1,7]]) print(x[np.ix_([1,5,7,2],[0,3,1,2])]) # 原矩阵的第4,2,1,7行构成的新矩阵（第0行起计），并将列按0,3,1,2顺序排序 #如果np.xi_ 中输入两个列表，则第一个列表存的是待提取元素的行标，第二个列表存的是待提取元素的列标，第一个列表中的每个元素都会遍历第二个列表中的每个值，构成新矩阵的一行元素。 [[ 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 30 31]] (8, 4) [[16 17 18 19] [ 8 9 10 11] [ 4 5 6 7] [28 29 30 31]] [[ 4 7 5 6] [20 23 21 22] [28 31 29 30] [ 8 11 9 10]]数值计算 算数运算
a = np.array([1,2,3,4]) b = np.array([10,20,30,40]) c = a * b d = a + b print(c) print(d) [ 10 40 90 160] [11 22 33 44]广播
注：当运算中两个数组的形状不同时，numpy自动触发广播机制
a = np.array([[ 0, 0, 0],
[10,10,10],
[20,20,20],
[30,30,30]])
b = np.array([1,2,3])
c = a + b
print(c)
[[ 1 2 3]
[11 12 13]
[21 22 23]
[31 32 33]]
统计计算
n = np.array([[1,2,3],[4,5,6],[7,8,9]])
最小值
numpy.amin(a, axis=None, ...) print(np.amin(n)) #数组的最小值 print(np.amin(n,0)) #列最小值 print(np.amin(n,1)) #按行求最小值 1 [1 2 3] [1 4 7]
最大值
numpy.amax(a, axis=None, ...) np.amax(n) #数组的最大值 np.amax(n,0) #列最大值 np.amax(n,1) #按行求最大值 9 [7 8 9] [3 6 9]
数组范围
Numpy.ptp(array,axis=None) #返回array中最大值-最小值的结果 print(np.ptp(n)) 8
百分位统计
numpy.percenetile(a,q,axis=None) #例如，第80个百分位数是这样一个值，它使得至少有80%的数据项小于或等于这个值，且至少有20%的数据项大于或等于这个值。 np.percentile(n,40) 4.2
#中位数
numpy.median(a,axis=None)
np.median(n)
5.0
#算数平均值
numpy.mean(a,axis=None)
np.mean(n)
5.0
#加权平均值
numpy.averager(a,axis=None,weights=None,returned=False)
np.averager(n)
5.0
weight = np.array([[1,2,3],[3,2,1],[1,2,3]]
print(np.average(n,weights=weight,returned=True))
#(5.111111111111111, 18.0)
#加权均值和权重和
#标准差
std = sqrt(mean(x-x.mean()**2))
print(np.std(n))
2.581988897471611
#方差
numpy.var(array)
print(np.var(n))
6.666666666666667
逻辑运算
score = np.random.randint(40, 100, (10, 5)) # 取出最后4名同学的成绩，用于逻辑判断 test_score = score[6:,0:5] print(test_score) [[69 44 54 58 61] [43 82 85 87 45] [44 54 80 76 86] [82 79 83 95 91]] #布尔运算 print(test_score > 60) [[ True False False False True] [False True True True False] [False False True True True] [ True True True True True]] #BOOL 赋值 test_score[test_score>60] = 1 print(test_score) [[ 1 44 54 58 1] [43 1 1 1 45] [44 54 1 1 1] [ 1 1 1 1 1]] # all , any 判断函数 #判断前两名同学的成绩[0:2, :]是否全及格 print(np.all(score[0:2, :] > 60)) False #判断前两名同学的成绩[0:2, :]是否有大于90分的 print(np.any(score[0:2, :] > 90)) True
where三元运算符 np.logical_and()、np.logical_or()复合逻辑
·ore = np.random.randint(40, 100, (10, 5)) # 取出最后4名同学的成绩，用于逻辑判断 test_score = score[:4,0:4] print(test_score) [[98 89 76 51] [98 53 41 49] [77 41 66 85] [47 42 91 66]] # #判断前四名学生,前四门课程中，成绩中大于60的置为1，否则为0 print(np.where(test_score > 60, 1, 0)) [[1 1 1 0] [1 0 0 0] [1 0 1 1] [0 0 1 1]] #判断前四名学生,前四门课程中，成绩中大于60且小于90的换为1，否则为0 print(np.where(np.logical_and(test_score > 60, test_score < 90), 1, 0)) [[0 1 1 0] [0 0 0 0] [1 0 1 1] [0 0 0 1]] #判断前四名学生,前四门课程中，成绩中大于90或小于60的换为1，否则为0 print(np.where(np.logical_or(test_score > 90, test_score < 60), 1, 0)) [[1 0 0 1] [1 1 1 1] [0 1 0 0] [1 1 1 0]]线性代数运算
numpy.dot() 向量结果 矩阵乘法 numpy.vdot() 标量结果，相应位置运算相乘在相加 numpy.inner 一维数组的向量内积 numpy.matmul() 两个数组的矩阵乘积 numpy.linalg.det() 计算输出矩阵的行列式 numpy.linalg.inv(a) 返回矩阵的逆矩阵 numpy.linalg.solve() 返回矩阵形式线性方程的解 #线性代数运算 a = np.array([[1,2],[3,4]]) b = np.array([[11,12],[13,14]]) #矩阵乘法 print(np.dot(a,b)) [[37 40] [85 92]] #点积 print(np.vdot(a,b)) 130 #数组矩阵乘积 print(np.matmul(a,b)) [[37 40] [85 92]] #向量内积 x = np.array([1,2,3]) y = np.array([0,1,0]) print(np.inner(x,y)) 2 #行列式 a=np.array([[1,2],[3,4]]) print(np.linalg.det(a)) -2.0000000000000004 #逆矩阵 a = np.array([[1,1,-1],[0,1,1],[0,0,1]]) print(np.linalg.inv(a)) [[ 1. -1. 2.] [ 0. 1. -1.] [ 0. 0. 1.]] #线性方程的解 非齐次方程---->齐次方程--->求解 转换 #常见线性方程求解： AX= B X=A^(-1)B a = np.array([[1,1,1],[2,0,5],[2,5,-1]]) b = np.array([[6],[-4],[27]]) print(np.linalg.solve(a,b)) [[13.] [-1.] [-6.]] print(np.dot(np.linalg.inv(a),b)) [[13.] [-1.] [-6.]]
一维情况下：numpy.vdot() numpy.inner() 效果一致
二维情况下 ：numpy.dot() numpy.matmul() 效果一致
a = np.array([[1,2],[3,4]]) b = np.array([[11,12],[13,14]]) print(np.vdot(a,b)) print(np.vdot(a,b).shape) () #数值 130 #矩阵形状一致 对应位置元素相乘再相加 print(np.inner(a,b)) print(np.inner(a,b).shape) (2, 2)#2*2矩阵 [[35 41] [81 95]] # 以向量的形式对应位置相乘 35 = [1,2]*[11,12]
三维情况下 ：
a = np.array([i for i in range(12)]).reshape([2,2,3]) b = np.array([i for i in range(12)]).reshape([2,3,2]) print(a) [[[ 0 1 2] [ 3 4 5]] [[ 6 7 8] [ 9 10 11]]] print(b) [[[ 0 1] [ 2 3] [ 4 5]] [[ 6 7] [ 8 9] [10 11]]] #矩阵乘法 print(np.dot(a,b)) [[[[ 10 13] [ 28 31]] [[ 28 40] [100 112]]] [[[ 46 67] [172 193]] [[ 64 94] [244 274]]]] print(np.dot(a,b).shape) (2, 2, 2, 2) #四维结果 dot将数组a最后一维作为向量，b倒数第二维作为向量 #a 2*2个向量 b 2*2个向量 故 a*b = （2*2）*（2*2） #eg:[[0,1,2]*[0,2,4],[0,1,2]*[1,3,5],[0,1,2]*[6,8,10],[0,1,2]*[7,9,11]] 故四个2*2矩阵 #数组矩阵乘积 print(np.matmul(a,b)) [[[ 10 13] [ 28 40]] [[172 193] [244 274]]] print(np.matmul(a,b).shape) (2, 2, 2) #matmul 将最后两维作为矩阵的两维，相当于两个2*2矩阵----->对应位置矩阵乘法 ------>2个2 * 2结果 #故最终呈现两个2*2矩阵迭代 nditer迭代
nditer迭代默认顺序与数组内存步距一致，不一定行序，不一定列序
对a.T使用nditer迭代输出顺序不变
a = np.arange(6).reshape(2,3)
print(a)
[[0 1 2]
[3 4 5]]
#默认
for x in np.nditer(a):
print(x,end=",")
0,1,2,3,4,5,
# Fortran order，即是列序优先
for x in np.nditer(a, order='F'):
print(x,end=",")
0,3,1,4,2,5,
# C order，即是行序优先
for x in np.nditer(a.T, order='C'):
print(x, end=",")
0,3,1,4,2,5,
#修改矩阵中元素的值 ...所有元素
for x in np.nditer(a, op_flags=['readwrite']):
x[...]=2*x
print(a)
[[ 0 2 4]
[ 6 8 10]]
广播迭代
a = np.arange(0,60,5).reshape(3,4)
b = np.array([1, 2, 3, 4])
print(a)
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
for x,y in np.nditer([a,b]):
print ("%d:%d" % (x,y), end=", " )
# 数组a有12个元素，数组b有4个，当迭代时，b会广播到长度与a相等（b|a）
#应用场景：物体识别中 同一目标的不同参数值 同意mask的不同预测边界框
0:1, 5:2, 10:3, 15:4, 20:1, 25:2, 30:3, 35:4, 40:1, 45:2, 50:3, 55:4,
flat迭代
#如果需要操作数组中的每一个元素，可以用flat属性，该属性是一个数组元素迭代器
a = np.arange(9).reshape(3,3)
for element in a.flat:
print (element)
#flatten 返回一份数组拷贝，默认按行
print(a.flatten())
[0 1 2 3 4 5 6 7 8]
print(a.flatten(order='F'))
[0 3 6 1 4 7 2 5 8]
数组操作
修改数组形状
numpy.reshape(arr, newshape, order='C') a = np.arange(8) print(a) [0 1 2 3 4 5 6 7] a = a.reshape(4,2) print(a) [[0 1] [2 3] [4 5] [6 7]]数组展开、降维
#flatten 展开 拷贝，修改不影响原矩阵 a = np.arange(8).reshape(2,4) print(a.flatten()) [0 1 2 3 4 5 6 7] #ravel 展开 返回一个原数组的展开序列（视图），对其修改会相应修改原矩阵 a = np.arange(8).reshape(2,4) print(a.ravel()) [0 1 2 3 4 5 6 7]矩阵转置
numpy.transpose() a = np.arange(8).reshape(2,4) print(a) [[0 1 2 3] [4 5 6 7]] print(np.transpose(a)) [[0 4] [1 5] [2 6] [3 7]]坐标轴调整
我们理解了一个数组的值，并且值所在坐标系中的位置后，再开始去变换数组中的数据，这里rollaxis和swapaxes 对数据的变换就是对坐标值的变换，变换完之后再按照顺序插回到新的数组中。
#分别获取数组中各个元素值所对应的坐标值
# 将 a 的值，从小到大打印坐标值
def print_sort_dim(A):
# 将a的值，从小到大打印坐标值
for value in range(0, A.size):
x, y, z = get_dim(A, value)
print(A[x][y][z], ":[", x, ",", y, ",", z, "]")
# 从a中拿到数字为i的几个坐标值
def get_dim(A, value):
for x in range(0, 2):
for y in range(0, 2):
for z in range(0, 2):
if A[x][y][z] == value:
return x, y, z
# 函数向后滚动特定的轴到一个特定位置
#arr：数组
#axis：要向后滚动的轴，其它轴的相对位置不会改变
#start：默认为零，表示完整的滚动。会滚动到特定位置。
#将数组arr所对应的axis轴 放在 start轴的前面，start轴往后移一“列”
numpy.rollaxis(arr, axis, start)
a = np.arange(8).reshape(2,2,2)
print(a)
[[[0 1]
[2 3]]
[[4 5]
[6 7]]
print_sort_dim(a)
0 :[ 0 , 0 , 0 ]
1 :[ 0 , 0 , 1 ]
2 :[ 0 , 1 , 0 ]
3 :[ 0 , 1 , 1 ]
4 :[ 1 , 0 , 0 ]
5 :[ 1 , 0 , 1 ]
6 :[ 1 , 1 , 0 ]
7 :[ 1 , 1 , 1 ]
b = np.rollaxis(a,2)
print(b)
[[[0 2]
[4 6]]
[[1 3]
[5 7]]]
print_sort_dim(b)
0 :[ 0 , 0 , 0 ]
1 :[ 1 , 0 , 0 ]
2 :[ 0 , 0 , 1 ]
3 :[ 1 , 0 , 1 ]
4 :[ 0 , 1 , 0 ]
5 :[ 1 , 1 , 0 ]
6 :[ 0 , 1 , 1 ]
7 :[ 1 , 1 , 1 ]
c = np.rollaxis(a,1)
print(c)
[[[0 1]
[4 5]]
[[2 3]
[6 7]]]
print_sort_dim(c)
0 :[ 0 , 0 , 0 ]
1 :[ 0 , 0 , 1 ]
2 :[ 1 , 0 , 0 ]
3 :[ 1 , 0 , 1 ]
4 :[ 0 , 1 , 0 ]
5 :[ 0 , 1 , 1 ]
6 :[ 1 , 1 , 0 ]
7 :[ 1 , 1 , 1 ]
# 交换矩阵的两个坐标轴
# 将n维数组中两个维度进行调换 注意维度不要越界
numpy.swapaxes(arr, axis1, axis2)
b = np.swapaxes(a,0,2)
print(b)
[[[0 4]
[2 6]]
[[1 5]
[3 7]]]
print_sort_dim(b)
# 坐标 0 2 互换
0 :[ 0 , 0 , 0 ]
1 :[ 1 , 0 , 0 ]
2 :[ 0 , 1 , 0 ]
3 :[ 1 , 1 , 0 ]
4 :[ 0 , 0 , 1 ]
5 :[ 1 , 0 , 1 ]
6 :[ 0 , 1 , 1 ]
7 :[ 1 , 1 , 1 ]
c = np.swapaxes(a,1,2)
print(c)
[[[0 2]
[1 3]]
[[4 6]
[5 7]]]
print_sort_dim(c)
0 :[ 0 , 0 , 0 ]
1 :[ 0 , 1 , 0 ]
2 :[ 0 , 0 , 1 ]
3 :[ 0 , 1 , 1 ]
4 :[ 1 , 0 , 0 ]
5 :[ 1 , 1 , 0 ]
6 :[ 1 , 0 , 1 ]
7 :[ 1 , 1 , 1 ]
维度扩展，复制扩展
broadcast_to扩展需要对维度扩展，原来是1行，可以扩展成多行，原来是2维，可以扩展到3维，但是tile是同一维度的复制，复制后两者不相关，修改其中一个不影响另一个
broadcast(x,y) # 模仿广播的对象,将y广播到x
x = np.array([[1], [2], [3]]) # 3行1列
y = np.array([4, 5, 6]) # 1行3列
b = np.broadcast(x,y) # b 是迭代器
for x,y in b:
print(x,y) #9行输出，每个x元素对应3个y元素
numpy.broadcast_to(array, shape, subok)
#将数组广播到新形状。它在原始数组上返回只读视图。
#对原数组的修改会影响视图的值
a = np.arange(4).reshape(1,4)
b = np.broadcast_to(a,(4,4))
print(a)
[[0 1 2 3]]
print(b)
[[0 1 2 3]
[0 1 2 3]
[0 1 2 3]
[0 1 2 3]]
b = np.arange(6).reshape(2,3)
bb = np.tile(b, (4, 2)) # 重复 b 的各个维度，纵向4倍，横向2倍
print(b)
[[0 1 2]
[3 4 5]]
print(bb)
[[0 1 2 0 1 2]
[3 4 5 3 4 5]
[0 1 2 0 1 2]
[3 4 5 3 4 5]
[0 1 2 0 1 2]
[3 4 5 3 4 5]
[0 1 2 0 1 2]
[3 4 5 3 4 5]]
维度扩展
#在原有的维数上再增加1个维度 numpy.expand_dims(arr, axis) # 从shape 来看 axis 新维度扩展位置
维度压缩
numpy.squeeze(arr, axis) # 从给定数组的形状中删除一维的条目 x = np.arange(9).reshape(1,3,3) y = np.squeeze(x) print(x.shape, y.shape) ((1, 3, 3), (3, 3)) # 厚度只有1的维会被删除数组连接
hstack和vstack效果与concatenate相同，在原数组平面的右方或者下方进行拼接，
但stack是在原数组平面上面“堆叠”，新增了一维
#沿指定轴连接相同形状的两个或多个数组 numpy.concatenate((a1, a2, ...), axis) a = np.array([[1,2],[3,4]]) b = np.array([[5,6],[7,8]]) print(np.concatenate((a,b))) [[1 2] [3 4] [5 6] [7 8]] print(np.concatenate((a,b),axis=1)) [[1 2 5 6] [3 4 7 8]] #沿新轴连接数组序列 numpy.stack(arrays, axis) a = np.array([[1,2],[3,4]]) b = np.array([[5,6],[7,8]]) print(np.stack((a,b),0)) [[[1 2] [3 4]] [[5 6] [7 8]]] print(np.stack((a,b),1)) [[[1 2] [5 6]] [[3 4] [7 8]]] print(np.hstack((a,b))) [[1 2 5 6] [3 4 7 8]] print(np.vstack((a,b))) [[1 2] [3 4] [5 6] [7 8]]数组分割
numpy.split(ary, indices_or_sections, axis)
#ary：要切分的数组
#indices_or_sections：如果是一个整数，就用该数平均切分，如果是一个数组，为沿轴切分的位置
#axis：沿着哪个维度进行切向，默认为0，横向切分
#一维数组：
x = np.array([0,1,2,3,4,5,6,7,8])
print(np.split(x,3))
#整数 均分 [array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])]
print(np.split(x,[3,5,6,9]))
#数组索引越界 最后为空 [array([0, 1, 2]), array([3, 4]), array([5]), array([6, 7, 8]), array([], dtype=int32)]
print(np.split(x,[3,5,6,8]))
#数组 根据数组中的元素进行切分 [array([0, 1, 2]), array([3, 4]), array([5]), array([6, 7]), array([8])]
#二维数组 整数代表均分 []代表基于该维度的划分位置
x = np.arange(16).reshape(4,4)
print(x)
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
print(np.split(x,2,axis= 0))
[array([[0, 1, 2, 3],
[4, 5, 6, 7]]), array([[ 8, 9, 10, 11],
[12, 13, 14, 15]])]
print(np.split(x,2,axis= 1))
[array([[ 0, 1],
[ 4, 5],
[ 8, 9],
[12, 13]]), array([[ 2, 3],
[ 6, 7],
[10, 11],
[14, 15]])]
print(np.split(x,[1,3],axis= 0))
# 维度不一致 每一层[]代表一个维度
[array([[0, 1, 2, 3]]), array([[ 4, 5, 6, 7],
[ 8, 9, 10, 11]]), array([[12, 13, 14, 15]])]
print(np.split(x,[1,3],axis= 1))
# 列 0 1，2 3 [] 中的元素代表划分位置
[array([[ 0],
[ 4],
[ 8],
[12]]), array([[ 1, 2],
[ 5, 6],
[ 9, 10],
[13, 14]]), array([[ 3],
[ 7],
[11],
[15]])]
]), array([8])]
#二维数组 整数代表均分 []代表基于该维度的划分位置
x = np.arange(16).reshape(4,4)
print(x)
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
print(np.split(x,2,axis= 0))
[array([[0, 1, 2, 3],
[4, 5, 6, 7]]), array([[ 8, 9, 10, 11],
[12, 13, 14, 15]])]
print(np.split(x,2,axis= 1))
[array([[ 0, 1],
[ 4, 5],
[ 8, 9],
[12, 13]]), array([[ 2, 3],
[ 6, 7],
[10, 11],
[14, 15]])]
print(np.split(x,[1,3],axis= 0))
维度不一致 每一层[]代表一个维度[array([[0, 1, 2, 3]]), array([[ 4, 5, 6, 7],
[ 8, 9, 10, 11]]), array([[12, 13, 14, 15]])]
print(np.split(x,[1,3],axis= 1))
[array([[ 0],
[ 4],
[ 8],
[12]]), array([[ 1, 2],
[ 5, 6],
[ 9, 10],
[13, 14]]), array([[ 3],
[ 7],
[11],
[15]])]
