Task 04

数学函数及逻辑函数

向量化和广播
向量化和广播这两个概念是 numpy 内部实现的基础。有了向量化，编写代码时无需使用显式循环。这些循环实际上不能省略，只不过是在内部实现，被代码中的其他结构代替。向量化的应用使得代码更简洁，可读性更强，也可以说使用了向量化方法的代码看上去更“Pythonic”。
广播（Broadcasting）机制描述了 numpy 如何在算术运算期间处理具有不同形状的数组，让较小的数组在较大的数组上“广播”，以便它们具有兼容的形状。并不是所有的维度都要彼此兼容才符合广播机制的要求，但它们必须满足一定的条件。
若两个数组的各维度兼容，也就是两个数组的每一维等长，或其中一个数组为 一维，那么广播机制就适用。如果这两个条件不满足，numpy就会抛出异常，说两个数组不兼容。

总结来说，广播的规则有三个：
如果两个数组的维度数dim不相同，那么小维度数组的形状将会在左边补1；
如果shape维度不匹配，但是有维度是1，那么可以扩展维度是1的维度匹配另一个数组；
如果shape维度不匹配，但是没有任何一个维度是1，则匹配引发错误。

  #  二维数组加一维数组
import numpy as np

x = np.arange(4)
y = np.ones((3, 4))
print(x.shape)  
print(y.shape)  
print()
print((x + y).shape)
pritn() 
print(x + y)
#  (4,)
#  (3, 4)

#  (3, 4)

#  [[1. 2. 3. 4.]
#   [1. 2. 3. 4.]
#   [1. 2. 3. 4.]]

  #  两个数组均需要广播
import numpy as np

x = np.arange(4).reshape(4, 1)
y = np.ones(5)

print(x.shape)  
print(y.shape)  
print((x + y).shape)
print()
print(x + y)
print()
x = np.array([0.0, 10.0, 20.0, 30.0])
y = np.array([1.0, 2.0, 3.0])
z = x[:, np.newaxis] + y
print(z)
#  (4, 1)
#  (5,)
#  (4, 5)

#  [[1. 1. 1. 1. 1.]
#   [2. 2. 2. 2. 2.]
#   [3. 3. 3. 3. 3.]
#   [4. 4. 4. 4. 4.]]

#  [[ 1.  2.  3.]
#   [11. 12. 13.]
#   [21. 22. 23.]
#   [31. 32. 33.]]

算数运算
numy.add(x1, x2, *args, **kwargs) # 加
numpy.subtract(x1, x2, *args, **kwargs) # 减
numpy.multiply(x1, x2, *args, **kwargs) # 乘
numpy.divide(x1, x2, *args, **kwargs)
numpy.floor_divide(x1, x2, *args, **kwargs)
numpy.power(x1, x2, *args, **kwargs)
在 numpy 中对以上函数进行了运算符的重载，且运算符为 元素级。也就是说，它们只用于位置相同的元素之间，所得到的运算结果组成一个新的数组。

#  numpy的广播规则
import numpy as np

x = np.array([1, 2, 3, 4, 5, 6, 7, 8])
y = x + 1
print(y)
print(np.add(x, 1))
print()
y = x - 1
print(y)
print(np.subtract(x, 1))
print()
y = x * 2
print(y)
print(np.multiply(x, 2))
print()
y = x / 2
print(y)
print(np.divide(x, 2))
print()
y = x // 2
print(y)
print(np.floor_divide(x, 2))
print()
y = x ** 2
print(y)
print(np.power(x, 2))
#  [2 3 4 5 6 7 8 9]
#  [2 3 4 5 6 7 8 9]

#  [0 1 2 3 4 5 6 7]
#  [0 1 2 3 4 5 6 7]

#  [ 2  4  6  8 10 12 14 16]
#  [ 2  4  6  8 10 12 14 16]

#  [0.5 1.  1.5 2.  2.5 3.  3.5 4. ]
#  [0.5 1.  1.5 2.  2.5 3.  3.5 4. ]

#  [0 1 1 2 2 3 3 4]
#  [0 1 1 2 2 3 3 4]

#  [ 1  4  9 16 25 36 49 64]
#  [ 1  4  9 16 25 36 49 64]

numpy.sqrt(x, *args, **kwargs)
numpy.square(x, *args, **kwargs)

import numpy as np

x = np.arange(1, 5)
print(x) 
print()
y = np.sqrt(x)
print(y)
print()
print(np.power(x, 0.5))
print()
y = np.square(x)
print(y)
print()
print(np.power(x, 2))
#  [1 2 3 4]

#  [1.         1.41421356 1.73205081 2.        ]

#  [1.         1.41421356 1.73205081 2.        ]

#  [ 1  4  9 16]

#  [ 1  4  9 16]

