通用函数
通用函数（ufunc）是一种对ndarray中对数据执行元素级运算的函数
# 例子数组
a = np.array([-1,2.1,0.2,2.6,9.1]) # [-1. 2.1 0.2 2.6 9.1]
b = np.arange(1,len(a)+1) # [1 2 3 4 5]
- 一元函数
| 函数 | 说明 | 例子 | 结果 |
|---|---|---|---|
| abs、fabs | 计算整数、浮点数和复数对绝对值，对于非复数值，可以使用更快对fabs | np.abs(a) | [1. 2.1 0.2 2.6 9.1] |
| sqrt | 计算各元素的平方根，相当于 arr**0.5 | np.sqrt(b) | |
| square | 计算各元素的平方，相当于 arr**2 | np.square(b) | [ 1 4 9 16 25 36 49 64 81] |
| exp | 计算各元素的指数 e(x) | ||
| log、log10、log2、log1p | 分别为自然对数（底数为e）、底数为10的log、底数为2的log、log(1+x) | ||
| sign | 计算各元素的符号 ，1（正数）、0（零）、-1（负数） | np.sign(a) | [-1. 1. 1. 1. 1.] |
| ceil | 向上取整 | np.ceil(a) | [-1. 3. 1. 3. 10.] |
| floor | 向下取整 | np.floor(a) | [-1. 2. 0. 2. 9.] |
| rint | 四舍五入，保留dtype | np.rint(a) | [-1. 2. 0. 3. 9.] |
| modf | 将元素的小数和整数部分以两个独立的数组形式返回 | np.modf(a) | (array([-0. , 0.1, 0.2, 0.6, 0.1]), array([-1., 2., 0., 2., 9.])) |
| nonzero | 将所有非零元素的行与列坐标分割开，重构成两个分别关于行和列的矩阵 | np.nonzero(a) | (array([0, 1, 2, 3, 4]),) |
| clip | 切除元素 | np.clip(a, 0, 5) 等同于 a.clip(0,5) | [0. 2.1 0.2 2.6 5. ] |
| isnan | 返回一个布尔数组，True位置的元素为NaN值 | ||
| isfinite、isinf | 返回一个布尔数组，True位置的元素为有穷的或者是无穷的 | ||
| cos、conh、sin、sinh、tan、tanh | 普通型和双曲型三角函数 | ||
| arccos、arccosh、arcsin、arcsinh、arctan、arctanh | 反三角函数 | ||
| logical_not | 计算各元素not x的真值，相当于 -arr |
- 二元函数
| 函数 | 说明 | 例子 | 结果 |
|---|---|---|---|
| add | 相加 | np.add(a,b) 等同于 a+b | [ 0. 4.1 3.2 6.6 14.1] |
| subtract | 第一个数组减第二个数组 | np.subtract(a,b) 等同于 a-b | [-2. 0.1 -2.8 -1.4 4.1] |
| multiply | 相乘 | np.multiply(a,b) 等同于 a*b | [-1. 4.2 0.6 10.4 45.5] |
| divide、floor_divide | 除法或做完除法后向下取整 | np.divide(a,b) 等同于 a/b；np.floor_divide(a,b) 等同于 np.floor(a/b) | |
| power | pow(a,b)，a的b次方 | np.power(a,b) | |
| maximum、fmax | 元素中最大值，fmax会忽略NaN | np.maximum(a,b) 、np.fmax(a,b) | |
| minimum、fmin | 元素中最小值，fmin会忽略NaN | ||
| mod | 求模 | np.mod(a,b) | |
| copysign | 将第二个数组中的值的符号复制给第一个数组中的值 | np.copysign(b,a) | [-1. 2. 3. 4. 5.] |
| greater、greater_equal、less、less_equal、equal、not_equal | >、>=、<、<=、=、!= | ||
| logical_and、logical_or、logical_xor | 元素级的真值逻辑运算，相当于中缀运算符&、|、^ |
数学与统计方法
| 函数 | 说明 | 例子 | 结果 |
|---|---|---|---|
| sum | 对数组中全部或者某轴方向的元素求和 | np.sum(a) 或 a.sum() | 13.0 |
| mean | 算术平均数，零长度的数组的mean为NaN | np.mean(a) 或 a.mean() | 2.6 |
| average | 加权平均，权重相同时，也可看作时算术平均 | np.average(a) | 2.6 |
| median | 中位数，一组有序数列的中间数，偶数时，取平均 | np.median(a) | 2.1 |
| std、var | 分别求标准差和方差，自由度可调（默认为n） | a.std()、a.var() | 3.4991427521608776、12.244 |
| min、max | 最小值和最大值 | ||
| argmin、argmax | 分别为最小元素和最大元素的索引 | a.argmin()、a.argmax() | 0、 4 |
| diff | diff(a, n=1, axis=-1),后一个与前一个的差值，参数n表示进行n轮运算，多维数组中，可通过axis控制方向 | np.diff(a) | [ 3.1 -1.9 2.4 6.5] |
| cumsum | 所有元素和累计和（数组） | a.cumsum() | [-1. 1.1 1.3 3.9 13. ] |
| cumprod | 所有元素的累计积（数组） | np.cumprod() | [-1. -2.1 -0.42 -1.092 -9.9372] |
注：
上述例子是一维数组，如果是二维数组调用方法类似，不过可以使用参数 axis 指定方向，1为横向，0为竖向
arr = np.arange(24).reshape(4,6)
'''
[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]
[12 13 14 15 16 17]
[18 19 20 21 22 23]]
'''
# 求和
arr.sum() # 276 总和
arr.sum(axis=0) # [36 40 44 48 52 56]
# 算术平均数
arr.mean() # 11.5 总数的算术平均数
arr.mean(axis=1) # [ 2.5 8.5 14.5 20.5] 竖向的算术平均数
关于加权平均数 ： average函数
arr = np.arange(10).reshape(2,5)
'''
[[0 1 2 3 4]
[5 6 7 8 9]]
'''
arr.mean() # 4.5 算术平均数
np.average(arr) # 4.5 可看作是算术平均数
np.average(arr, axis=1) # [2. 7.]，给出了方向
np.average(arr, weights=np.arange(arr1.size).reshape(2,5)) # 传入了权重 6.333333333333333
集合
# 例子数组
s0 = np.array([1,2,3,2,1,4,5,2]) # [1 2 3 2 1 4 5 2]
s1 = np.arange(0,30,2) # [ 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28]
s2 = np.arange(0,30,3) # [ 0 3 6 9 12 15 18 21 24 27]
| 函数 | 说明 | 例子 | 结果
| --- | --- |
| unique(x) | 计算x中唯一元素，并返回有序的结果 | np.unique(s0) | [1 2 3 4 5] |
| intersect1d(x,y) | 交集，并返回有序结果 | np.intersect1d(s1,s2) | [ 0 6 12 18 24] |
| union1d(x,y) | 并集，并返回有序结果 | np.union1d(s1,s2) | [ 0 2 3 4 6 8 9 10 12 14 15 16 18 20 21 22 24 26 27 28] |
| setdiff1d(x,y) | 集合差，即元素在x中且不再y中 | np.setdiff1d(s1,s2) | [ 2 4 8 10 14 16 20 22 26 28] |
| setxor1d(x,y) | 集合对称差，只存在x和y中的元素集合 | np.setxor1d(s1,s2) | [ 2 3 4 8 9 10 14 15 16 20 21 22 26 27 28] |
| in1d(x,y) | 得到一个"x的元素是否包含于y"的布尔行数组 | np.in1d(s2,s1) | [ True False True False True False True False True False] |
注：数组1和数组2的元素数量及shape都可以不同
上述例子中的s1和s2虽然都是一维的，但是数量并不相同；为了验证集合操作无关shape，我们将s1和s2的shape做一下改变
s1 = s1.reshape(3,5)
'''
[[ 0 2 4 6 8]
[10 12 14 16 18]
[20 22 24 26 28]]
'''
s2 = s2.reshape(2,5)
'''
[[ 0 3 6 9 12]
[15 18 21 24 27]]
'''
np.intersect1d(s1,s2) # [15 18 21 24 27]]
np.union1d(s1,s2) # [ 0 2 3 4 6 8 9 10 12 14 15 16 18 20 21 22 24 26 27 28]
np.setdiff1d(s2,s1) # [ 3 9 15 21 27]
补充（where、sort、any、all）
- where
where函数是一个三目运算符，where(condition, x, y)，
完成类似下面的工作
if（condition）：
x
else:
y
例子1：有xarr和yarr两个数组，需要根据condition选择数据
xarr = np.array(np.arange(1.1, 1.6, 0.1))
yarr = np.array(np.arange(2.1, 2.6, 0.1))
cond = np.array([True, False, True, True, False])
在python语法中：
result = [x if c else y for x, y, c in zip(xarr, yarr, cond)]
输出：
[1.1, 2.2, 1.3000000000000003, 1.4000000000000004, 2.5000000000000004]
非常不方便，而且出现了数据异常问题
在numpy中使用where函数：
result = np.where(cond, xarr, yarr)
输出：
[1.1 2.2 1.3 1.4 2.5]
例子2：将arr数组中小于0的部分重制为0，其余部分保留
arr = np.random.randn(4,4)
输出：
[[ 0.40336609 -1.42094364 -1.1257582 0.2787659 ]
[-0.64618146 -0.56508989 0.20527747 1.8542685 ]
[-0.39792887 0.94738928 -0.68713023 0.60328758]
[-0.94495984 -1.47217366 0.03280616 -0.13120201]]
arr = np.where(arr>0, arr, 0)
输出：
[[0.40336609 0. 0. 0.2787659 ]
[0. 0. 0.20527747 1.8542685 ]
[0. 0.94738928 0. 0.60328758]
[0. 0. 0.03280616 0. ]]
例子3：复杂嵌套的情况
cond1 = np.array([True, False, True, True, False])
cond2 = np.array([True, True, True, False, False])
result = []
python语法：
for i in range(len(cond1)):
if cond1[i] and cond2[i]:
result.append(0)
elif cond1[i]:
result.append(1)
elif cond2[i]:
result.append(2)
else:
result.append(3)
print(result) # [0, 2, 0, 1, 3]
在numpy中使用where函数：
result = np.where(cond1&cond2, 0 ,
np.where(cond1, 1,
np.where(cond2, 2, 3)))
list(result) # [0, 2, 0, 1, 3]
注：where函数可以只传条件，返回条件对象的真值下标数组
arr = np.random.randn(10)
np.where(arr>0) # (array([1, 2, 3, 6, 9]),)
如果是多维数组，返回也是数组，分别返回纬度数组索引
cond1 = np.array([True, False, True, True, False])
cond2 = np.array([True, True, True, False, False])
arr = np.array([cond1,cond2])
np.where(arr)
# (array([0, 0, 0, 1, 1, 1]), array([0, 2, 3, 0, 1, 2]))
# 即 [(0,0),(0,2),(0,3),(1,0),(1,1),(1,2)]位置
- sort 排序
# 多维数组，可指定方向
arr = np.random.randn(20).reshape(4,5)
'''
[[-0.94603557 -0.18393318 0.11450866 0.40325255 0.45881851]
[ 1.17704035 -0.41401001 0.75339636 -0.43745415 2.7929479 ]
[-0.28784153 -1.48745643 -0.07142102 -0.5482369 -0.22610164]
[ 1.35561729 -1.08766432 0.83278514 -1.32299757 0.04410116]]
'''
np.sort(arr, axis=0) # 竖向排序（默认为横向排序）
'''
[[-0.94603557 -1.48745643 -0.07142102 -1.32299757 -0.22610164]
[-0.28784153 -1.08766432 0.11450866 -0.5482369 0.04410116]
[ 1.17704035 -0.41401001 0.75339636 -0.43745415 0.45881851]
[ 1.35561729 -0.18393318 0.83278514 0.40325255 2.7929479 ]]
'''
# 一维数组
arr = np.array([2,6,4,2,1,4])
arr.sort() # 这种方式排序会直接改变「原」数组，使用np.sort()方式则将产生新的排序后的数组，而不改变原数组
print(arr) # [2 6 4 2 1 4]
例子：我想知道一组数据的25%分位数是多少？
# 产生一组数据
arr = np.random.randn(20).reshape(4,5)
# 1.我们先将其转化为一维数组，并进行排序处理
arr = arr.flatten()
# 排序
arr.sort()
# 获取25%下标数据
value = arr[int(0.25*len(arr))] # 获取25%分位数
print(arr)
'''
[-1.8819284 -1.84223613 -1.55037549 -1.19713841 -0.91661269 -0.69222229
-0.6796624 -0.65882803 -0.55325753 -0.34502426 -0.1197655 0.36925446
0.5343373 0.62780224 0.74335279 0.82012463 1.00546263 1.08559715
1.29212188 1.47629451]
'''
print(value) # -0.69222229
- all、any
all：是否都是 True , 如果都是返回 True 否则 False
any: 是否存在 True , 如果存在 True 返回 True 否则 False
arr = np.array([True,False,True,True,False])
arr.all() # False
arr.any() # True
布尔型数组的统计方法
arr = np.random.randn(100)
(arr>0).sum() # 统计正值的总数