指数与对数函数

1. \(e^x\): exp函数

2. \(2^x\): exp2函数

3. \(e^x-1\): expm1函数，log1p的逆函数

4. \(x = y_{1} \times 2^{y_{2}}\):

5. frexp函数，将x分解返回y1组成的数组和y2组成的数组

6. ldexp函数，将y1和y2合成返回x的数组，即frexp函数的逆函数

7. \(\ln x\): log函数

8. \(\log_{2}{x}\): log2函数

9. \(\log_{10}{x}\): log10函数

10. \(\ln (1+x)\): log1p函数，expm1函数的逆函数

11. \(\ln(e^{x_{1}}+e^{x_{2}})\): logaddexp函数

12. \(\log_{2}{(2^{x_{1}}+2^{x_{2}})}\): logaddexp2函数

n1 = np.array([1, 2, 3, 4])

print(np.exp(n1))
"""
[ 2.71828183  7.3890561  20.08553692 54.59815003]
"""

print(np.exp2(n1))
"""
[ 2.  4.  8. 16.]
"""

print(np.expm1(n1), np.exp(n1) - 1)
"""
[ 1.71828183  6.3890561  19.08553692 53.59815003] [ 1.71828183  6.3890561  19.08553692 53.59815003]
"""

y1, y2 = np.frexp(n1)
print(y1, y2, y1 * 2 ** y2)
"""
[0.5  0.5  0.75 0.5 ] [1 2 2 3] [1. 2. 3. 4.]
"""

print(np.ldexp(y1, y2))
"""
[1. 2. 3. 4.]
"""

print(np.log(n1))
"""
[0.         0.69314718 1.09861229 1.38629436]
"""

print(np.log2(n1))
"""
[0.        1.        1.5849625 2.       ]
"""

print(np.log10(n1))
"""
[0.         0.30103    0.47712125 0.60205999]
"""

print(np.log1p(n1), np.log(n1+1))
"""
[0.69314718 1.09861229 1.38629436 1.60943791] [0.69314718 1.09861229 1.38629436 1.60943791]
"""

x1 = np.array([1, 2, 3, 4])
x2 = np.array([5, 6, 7, 8])

print(np.logaddexp(x1, x2))
"""
[5.01814993 6.01814993 7.01814993 8.01814993]
"""

print(np.logaddexp2(x1, x2))
"""
[5.08746284 6.08746284 7.08746284 8.08746284]
"""

幂函数

11. \(\sqrt{x}\): sqrt函数

12. \(x^{2}\): square函数

13. \(\sqrt[3]{x}\): cbrt函数

14. \(1 \over x\): reciprocal函数，不适用于整数，对于整数\(\left| {x} \right| > 1\)，结果始终为0

n1 = np.array([1, 2, 3, 4])

print(np.sqrt(n1))
"""
[1.         1.41421356 1.73205081 2.        ]
"""

print(np.square(n1))
"""
[ 1  4  9 16]
"""

print(np.cbrt(n1))
"""
[1.         1.25992105 1.44224957 1.58740105]
"""

print(np.reciprocal(n1))
"""
[1 0 0 0]
"""

n2 = np.float_(n1)
print(np.reciprocal(n2))
"""
[1.         0.5        0.33333333 0.25      ]
"""

最大公约数与最小公倍数

15. 最大公约数: gcd函数

16. 最小公倍数: lcm函数

n0 = np.array([2, 3, 4, 5])
n1 = np.array([10, 20, 30, 40])

print(np.gcd(n0, n1))
"""
[2 1 2 5]
"""

print(np.lcm(n0, n1))
"""
[10 60 60 40]
"""

舍入函数

17. round（around）函数、round方法: 四舍五入到小数点后指定位数

18. floor函数: ≤x的最大整数

19. ceil函数: ≥x的最小整数

20. trunc函数: 截取整数部分

21. rint函数: 最接近的整数，但对于中间值x.5遵循"奇进偶不进"原则

22. fix函数: 接近于0的整数

23. modf函数: 分开小数部分和整数部分，均带符号

n0 = np.array([-3.34534654, 4.354235434534, 3.45345, 6.453453445, 1.5, 2.5])

print(n0.round(2))
"""
[-3.35  4.35  3.45  6.45  1.5   2.5 ]
"""

print(np.round(n0, 2))
"""
[-3.35  4.35  3.45  6.45  1.5   2.5 ]
"""

print(np.around(n0, 2))
"""
[-3.35  4.35  3.45  6.45  1.5   2.5 ]
"""

print(np.floor(n0))
"""
[-4.  4.  3.  6.  1.  2.]
"""

print(np.ceil(n0))
"""
[-3.  5.  4.  7.  2.  3.]
"""

print(np.trunc(n0))
"""
[-3.  4.  3.  6.  1.  2.]
"""

print(np.rint(n0))
"""
[-3.  4.  3.  6.  2.  2.]
"""

print(np.fix(n0))
"""
[-3.  4.  3.  6.  1.  2.]
"""

print(np.modf(n0))
"""
(array([-0.34534654, 0.35423543, 0.45345, 0.45345345, 0.5, 0.5]), array([-3., 4., 3., 6., 1., 2.]))
"""

符号函数

24. \(|x|\): absolute函数、abs函数、fabs函数（该函数不支持复数求模，且返回类型始终为浮点数）

25. \(-x\): negative函数

26. \(+x\): positive函数

27. 共轭复数: conjugate函数、conj函数

28. 符号标识: sign函数

29. x < 0: -1

30. x = 0: 0

31. x > 0: 1

32. x = nan: nan

33. m + nj: sign(m) + 0j

34. nj: sign(n) + 0j

