十月学习打卡-numpy-4
1.向量化和广播
向量化和广播这两个概念是 numpy 内部实现的基础。有了向量化，编写代码时无需使用显式循环。这些循环实际上不能省略，只不过是在内部实现，被代码中的其他结构代替。向量化的应用使得代码更简洁，可读性更强，也可以说使用了向量化方法的代码看上去更“Pythonic”。
广播（Broadcasting）机制描述了 numpy 如何在算术运算期间处理具有不同形状的数组，让较小的数组在较大的数组上“广播”，以便它们具有兼容的形状。并不是所有的维度都要彼此兼容才符合广播机制的要求，但它们必须满足一定的条件。
若两个数组的各维度兼容，也就是两个数组的每一维等长，或其中一个数组为 一维，那么广播机制就适用。如果这两个条件不满足，numpy就会抛出异常，说两个数组不兼容。
总结来说，广播的规则有三个：
1.如果两个数组的维度数dim不相同，那么小维度数组的形状将会在左边补1。
2.如果shape维度不匹配，但是有维度是1，那么可以扩展维度是1的维度匹配另一个数组；
3.如果shape维度不匹配，但是没有任何一个维度是1，则匹配引发错误；
【例】二维数组加一维数组
import numpy as np
x = np.arange(4)
y = np.ones((3, 4))
print(x.shape) # (4,)
print(y.shape) # (3, 4)
print((x + y).shape) # (3, 4)
print(x + y)
# [[1. 2. 3. 4.]
# [1. 2. 3. 4.]
# [1. 2. 3. 4.]]
【例】两个数组均需要广播
x = np.arange(4).reshape(4, 1)
y = np.ones(5)
print(x.shape) # (4, 1)
print(y.shape) # (5,)
print((x + y).shape) # (4, 5)
print(x + y)
# [[1. 1. 1. 1. 1.]
# [2. 2. 2. 2. 2.]
# [3. 3. 3. 3. 3.]
# [4. 4. 4. 4. 4.]]
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)
# [[ 1. 2. 3.]
# [11. 12. 13.]
# [21. 22. 23.]
# [31. 32. 33.]]
2.数学函数
算数运算
numpy.add
numpy.subtract
numpy.multiply
numpy.divide
numpy.floor_divide
numpy.power
numpy.add(x1, x2, *args, **kwargs) Add arguments element-wise.
numpy.subtract(x1, x2, *args, **kwargs) Subtract arguments element-wise.
numpy.multiply(x1, x2, *args, **kwargs) Multiply arguments element-wise.
numpy.divide(x1, x2, *args, **kwargs) Returns a true division of the inputs, element-wise.
numpy.floor_divide(x1, x2, *args, **kwargs) Return the largest integer smaller or equal to the division of the inputs.
numpy.power(x1, x2, *args, **kwargs) First array elements raised to powers from second array, element-wise.
在numpy 中对以上函数进行了运算符的重载，且运算符为 元素级。也就是说，它们只用于位置相同的元素之间，所得到的运算结果组成一个新的数组。
【例】一维数组的数学运算,注意 numpy 的广播规则。
x = np.array([1, 2, 3, 4, 5, 6, 7, 8])
y = x + 1
print(y)
print(np.add(x, 1))
# [2 3 4 5 6 7 8 9]
y = x - 1
print(y)
print(np.subtract(x, 1))
# [0 1 2 3 4 5 6 7]
y = x * 2
print(y)
print(np.multiply(x, 2))
# [ 2 4 6 8 10 12 14 16]
y = x / 2
print(y)
print(np.divide(x, 2))
# [0.5 1. 1.5 2. 2.5 3. 3.5 4. ]
y = x // 2
print(y)
print(np.floor_divide(x, 2))
# [0 1 1 2 2 3 3 4]
y = x ** 2
print(y)
print(np.power(x, 2))
# [ 1 4 9 16 25 36 49 64]
【例】多维数组的数学运算,注意 numpy 的广播规则。
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 = x + 1
print(y)
print(np.add(x, 1))
# [[12 13 14 15 16]
# [17 18 19 20 21]
# [22 23 24 25 26]
# [27 28 29 30 31]
# [32 33 34 35 36]]
y = x - 1
print(y)
print(np.subtract(x, 1))
# [[10 11 12 13 14]
# [15 16 17 18 19]
# [20 21 22 23 24]
# [25 26 27 28 29]
# [30 31 32 33 34]]
y = x * 2
print(y)
print(np.multiply(x, 2))
# [[22 24 26 28 30]
# [32 34 36 38 40]
# [42 44 46 48 50]
# [52 54 56 58 60]
# [62 64 66 68 70]]
y = x / 2
print(y)
print(np.divide(x, 2))
# [[ 5.5 6. 6.5 7. 7.5]
# [ 8. 8.5 9. 9.5 10. ]
# [10.5 11. 11.5 12. 12.5]
# [13. 13.5 14. 14.5 15. ]
# [15.5 16. 16.5 17. 17.5]]
y = x // 2
print(y)
print(np.floor_divide(x, 2))
# [[ 5 6 6 7 7]
# [ 8 8 9 9 10]
# [10 11 11 12 12]
# [13 13 14 14 15]
# [15 16 16 17 17]]
y = x ** 2
print(y)
print(np.power(x, 2))
# [[ 121 144 169 196 225]
# [ 256 289 324 361 400]
# [ 441 484 529 576 625]
# [ 676 729 784 841 900]
# [ 961 1024 1089 1156 1225]]
numpy.diff 差值
numpy.diff(a, n=1, axis=-1, prepend=np._NoValue, append=np._NoValue) Calculate the n-th discrete difference along the given axis.
a：输入矩阵
n：可选，代表要执行几次差值
axis：默认是最后一个
【例】沿着指定轴计算第N维的离散差值
A = np.arange(2, 14).reshape((3, 4))
A[1, 1] = 8
print(A)
# [[ 2 3 4 5]
# [ 6 8 8 9]
# [10 11 12 13]]
print(np.diff(A))
# [[1 1 1]
# [2 0 1]
# [1 1 1]]
print(np.diff(A, axis=0))
# [[4 5 4 4]
# [4 3 4 4]]
四舍五入
numpy.around(a, decimals=0, out=None) Evenly round to the given number of decimals.
【例】将数组舍入到给定的小数位数。
x = np.random.rand(3, 3) * 10
print(x)
# [[6.59144457 3.78566113 8.15321227]
# [1.68241475 3.78753332 7.68886328]
# [2.84255822 9.58106727 7.86678037]]
y = np.around(x)
print(y)
# [[ 7. 4. 8.]
# [ 2. 4. 8.]
# [ 3. 10. 8.]]
y = np.around(x, decimals=2)
print(y)
# [[6.59 3.79 8.15]
# [1.68 3.79 7.69]
# [2.84 9.58 7.87]]
numpy.clip 裁剪
numpy.clip(a, a_min, a_max, out=None, **kwargs): Clip (limit) the values in an array.
Given an interval, values outside the interval are clipped to the interval edges. For example, if an interval of [0, 1] is specified, values smaller than 0 become 0, and values larger than 1 become 1.
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]]
3.逻辑运算
numpy.isnan(x, *args, **kwargs) Test element-wise for NaN and return result as a boolean array.
【例】
a=np.array([1,2,np.nan])
print(np.isnan(a))
#[False False True]
numpy.equal:
numpy.equal(x1, x2, *args, **kwargs) Return (x1 == x2) element-wise.
numpy.not_equal:
numpy.not_equal(x1, x2, *args, **kwargs) Return (x1 != x2) element-wise.
x = np.array([1, 2, 3, 4, 5, 6, 7, 8])
y = x == 2
print(y)
print(np.equal(x, 2))
# [False True False False False False False False]
[False True False False False False False False]
[False True False False False False False False]
y = x != 2
print(y)
print(np.not_equal(x, 2))
# [ True False True True True True True True]
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
