Numpy库：简单的索引值（几个索引框）、切片、布尔掩码、花哨的索引（仅一个索引框）和组合索引

来自和鲸社区
先介绍两个简短的索引方法
简单的索引值：无论是一维数组还是多维数组，都可以根据元素是总数组的第几个值来进行索引–arr[0]
切片：类似于列表的切片，只要搞清arr[x1:x2],arr[y1:y2][x1:x2],arr[z1:z2][y1:y2][x1:x2]等每个位置的[]代表着什么轴即可

• 一维数组很简单，就是一条线
• 二维数组则是以x轴为转轴，旋转180度后的平面笛卡尔坐标系
• 三维数组则是zyx

1 布尔掩码

布尔掩码有两个主要来源，一种是利用Numpy实现小于和大于的逐元素比较的通用函数，另一种则是复合表达式，也能得到一个布尔数据类型的数组。数组通过布尔掩码，将满足条件的True值取出，即掩码操作。

1.1 比较运算通用函数

# 比较运算通用函数
x = np.array([1, 2, 3, 4, 5])
print('x =      ', x)
print('x < 3  : ', x < 3, np.less(x, 3))
print('x > 3  : ', x > 3, np.greater(x, 3))
print('x <= 3 : ', x <= 3, np.less_equal(x, 3))
print('x >= 3 : ', x >= 3, np.greater_equal(x, 3))
print('x != 3 : ', x != 3, np.not_equal(x, 3))
print('x == 3 : ', x == 3, np.equal(x, 3))
# 利用复合表达式实现对两个数组逐元素比较
print(2 * x)
print(x ** 2)
print((2 * x) == (x ** 2))
# 以上方法可以用于任意形状、大小的数组

x = [1 2 3 4 5]
x < 3 : [ True True False False False] [ True True False False False]
x > 3 : [False False False True True] [False False False True True]
x <= 3 : [ True True True False False] [ True True True False False]
x >= 3 : [False False True True True] [False False True True True]
x != 3 : [ True True False True True] [ True True False True True]
x == 3 : [False False True False False] [False False True False False]
[ 2 4 6 8 10]
[ 1 4 9 16 25]
[False True False False False]

1.2 统计True的函数

此外，也有通用函数可以统计True的情况

# 使用np.count_nonzero函数统计布尔数组中True记录的个数
print('x: \n', x)
print('x < 6 : \n', x < 6)
print('x < 6 的个数：', np.count_nonzero(x < 6))

# np.sum(x < 6)中False被解释为0， True解释为1, 好处是可以指定行或者列方向
print('x < 6 的个数：', np.sum(x < 6))
print('每列 x < 6的个数：', np.sum(x < 6, axis = 0))
print('每行 x < 6的个数：', np.sum(x < 6, axis = 1))

# 快速检查所有值或者任意值是否为True，可以沿指定轴方向
print('有没有值大于8：', np.any(x > 8))
print('有没有值小于0：', np.any(x < 0))
print('是否所有值都小于10：', np.all(x < 10))
print('是否每行所以值都小于8：', np.all(x < 8, axis = 1))

x:
[[5 0 3 3]
[7 9 3 5]
[2 4 7 6]]
x < 6 :
[[ True True True True]
[False False True True]
[ True True False False]]
x < 6 的个数： 8
x < 6 的个数： 8
每列 x < 6的个数： [2 2 2 2]
每行 x < 6的个数： [4 2 2]
有没有值大于8： True
有没有值小于0： False
是否所有值都小于10： True
是否每行所以值都小于8： [ True False True]

1.3 布尔运算符：逐位逻辑运算符（与或非）： & | ~

• & = np.bitwise_and
• | = np.bitwise_or
• ~ = np.bitwise_not
• ^ = np.bitwise_xor （或与）

import numpy as np
import pandas as pd

# 利用Pandas抽取降雨量，放入一个Numpy数组
rainfall = pd.read_csv('/home/mw/input/datascience8949/Seattle2014.csv')['PRCP'].values # values转化为numpy数组
inches = rainfall / 254 # 从英寸inches转化为毫米mm, 1英寸=25.4毫米
print('统计降水量大于0.5英寸 且 小于1英寸的天数：', np.sum((inches > 0.5) & (inches < 1)))
print('统计降水量大于0.5英寸 且 小于1英寸的天数：', np.sum(~((inches <= 0.5) | (inches >= 1))))
print('统计降水量大于0.5英寸 且 小于1英寸的天数：', np.sum(np.bitwise_and(inches > 0.5, inches < 1)))