35. 阶跃函数: heaviside函数

36. x1 < 0: 0

37. x1 = 0: x2（通常视为0.5）

38. x1 > 0: 1

39. 符号位: signbit函数，≥ 0返回False，＜ 0返回True

40. 符号复制: copysign函数，将x1的符号更改为x2的符号

n0 = np.array([-1, 2, -3, 4, 0])

print(np.absolute(n0))
"""
[1 2 3 4 0]
"""

print(np.abs(n0))
"""
[1 2 3 4 0]
"""

print(np.fabs(n0))
"""
[1. 2. 3. 4. 0.]
"""

print(np.absolute(3 + 4j))
"""
5.0
"""

print(np.abs(3 + 4j))
"""
5.0
"""

print(np.negative(n0))
"""
[ 1 -2  3 -4  0]
"""

print(np.positive(n0))
"""
[-1  2 -3  4  0]
"""

print(np.conjugate(3 + 4j))
"""
(3-4j)
"""

print(np.conj(3 + 4j))
"""
(3-4j)
"""

print(np.sign(n0))
"""
[-1  1 -1  1  0]
"""

print(np.sign(np.nan))
"""
nan
"""

print(np.sign(-3 + 4j))
"""
(-1+0j)
"""

print(np.sign(-4j))
"""
(-1+0j)
"""

print(np.heaviside(n0, 0.5))
"""
[0.  1.  0.  1.  0.5]
"""

print(np.signbit(n0))
"""
[ True False  True False False]
"""

print(np.copysign(n0, -2))
"""
[-1. -2. -3. -4. -0.]
"""

三角函数

32. \(\sin(x)\): 正弦函数，sin函数，以弧度为单位

33. \(\cos(x)\): 余弦函数，cos函数，以弧度为单位

34. \(\tan(x)\): 正切函数，tan函数，以弧度为单位

35. \(\arcsin(x)\): 反正弦函数，arcsin函数，返回弧度实部范围在[-π/2, π/2]

36. \(\arccos(x)\): 反余弦函数，arccos函数，返回弧度实部范围在[0, π]

37. \(\arctan(x)\): 反正切函数，arctan函数，返回弧度实部范围在[-π/2, π/2]

38. \(\arctan(x1/x2)\): arctan2函数，返回经过（x2, x1）和原点的射线与x轴形成角的弧度，返回弧度范围在[-π, π]

x2	x1	arctan2(x1, x2)
+ 0	± 0	± 0
- 0	± 0	± π
± inf	> 0	+ 0/+ π
± inf	< 0	- 0/- π
+ inf	± inf	± (π/4)
- inf	± inf	± (3π/4)

39. \(\sinh(x) = {e^{x}-e^{-x} \over 2} = -1i\times\sin(1i\times x)\): 双曲正弦函数，sinh函数，以弧度为单位

40. \(\cosh(x) = {e^{x}+e^{-x} \over 2} = \cos(1i\times x)\): 双曲余弦函数，cosh函数，以弧度为单位

41. \(\tanh(x)={\sinh(x) \over \cosh(x)}=-1i\times \tan(1i\times x)\): 双曲正切函数，tanh函数，以弧度为单位

42. 反双曲正弦函数: arcsinh函数，返回弧度虚部范围在[-π/2, π/2]

43. 反双曲余弦函数: arccosh函数，返回弧度虚部范围在[-π, π]，实部范围在[0, inf]

44. 反双曲正切函数: arctanh函数，返回弧度虚部范围在[-π/2, π/2]

45. \(deg \times \pi \over 180\): 度转弧度，radians函数、deg2rad函数

46. \(rad\times180 \over \pi\): 弧度转度，degrees函数、rad2deg函数

47. \(\sqrt{x_{1}^{2} + x_{2}^{2}}\): 勾股定理，hypot函数

n0 = np.array([0, 30, 45, 60, 90, 180])    # 角度
n1 = n0 * np.pi / 180    # 弧度
n3 = np.array([1, -1, 1, -1])
n4 = np.array([1, -1, -1, 1])

print(n0)
"""
[  0  30  45  60  90 180]
"""

print(n1)
"""
[0.  0.52359878  0.78539816  1.04719755  1.57079633  3.14159265]
"""

# sin(x)与arcsin(x)
print(np.sin(n1))
"""
[0.00000000e+00  5.00000000e-01  7.07106781e-01  8.66025404e-01  1.00000000e+00  1.22464680e-16]
"""

print(np.arcsin(np.sin(n1)))
"""
[ 0.00000000e+00  5.23598776e-01  7.85398163e-01  1.04719755e+00  1.57079633e+00  1.22464680e-16]
"""

# cos(x)与arccos(x)
print(np.cos(n1))
"""
[ 1.00000000e+00  8.66025404e-01  7.07106781e-01  5.00000000e-01  6.12323400e-17  -1.00000000e+00]
"""

print(np.arccos(np.cos(n1)))
"""
[ 0.  0.52359878  0.78539816  1.04719755  1.57079633  3.14159265]
"""

# tan(x)与arctan(x)
print(np.tan(n1))
"""
[ 0.00000000e+00  5.77350269e-01  1.00000000e+00  1.73205081e+00  1.63312394e+16  -1.22464680e-16]
"""

print(np.arctan(np.tan(n1)))
"""
[ 0.00000000e+00  5.23598776e-01  7.85398163e-01  1.04719755e+00  1.57079633e+00  -1.22464680e-16]
"""

# arctan2函数
print(np.arctan2(n3, n4) * 180 / np.pi)
"""
[  45. -135.  135.  -45.]
"""

