python之Numpy 数学函数及逻辑函数_numpy 逻辑判断自定义函数-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_27326125/article/details/109608829

本文介绍了NumPy库中的数学函数和逻辑函数，包括向量化和广播机制的基础知识，数学运算如加减乘除和幂运算，三角函数，指数与对数函数，聚合函数如求和与乘积，以及逻辑函数如比较和布尔运算。还详细解释了这些函数的用法和参数。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

数学函数及逻辑函数

数学函数

向量化和广播

有了向量化，代码无需使用显式循环（这些循环实际上不能省略，只不过是在内部实现，被代码中的其他结构代替）
广播机制：描述了numpy如何在算术运算期间处理具有不同形状的数组，让较小的数组在较大的数组上“广播”，以便他们具有兼容的形状，兼容条件：两个数组的每一维等长，或其中一个数组为一维，那么广播机制就适用。
广播规则：

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

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

数学函数

算数运算

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.sqrt(x, *args, **kwargs)Return the non-negative square-root of an array, element-wise.
numpy.square(x, *args, **kwargs)Return the element-wise square of the input

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

y = np.sqrt(x)
print(y)
# [1.         1.41421356 1.73205081 2.        ]
print(np.power(x, 0.5))
# [1.         1.41421356 1.73205081 2.        ]

y = np.square(x)
print(y)
# [ 1  4  9 16]
print(np.power(x, 2))
# [ 1  4  9 16]

三角函数

numpy.sin
numpy.cos
numpy.tan
numpy.arcsin
numpy.arccos
numpy.arctan
*numpy.sin(x, *args, **kwargs) Trigonometric sine, element-wise.
numpy.cos(x, *args, **kwargs) Cosine element-wise.
numpy.tan(x, *args, **kwargs) Compute tangent element-wise.
numpy.arcsin(x, *args, **kwargs) Inverse sine, element-wise.
numpy.arccos(x, *args, **kwargs) Trigonometric inverse cosine, element-wise.
numpy.arctan(x, *args, *kwargs) Trigonometric inverse tangent, element-wise.
通用函数（universal function）通常叫作ufunc，它对数组中的各个元素逐一进行操作。这表明，通用函数分别处理输入数组的每个元素，生成的结果组成一个新的输出数组。输出数组的大小跟输入数组相同。

三角函数等很多数学运算符合通用函数的定义，例如，计算平方根的sqrt()函数、用来取对数的log()函数和求正弦值的sin()函数。

x = np.linspace(start=0, stop=np.pi / 2, num=10)
print(x)
# [0.         0.17453293 0.34906585 0.52359878 0.6981317  0.87266463
#  1.04719755 1.22173048 1.3962634  1.57079633]

y = np.sin(x)
print(y)
# [0.         0.17364818 0.34202014 0.5        0.64278761 0.76604444
#  0.8660254  0.93969262 0.98480775 1.        ]

z = np.arcsin(y)
print(z)
# [0.         0.17453293 0.34906585 0.52359878 0.6981317  0.87266463
#  1.04719755 1.22173048 1.3962634  1.57079633]

y = np.cos(x)
print(y)
# [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]

z = np.arccos(y)
print(z)
# [0.         0.17453293 0.34906585 0.52359878 0.6981317  0.87266463
#  1.04719755 1.22173048 1.3962634  1.57079633]

y = np.tan(x)
print(y)
# [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]

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]

指数和对数

numpy.exp
numpy.log
numpy.exp2
numpy.log2
numpy.log10
*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, …])
通过不同的 axis，numpy 会沿着不同的方向进行操作：如果不设置，那么对所有的元素操作；如果axis=0，则沿着纵轴进行操作；axis=1，则沿着横轴进行操作。但这只是简单的二位数组，如果是多维的呢？可以总结为一句话：设axis=i，则 numpy 沿着第i个下标变化的方向进行操作。
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)
# [ 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]

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

y = np.cumsum(x, axis=1)
print(y)
# [[ 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)累乘

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)  # 788529152

y = np.prod(x, axis=0)
print(y)
# [2978976 3877632 4972968 6294624 7875000]

y = np.prod(x, axis=1)
print(y)
# [  360360  1860480  6375600 17100720 38955840]

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

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

