NumPy 切片和索引
目录
ndarry对象的内容可以通过索引或切片来访问和修改,与 Python 中 list 的切片操作一样。
切片对象可以通过内置的 slice 函数,从原数组中切割出一个新数组。
slice(start,stop,step)
* start 起始索引
* stop 结束索引
* step 步长
* 注意:左闭右开
import numpy as np
a = np.arange(10)
s = slice(2,8,2) # 从下标2~8,步长为2定义这样一个切割对象
a_sub = a[s] # 这种写法不推荐,可以了解
print(a_sub)
[2 4 6 8]
b = a[5]# 如果只放置一个参数,如 [5],将返回与该索引相对应的单个元素
print(b)
5
print(a[2:]) # 下标2~末尾下标之间的所有元素
[2 3 4 5 6 7 8 9]
#多维数组切片
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print(a)
# 从数据索引a[1:]处分割,得到的是[3,4,5],[4,5,6]
print("*"*10)
print(a[1:])
[[1 2 3]
[3 4 5]
[4 5 6]]
**********
[[3 4 5]
[4 5 6]]
在多维数组的切片中,使用 ,
区分维数。
比如下面的例子中,可以把冒号左边的数看成是横坐标,右边的数看成是纵坐标,四个坐标做笛卡尔积,即取数组 a 下标是 (0,1),(0,2),(1,1),(1,2) 四个位置的数。
import numpy as np
a=np.arange(0,12)
a.shape=(3,4)
print(a)
print(a[0:2,1:3]) # 相当于得到了行列式子式(第1~2列和第2~3列) 【注意这里的行数和列数在程序中都要减1,因为程序中计数是从0开始的】
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[[1 2]
[5 6]]
在多维数组中,连续索引切片
a[1:3, 2:5]
中逗号左边的为行,右边为列(第 2 行到第 3 行,第 3 列到第 5 列),输出结果:
import numpy as np
a=np.arange(0,80)
a.shape=(8,10)
print(a)
print('切片后')
print(a[1:3, 2:5])
[[ 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 32 33 34 35 36 37 38 39]
[40 41 42 43 44 45 46 47 48 49]
[50 51 52 53 54 55 56 57 58 59]
[60 61 62 63 64 65 66 67 68 69]
[70 71 72 73 74 75 76 77 78 79]]
切片后
[[12 13 14]
[22 23 24]]
在多维数组中,非连续索引切片
切片向量既可以为array,也可以为list类型
a = np.arange(0,25)
a.shape = (5,5)
print("原始数组:")
print(a)
print("想要将原数组的135行,24列切片组成新的矩阵..")
row_sli = np.array([0,2,4]) # 使用array作为切片向量
cow_sli = [1,3] # 使用列表list作为切片向量
print(a[row_sli,:][:,cow_sli])
原始数组:
[[ 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]]
想要将原数组的135行,24列切片组成新的矩阵..
[[ 1 3]
[11 13]
[21 23]]
整数数组索引
- 以下实例获取数组中(0,0),(1,1)和(2,0)位置处的元素。
import numpy as np
x = np.array([[1, 2], [3, 4], [5, 6]])
print(x)
y = x[[0,1,2], [0,1,0]] # 方括号之间的","区分维度
print (y)
[[1 2]
[3 4]
[5 6]]
[1 4 5]
- 以下实例获取了 4X3 数组中的四个角的元素。 行索引是
[0,0] 和 [3,3],而列索引是 [0,2] 和 [0,2]
。
import numpy as np
x = np.arange(12)
x.shape =(4,3)
print ('原数组:' )
print (x)
print ('\n')
rows = np.array([[0,0],[3,3]])
cols = np.array([[0,2],[0,2]])
y = x[rows,cols]
print ('这个数组的四个角元素是:')
print (y)
原数组:
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
这个数组的四个角元素是:
[[ 0 2]
[ 9 11]]
- 切片还可以包括省略号 …,来使选择元组的长度与数组的维度相同。 如果在行位置使用省略号,它将返回包含行中元素的 ndarray。
import numpy as np
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print(a)
print (a[...,1]) # 第2列元素
print (a[1,...]) # 第2行元素
print (a[...,1:]) # 第2列及剩下的所有元素
print(a[...]) # 原数组
[[1 2 3]
[3 4 5]
[4 5 6]]
[2 4 5]
[3 4 5]
[[2 3]
[4 5]
[5 6]]
[[1 2 3]
[3 4 5]
[4 5 6]]
- 可以借助切片 : 或 … 与索引数组组合。如下面例子:
import numpy as np
a = np.arange(1,10)
a.shape=(3,3)
print(a)
b = a[1:3,1:3] # 左闭右开
c = a[1:3,[1,2]]
d = a[...,1:]
print(b)
print(c)
print(d)
[[1 2 3]
[4 5 6]
[7 8 9]]
[[5 6]
[8 9]]
[[5 6]
[8 9]]
[[2 3]
[5 6]
[8 9]]
布尔索引
布尔索引通过布尔运算(如:比较运算符)来获取符合指定条件的元素的数组。
- 获取大于 5 的元素:
x =np.arange(0,12)
x.shape=(3,4)
print("原数组:")
print(x)
print ('大于 5 的元素是:')
print(x[x>5])
原数组:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
大于 5 的元素是:
[ 6 7 8 9 10 11]
- 使用 ~(取补运算符)来过滤 NaN。(NaN即None空数据)
a=np.array([np.nan,1,2,np.nan,3,4,5])
print("过滤前的原数组:")
print(a)
print("过滤NaN数据后的数组:")
print(a[~np.isnan(a)])
过滤前的原数组:
[nan 1. 2. nan 3. 4. 5.]
过滤NaN数据后的数组:
[1. 2. 3. 4. 5.]
- 从数组中过滤掉非复数元素。
a = np.array([[1,2+6j,5],[2,4+2j,3],[4,6+2j,8]])
print("过滤前的原数组:")
print(a)
print("过滤复数数据后的数组:")
print(a[~np.iscomplex(a)])
print("过滤非复数数据后的数组:")
print(a[np.iscomplex(a)])
过滤前的原数组:
[[1.+0.j 2.+6.j 5.+0.j]
[2.+0.j 4.+2.j 3.+0.j]
[4.+0.j 6.+2.j 8.+0.j]]
过滤复数数据后的数组:
[1.+0.j 5.+0.j 2.+0.j 3.+0.j 4.+0.j 8.+0.j]
过滤非复数数据后的数组:
[2.+6.j 4.+2.j 6.+2.j]
花式索引
花式索引指的是利用整数数组作为索引。
花式索引根据索引数组的值作为目标数组的某个轴的下标来取值。对于使用一维整型数组作为索引,如果目标是一维数组,那么索引的结果就是对应位置的元素;如果目标是二维数组,那么就是对应下标的行。
花式索引跟切片不一样,它总是将数据复制到新数组中。
- 传入顺序索引数组(体会花式索引和整数数组索引的区别)
import numpy as np
x=np.arange(32).reshape((8,4))
print (x)
arr = np.array([[4,2,1,7],[2,1,2,3]]) # 定义顺序索引数组,目标是二维数组,数字4,2,1,7就是对应下标的行。
print("*"*20)
print("花式索引x[ [4,2,1,7] ]")
print(x[[4,2,1,7]])
print("*"*20)
# print("整数数组索引x[4,2,1,7]") # 报错
# print(x[4,2,1,7])
print("花式索引x[ [[4,2,1,7],[2,1,2,3]] ]")
print("*"*20)
print(x[arr])
print("整数数组索引x[[4,2,1,7],[2,1,2,3]]")
print("*"*20)
print(x[[4,2,1,7],[2,1,2,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 30 31]]
********************
花式索引x[ [4,2,1,7] ]
[[16 17 18 19]
[ 8 9 10 11]
[ 4 5 6 7]
[28 29 30 31]]
********************
花式索引x[ [[4,2,1,7],[2,1,2,3]] ]
********************
[[[16 17 18 19]
[ 8 9 10 11]
[ 4 5 6 7]
[28 29 30 31]]
[[ 8 9 10 11]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]]
整数数组索引x[[4,2,1,7],[2,1,2,3]]
********************
[18 9 6 31]
- 传入倒序索引数组
import numpy as np
x=np.arange(32).reshape((8,4))
print(x)
print("*"*20)
print (x[[-4,-2,-1,-7]]) # -1 索引对应二维的最后一行,对应1维的最后一个元素,然后递推
[[ 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]]
********************
[[16 17 18 19]
[24 25 26 27]
[28 29 30 31]
[ 4 5 6 7]]
- 传入多个索引数组(要使用np.ix_)
如果 np.xi_ 中输入两个列表,则第一个列表存的是待提取元素的行标,第二个列表存的是待提取元素的列标,第一个列表中的每个元素都会遍历第二个列表中的每个值,构成新矩阵的一行元素。
import numpy as np
x=np.arange(32).reshape((8,4))
print(x)
print("-"*20)
print (x[np.ix_([1,5,7,2],[0,3,1,2])])
[[ 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]]
--------------------
[[ 4 7 5 6]
[20 23 21 22]
[28 31 29 30]
[ 8 11 9 10]]
原理:np.ix_函数就是输入两个数组,产生笛卡尔积的映射关系.
例如就这个例子,np.ix_函数,将数组[1,5,7,2]和数组[0,3,1,2]产生笛卡尔积,就是得到(1,0),(1,3),(1,1),(1,2);(5,0),(5,3),(5,1),(5,2);(7,0),(7,3),(7,1),(7,2);(2,0),(2,3),(2,1),(2,2);
就是按照坐标(1,0),(1,3),(1,1),(1,2)取得 arr2 所对应的元素4,7,5,6
(5,0),(5,3),(5,1),(5,2)取得 arr2 所对应的元素20,23,21,22
如此类推。
这一段论述转载至TzeSing的博客:原文链接:https://blog.csdn.net/weixin_40001181/article/details/79775792