# sinh(x)与arcsinh(x)
print(np.sinh(n1), 1/2 * (np.exp(n1) - np.exp(-n1)))
"""
[ 0.  0.54785347  0.86867096  1.24936705  2.3012989  11.54873936] 
[ 0.  0.54785347  0.86867096  1.24936705  2.3012989  11.54873936]
"""

print(np.arcsinh(np.sinh(n1)))
"""
[ 0.  0.52359878  0.78539816  1.04719755  1.57079633  3.14159265]
"""

# cosh(x)与arccosh(x)
print(np.cosh(n1), 1/2 * (np.exp(n1) + np.exp(-n1)))
"""
[ 1.  1.14023832  1.32460909  1.60028686  2.50917848 11.59195328] 
[ 1.  1.14023832  1.32460909  1.60028686  2.50917848 11.59195328]
"""

print(np.arccosh(np.cosh(n1)))
"""
[ 0.  0.52359878  0.78539816  1.04719755  1.57079633  3.14159265]
"""

# tanh(x)与arctanh(x)
print(np.tanh(n1))
"""
[ 0.  0.48047278  0.6557942  0.78071444  0.91715234  0.99627208]
"""

print(np.arctanh(np.tanh(n1)))
"""
[ 0.  0.52359878  0.78539816  1.04719755  1.57079633  3.14159265]
"""

# 度转弧度
print(np.radians(n0), np.deg2rad(n0), n0 * np.pi / 180)
"""
[0.  0.52359878 0.78539816 1.04719755 1.57079633 3.14159265] 
[0.  0.52359878 0.78539816 1.04719755 1.57079633 3.14159265] 
[0.  0.52359878 0.78539816 1.04719755 1.57079633 3.14159265]
"""

# 弧度转度
print(np.degrees(n1), np.rad2deg(n1), 180 * n1 / np.pi)
"""
[  0.  30.  45.  60.  90. 180.] 
[  0.  30.  45.  60.  90. 180.] 
[  0.  30.  45.  60.  90. 180.]
"""

# 勾股定理
print(np.hypot(3, 4))
"""
5.0
"""

判断函数

48. isfinite函数: 是否为有限数

49. isinf函数: 是否为无穷数（± inf）

50. isneginf函数: 是否为负无穷大（- inf）

51. isposinf函数: 是否为正无穷大（+ inf）

52. isnan函数: 是否为非数字（nan）

53. isnat函数：是否非时间(NaT)

data = np.array([1, 2, 3, 4, 0, np.divide(1, 0), np.log(0), np.log(-1)])
posinf = np.array([np.Inf, np.Infinity, np.PINF, np.infty, np.inf, -np.NINF])
neginf = np.array([-np.Inf, -np.Infinity, -np.PINF, -np.infty, -np.inf, np.NINF])
nan = np.array([np.NAN, np.NaN, np.nan])
datetime = np.array([np.datetime64('NaT'), np.datetime64('2024-02-14')])

print(np.isfinite(data), np.isfinite(posinf), np.isfinite(neginf), np.isfinite(nan))
"""
[ True  True  True  True  True False False False] 
[False False False False False False] 
[False False False False False False] 
[False False False]
"""

print(np.isinf(data), np.isinf(posinf), np.isinf(neginf), np.isinf(nan))
"""
[False False False False False  True  True False] 
[ True  True  True  True  True True] 
[ True  True  True  True  True True] 
[False False False]
"""

print(np.isneginf(data), np.isneginf(posinf), np.isneginf(neginf), np.isneginf(nan))
"""
[False False False False False False  True False] 
[False False False False False False] 
[ True  True  True  True  True  True] 
[False False False]
"""

print(np.isposinf(data), np.isposinf(posinf), np.isposinf(neginf), np.isposinf(nan))
"""
[False False False False False  True False False] 
[ True  True  True  True  True True] 
[False False False False False False] 
[False False False]
"""
print(np.isnan(data), np.isnan(posinf), np.isnan(neginf), np.isnan(nan))
"""
[False False False False False False False  True] 
[False False False False False False] 
[False False False False False False] 
[ True  True  True]
"""

print(np.isnat(datetime))
"""
[ True False]
"""

统计分析函数

求和(sum)与累计求和(cumsum)

54. ndarray.sum(axis=None, dtype=None, out=None, keepdims=np._NoValue, initial=np._NoValue, where=np._NoValue) sum(a, axis=None, dtype=None, out=None, keepdims=np._NoValue, initial=np._NoValue, where=np._NoValue) nansum(a, axis=None, dtype=None, out=None, keepdims=np._NoValue, initial=np._NoValue, where=np._NoValue) nansum函数将nan视为0

55. a: 待求和的数组

56. axis: 求和所沿的轴。默认为None，即直接求和数组所有元素。若指定多个轴，将对指定轴组成的数组所有元素求和

57. dtype: 数据类型和累加器类型

58. out: 存放结果的数组

59. keepdims: 是否保留维度。默认不保留

60. initial: 累加初始值。默认为0

61. where: 参与求和的元素条件

