Numpy 数学函数及逻辑函数_numpy 逻辑与-优快云博客

函数	描述	用法
abs fabs	计算整型/浮点/复数的绝对值对于没有复数的快速版本求绝对值	np.abs() np.fabs()
sqrt	计算元素的平方根。等价于array ** 0.5	np.sqrt()
square	计算元素的平方。等价于 array **2	np.squart()
exp	计算以自然常数e为底的幂次方	np.exp()
log log10 log2 log1p	自然对数(e) 基于10的对数基于2的对数基于log(1+x)的对数	np.log() np.log10() np.log2() np.log1p()
sign	计算元素的符号：1：正数 0：0 -1：负数	np.sign()
ceil	计算大于或等于元素的最小整数	np.ceil()
floor	计算小于或等于元素的最大整数	np.floor()
rint	对浮点数取整到最近的整数，但不改变浮点数类型	np.rint()
modf	分别返回浮点数的整数和小数部分的数组	np.modf()
isnan	返回布尔数组标识哪些元素是 NaN （不是一个数）	np.isnan()
isfinite isinf	返回布尔数组标识哪些元素是有限的（non-inf, non-NaN）或无限的	np.isfiniter() np.isinf()
cos, cosh, sin sinh, tan, tanh	三角函数
arccos, arccosh, arcsin, arcsinh, arctan, arctanh	反三角函数
logical_and/or/not/xor	逻辑与/或/非/异或等价于 ‘&’ ‘\|’ ‘!’ ‘^’	测试见下方

# 逻辑与
>>> np.logical_and(True, False)
False
>>> np.logical_and([True, False], [False, False])
array([False, False], dtype=bool)

>>> x = np.arange(5)
>>> np.logical_and(x>1, x<4)
array([False, False,  True,  True, False], dtype=bool)

# 逻辑或
>>> np.logical_or(True, False)
True
>>> np.logical_or([True, False], [False, False])
array([ True, False], dtype=bool)

>>> x = np.arange(5)
>>> np.logical_or(x < 1, x > 3)
array([ True, False, False, False,  True], dtype=bool)

# 逻辑非
>>> np.logical_not(3)
False
>>> np.logical_not([True, False, 0, 1])
array([False,  True,  True, False], dtype=bool)

>>> x = np.arange(5)
>>> np.logical_not(x<3)
array([False, False, False,  True,  True], dtype=bool)

# 逻辑异或
>>> np.logical_xor(True, False)
True
>>> np.logical_xor([True, True, False, False], [True, False, True, False])
array([False,  True,  True, False], dtype=bool)

>>> x = np.arange(5)
>>> np.logical_xor(x < 1, x > 3)
array([ True, False, False, False,  True], dtype=bool)

>>> np.logical_xor(0, np.eye(2))
array([[ True, False],
       [False,  True]], dtype=bool)

一、向量化和广播

向量化和广播这两个概念是 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)  # (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.]]

两个数组均需要广播
 
import numpy as np
 
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.]]

不匹配报错的例子
 
import numpy as np
 
x = np.arange(4)
y = np.ones(5)
 
print(x.shape)  # (4,)
print(y.shape)  # (5,)
 
print(x + y)
# ValueError: operands could not be broadcast together with shapes (4,) (5,)