y = np.cumprod(x, axis=1)
print(y)
# [[      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)
# [[ 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)舍入

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.ceil(x, *args, **kwargs)上限
numpy.floor(x, *args, **kwargs)下限

x = np.random.rand(3, 3) * 10
print(x)
# [[0.67847795 1.33073923 4.53920122]
#  [7.55724676 5.88854047 2.65502046]
#  [8.67640444 8.80110812 5.97528726]]

y = np.ceil(x)
print(y)
# [[1. 2. 5.]
#  [8. 6. 3.]
#  [9. 9. 6.]]

y = np.floor(x)
print(y)
# [[0. 1. 4.]
#  [7. 5. 2.]
#  [8. 8. 5.]]

杂项

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

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)

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

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

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

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

x = np.arange(-5, 5)
print(x)
#[-5 -4 -3 -2 -1  0  1  2  3  4]
print(np.sign(x))
#[-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)

a = np.array([0, 4, 5])
b = np.copy(a)
print(np.all(a == b))  # True
print(np.any(a == b))  # True

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

print(np.all([1.0, np.nan]))  # True
print(np.any([1.0, np.nan]))  # True

a = np.eye(3)
print(np.all(a, axis=0))  # [False False False]
print(np.any(a, axis=0))  # [ True  True  True]

numpy.isnan(x, *args, **kwargs)数组内容

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

numpy.logical_not
numpy.logical_and
numpy.logical_or
numpy.logical_xor
numpy.logical_not(x, *args, **kwargs)Compute the truth value of NOT x element-wise.
numpy.logical_and(x1, x2, *args, **kwargs) Compute the truth value of x1 AND x2 element-wise.
numpy.logical_or(x1, x2, *args, **kwargs)Compute the truth value of x1 OR x2 element-wise.
numpy.logical_xor(x1, x2, *args, **kwargs)Compute the truth value of x1 XOR x2, element-wise.
numpy.greater
numpy.greater_equal
numpy.equal
numpy.not_equal
numpy.less
numpy.less_equal返回true，false的数组
numpy.greater(x1, x2, *args, **kwargs) Return the truth value of (x1 > x2) element-wise.
numpy.greater_equal(x1, x2, *args, **kwargs) Return the truth value of (x1 >= x2) element-wise.
numpy.equal(x1, x2, *args, **kwargs) Return (x1 == x2) element-wise.
numpy.not_equal(x1, x2, *args, **kwargs) Return (x1 != x2) element-wise.
numpy.less(x1, x2, *args, **kwargs) Return the truth value of (x1 < x2) element-wise.
numpy.less_equal(x1, x2, *args, **kwargs) Return the truth value of (x1 =< x2) element-wise.
numpy.isclose(a, b, rtol=1.e-5, atol=1.e-8, equal_nan=False)
numpy.allclose(a, b, rtol=1.e-5, atol=1.e-8, equal_nan=False)
判断是否为True的计算依据：

np.absolute(a - b) <= (atol + rtol * absolute(b))

- atol：float，绝对公差。
- rtol：float，相对公差。

x = np.isclose([1e10, 1e-7], [1.00001e10, 1e-8])
print(x)  # [ True False]

x = np.allclose([1e10, 1e-7], [1.00001e10, 1e-8])
print(x)  # False

x = np.isclose([1e10, 1e-8], [1.00001e10, 1e-9])
print(x)  # [ True  True]

x = np.allclose([1e10, 1e-8], [1.00001e10, 1e-9])
print(x)  # True

x = np.isclose([1e10, 1e-8], [1.0001e10, 1e-9])
print(x)  # [False  True]

x = np.allclose([1e10, 1e-8], [1.0001e10, 1e-9])
print(x)  # False

x = np.isclose([1.0, np.nan], [1.0, np.nan])
print(x)  # [ True False]

x = np.allclose([1.0, np.nan], [1.0, np.nan])
print(x)  # False

x = np.isclose([1.0, np.nan], [1.0, np.nan], equal_nan=True)
print(x)  # [ True  True]

x = np.allclose([1.0, np.nan], [1.0, np.nan], equal_nan=True)
print(x)  # True