```Python n0 = np.arange(1, 17, dtype=np.float_).reshape(2, 2, 4) print(n0) """ [[[ 1. 2. 3. 4.] [ 5. 6. 7. 8.]]

[[ 9. 10. 11. 12.] [13. 14. 15. 16.]]] """

print(n0.sum()) """ 136.0 """

print(np.sum(n0)) """ 136.0 """

设置aixs

print(np.sum(n0, axis=0)) """ [[10. 12. 14. 16.] [18. 20. 22. 24.]] """

print(np.sum(n0, axis=1)) """ [[ 6. 8. 10. 12.] [22. 24. 26. 28.]] """

print(np.sum(n0, axis=2)) """ [[10. 26.] [42. 58.]] """

print(np.sum(n0, axis=(0, 2))) """ [52. 84.] """

设置keepdims

print(np.sum(n0, axis=0, keepdims=False)) """ [[10. 12. 14. 16.] [18. 20. 22. 24.]] """

print(np.sum(n0, axis=0, keepdims=True)) """ [[[10. 12. 14. 16.] [18. 20. 22. 24.]]] """

设置initial

print(np.sum(n0, axis=0, initial=2)) """ [[12. 14. 16. 18.] [20. 22. 24. 26.]] """

设置where

print(np.sum(n0, axis=0, where=n0 >= 3)) """ [[ 9. 10. 14. 16.] [18. 20. 22. 24.]] """

nansum函数

n0[0] = np.nan print(n0) """ [[[nan nan nan nan] [nan nan nan nan]]

[[ 9. 10. 11. 12.] [13. 14. 15. 16.]]] """

print(np.sum(n0)) """ nan """

print(np.nansum(n0)) """ 100.0 """

55. `ndarray.cumsum(axis=None, dtype=None, out=None)`
`cumsum(a, axis=None, dtype=None, out=None)`
`nancumsum(a, axis=None, dtype=None, out=None)`
nancumsum函数将nan视为0

  1. **a**: 待累计求和的数组

  2. **axis**: 累计求和所沿的轴。默认为None，即直接累计求和数组所有元素。不能指定多个轴

  3. dtype: 同上

  4. out: 同上

  ```Python
n0 = np.arange(1, 17, dtype=np.float_).reshape(2, 2, 4)
print(n0)
"""
[[[ 1.  2.  3.  4.]
  [ 5.  6.  7.  8.]]

 [[ 9. 10. 11. 12.]
  [13. 14. 15. 16.]]]
"""

print(n0.cumsum())
"""
[  1.   3.   6.  10.  15.  21.  28.  36.  45.  55.  66.  78.  91. 105. 120. 136.]
"""

print(np.cumsum(n0))
"""
[  1.   3.   6.  10.  15.  21.  28.  36.  45.  55.  66.  78.  91. 105. 120. 136.]
"""

print(np.cumsum(n0, axis=0))
"""
[[[ 1.  2.  3.  4.]
  [ 5.  6.  7.  8.]]

 [[10. 12. 14. 16.]
  [18. 20. 22. 24.]]]
"""

print(np.cumsum(n0, axis=1))
"""
[[[ 1.  2.  3.  4.]
  [ 6.  8. 10. 12.]]

 [[ 9. 10. 11. 12.]
  [22. 24. 26. 28.]]]
"""

print(np.cumsum(n0, axis=2))
"""
[[[ 1.  3.  6. 10.]
  [ 5. 11. 18. 26.]]

 [[ 9. 19. 30. 42.]
  [13. 27. 42. 58.]]]
"""



# nancumsum函数
n0[0] = np.nan
print(n0)
"""
[[[nan nan nan nan]
  [nan nan nan nan]]

 [[ 9. 10. 11. 12.]
  [13. 14. 15. 16.]]]
"""

print(np.cumsum(n0))
"""
[nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan]
"""

print(np.nancumsum(n0))
"""
[  0.   0.   0.   0.   0.   0.   0.   0.   9.  19.  30.  42.  55.  69. 84. 100.]
"""

求积(prod)与累计求积(cumprod)

56. ndarray.prod(axis=None, dtype=None, out=None, keepdims=np._NoValue, initial=np._NoValue, where=np._NoValue) prod(a, axis=None, dtype=None, out=None, keepdims=np._NoValue, initial=np._NoValue, where=np._NoValue) nanprod(a, axis=None, dtype=None, out=None, keepdims=np._NoValue, initial=np._NoValue, where=np._NoValue) nanprod函数将nan视为1

57. a: 同上

58. axis: 同上。可指定多个轴

59. dtype: 同上

60. out: 同上

61. keepdims: 同上

62. initial: 同上。默认为1

63. where: 同上

```Python n0 = np.arange(1, 17, dtype=np.float_).reshape(2, 2, 4) print(n0) """ [[[ 1. 2. 3. 4.] [ 5. 6. 7. 8.]]

[[ 9. 10. 11. 12.] [13. 14. 15. 16.]]] """

print(n0.prod()) """ 20922789888000.0 """

print(np.prod(n0)) """ 20922789888000.0 """

设置aixs

print(np.prod(n0, axis=0)) """ [[ 9. 20. 33. 48.] [ 65. 84. 105. 128.]] """

print(np.prod(n0, axis=1)) """ [[ 5. 12. 21. 32.] [117. 140. 165. 192.]] """

print(np.prod(n0, axis=2)) """ [[2.400e+01 1.680e+03] [1.188e+04 4.368e+04]] """

print(np.prod(n0, axis=(0, 2))) """ [ 285120. 73382400.] """

设置keepdims

print(np.prod(n0, axis=0, keepdims=False)) """ [[ 9. 20. 33. 48.] [ 65. 84. 105. 128.]] """

print(np.prod(n0, axis=0, keepdims=True)) """ [[[ 9. 20. 33. 48.] [ 65. 84. 105. 128.]]] """

设置initial

print(np.prod(n0, axis=0, initial=2)) """ [[ 18. 40. 66. 96.] [130. 168. 210. 256.]] """

设置where

print(np.prod(n0, axis=0, where=n0 >= 3)) """ [[ 9. 10. 33. 48.] [ 65. 84. 105. 128.]] """

nanprod函数

n0[0] = np.nan print(n0) """ [[[nan nan nan nan] [nan nan nan nan]]

[[ 9. 10. 11. 12.] [13. 14. 15. 16.]]] """

print(np.prod(n0)) """ nan """

print(np.nanprod(n0)) """ 518918400.0 """

57. `ndarray.cumprod(axis=None, dtype=None, out=None)`
`cumprod(a, axis=None, dtype=None, out=None)`
`nancumprod(a, axis=None, dtype=None, out=None)`
nancumprod函数将nan视为1

  1. **a**: 同上

  2. **axis**: 同上。不可指定多个轴

  3. dtype: 同上

  4. out: 同上

  ```Python
