ndarray数组的索引和切片

2019/04/10 10:10
阅读数 13

索引:获取数组中特定位置元素的过程

切片:获取数组元素子集的过程

利用切片得到的数组为浅复制,即原数组改变,新的数组也会随之改变。为避免浅复制,建议使用副本切片,即copy()

import numpy as np

一维数组

一维数组的索引和切片与python中的列表类似

索引:若元素个数为n,则索引下标可表示为[0,1,2,...,n-1]或[-n,-(n-1),-(n-2),...,-2,-1]

print('*'*8+'一维数组的索引和切片'+'*'*8)
# 若元素个数为n,则索引下标可表示为[0,1,2,...,n-1]或[-n,-(n-1),-(n-2),...,-2,-1]
ar1 = np.array([5, 6, 7, 8, 9])
print(ar1[4])   # 索引自左向右从下标0开始
print(ar1[-2])  # 索引自右向左从下标-1递减,最右边为-1,相邻的为-2

切片:切片可用三元素冒号分割

ar1[起始编号 : 终止编号(不含) : 步长],起始编号默认是0,终止编号默认是n,步长默认是1

仍然是ndarray数组
b = ar1[1:4:2]
print(b)
print(type(b))

多维数组

ar2 = np.arange(24).reshape((2, 3, 4))
print('*'*8+'多维数组的索引和切片'+'*'*8)

多维数组的索引,每个维度一个索引值,逗号分隔————r2[ax0上索引,ax1上索引,ax2上索引],各个维度索引和一维相同0~n-1-n~-1

print(ar2)
print(ar2[1, 1, 2])
print(ar2[-1, -2, -2])

多维数组的切片,逗号分隔,每个维度同一维切片一样,用三冒号分隔, 如果只有一个:表示选取整个维度

print(ar2[:, 1:3, :])
print(ar2[:, 1:3, ::2])
print(ar2[:, 1, -3])

索引数组:将数组作为索引,通常是一维数组(每个元素代表对应维度索引)

1.布尔索引

<font size=4>布尔数组</font>:顾名思义,元素类型为布尔值的数组,同样可以是一维或者多维数组

例如:bool_arr1 = np.array([True, False, False, False, False, False,True])

如下的数组定义也是布尔数组

names = np.array(['Liu', 'Zhang', 'Li', 'Wang', 'Sun', 'Zong', 'Kong'])
bool_arr2 = names == 'Zhang'

此时bool_arr2array[False True False False False False False]

若想得到bool_arr1,则:bool_arr1 = (names == 'Liu') | (names == 'Kong')

同样的,与 &非 ~不等于 !=>=<=><等条件判断同样可以用于布尔数组赋值语句里。

注意!Python中的关键字andor对布尔值数组并没有用,is在特殊情况可能会有效,即判断两个布尔数组是否相等

如:bool_arr3 = ~(names == 'Zhang')等价于boo_arr3 = names != 'Zhang'

一维布尔数组 作为 布尔索引数组,例如:

names = np.array(['Liu', 'Zhang', 'Li', 'Wang', 'Sun', 'Zong', 'Kong'])
bool_arr2 = names == 'Zhang'
data = np.arange(21).reshape((7,3))
print(data)
print(data[bool_arr2])

输出为:

[[ 0  1  2]
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]
 [12 13 14]
 [15 16 17]
 [18 19 20]] # data
 
[[3 4 5]]	# data[bool_arr2]

2.神奇索引

使用整数数组作为数据索引数组,整数数组可以是一维或多维

2.1一维数据索引数组

一维数据索引数组传递包含指定顺序的列表或数组。即:

一维数据索引数据每个元素i代表数组轴axis=0上,即取第1维的第i个数据。

例1:

data1 = np.arange(28).reshape((7, 4))
print(data1)
print('-'*20 + 'data1[[1, 5, 6, 2, 1]]' + '-'*20)
print(data1[[1, 5, 6, 2, 1]])
print('-'*20 + 'data1[[-1, 3, -2, -5, 1]]' + '-'*20)
print(data1[[-1, 3, -2, -5, 1]])

