numpy Task04数学函数和逻辑函数

数学函数

向量化和广播

向量化和广播这两个概念是 numpy 内部实现的基础。有了向量化，编写代码时无需使用显式循环。这些循环实际上不能省略，只不过是在内部实现，被代码中的其他结构代替。向量化的应用使得代码更简洁，可读性更强，也可以说使用了向量化方法的代码看上去更“Pythonic”。

广播机制描述了 numpy 如何在算术运算期间处理具有不同形状的数组，让较小的数组在较大的数组上“广播”，以便它们具有兼容的形状。并不是所有的维度都要彼此兼容才符合广播机制的要求，但它们必须满足一定的条件。

若两个数组的各维度兼容，也就是两个数组的每一维等长，或其中一个数组为 一维，那么广播机制就适用。如果这两个条件不满足，numpy就会抛出异常，说两个数组不兼容。

总结来说，广播的规则有三个：

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

二维数组加一维数组

import numpy as np
x = np.arange(4)
y = np.ones((3,4))
print(x+y)

[[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+y)

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

数学函数

数学运算

• numpy.add(x1, x2, *args, **kwargs) 相加.

import numpy as np
x = np.array([1,2,3,4,5,6,7,8])
print(np.add(x,1))

[2 3 4 5 6 7 8 9]

• numpy.subtract(x1, x2, *args, **kwargs) 相减.

print(x)
print("++++++++++++++")
print(np.multiply(x,2))

print(x)
print("++++++++++++++")
print(np.multiply(x,2))
print(x)
print("++++++++++++++")
print(np.multiply(x,2))
[1 2 3 4 5 6 7 8]
++++++++++++++
[ 2 4 6 8 10 12 14 16]

• numpy.divide(x1, x2, *args, **kwargs) 相除.

print(x)
print('++++++++++++++')
print(np.divide(x,2))

[1 2 3 4 5 6 7 8]
++++++++++++++
[0.5 1. 1.5 2. 2.5 3. 3.5 4. ]

• numpy.floor_divide(x1, x2, *args, **kwargs) 除法并向下取整.

print(x)
print('+++++++++++++++')
print(np.floor_divide(x,2))

[1 2 3 4 5 6 7 8]
+++++++++++++++
[0 1 1 2 2 3 3 4]

• numpy.power(x1, x2, *args, **kwargs) 次幂.

print(x)
print('++++++++++++++')
print(np.power(x,2))

[1 2 3 4 5 6 7 8]
++++++++++++++
[ 1 4 9 16 25 36 49 64]

• numpy.sqrt(x, *args, **kwargs) 平方根.

x = np.arange(1,5)
print(np.sqrt(x))

[1. 1.41421356 1.73205081 2. ]

• numpy.square(x, *args, **kwargs)平方.

print(x)
print('++++++++++++++')
print(np.square(x))

[1 2 3 4]
++++++++++++++
[ 1 4 9 16]

三角函数

• numpy.sin(x, *args, **kwargs) Trigonometric sine, element-wise.
• numpy.arcsin(x, *args, **kwargs) Inverse sine, element-wise.

import numpy as np
x = np.linspace(start=0,stop=np.pi, num=10)
print(x)
print('++++++++++++++')
y = np.sin(x)
print(y)
print('+++++++++++++++')
print(np.arcsin(y))

[0. 0.34906585 0.6981317 1.04719755 1.3962634 1.74532925
2.0943951 2.44346095 2.7925268 3.14159265]
++++++++++++++
[0.00000000e+00 3.42020143e-01 6.42787610e-01 8.66025404e-01
9.84807753e-01 9.84807753e-01 8.66025404e-01 6.42787610e-01
3.42020143e-01 1.22464680e-16]
+++++++++++++++
[0.00000000e+00 3.49065850e-01 6.98131701e-01 1.04719755e+00
1.39626340e+00 1.39626340e+00 1.04719755e+00 6.98131701e-01
3.49065850e-01 1.22464680e-16]

• numpy.cos(x, *args, **kwargs) Cosine element-wise.
• numpy.arccos(x, *args, **kwargs) Trigonometric inverse cosine, element-wise.

print(x)
print('++++++++++++++')
y = np.cos(x)
print(y)
print('+++++++++++++++')
print(np.arccos(y))

[0. 0.34906585 0.6981317 1.04719755 1.3962634 1.74532925
2.0943951 2.44346095 2.7925268 3.14159265]
++++++++++++++
[ 1. 0.93969262 0.76604444 0.5 0.17364818 -0.17364818
-0.5 -0.76604444 -0.93969262 -1. ]
+++++++++++++++
[0. 0.34906585 0.6981317 1.04719755 1.3962634 1.74532925
2.0943951 2.44346095 2.7925268 3.14159265]

• numpy.tan(x, *args, **kwargs) Compute tangent element-wise.
• numpy.arctan(x, *args, **kwargs) Trigonometric inverse tangent, element-wise.

print(x)
print('++++++++++++++')
y = np.tan(x)
print(y)
print('+++++++++++++++')
print(np.arctan(y))

[0. 0.34906585 0.6981317 1.04719755 1.3962634 1.74532925
2.0943951 2.44346095 2.7925268 3.14159265]
++++++++++++++
[ 0.00000000e+00 3.63970234e-01 8.39099631e-01 1.73205081e+00
5.67128182e+00 -5.67128182e+00 -1.73205081e+00 -8.39099631e-01
-3.63970234e-01 -1.22464680e-16]
+++++++++++++++
[ 0.00000000e+00 3.49065850e-01 6.98131701e-01 1.04719755e+00
1.39626340e+00 -1.39626340e+00 -1.04719755e+00 -6.98131701e-01
-3.49065850e-01 -1.22464680e-16]

指数和对数

• numpy.exp(x, *args, **kwargs) Calculate the exponential of all elements in the input array.
• numpy.log(x, *args, **kwargs) Natural logarithm, element-wise.
• numpy.exp2(x, *args, kwargs) Calculate 2p for all p in the input array.
• numpy.log2(x, *args, **kwargs) Base-2 logarithm of x.
• numpy.log10(x, *args, **kwargs) Return the base 10 logarithm of the input array, element-wise.

加法函数、乘法函数

• numpy.sum(a[, axis=None, dtype=None, out=None, …]) 整体求和.

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]