n0 = np.arange(1, 17, dtype=np.float_).reshape(2, 2, 4)
print(n0)
"""
[[[ 1.  2.  3.  4.]
  [ 5.  6.  7.  8.]]

 [[ 9. 10. 11. 12.]
  [13. 14. 15. 16.]]]
"""

print(n0.cumprod())
"""
[1.00000000e+00 2.00000000e+00 6.00000000e+00 2.40000000e+01
 1.20000000e+02 7.20000000e+02 5.04000000e+03 4.03200000e+04
 3.62880000e+05 3.62880000e+06 3.99168000e+07 4.79001600e+08
 6.22702080e+09 8.71782912e+10 1.30767437e+12 2.09227899e+13]
"""

print(np.cumprod(n0))
"""
[1.00000000e+00 2.00000000e+00 6.00000000e+00 2.40000000e+01
 1.20000000e+02 7.20000000e+02 5.04000000e+03 4.03200000e+04
 3.62880000e+05 3.62880000e+06 3.99168000e+07 4.79001600e+08
 6.22702080e+09 8.71782912e+10 1.30767437e+12 2.09227899e+13]
"""

print(np.cumprod(n0, axis=0))
"""
[[[  1.   2.   3.   4.]
  [  5.   6.   7.   8.]]

 [[  9.  20.  33.  48.]
  [ 65.  84. 105. 128.]]]
"""

print(np.cumprod(n0, axis=1))
"""
[[[  1.   2.   3.   4.]
  [  5.  12.  21.  32.]]

 [[  9.  10.  11.  12.]
  [117. 140. 165. 192.]]]
"""

print(np.cumprod(n0, axis=2))
"""
[[[1.000e+00 2.000e+00 6.000e+00 2.400e+01]
  [5.000e+00 3.000e+01 2.100e+02 1.680e+03]]

 [[9.000e+00 9.000e+01 9.900e+02 1.188e+04]
  [1.300e+01 1.820e+02 2.730e+03 4.368e+04]]]
"""



# nancumprod函数
n0[0] = np.nan
print(n0)
"""
[[[nan nan nan nan]
  [nan nan nan nan]]

 [[ 9. 10. 11. 12.]
  [13. 14. 15. 16.]]]
"""

print(np.cumprod(n0))
"""
[nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan]
"""

print(np.nancumprod(n0))
"""
[1.000000e+00 1.000000e+00 1.000000e+00 1.000000e+00 1.000000e+00
 1.000000e+00 1.000000e+00 1.000000e+00 9.000000e+00 9.000000e+01
 9.900000e+02 1.188000e+04 1.544400e+05 2.162160e+06 3.243240e+07
 5.189184e+08]
"""

求均值(mean)

ndarray.mean(axis=None, dtype=None, out=None, keepdims=np._NoValue, where=np._NoValue) mean(a, axis=None, dtype=None, out=None, keepdims=np._NoValue, where=np._NoValue) nanmean(a, axis=None, dtype=None, out=None, keepdims=np._NoValue, where=np._NoValue) nanmean函数将忽略nan

58. a: 同上

59. axis: 同上。可指定多个轴

60. dtype: 同上

61. out: 同上

62. keepdims: 同上

63. where: 同上

n0 = np.arange(1, 17, dtype=np.float_).reshape(2, 2, 4)
print(n0)
"""
[[[ 1.  2.  3.  4.]
  [ 5.  6.  7.  8.]]

 [[ 9. 10. 11. 12.]
  [13. 14. 15. 16.]]]
"""

print(n0.mean())
"""
8.5
"""

print(np.mean(n0))
"""
8.5
"""



# 设置aixs
print(np.mean(n0, axis=0))
"""
[[ 5.  6.  7.  8.]
 [ 9. 10. 11. 12.]]
"""

print(np.mean(n0, axis=1))
"""
[[ 3.  4.  5.  6.]
 [11. 12. 13. 14.]]
"""

print(np.mean(n0, axis=2))
"""
[[ 2.5  6.5]
 [10.5 14.5]]
"""

print(np.mean(n0, axis=(0, 2)))
"""
[ 6.5 10.5]
"""



# 设置keepdims
print(np.mean(n0, axis=0, keepdims=False))
"""
[[ 5.  6.  7.  8.]
 [ 9. 10. 11. 12.]]
"""

print(np.mean(n0, axis=0, keepdims=True))
"""
[[[ 5.  6.  7.  8.]
  [ 9. 10. 11. 12.]]]
"""



# 设置where
print(np.mean(n0, axis=0, where=n0 >= 3))
"""
[[ 9. 10.  7.  8.]
 [ 9. 10. 11. 12.]]
"""



# nanmean函数
n0[0] = np.nan
print(n0)
"""
[[[nan nan nan nan]
  [nan nan nan nan]]

 [[ 9. 10. 11. 12.]
  [13. 14. 15. 16.]]]
"""

print(np.mean(n0))
"""
nan
"""

print(np.nanmean(n0))
"""
12.5
"""

求加权均值(average)

average(a, axis=None, weights=None, returned=False, keepdims=np._NoValue)

64. a: 同上

65. axis: 同上。可指定多个轴