输出为:

[[ 0  1  2  3]  # 0或-7
 [ 4  5  6  7]	# 1或-6
 [ 8  9 10 11]	# 2或-5
 [12 13 14 15]	# 3或-4
 [16 17 18 19]	# 4或-3
 [20 21 22 23]	# 5或-2
 [24 25 26 27]]	# 6或-1
--------------------data1[[1, 5, 6, 2, 1]]--------------------
[[ 4  5  6  7]
 [20 21 22 23]
 [24 25 26 27]
 [ 8  9 10 11]
 [ 4  5  6  7]]
--------------------data1[[-1, 3, -2, -5, 1]]--------------------
[[24 25 26 27]
 [12 13 14 15]
 [20 21 22 23]
 [ 8  9 10 11]
 [ 4  5  6  7]]

例2:

data2 = np.arange(48).reshape((4, 4, 3))
print(data2)
print('-'*20 + 'data2[[3, 0, 2, 1, 0]]' + '-'*20)
print(data2[[3, 0, 2, 1, 0]])
print('-'*20 + 'data2[[-1, -2, 1, 2]]' + '-'*20)
print(data2[[-1, -2, 1, 2]])

输出为:

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

 [[12 13 14]
  [15 16 17]
  [18 19 20]
  [21 22 23]]	# 1或-3

 [[24 25 26]
  [27 28 29]
  [30 31 32]
  [33 34 35]]	# 2或-2

 [[36 37 38]
  [39 40 41]
  [42 43 44]
  [45 46 47]]]	# 3或-1
--------------------data2[[3, 0, 2, 1, 0]]--------------------
[[[36 37 38]
  [39 40 41]
  [42 43 44]
  [45 46 47]]

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

 [[24 25 26]
  [27 28 29]
  [30 31 32]
  [33 34 35]]

 [[12 13 14]
  [15 16 17]
  [18 19 20]
  [21 22 23]]

 [[ 0  1  2]
  [ 3  4  5]
  [ 6  7  8]
  [ 9 10 11]]]
--------------------data2[[-1, -2, 1, 2]]--------------------
[[[36 37 38]
  [39 40 41]
  [42 43 44]
  [45 46 47]]

 [[24 25 26]
  [27 28 29]
  [30 31 32]
  [33 34 35]]

 [[12 13 14]
  [15 16 17]
  [18 19 20]
  [21 22 23]]

 [[24 25 26]
  [27 28 29]
  [30 31 32]
  [33 34 35]]]

data2是多维数组,其在轴axis=0共有4个数据,每个数据其实又是一个数组

2.2 多个索引数组

传递多个索引数组作为索引时,会根据每个索引数组对应元素选出一个一维数组

每个索引数组大小应相同,设为n数组个数应等于数据数组的维数,相当于得到n个点的坐标,坐标分量即为数据数组对应维度。

例:

data3 = np.arange(32).reshape((8, 4))
print(data3)
print('-'*20 + 'data3[[1, 5, 7, 2], [0, 3, 1, 2]]' + '-'*20)
print(data3[[1, 5, 7, 2], [0, 3, 1, 2]])
data4 = np.arange(48).reshape((4, 4, 3))
print('-'*20 + 'data4' + '-'*40)
print(data4)
print('-'*20 + 'ddata4[[3, 3, 1, 2, 0], [2, 1, 2, 0, 3], [2, 2, 0, 2, 1]' + '-'*20)
print(data4[[3, 3, 1, 2, 0], [2, 1, 2, 0, 3], [2, 2, 0, 2, 1]])

输出为:

   0  1  2  3 	#  “坐标”
