【NumPy】官方文档详解（二）NumPy快速入门：广播机制和高级索引

1 . 广播机制Broadcasting rules

1.1 原理介绍

广播提供了一种矢量化数组操作的方法，以便循环在C而不是Python中发生，从而更加高效。而在某些情况下，广播也会导致内存使用效率低下，从而减慢计算速度。因此，我们要善于在适合的场景下使用广播。

广播允许通用函数以有意义的方式处理形状不完全相同的输入。 根据某些约束，较小的数组可以在较大的数组上“广播”，以便它们具有匹配和兼容的形状。

numpy操作通常是逐个元素完成的，这需要两个数组具有完全相同的形状。而当数组的形状满足某些条件时，numpy 的广播规则会放宽此约束。例如，在进行数组与标量值的计算时，可以看作将标量拉伸成与之形状相同的数组：

a = np.array([[1,2,3,4],[5,6,7,8]])
a = a+1
print(a)

[[2 3 4 5]
 [6 7 8 9]]

1.2 广播规则

在对两个数组进行操作时，NumPy 会按比较它们的形状。它从尾随（即最右边）尺寸开始，然后向左进行。当两个尺寸兼容时：

• 它们是相等的，或者
• 其中之一是 1

如果不满足这些条件，则会引发异常，指示数组具有不兼容的形状。当比较的尺寸之一为“1”时，将使用另一个尺寸。换言之，尺寸为 1 的将被拉伸或"复制"以匹配其他尺寸。最后生成的数组的大小是沿输入的每个轴不是 1 的大小。

例如，A与B维数不同，在B形状的最左侧补1，B变成(1,7,1,5) ，从右边开始比较，1和5不同，将A的该维度"复制"5次以匹配B，6和1不同，将B的该维度“复制”6次，……，最后形成的数组形状为(8,7,6,5)

A      (4d array):  8 x 1 x 6 x 1          
B      (3d array):      7 x 1 x 5
Result (4d array):  8 x 7 x 6 x 5

再举个直观的例子：

a = np.array([1,2,3])
b = np.array([1,2,3]).reshape((3,1))
print(a)
print(b)
print(a+b)

[1 2 3]     # a  1*3

[[1]
 [2]
 [3]]       # b  3*1
 
[[2 3 4]
 [3 4 5]
 [4 5 6]]   # a+b  3*3

---

2. 索引技巧

NumPy提供了比常规Python序列更多的索引工具。除了按整数和切片编制索引之外，数组还可以通过整数数组和布尔数组进行索引。

2.1 以“索引的数组”为索引 Indexing with Arrays of Indices

2.1.1 当被索引数组是一维时

a = np.arange(12)**2    # a是一维数组
i = np.array([1, 1, 3, 8, 5])
j = np.array([[3, 4], [9, 7]])
print(a[i])  
print(a[j])  

[ 1  1  9 64 25]

[[ 9 16]
 [81 49]]              # 形状和j相同

2.1.2 当被索引数组是多维时

（1）索引数组中每个数指的是第一维各元素的编号，例如：

a = np.arange(15).reshape((5,3))
b = np.array([0,0,2,4])
print(a)
print(a[b])

[[ 0  1  2]  # 0
 [ 3  4  5]  # 1
 [ 6  7  8]  # 2
 [ 9 10 11]  # 3
 [12 13 14]] # 4
 
[[ 0  1  2]  # 0
 [ 0  1  2]  # 0
 [ 6  7  8]  # 2
 [12 13 14]]  # 4

（2）也可以对多个维度都进行索引，对不同维度的索引用逗号进行隔开。每个维度的索引数组都要有相同的形状：

>>> a = np.arange(12).reshape(3,4)
>>> a
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
>>> i = np.array( [ [0,1],                      # 第一个轴的索引
...                 [1,2] ] )
>>> j = np.array( [ [2,1],                        # 第二个轴的索引
...                 [3,3] ] )
>>>
>>> a[i,j]                                     # i 和 j形状必须相同
array([[ 2,  5],
       [ 7, 11]])

$a[i,j]$的机制是数组 $i$ 和数组 $j$ 相同位置的对应数字两两组成一对索引，然后用这对索引在数组a中进行取值。比如数组 $i$ 的索引(0,0)处的值为0，数组 $j$ 的索引(0,0)处的值为2，它们组成的索引对是(0,2)，在数组a中对应的值是2。在这样的机制下，理所当然要求数组i和数组 $j$ 需要有相同的形状，否则将无法取得相应的索引对。又因为数组 $i$ 和数组 $j$ 分别是数组a的两个轴(axis)上的索引数组，所以最终的结果也就和数组i/j的形状相同。

数组 $i$ 是数组a第一个轴的索引数组，a[i,2]中的数字2表示数组a的第二个轴的索引，即取a中[0,2],[1,2],[1,2],[2,2]对应的值：

>>> a[i, 2]
array([[ 2,  6],
       [ 6, 10]])

对数组a第一个轴进行完整切片，得到(0,1,2)，然后每个值都与数组j中的元素两两组成索引对，也就是组成3个二维索引对，然后根据索引对取数组a中的值：

>>> a[:, j]
array([[[ 2,  1],
        [ 3,  3]],

       [[ 6,  5],
        [ 7,  7]],

       [[10,  9],
        [11, 11]]])

可以利用数组索引对数组赋值，但是，如果索引列表有重复值，也会多次赋值，以最后一次赋值为准：

>>> a = np.arange(5)
>>> a[[0,0,2]]=[1,2,3]
>>> a
array([2, 1, 3, 3, 4])

2.2 以布尔值数组为索引

对于布尔索引，可以想到的最自然的方法是使用与原始数组具有相同形状的布尔数组：

>>> a = np.arange(12).reshape(3, 4)
>>> b = a > 4
>>> b  # `b` is a boolean with `a`'s shape
array([[False, False, False, False],
       [False,  True,  True,  True],
       [ True,  True,  True,  True]])
>>> a[b]  # 1d array with the selected elements
array([ 5,  6,  7,  8,  9, 10, 11])

此属性在赋值中非常有用：

>>> a[b] = 0  # 所有大于4的值变为0
>>> a
array([[0, 1, 2, 3],
       [4, 0, 0, 0],
       [0, 0, 0, 0]])

使用布尔索引的第二种方式比较类似于整数索引；对数组每一维，我们提供一维的布尔数组来选择我们想要的值。

>>> a = np.arange(12).reshape(3, 4)
>>> b1 = np.array([False, True, True])         # 对a第一维的选择
>>> b2 = np.array([True, False, True, False])  # 对a第二维的选择
>>>
>>> a[b1, :]                                   # 选择行
array([[ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
>>>
>>> a[b1]                                      # 同上
array([[ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
>>>
>>> a[:, b2]                                   # 选择列
array([[ 0,  2],
       [ 4,  6],
       [ 8, 10]])
>>>
>>> a[b1, b2]                                  # a weird thing to do
array([ 4, 10])