66. weights: 权重。若为一维数组，则需与a的给定轴大小相等；否则应与a形状相同。默认为None，即所有元素权重为1，此时等价于mean函数

67. returned: 是否同时返回权重和。默认为False

68. keepdims: 同上

n0 = np.arange(1, 17, dtype=np.float_).reshape(2, 2, 4)
print(n0)
"""
[[[ 1.  2.  3.  4.]
  [ 5.  6.  7.  8.]]

 [[ 9. 10. 11. 12.]
  [13. 14. 15. 16.]]]
"""

print(np.average(n0, axis=0, weights=np.arange(1, 17).reshape(2, 2, 4)))
"""
[[ 8.2         8.66666667  9.28571429 10.        ]
 [10.77777778 11.6        12.45454545 13.33333333]]
"""

print(np.average(n0, axis=0, weights=np.array([1, 2])))
"""
[[ 6.33333333  7.33333333  8.33333333  9.33333333]
 [10.33333333 11.33333333 12.33333333 13.33333333]]
"""

print(np.average(n0, axis=0, weights=np.array([1, 2]), returned=True))
"""
(array([[ 6.33333333,  7.33333333,  8.33333333,  9.33333333], 
        [10.33333333, 11.33333333, 12.33333333, 13.33333333]]), 
 array([[3., 3., 3., 3.], 
        [3., 3., 3., 3.]]))
"""

求中位数(median)

median(a, axis=None, out=None, overwrite_input=False, keepdims=False) nanmedian(a, axis=None, out=None, overwrite_input=False, keepdims=np._NoValue) nanmedian函数将忽略nan

69. a: 同上

70. axis: 同上。可指定多个轴

71. out: 同上

72. overwrite_input: \

73. keepdims: 同上

n0 = np.arange(1, 17, dtype=np.float_).reshape(2, 2, 4)
print(n0)
"""
[[[ 1.  2.  3.  4.]
  [ 5.  6.  7.  8.]]

 [[ 9. 10. 11. 12.]
  [13. 14. 15. 16.]]]
"""

print(np.median(n0))
"""
8.5
"""

print(np.median(n0, axis=0))
"""
[[ 5.  6.  7.  8.]
 [ 9. 10. 11. 12.]]
"""

print(np.median(n0, axis=1))
"""
[[ 3.  4.  5.  6.]
 [11. 12. 13. 14.]]
"""

print(np.median(n0, axis=2))
"""
[[ 2.5  6.5]
 [10.5 14.5]]
"""

print(np.median(n0, axis=(0, 2)))
"""
[ 6.5 10.5]
"""



# nanmedian函数
n0[0] = np.nan
print(n0)
"""
[[[nan nan nan nan]
  [nan nan nan nan]]

 [[ 9. 10. 11. 12.]
  [13. 14. 15. 16.]]]
"""

print(np.median(n0))
"""
nan
"""

print(np.nanmedian(n0))
"""
12.5
"""

求方差(var)

ndarray.var(axis=None, dtype=None, out=None, ddof=0, keepdims=np._NoValue, where=np._NoValue) var(a, axis=None, dtype=None, out=None, ddof=0, keepdims=np._NoValue, where=np._NoValue) nanvar(a, axis=None, dtype=None, out=None, ddof=0, keepdims=np._NoValue, where=np._NoValue) nanvar函数将忽略nan

74. a: 同上

75. axis: 同上。可指定多个轴

76. dtype: 同上

77. out: 同上

78. ddof: 自由度。默认为0

79. keepdims: 同上

80. where: 同上

n0 = np.arange(1, 17, dtype=np.float_).reshape(2, 2, 4)
print(n0)
"""
[[[ 1.  2.  3.  4.]
  [ 5.  6.  7.  8.]]

 [[ 9. 10. 11. 12.]
  [13. 14. 15. 16.]]]
"""

print(n0.var())
"""
21.25
"""

print(np.var(n0))
"""
21.25
"""



# 设置aixs
print(np.var(n0, axis=0))
"""
[[16. 16. 16. 16.]
 [16. 16. 16. 16.]]
"""

print(np.var(n0, axis=1))
"""
[[4. 4. 4. 4.]
 [4. 4. 4. 4.]]
"""

print(np.var(n0, axis=2))
"""
[[1.25 1.25]
 [1.25 1.25]]
"""

print(np.var(n0, axis=(0, 2)))
"""
[17.25 17.25]
"""



# 设置ddof
print(np.var(n0, axis=0, ddof=1))
"""
[[32. 32. 32. 32.]
 [32. 32. 32. 32.]]
"""



# 设置keepdims
print(np.var(n0, axis=0, keepdims=False))
"""
[[16. 16. 16. 16.]
 [16. 16. 16. 16.]]
"""

print(np.var(n0, axis=0, keepdims=True))
"""
[[[16. 16. 16. 16.]
  [16. 16. 16. 16.]]]
"""



# 设置where
print(np.var(n0, axis=0, where=n0 >= 3))
"""
[[ 0.  0. 16. 16.]
 [16. 16. 16. 16.]]
"""



# nanvar函数
n0[0] = np.nan
print(n0)
"""
[[[nan nan nan nan]
  [nan nan nan nan]]

 [[ 9. 10. 11. 12.]
  [13. 14. 15. 16.]]]
"""

print(np.var(n0))
"""
nan
"""

print(np.nanvar(n0))
"""
5.25
"""

求标准差(std)

ndarray.std(axis=None, dtype=None, out=None, ddof=0, keepdims=np._NoValue, where=np._NoValuev) std(a, axis=None, dtype=None, out=None, ddof=0, keepdims=np._NoValue, where=np._NoValue) nanstd(a, axis=None, dtype=None, out=None, ddof=0, keepdims=np._NoValue, where=np._NoValue) nanstd函数将忽略nan

