算数运算

与常规的list对象不同，numpy支持把整个数组带入算数运算。

之前提过，array对象往往要求所有元素保持统一的数据类型，因此numpy的运算能以数组为单位，而不用将元素提出来。
这也是numpy能够胜任高效运算的原因之一。

来看几个例子：

import numpy as np
arr = np.arange(1,10).reshape(3, 3)
array_1 = arr > 7   # 条件比较，返回bool
array_2 = arr * 0.3   # 加减乘除运算

arrs = np.arange(11,20).reshape(3,3)
array_3 = arrs / arr   # 数组间的运算

print(array_1)
print('* '*20)
print(array_2)
print('* '*20)
print(array_3)
# 运行结果：
[[False False False]
 [False False False]
 [False  True  True]]
* * * * * * * * * * * * * * * * * * * * 
[[0.3 0.6 0.9]
 [1.2 1.5 1.8]
 [2.1 2.4 2.7]]
* * * * * * * * * * * * * * * * * * * * 
[[11.          6.          4.33333333]
 [ 3.5         3.          2.66666667]
 [ 2.42857143  2.25        2.11111111]]

可以看到，numpy甚至支持两个数组对象的算数运算。我们因此得到结论：
在numpy中，参与算术运算的单位可以是数组（“可以”不是“只能”）。

数组和数字的计算没什么好说的。
而数组与数组的运算，我们发现上面的例子中，两个运算的数组结构相同。这很好理解，两组的元素呈一一对应关系，这是映射。

那如果一对结构不同的数组呢？这就是我们要讲的广播机制。

广播机制

“广播”，顾名思义有传递、向外扩散的意思。

numpy的广播机制也是如此，指两个不同shape的数组，在它们的shape满足一定条件时，可进行广播运算。这时，两个数组的元素按照一定规则扩散开来运算，并得到一个新的数组。

借用经典的描述就是，numpy中的广播机制旨在解决不同形状数组之间的算数运算问题。
我们来看数组运算的几个例子，观察广播机制是如何运作的：

import numpy as np
arr_2d_3x3 = np.arange(1,10).reshape(3, 3)   # 3*3
arr_1d_3 = np.arange(1,4)   # 3个元素的一维数组
arr_1d_4 = np.arange(1,5)   # 4个元素

array_jia = arr_2d_3x3 + arr_1d_3   # 3*3 与 3个元素 运算（拿拼音代替了..）
array_jian = arr_2d_3x3 - arr_1d_4   # 3*3 与 4个元素 运算

print(arr_2d_3x3)
print('- '*5)
print(arr_1d_3)
print(arr_1d_4)
print('* '*20)
print(array_jia)
print('* '*20)
print(array_jian)
# 运行结果：
[[1 2 3]
 [4 5 6]
 [7 8 9]]   # arr_2d_3x3
- - - - - 
[1 2 3]   # arr_1d_3
[1 2 3 4]   # arr_1d_4
* * * * * * * * * * * * * * * * * * * * 
[[ 2  4  6]
 [ 5  7  9]
 [ 8 10 12]]   # array_jia，3*3 与 3个元素 运算
* * * * * * * * * * * * * * * * * * * * 
ValueError: operands could not be broadcast together with shapes (3,3) (4,)    # array_jian，3*3 与 4个元素 运算

可以看到，两个数组在列数（个数）相同、行数（长短）不同时，“较短”的数组对“较长”的数组向下做了传播式的运算，这便是"广播机制"叫法的由来。而列数不同的数组就报错了，便不能广播。
到这还没完，再看一组例子：

import numpy as np
arr_2d_3x3 = np.arange(1,10).reshape(3, 3)   # 3*3
arr_2d_1x3 = np.arange(1,4).reshape(1, 3)   # 1*3
arr_2d_3x1 = np.arange(1,4).reshape(3, 1)   # 3*1
array_jia = arr_2d_3x3 + arr_2d_1x3   # 3*3 与 1*3 运算
array_jian = arr_2d_3x3 - arr_2d_3x1   # 3*3 与 3*1 运算

print(arr_2d_3x3)
print('- '*5)
print(arr_2d_1x3)
print('- '*5)
print(arr_2d_3x1)
print('* '*20)
print(array_jia)
print('* '*20)
print(array_jian)
# 运行结果：
[[1 2 3]
 [4 5 6]
 [7 8 9]]   # 3*3
- - - - - 
[[1 2 3]]   # 1*3
- - - - - 
[[1]
 [2]
 [3]]   # 3*1
* * * * * * * * * * * * * * * * * * * * 
[[ 2  4  6]
 [ 5  7  9]
 [ 8 10 12]]   # 3*3 与 1*3 运算
* * * * * * * * * * * * * * * * * * * * 
[[0 1 2]
 [2 3 4]
 [4 5 6]]   # 3*3 与 3*1 运算

arr_2d_3x3 = np.arange(1,10).reshape(3, 3)   # 3*3
arr_2d_1x3 = np.arange(1,7).reshape(2, 3)   # 2*3
array_jia = arr_2d_3x3 + arr_2d_1x3   # 3*3 与 2*3 运算
print(array_jia)
# 运行结果：
ValueError: operands could not be broadcast together with shapes (3,3) (2,3) 

通过上面第一个例子，很明显numpy在对两个方向不一致的数组进行运算时，基于“较短”数组的shape，选择运算规则是向行扩散还是列扩散。
用大白话说就是，相对于大数组，小数组行、列的饱和度。即：

• 列饱和、行缺失则广播行补充；
• 行饱和、列缺失则广播列补充。

无论如何，只要行/列有一个饱和的情况下，就将不饱和的地方广播至饱和。

而第二个例子可能你也感觉到了，3x3 和 2x3 这种形状好像根本没法广播，因为小数组拿来广播的元素是不唯一的。

是的，就是这么好理解。

可能你想问，那3d及以上的数组怎么广播呢？

其实，我们已经知道高维数组（体）由多个2维数组（面）组成。
所以你可能知道了，无非就是对多个“面”逐一广播而已。
就像这样：

import numpy as np
arr_2d_3x3 = np.arange(1,13).reshape(2, 3, 2)   # 3*3
arr_2d_3x1 = np.arange(1,4).reshape(3,1)
array_jia = arr_2d_3x3 + arr_2d_3x1   # 3*3 与 3*1 运算

print(arr_2d_3x3)
print('- '*5)
print(arr_2d_3x1)
print('* '*20)
print(array_jia)
# 运行结果：
[[[ 1  2]
  [ 3  4]
  [ 5  6]]

 [[ 7  8]
  [ 9 10]
  [11 12]]]
- - - - - 
[[1]
 [2]
 [3]]   # 这是多行一列，一行多列就不举例了
* * * * * * * * * * * * * * * * * * * * 
[[[ 2  3]
  [ 5  6]
  [ 8  9]]   # 先广播第一块

 [[ 8  9]
  [11 12]
  [14 15]]]   # 再广播第二块

最后，我们总结一下广播机制：

• 广播机制，指两个数组间的推广运算；
• 广播对shape有一定要求。相对于大数组，小数组的行/列必须有一处饱和，且另一处唯一。即shape(1, n)或shape(n,1)；
• array对象和数字直接运算（object + 1），就是numpy广播机制的体现。
• 用于广播的小数组，必须是单个数字或二维（行、列）。

• 广播的本质是一种算数运算，适用于加减乘除及其他所有的运算方式。

  

  广播机制.png