三角函数
numpy.sin(x, *args, **kwargs)
numpy.cos(x, *args, **kwargs)
numpy.tan(x, *args, **kwargs)
numpy.arcsin(x, *args, **kwargs)
numpy.arccos(x, *args, **kwargs)
numpy.arctan(x, *args, **kwargs)
通用函数（universal function）通常叫作ufunc，它对数组中的各个元素逐一进行操作。这表明，通用函数分别处理输入数组的每个元素，生成的结果组成一个新的输出数组。输出数组的大小跟输入数组相同。
三角函数等很多数学运算符合通用函数的定义，例如，计算平方根的sqrt()函数、用来取对数的log()函数和求正弦值的sin()函数。

import numpy as np

x = np.linspace(start=0, stop=np.pi / 2, num=10)
print(x)
print()
y = np.sin(x)
print(y)
print()
z = np.arcsin(y)
print(z)
print()
y = np.cos(x)
print(y)
print()
z = np.arccos(y)
print(z)
print()
y = np.tan(x)
print(y)
print()
z = np.arctan(y)
print(z)
#  [0.         0.17453293 0.34906585 0.52359878 0.6981317  0.87266463
#   1.04719755 1.22173048 1.3962634  1.57079633]

#  [0.         0.17364818 0.34202014 0.5        0.64278761 0.76604444
#   0.8660254  0.93969262 0.98480775 1.        ]

#  [0.         0.17453293 0.34906585 0.52359878 0.6981317  0.87266463
#   1.04719755 1.22173048 1.3962634  1.57079633]

#  [1.00000000e+00 9.84807753e-01 9.39692621e-01 8.66025404e-01
#   7.66044443e-01 6.42787610e-01 5.00000000e-01 3.42020143e-01
#   1.73648178e-01 6.12323400e-17]

#  [0.         0.17453293 0.34906585 0.52359878 0.6981317  0.87266463
#   1.04719755 1.22173048 1.3962634  1.57079633]

#  [0.00000000e+00 1.76326981e-01 3.63970234e-01 5.77350269e-01
#   8.39099631e-01 1.19175359e+00 1.73205081e+00 2.74747742e+00
#   5.67128182e+00 1.63312394e+16]

#  [0.         0.17453293 0.34906585 0.52359878 0.6981317  0.87266463
#   1.04719755 1.22173048 1.3962634  1.57079633]

指数和对数
numpy.exp(x, *args, **kwargs)
numpy.log(x, *args, **kwargs)
numpy.exp2(x, *args, **kwargs)
numpy.log2(x, *args, **kwargs)
numpy.log10(x, *args, **kwargs)

import numpy as np

x = np.arange(1, 5)
print(x)
print()
y = np.exp(x)
print(y)
print()
z = np.log(y)
print(z)
#  [1 2 3 4]

#  [ 2.71828183  7.3890561  20.08553692 54.59815003]

#  [1. 2. 3. 4.]

加法函数、乘法函数
numpy.sum(a[, axis=None, dtype=None, out=None, …])
通过不同的 axis，numpy 会沿着不同的方向进行操作：如果不设置，那么对所有的元素操作；如果axis=0，则沿着纵轴进行操作；axis=1，则沿着横轴进行操作。但这只是简单的二位数组，如果是多维的呢？可以总结为一句话：设axis=i，则 numpy 沿着第i个下标变化的方向进行操作。
numpy.cumsum(a, axis=None, dtype=None, out=None)
聚合函数 是指对一组值（比如一个数组）进行操作，返回一个单一值作为结果的函数。因而，求数组所有元素之和的函数就是聚合函数。ndarray类实现了多个这样的函数。

  #  返回给定轴上的数组元素的总和
import numpy as np

x = np.array([[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]])
y = np.sum(x)
print(y)  
print()
y = np.sum(x, axis=0)
print(y)
print()
y = np.sum(x, axis=1)
print(y)
#  575

#  [105 110 115 120 125]

#  [ 65  90 115 140 165]

#  返回定轴上的数组元素累加和
import numpy as np

x = np.array([[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]])
y = np.cumsum(x)
print(y)
print()
y = np.cumsum(x, axis=0)
print(y)
print()
y = np.cumsum(x, axis=1)
print(y)
[ 11  23  36  50  65  81  98 116 135 155 176 198 221 245 270 296 323 351
 380 410 441 473 506 540 575]

#  [[ 11  12  13  14  15]
#   [ 27  29  31  33  35]
#   [ 48  51  54  57  60]
#   [ 74  78  82  86  90]
#   [105 110 115 120 125]]

#  [[ 11  23  36  50  65]
#   [ 16  33  51  70  90]
#   [ 21  43  66  90 115]
#   [ 26  53  81 110 140]
#   [ 31  63  96 130 165]]