81. a: 同上

82. axis: 同上。可指定多个轴

83. dtype: 同上

84. out: 同上

85. ddof: 同上

86. keepdims: 同上

87. where: 同上

n0 = np.arange(1, 17, dtype=np.float_).reshape(2, 2, 4)
print(n0)
"""
[[[ 1.  2.  3.  4.]
  [ 5.  6.  7.  8.]]

 [[ 9. 10. 11. 12.]
  [13. 14. 15. 16.]]]
"""

print(n0.std())
"""
4.6097722286464435
"""

print(np.std(n0))
"""
4.6097722286464435
"""



# 设置aixs
print(np.std(n0, axis=0))
"""
[[4. 4. 4. 4.]
 [4. 4. 4. 4.]]
"""

print(np.std(n0, axis=1))
"""
[[2. 2. 2. 2.]
 [2. 2. 2. 2.]]
"""

print(np.std(n0, axis=2))
"""
[[1.11803399 1.11803399]
 [1.11803399 1.11803399]]
"""

print(np.std(n0, axis=(0, 2)))
"""
[4.15331193 4.15331193]
"""



# 设置ddof
print(np.std(n0, axis=0, ddof=1))
"""
[[5.65685425 5.65685425 5.65685425 5.65685425]
 [5.65685425 5.65685425 5.65685425 5.65685425]]
"""



# 设置keepdims
print(np.std(n0, axis=0, keepdims=False))
"""
[[4. 4. 4. 4.]
 [4. 4. 4. 4.]]
"""

print(np.std(n0, axis=0, keepdims=True))
"""
[[[4. 4. 4. 4.]
  [4. 4. 4. 4.]]]
"""



# 设置where
print(np.std(n0, axis=0, where=n0 >= 3))
"""
[[0. 0. 4. 4.]
 [4. 4. 4. 4.]]
"""



# nanstd函数
n0[0] = np.nan
print(n0)
"""
[[[nan nan nan nan]
  [nan nan nan nan]]

 [[ 9. 10. 11. 12.]
  [13. 14. 15. 16.]]]
"""

print(np.std(n0))
"""
nan
"""

print(np.nanstd(n0))
"""
2.29128784747792
"""

求最大值(max)与最大值位置(argmax)

88. ndarray.max(axis=None, out=None, keepdims=np._NoValue, initial=np._NoValue, where=np._NoValue) max(a, axis=None, out=None, keepdims=np._NoValue, initial=np._NoValue, where=np._NoValue) nanmax(a, axis=None, out=None, keepdims=np._NoValue, initial=np._NoValue, where=np._NoValue) nanmax函数将忽略nan

89. a: 同上

90. axis: 同上。可指定多个轴

91. dtype: 同上

92. out: 同上

93. keepdims: 同上

94. initial: 设置输出结果中元素的最小值

95. where: 同上。必须同时指定initial参数

```Python n0 = np.arange(1, 17, dtype=np.float_).reshape(2, 2, 4) print(n0) """ [[[ 1. 2. 3. 4.] [ 5. 6. 7. 8.]]

[[ 9. 10. 11. 12.] [13. 14. 15. 16.]]] """

print(n0.max()) """ 16.0 """

print(np.max(n0)) """ 16.0 """

设置aixs

print(np.max(n0, axis=0)) """ [[ 9. 10. 11. 12.] [13. 14. 15. 16.]] """

print(np.max(n0, axis=1)) """ [[ 5. 6. 7. 8.] [13. 14. 15. 16.]] """

print(np.max(n0, axis=2)) """ [[ 4. 8.] [12. 16.]] """

print(np.max(n0, axis=(0, 2))) """ [12. 16.] """

设置keepdims

print(np.max(n0, axis=0, keepdims=False)) """ [[ 9. 10. 11. 12.] [13. 14. 15. 16.]] """

print(np.max(n0, axis=0, keepdims=True)) """ [[[ 9. 10. 11. 12.] [13. 14. 15. 16.]]] """

设置initial和where

print(np.max(n0, axis=0, initial=9)) """ [[ 9. 10. 11. 12.] [13. 14. 15. 16.]] """

print(np.max(n0, axis=0, initial=9, where=n0 <= 13)) """ [[ 9. 10. 11. 12.] [13. 9. 9. 9.]] """

nansum函数

n0[0] = np.nan print(n0) """ [[[nan nan nan nan] [nan nan nan nan]]

[[ 9. 10. 11. 12.] [13. 14. 15. 16.]]] """

print(np.max(n0)) """ nan """

print(np.nanmax(n0)) """ 16.0 """

89. `ndarray.argmax(axis=None, out=None, keepdims=np._NoValue)`
`argmax(a, axis=None, out=None, keepdims=np._NoValue)`
返回指定轴上最大值在指定轴上的索引，若最大值有重复，则只返回第一个的位置

  1. **a**: 同上

  2. **axis**: 同上。不能指定多个轴

  3. out: 同上

  4. **keepdims**: 同上

  ```Python
n0 = np.arange(1, 17, dtype=np.float_).reshape(2, 2, 4)
print(n0)
"""
[[[ 1.  2.  3.  4.]
  [ 5.  6.  7.  8.]]

 [[ 9. 10. 11. 12.]
  [13. 14. 15. 16.]]]
"""

print(n0.argmax())
"""
15
"""

print(np.argmax(n0))
"""
15
"""

print(np.argmax(n0, axis=0))
"""
[[1 1 1 1]
 [1 1 1 1]]
"""

print(np.argmax(n0, axis=1))
"""
[[1 1 1 1]
 [1 1 1 1]]
"""