0[[ 0  1  2  3]
1 [ 4  5  6  7]
2 [ 8  9 10 11]
3 [12 13 14 15]
4 [16 17 18 19]
5 [20 21 22 23]
6 [24 25 26 27]
7 [28 29 30 31]]
--------------------data3[[1, 5, 7, 2], [0, 3, 1, 2]]--------------------
[ 4 23 29 10]
--------------------data4----------------------------------------
[[[ 0  1  2]
  [ 3  4  5]       # 0(axis=0)
  [ 6  7  8]
  [ 9 10 11]]

 [[12 13 14]
  [15 16 17]      # 1
  [18 19 20]
  [21 22 23]]

 [[24 25 26]
  [27 28 29]      # 2
  [30 31 32]
  [33 34 35]]

 [[36 37 38]
  [39 40 41]	 # 3
  [42 43 44]
  [45 46 47]]]
--------------------ddata4[[3, 3, 1, 2, 0], [2, 1, 2, 0, 3], [2, 2, 0, 2, 1]--------------------
[44 41 18 26 10]

<font size=4>data3[[1, 5, 7, 2], [0, 3, 1, 2]] 即为“坐标“为<font color=red>(1,0)、(5,3)、(7,1)、(2,2)</font>的元素被选中。</font>

<font size=4>data4是一个三维数组,在0轴上,又是一个二维数组,同理:</font>

<font size=4>data4[[3, 3, 1, 2, 0], [2, 1, 2, 0, 3], [2, 2, 0, 2, 1]]即为坐标为<font color=red>(3,2,2)、(3,1,2)、(1,2,0)、(2,0,2)、(0,3,1)</font>的元素</font>

2.3神奇索引发挥类似切片功能

<font size=4>切片是逗号分隔,在每一维上可用一维数据索引数组作为其索引</font>

多个索引数组其实就是一种特殊的切片,每维索引都是一个一维数据索引

例:

data3 = np.arange(32).reshape((8, 4))
print(data3)
kols = data3[[1, 5, 7, 2]]
print('-'*20 + 'kols' + '-'*20)
print(kols)
print('-'*20 + 'data3[[1, 5, 7, 2]][:, [0, 3, 1, 2, 3]]' + '-'*20)
print(data3[[1, 5, 7, 2]][:, [0, 3, 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]]
--------------------kols--------------------
[[ 4  5  6  7]
 [20 21 22 23]
 [28 29 30 31]
 [ 8  9 10 11]]
--------------------data3[[1, 5, 7, 2]][:, [0, 3, 1, 2, 3]]--------------------
[[ 4  7  5  6  7]
 [20 23 21 22 23]
 [28 31 29 30 31]
 [ 8 11  9 10 11]]

data3[[1, 5, 7, 2]][:, [0, 3, 1, 2]]其实就是data3[[1, 5, 7, 2]],即kols的切片,切片第一维取全部,即全部行。

第二维取一维数据数组[0,3,1,2]即:

新数组第一列为kols第一列(0)[4 20 28 8]

第二列为kols第4列(3)[7 23 31 11]

第三列为kols第2列(1)[5 21 29 9]

第四列为kols第3列(2)[6 22 30 10]

第五列为kols第4列(3)[7 23 31 11]

<font size=5>numpy.newaxis关键字</font>

numpy.axis用来增加数组新维度,如数组a.shape=(d0,d1,...,dn),那么在其di-1和di中间添加np.newaxis,即第i轴增加newaxis,那么a.shape$\rightarrow$(d0,d1,..di-1,1,di,..,dn) 例:

a = np.arange(24).reshape((2, 3, 4))
print("数组a:\n", a)
b = a[:, np.newaxis, :, :]
print("数组b:\n", b)

输出:

数组a:
 [[[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]]

 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]]
数组b:
 [[[[ 0  1  2  3]
   [ 4  5  6  7]
   [ 8  9 10 11]]]


 [[[12 13 14 15]
   [16 17 18 19]
   [20 21 22 23]]]]
b.shape =  (2, 1, 3, 4)

我们经常在取数组一列或一行时,得到一个一维数组,但我们仍然希望是二维数组形式,则可以使用numpy.newaxis关键字。

原文出处:https://www.cnblogs.com/hashcoin/p/12389714.html

展开阅读全文
打赏
0
0 收藏
分享
加载中
更多评论
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部