• numpy.cumsum(a, axis=None, dtype=None, out=None) 聚合函数 是指对一组值（比如一个数组）进行操作，返回一个单一值作为结果的函数。因而，求数组所有元素之和的函数就是聚合函数。ndarray类实现了多个这样的函数.

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, …]) 乘积.

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)

• 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.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：默认是最后一个

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)

[[7.1548064 3.89050129 0.6841653 ]
[3.42990897 8.80920902 4.16570523]
[3.22147592 5.48891666 2.94508988]]
+++++++++++++++
[[7. 4. 1.]
[3. 9. 4.]
[3. 5. 3.]]
+++++++++++++++
[[7.15 3.89 0.68]
[3.43 8.81 4.17]
[3.22 5.49 2.95]]

• numpy.ceil(x, *args, **kwargs) 向上取整。
• numpy.floor(x, *args, **kwargs)向下取整。

其他

• 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.abs(x, *args, **kwargs) 绝对值

x = np.arange(-5, 5)
print(x)
print('+++++++++++++++')
y = np.abs(x)
print(y)

[-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]

逻辑函数

真值测试

• numpy.all(a, axis=None, out=None, keepdims=np._NoValue) 全真则为真.
• numpy.any(a, axis=None, out=None, keepdims=np._NoValue) 任一真则为真.

import numpy as np
a = np.array([0,4,5])
b = np.copy(a)
print(np.all(a==b))
print(np.any(a==b))

b[0]=1
print(np.all(a==b))
print(np.any(a==b))

True
True
False
True

数组内容

• numpy.isnan(x, *args, **kwargs) 判断元素是否为NAN

a = np.array([1,2,np.nan])
print(np.isnan(a))

[False False True]

逻辑运算

• numpy.logical_not(x, *args, **kwargs)非.
• numpy.logical_and(x1, x2, *args, **kwargs)与.
• numpy.logical_or(x1, x2, *args, **kwargs)或.
• numpy.logical_xor(x1, x2, *args, **kwargs)异或.

print(np.logical_not([True,False,0,1]))

print(np.logical_and([True,False],[True,False]))

print(np.logical_or([True,False],[False,False]))

print(np.logical_xor([True,True,False,False],[True,False,True,False]))

[False True True False]
[ True False]
[ True False]
[False True True False]

对照

• numpy.greater(x1, x2, *args, **kwargs) 大于
• numpy.greater_equal(x1, x2, *args, **kwargs) 大于等于
• numpy.equal(x1, x2, *args, **kwargs) 等于.
• numpy.not_equal(x1, x2, *args, **kwargs) 不等于.
• numpy.less(x1, x2, *args, **kwargs) 小于
• numpy.less_equal(x1, x2, *args, **kwargs) 小于等于

x = np.array([1,2,3,4,5,6,7,8])
print(np.greater(x,2))
print(np.greater_equal(x,2))
print(np.equal(x,2))
print(np.not_equal(x,2))
print(np.less(x,2))
print(np.less_equal(x,2))

[False False True True True True True True]
[False True True True True True True True]
[False True False False False False False False]
[ True False True True True True True True]
[ True False False False False False False False]
[ True True False False False False False False]