print(np.argmax(n0, axis=2))
"""
[[3 3]
 [3 3]]
"""

print(np.argmax(n0, axis=0, keepdims=False))
"""
[[1 1 1 1]
 [1 1 1 1]]
"""

print(np.argmax(n0, axis=0, keepdims=True))
"""
[[[1 1 1 1]
  [1 1 1 1]]]
"""

求最小值(min)与最小值位置(argmin)

90. ndarray.min(axis=None, out=None, keepdims=np._NoValue, initial=np._NoValue, where=np._NoValue) min(a, axis=None, out=None, keepdims=np._NoValue, initial=np._NoValue, where=np._NoValue) nanmin(a, axis=None, out=None, keepdims=np._NoValue, initial=np._NoValue, where=np._NoValue) nanmin函数将忽略nan

91. a: 同上

92. axis: 同上。可指定多个轴

93. dtype: 同上

94. out: 同上

95. keepdims: 同上

96. initial: 设置输出结果中元素的最大值

97. where: 同上

n0 = np.arange(1, 17, dtype=np.float_).reshape(2, 2, 4)
print(n0)
"""
[[[ 1.  2.  3.  4.]
  [ 5.  6.  7.  8.]]

 [[ 9. 10. 11. 12.]
  [13. 14. 15. 16.]]]
"""

print(n0.max())
"""
1.0
"""

print(np.max(n0))
"""
1.0
"""



# 设置aixs
print(np.max(n0, axis=0))
"""
[[1. 2. 3. 4.]
 [5. 6. 7. 8.]]
"""

print(np.max(n0, axis=1))
"""
[[ 1.  2.  3.  4.]
 [ 9. 10. 11. 12.]]
"""

print(np.max(n0, axis=2))
"""
[[ 1.  5.]
 [ 9. 13.]]
"""

print(np.max(n0, axis=(0, 2)))
"""
[1. 5.]
"""



# 设置keepdims
print(np.max(n0, axis=0, keepdims=False))
"""
[[1. 2. 3. 4.]
 [5. 6. 7. 8.]]
"""

print(np.max(n0, axis=0, keepdims=True))
"""
[[[1. 2. 3. 4.]
  [5. 6. 7. 8.]]]
"""



# 设置initial和where
print(np.min(n0, axis=0, initial=3))
"""
[[1. 2. 3. 3.]
 [3. 3. 3. 3.]]
"""

print(np.min(n0, axis=0, initial=3, where=n0 >= 3))
"""
[[3. 3. 3. 3.]
 [3. 3. 3. 3.]]
"""



# nansum函数
n0[0] = np.nan
print(n0)
"""
[[[nan nan nan nan]
  [nan nan nan nan]]

 [[ 9. 10. 11. 12.]
  [13. 14. 15. 16.]]]
"""

print(np.max(n0))
"""
nan
"""

print(np.nanmax(n0))
"""
9.0
"""

91. ndarray.argmin(axis=None, out=None, keepdims=np._NoValue) argmin(a, axis=None, out=None, keepdims=np._NoValue) 返回指定轴上最小值在指定轴上的索引，若最小值有重复，则只返回第一个的位置

92. a: 同上

93. axis: 同上。不能指定多个轴

94. out: 同上

95. keepdims: 同上

```Python n0 = np.arange(1, 17, dtype=np.float_).reshape(2, 2, 4) print(n0) """ [[[ 1. 2. 3. 4.] [ 5. 6. 7. 8.]]

[[ 9. 10. 11. 12.] [13. 14. 15. 16.]]] """

print(n0.argmin()) """ 0 """

print(np.argmin(n0)) """ 0 """

print(np.argmin(n0, axis=0)) """ [[0 0 0 0] [0 0 0 0]] """

print(np.argmin(n0, axis=1)) """ [[0 0 0 0] [0 0 0 0]] """

print(np.argmin(n0, axis=2)) """ [[0 0] [0 0]] """

print(np.argmin(n0, axis=0, keepdims=False)) """ [[0 0 0 0] [0 0 0 0]] """

print(np.argmin(n0, axis=0, keepdims=True)) """ [[[0 0 0 0] [0 0 0 0]]] """

### 求极差(ptp)

`ndarray.ptp(axis=None, out=None, keepdims=np._NoValue)`
`ptp(a, axis=None, out=None, keepdims=np._NoValue)`

92. **a**: 同上

93. **axis**: 同上。可指定多个轴

94. out: 同上

95. **keepdims**: 同上

```Python
n0 = np.arange(1, 17, dtype=np.float_).reshape(2, 2, 4)
print(n0)
"""
[[[ 1.  2.  3.  4.]
  [ 5.  6.  7.  8.]]

 [[ 9. 10. 11. 12.]
  [13. 14. 15. 16.]]]
"""

print(n0.ptp())
"""
15.0
"""

print(np.ptp(n0))
"""
15.0
"""

print(np.ptp(n0, axis=0))
"""
[[8. 8. 8. 8.]
 [8. 8. 8. 8.]]
"""

print(np.ptp(n0, axis=1))
"""
[[4. 4. 4. 4.]
 [4. 4. 4. 4.]]
"""

print(np.ptp(n0, axis=2))
"""
[[3. 3.]
 [3. 3.]]
"""

print(np.ptp(n0, axis=(0, 2)))
"""
[11. 11.]
"""

print(np.ptp(n0, axis=0, keepdims=False))
"""
[[8. 8. 8. 8.]
 [8. 8. 8. 8.]]
"""

print(np.ptp(n0, axis=0, keepdims=True))
"""
[[[8. 8. 8. 8.]
  [8. 8. 8. 8.]]]
"""

Comments