numpy.prod(a[, axis=None, dtype=None, out=None, …]) # 乘积
numpy.cumprod(a, axis=None, dtype=None, out=None) # 累乘

#  返回给定轴上数组元素的乘积
import numpy as np

x = np.array([[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]])
y = np.prod(x)
print(y)  
print()
y = np.prod(x, axis=0)
print(y)
print()
y = np.prod(x, axis=1)
print(y)
#  788529152

#  [2978976 3877632 4972968 6294624 7875000]

#  [  360360  1860480  6375600 17100720 38955840]

  #  返回给定轴上数组元素的累乘
import numpy as np

x = np.array([[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]])
y = np.cumprod(x)
print(y)
print()
y = np.cumprod(x, axis=0)
print(y)
print()
y = np.cumprod(x, axis=1)
print(y)
#  [         11         132        1716       24024      360360     #  5765760
#      98017920  1764322560  -837609728   427674624   391232512    #  17180672
#     395155456   893796352   870072320  1147043840   905412608  #  -418250752
#     755630080  1194065920 -1638662144  -897581056   444596224 #  -2063597568
#     788529152]


#  [[     11      12      13      14      15]
#   [    176     204     234     266     300]
#   [   3696    4488    5382    6384    7500]
#   [  96096  121176  150696  185136  225000]
#   [2978976 3877632 4972968 6294624 7875000]]

#  [[      11      132     1716    24024   360360]
#   [      16      272     4896    93024  1860480]
#   [      21      462    10626   255024  6375600]
#   [      26      702    19656   570024 17100720]
#   [      31      992    32736  1113024 38955840]]

numpy.diff(a, n=1, axis=-1, prepend=np._NoValue, append=np._NoValue) # 差值
a：输入矩阵.
n：可选，代表要执行几次差值.
axis：默认是最后一个.

沿着指定轴计算第N维的离散差值
import numpy as np

A = np.arange(2, 14).reshape((3, 4))
A[1, 1] = 8
print(A)
print()
print(np.diff(A))
print()
print(np.diff(A, axis=0))
#  [[ 2  3  4  5]
#   [ 6  8  8  9]
#   [10 11 12 13]]

#  [[1 1 1]
#   [2 0 1]
#   [1 1 1]]

#  [[4 5 4 4]
#   [4 3 4 4]]

四舍五入
numpy.around(a, decimals=0, out=None) # 舍入

import numpy as np

x = np.random.rand(3, 3) * 10
print(x)
print()
y = np.around(x)
print(y)
print()
y = np.around(x, decimals=2)
print(y)
[[6.21405305 3.9502371  5.99466005]
 [8.41636019 0.36589317 0.29549992]
 [9.68230437 5.19238791 2.31586774]]

[[ 6.  4.  6.]
 [ 8.  0.  0.]
 [10.  5.  2.]]

#  [[6.21 3.95 5.99]
#   [8.42 0.37 0.3 ]
#   [9.68 5.19 2.32]]

numpy.ceil(x, *args, **kwargs) # 上限
numpy.floor(x, *args, **kwargs) # 下限

import numpy as np

x = np.random.rand(3, 3) * 10
print(x)
print()
y = np.ceil(x)
print(y)
print()
y = np.floor(x)
print(y)
[[6.21132493 6.22116606 1.30223519]
 [6.75712874 3.79677817 2.14575888]
 [7.16364242 4.04178689 9.35675049]]

#  [[ 7.  7.  2.]
#   [ 7.  4.  3.]
#   [ 8.  5. 10.]]

#  [[6. 6. 1.]
#   [6. 3. 2.]
#   [7. 4. 9.]]

杂项
numpy.clip(a, a_min, a_max, out=None, **kwargs) # 裁剪

import numpy as np

x = np.array([[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]])
y = np.clip(x, a_min=20, a_max=30)
print(y)
#  [[20 20 20 20 20]
#   [20 20 20 20 20]
#   [21 22 23 24 25]
#   [26 27 28 29 30]
#   [30 30 30 30 30]]

numpy.absolute(x, *args, **kwargs) # 绝对值
numpy.abs(x, *args, **kwargs)

import numpy as np

x = np.arange(-5, 5)
print(x)
print()
y = np.abs(x)
print(y)
print()
y = np.absolute(x)
print(y)
#  [-5 -4 -3 -2 -1  0  1  2  3  4]

#  [5 4 3 2 1 0 1 2 3 4]

#  [5 4 3 2 1 0 1 2 3 4]

numpy.sign(x, *args, **kwargs) # 返回数字符号的逐元素指示

x = np.arange(-5, 5)
print(x)
print()
print(np.sign(x))
#  [-5 -4 -3 -2 -1  0  1  2  3  4]

#  [-1 -1 -1 -1 -1  0  1  1  1  1]