统计降水量大于0.5英寸 且 小于1英寸的天数： 29
统计降水量大于0.5英寸 且 小于1英寸的天数： 29
统计降水量大于0.5英寸 且 小于1英寸的天数： 29

• 关键字and/or 与逻辑运算符&/|的区别：
• and/or 判断整个对象是真是假，0是False，非0整数均为True
• &/| 判断每个对象中的比特位，即将整数转化为二进制判断每个位，&：两个都为1则为1，有一个为0则为0；
• |：两个都为0则为0，有一个为1则为1
• 布尔数组可以被当作是由比特字符组成，其中True =1 , False = 0, 因此数组通常用逻辑运算符而不用and/or

print('bool(0), bool(1):', bool(0), bool(1))
print('bool(1 and 0): ', bool(1 and 0))
print('bool(1 or 0): ', bool(1 or 0))
print('二进制3：', bin(42))
print('二进制4：', bin(59))
print('42 & 59 :', bin(42 & 59), 42 & 59)
print('42 | 59 :', bin(42 | 59), 42 | 59)

bool(0), bool(1): False True
bool(1 and 0): False
bool(1 or 0): True
二进制3： 0b101010
二进制4： 0b111011
42 & 59 : 0b101010 42
42 | 59 : 0b111011 59

2 花哨的索引（仅一个索引框）

# 花哨的索引意味着传递一个索引数组来一次性获得多个数组元素
import numpy as np
rand = np.random.RandomState(42)
x = rand.randint(100, size = 10)
print('x:', x)
print('获得三个不同的元素：[x[3], x[7], x[2]:', [x[3], x[7], x[2]])
# 通过传递索引的单个列表或数组获得三个不同的元素
ind = [3, 7, 2]
print(x[ind])

# 利用花哨的索引获得的结果形状与索引数组的形状一致，而不是与被索引数据的形状一致
ind = np.array([[3, 7], 
                [4, 5]])
print(x[ind])
print('--------------')
# 对多个维度适用，和标准的索引一样，第一个索引指的是行，第二个索引指的是列
X = np.arange(12).reshape(3, 4)
print('X:\n', X)
row = np.array([0, 1, 2])
col = np.array([2, 1, 3])
print('row, col', row, col)
print('X[0, 2]:', X[0, 2])
print('X[1, 1]:', X[1, 1])
print('X[2, 3]:', X[2, 3])
# 结果的第一个值是X[0, 2]，第二个值是X[1, 1]，第三个值是X[2, 3]
print('X[row, col]:', X[row, col])
print('--------------')
# 索引数组[row, col]的配对遵循广播的规则
print(row[:, np.newaxis])
print(X[row[:, np.newaxis], col])
print(X[[[0, 0, 0],
  [1, 1, 1],
  [2, 2, 2]]
,
[[2, 1, 3],
 [2, 1, 3],
 [2, 1, 3]]])

x: [51 92 14 71 60 20 82 86 74 74]
获得三个不同的元素：[x[3], x[7], x[2]: [71, 86, 14]
[71 86 14]
[[71 86]
[60 20]]

---

X:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
row, col [0 1 2] [2 1 3]
X[0, 2]: 2
X[1, 1]: 5
X[2, 3]: 11
X[row, col]: [ 2 5 11]

---

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

3 组合索引

花哨索引和其他索引组合（简单索引、切片、布尔掩码）使用

print('X: \n', X)
print('---------')

# 花哨索引和简单索引组合使用
print('X[2, [2, 0, 1]]: ', X[2, [2, 0, 1]])

# 花哨索引和切片组合使用
# 选择了X第2行到最后一行，索引2,0,1列对应的一个2X3的数组
print('X[1:, [2, 0, 1]: \n', X[1:, [2, 0, 1]])

# 花哨索引和掩码组合使用，1=True表示选择该列，0=False表示不选择
mask = np.array([1, 0, 1, 0], dtype = bool)
print('布尔数组掩码：', mask)
print('X[row[:, np.newaxis], mask]: \n', X[row[:, np.newaxis], mask])

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

---

X[2, [2, 0, 1]]: [10 8 9]
X[1:, [2, 0, 1]:
[[ 6 4 5]
[10 8 9]]
布尔数组掩码： [ True False True False]
X[row[:, np.newaxis], mask]:
[[ 0 2]
[ 4 6]
[ 8 10]]