Numpy 第五章数学函数

一.向量化和广播

向量化：用数组操作代替显式循环（for/while），让底层C语言处理循环，代码更简洁高效，也更符合Python风格（Pythonic）。
广播：当对两个形状不同（shape不同）的数组进行算术运算时，NumPy自动将较小的数组"扩展"成与较大数组兼容的形状，再进行运算，避免手动复制数据。

广播的三大规则

广播机制遵循以下规则来判断两个数组是否能进行运算：

维度对齐 ：如果两个数组的维度数（dim）不同，会在维度较少的数组的左边补 1，直到维度数相同。
维度扩展：从后往前比较两个数组的每一维：
- 如果某一维的长度相同，则继续比较前一位；
- 如果某一维的长度为 1，则将其扩展成与另一个数组对应维度相同的长度（相当于复制数据）；
报错条件 ：如果某一维的长度既不相同，也不为 1，则广播失败，抛出 ValueError。

例：二维数组加一维数组（兼容）

复制代码

import numpy as np
x = np.arange(4)       # shape: (4,)
y = np.ones((3, 4))    # 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的 shape 是 (4,)，y的 shape 是 (3, 4)。
根据规则1，x左边补1 → (1, 4)。
根据规则2，x的第0维（长度为1）扩展为3，y的第1维（长度为4）保持不变 → 两者都变成 (3, 4)，匹配成功。
结果：每一行都是 x的值加上 y的对应列。

例：两个数组均需要广播（复杂匹配）

复制代码

x = np.arange(4).reshape(4, 1)  # shape: (4, 1)
y = np.ones(5)                  # 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的 shape 是 (4, 1)，y的 shape 是 (5,)。
规则1：y左边补1 → (1, 5)。
规则2：从右往左比，x第1维是1 → 扩展为5；y第0维是1 → 扩展为4。
最终：x变为 (4, 5)，y变为 (4, 5)，匹配成功。
结果：每行都是 x的行值（1,2,3,4）重复5次。

例:不匹配报错例子

复制代码

x = np.arange(4)   # shape: (4,)
y = np.ones(5)     # shape: (5,)

print(x + y)       # ValueError: operands could not be broadcast together with shapes (4,) (5,)

分析：

x和 y的 shape 分别是 (4,)和 (5,)。
规则1：无需补位，都是1维。
规则2：从右往左比，长度分别为4和5，既不相等，也没有1，因此广播失败，报错。

关键技巧：np.newaxis

复制代码

x = np.array([0., 10., 20., 30.])  # shape: (4,)
y = np.array([1., 2., 3.])         # shape: (3,)
z = x[:, np.newaxis] + y           # 等价于 x.reshape(4, 1) + y

x[:, np.newaxis]的作用是在 x的第1维（列）插入一个新轴，使 x的 shape 从 (4,)变为 (4, 1)，从而可以与 (3,)的 y进行广播运算，得到 (4, 3)的结果。

二.算数运算

1.运算函数介绍：

numpy.add(x1, x2, *args, **kwargs)：对数组进行逐元素相加。
numpy.subtract(x1, x2, *args, **kwargs)：对数组进行逐元素相减。
numpy.multiply(x1, x2, *args, **kwargs)：对数组进行逐元素相乘。
numpy.divide(x1, x2, *args, **kwargs)：对数组进行逐元素除法，返回精确的商。
numpy.floor_divide(x1, x2, *args, **kwargs)：对数组进行逐元素除法，返回不大于商的整数。
numpy.power(x1, x2, *args, **kwargs)：对数组进行逐元素幂运算。

广播规则：

当数组与标量进行运算时，标量会与数组中的每个元素分别进行运算。
例如，x + 1会将1加到数组 x的每个元素上。

例：一维数组

复制代码

import numpy as np

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

加法：
复制代码
```
y = x + 1
print(y)  # [2 3 4 5 6 7 8 9]
print(np.add(x, 1))  # [2 3 4 5 6 7 8 9]
```
解释：x + 1和 np.add(x, 1)都是将数组 x中的每个元素加1。
减法：
复制代码
```
y = x - 1
print(y)  # [0 1 2 3 4 5 6 7]
print(np.subtract(x, 1))  # [0 1 2 3 4 5 6 7]
```
解释：x - 1和 np.subtract(x, 1)都是将数组 x中的每个元素减1。

乘法：

复制代码

y = x * 2
print(y)  # [ 2  4  6  8 10 12 14 16]
print(np.multiply(x, 2))  # [ 2  4  6  8 10 12 14 16]

解释：x * 2和 np.multiply(x, 2)都是将数组 x中的每个元素乘以2。

除法：
复制代码
```
y = x / 2
print(y)  # [0.5 1.  1.5 2.  2.5 3.  3.5 4. ]
print(np.divide(x, 2))  # [0.5 1.  1.5 2.  2.5 3.  3.5 4. ]
```
解释：x / 2和 np.divide(x, 2)都是将数组 x中的每个元素除以2，返回浮点数结果。
地板除法：
复制代码
```
y = x // 2
print(y)  # [0 1 2 2 3 3 4 4]
print(np.floor_divide(x, 2))  # [0 1 2 2 3 3 4 4]
```
解释：x // 2和 np.floor_divide(x, 2)都是将数组 x中的每个元素除以2，然后向下取整。
幂运算：
复制代码
```
y = x ** 2
print(y)  # [ 1  4  9 16 25 36 49 64]
print(np.power(x, 2))  # [ 1  4  9 16 25 36 49 64]
```
解释：x ** 2和 np.power(x, 2)都是将数组 x中的每个元素进行平方运算。

例：二维数组x = np.array([[11, 12, 13, 14, 15], ...])

二维数组的运算逻辑和一维一致，标量会被广播到所有行、所有列的元素上，逐元素运算。

加法：

复制代码

y = x + 1          # 标量 1 广播到 x 的每个元素，逐元素加 1
print(y)           
# 输出:
# [[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]]
print(np.add(x, 1)) # 等价于 x + 1

减法：

复制代码

y = x - 1          # 标量 1 广播到 x 的每个元素，逐元素减 1
print(y)           
# 输出:
# [[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]]
print(np.subtract(x, 1)) # 等价于 x - 1

乘法：

复制代码

y = x * 2          # 标量 2 广播到 x 的每个元素，逐元素乘 2
print(y)           
# 输出:
# [[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]]
print(np.multiply(x, 2)) # 等价于 x * 2

除法：

复制代码

y = x / 2          # 标量 2 广播到 x 的每个元素，逐元素做真除法（保留小数）
print(y)           
# 输出:
# [[ 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]]
print(np.divide(x, 2))  # 等价于 x / 2

地板除法：

复制代码

y = x // 2         # 标量 2 广播到 x 的每个元素，逐元素做地板除（取不大于商的整数）
print(y)           
# 输出:
# [[ 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]]
print(np.floor_divide(x, 2)) # 等价于 x // 2

幂运算：

复制代码

y = x ** 2         # 标量 2 广播到 x 的每个元素，逐元素求平方（即 x²）
print(y)           
# 输出:
# [[ 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]]
print(np.power(x, 2))    # 等价于 x ** 2

例：二维数组与一维数组的运算

复制代码

import numpy as np
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.arange(1, 6)  # y = [1, 2, 3, 4, 5] (形状为 (5,))

加减法

z = x + y # 或 np.add(x, y)
print(z)

输出：

[[12 14 16 18 20]

[17 19 21 23 25]

[22 24 26 28 30]

[27 29 31 33 35]

[32 34 36 38 40]]

z = x - y # 或 np.subtract(x, y)
print(z)

输出：

[[10 10 10 10 10]

[15 15 15 15 15]

...（后续行类似，每行减去 y 的对应元素）]
广播过程 ：y从 (5,)扩展为 (5,5)（每行都是 [1,2,3,4,5]）。
运算逻辑 ：x的每个元素 x[i,j]与 y[j]相加/相减（j为列索引）。

乘法、除法、整除

复制代码

z = x * y  # 或 np.multiply(x, y)
# 输出：[[ 11  24  39  56  75], [ 16  34  54  76 100], ...]

z = x / y  # 或 np.divide(x, y)
# 输出：[[11.          6.          4.33333333  3.5         3.        ], ...]

z = x // y  # 或 np.floor_divide(x, y)
# 输出：[[11  6  4  3  3], [16  8  6  4  4], ...]

乘法：x[i,j] * y[j]（逐元素相乘）。
除法：x[i,j] / y[j]（浮点除法）。
整除：x[i,j] // y[j]（向下取整除法）。
广播机制让 y自动扩展为 5×5，避免手动 reshape。

幂运算（广播+自定义形状）

复制代码

z = x ** np.full([1, 5], 2)  # np.full([1,5],2) 生成 [[2,2,2,2,2]]
# 等价于 x ** 2（因为 [[2,2,2,2,2]] 广播为 5×5 的全 2 矩阵）
print(z)
# 输出：[[121 144 169 196 225], [256 289 324 361 400], ...]

# 或用 np.power(x, np.full([5,5], 2)) 效果相同

np.full([1,5], 2)生成形状 (1,5)的数组（全 2），广播为 (5,5)后与 x逐元素求幂。
结果：每个元素 x[i,j]的平方（x[i,j] ** 2）。

总结：

当两个数组进行算术运算时，若形状不完全相同，NumPy 会从 最后一个维度开始 检查兼容性：

若维度大小相同（如 (5,5)和 (5,5)），直接运算。

若一个数组维度大小为 1（如 (1,5)），则自动扩展该维度至与另一个数组匹配（如 (5,5)）。

若维度不满足上述条件（如 (3,5)和 (2,5)），则报错。

2.`numpy.sqrt（）函数和numpy.square（）函数`

**numpy.sqrt(x)**

返回数组 x中每个元素的非负平方根，逐元素操作（element-wise）。
**numpy.square(x)**

返回数组 x中每个元素的平方值，逐元素操作。

例：

复制代码

import numpy as np

x = np.arange(1, 5)  # 生成数组 [1, 2, 3, 4]
print(x)  # 输出: [1 2 3 4]

# 1. 计算平方根
y = np.sqrt(x)
print(y)
# 输出: [1.         1.41421356 1.73205081 2.        ]
print(np.power(x, 0.5))  # 等价于 sqrt，输出相同

# 2. 计算平方
y = np.square(x)
print(y)
# 输出: [ 1  4  9 16]
print(np.power(x, 2))    # 等价于 square，输出相同

总结

np.sqrt(x)与 np.power(x, 0.5)功能相同，都是开平方。

np.square(x)与 np.power(x, 2)功能相同，都是平方。

所有操作均为逐元素（element-wise），即对数组中每个元素独立计算。

输入可以是标量、列表、元组或 NumPy 数组，输出为 NumPy 数组。

记忆口诀：

"sqrt 开根，square 平方；power 灵活，0.5 是根，2 是方。"

3.三角函数

（1）通用函数（ufunc）的概念

NumPy 的通用函数（universal function，简称 ufunc）会对数组中的每个元素逐一操作 ，生成与原数组形状相同的新数组。例如 sin()、sqrt()、log()等函数都属于 ufunc。

（2）三角函数与反三角函数列表

图片中列出了以下函数（均为 element-wise 逐元素操作）：

三角函数 ：numpy.sin、numpy.cos、numpy.tan

分别对数组元素计算正弦、余弦、正切值。
反三角函数 ：numpy.arcsin、numpy.arccos、numpy.arctan

分别对数组元素计算反正弦、反余弦、反正切值（输入需在函数定义域内，如 arcsin/arccos的输入范围是 [-1, 1]）。

例：生成等间距数组 x

复制代码

x = np.linspace(start=0, stop=np.pi / 2, num=10)
print(x)
# 输出：0 到 π/2 之间的 10 个等间距数，例如：
# [0.         0.17453293 0.34906585 0.52359878 0.6981317  0.87266463
#  1.04719755 1.22173048 1.3962634  1.57079633]

np.linspace用于生成指定区间内的等间距数值，这里生成了从 0到 π/2（约 1.5708）的 10 个点。

例：计算正弦函数 y = np.sin(x)

复制代码

y = np.sin(x)
print(y)
# 输出：x 中每个元素的正弦值，例如：
# [0.         0.17364818 0.34202014 0.5        0.64278761 0.76604444
#  0.8660254  0.93969262 0.98480775 1.        ]

np.sin对每个 x[i]计算 sin(x[i])，结果为新数组 y。

例:反正弦函数 z = np.arcsin(y)

复制代码

z = np.arcsin(y)
print(z)
# 输出：y 中每个元素的反正弦值（因 y 是 sin(x) 的结果，理论上应还原为 x）
# [0.         0.17453293 0.34906585 0.52359878 0.6981317  0.87266463
#  1.04719755 1.22173048 1.3962634  1.57079633]

np.arcsin是 sin的反函数，若 y = sin(x)，则 arcsin(y) ≈ x（需注意浮点精度）。

例：余弦函数 y = np.cos(x)

复制代码

y = np.cos(x)
print(y)
# 输出：x 中每个元素的余弦值，例如：
# [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]  # 最后一个数接近 0（因 cos(π/2)=0）

np.cos对每个 x[i]计算 cos(x[i])。

例: 反余弦函数 z = np.arccos(y)

复制代码

z = np.arccos(y)
print(z)
# 输出：y 中每个元素的反余弦值（因 y 是 cos(x) 的结果，理论上应还原为 x）
# [0.         0.17453293 0.34906585 0.52359878 0.6981317  0.87266463
#  1.04719755 1.22173048 1.3962634  1.57079633]

np.arccos是 cos的反函数，若 y = cos(x)，则 arccos(y) ≈ x（需注意浮点精度）。

例：正切函数 y = np.tan(x)

复制代码

y = np.tan(x)
print(y)
# 输出：x 中每个元素的正切值，例如：
# [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]  # 最后一个数极大（因 tan(π/2) 趋近于无穷大）

np.tan对每个 x[i]计算 tan(x[i])，当 x接近 π/2时，正切值会急剧增大（浮点精度限制下可能溢出）。

例: 反正切函数 z = np.arctan(y)

复制代码

z = np.arctan(y)
print(z)
# 输出：y 中每个元素的反正切值（因 y 是 tan(x) 的结果，理论上应还原为 x）
# [0.         0.17453293 0.34906585 0.52359878 0.6981317  0.87266463
#  1.04719755 1.22173048 1.3962634  1.57079633]

np.arctan是 tan的反函数，若 y = tan(x)，则 arctan(y) ≈ x（需注意浮点精度）。

总结：

逐元素操作：所有三角函数/反三角函数都是 ufunc，对输入数组的每个元素独立计算，输出数组形状与输入一致。

反函数还原性 ：若 y = f(x)（f是三角/反三角函数），则 f⁻¹(y) ≈ x（忽略浮点精度误差）。

定义域注意 ：反三角函数（如 arcsin/arccos）的输入必须在合法范围内（如 arcsin要求输入 ∈ [-1, 1]），否则会报错或得到非预期结果。

4.指数和对数

函数名	功能描述
`numpy.exp`	计算输入数组中所有元素的自然指数（即 ex，其中 e是自然常数）
`numpy.log`	计算输入数组中所有元素的自然对数（以 e为底，即 ln(x)）
`numpy.exp2`	计算输入数组中所有元素的以 2 为底的指数（即 2x）
`numpy.log2`	计算输入数组中所有元素的以 2 为底的对数（即 log2(x)）
`numpy.log10`	计算输入数组中所有元素的以 10 为底的对数（即 log10(x)）

例：numpy.exp和 numpy.log的互逆关系：

复制代码

import numpy as np

x = np.arange(1, 5)  # 生成数组 [1, 2, 3, 4]
print(x)             # 输出: [1 2 3 4]

y = np.exp(x)        # 计算每个元素的自然指数：e^1, e^2, e^3, e^4
print(y)             # 输出: [ 2.71828183  7.3890561  20.08553692  54.59815003]

z = np.log(y)        # 计算自然对数的逆运算：ln(e^1), ln(e^2), ln(e^3), ln(e^4)
print(z)             # 输出: [1. 2. 3. 4.]

原理：自然指数函数 exp和自然对数函数 log是互逆运算 ，即 ln(ex)=x。示例中也验证了这一点：z的输出与原始数组 x完全一致。

特点：

逐元素操作：这些函数对所有数组元素独立计算，返回与原数组形状相同的数组。

定义域限制 ：对数函数（如 log、log2、log10）的输入必须大于 0；反三角函数（如 arcsin、arccos）的输入需在 [-1, 1] 范围内。

数学意义：指数和对数函数在科学计算、信号处理、统计分析等领域广泛应用（如归一化、衰减模型、对数坐标绘图等）。

5.加法函数

（1）聚合函数：`numpy.sum`

功能：对数组元素求和，可通过 axis参数指定求和的维度。
参数：
- a：输入数组。
- axis：求和的维度（默认 None，对所有元素求和；axis=0沿纵轴（行） 求和，axis=1沿**横轴（列）**求和）。
- dtype：输出数据类型（可选）。
- out：输出数组（可选）。
  
  import numpy as np
  
  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]])
  
  1. 对所有元素求和（axis=None）
  
  y = np.sum(x)
  print(y) # 输出: 575（所有元素总和：11+12+...+35 = 575）
  
  2. 沿纵轴（axis=0）求和（每列的和）
  
  y = np.sum(x, axis=0)
  print(y) # 输出: [105 110 115 120 125]（每列元素相加：11+16+21+26+31=105，依此类推）
  
  3. 沿横轴（axis=1）求和（每行的和）
  
  y = np.sum(x, axis=1)
  print(y) # 输出: [65 90 115 140 165]（每行元素相加：11+12+13+14+15=65，依此类推）

（2）累加函数：`numpy.cumsum`

功能：返回数组元素沿指定轴的累加和（即第 i 个元素是前 i 个元素的累加）。
参数：
- a：输入数组。
- axis：累加的维度（默认 None，对所有元素累加；axis=0沿纵轴累加，axis=1沿横轴累加）。
- dtype：输出数据类型（可选）。
- out：输出数组（可选）。
  
  import numpy as np
  
  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]])
  
  1. 对所有元素累加（axis=None）
  
  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]
  
  （解释：先加第一行[11,23,36,50,65]，再加第二行[81(65+16),98(81+17),...], 依此类推）
  
  2. 沿纵轴（axis=0）累加（每列的累加和）
  
  y = np.cumsum(x, axis=0)
  print(y)
  
  输出:
  
  [[ 11 12 13 14 15]
  
  [ 27 29 31 33 35] （第一行+第二行：11+16=27, 12+17=29, ...）
  
  [ 48 51 54 57 60] （前两行+第三行：27+21=48, 29+22=51, ...）
  
  [ 74 78 82 86 90] （前三行+第四行：48+26=74, 51+27=78, ...）
  
  [105 110 115 120 125]]（前四行+第五行：74+31=105, 78+32=110, ...）
  
  3. 沿横轴（axis=1）累加（每行的累加和）
  
  y = np.cumsum(x, axis=1)
  print(y)
  
  输出:
  
  [[ 11 23 36 50 65] （第一行：11, 11+12=23, 23+13=36, ...）
  
  [ 16 33 51 70 90] （第二行：16, 16+17=33, 33+18=51, ...）
  
  [ 21 43 66 90 115] （第三行：21, 21+22=43, 43+23=66, ...）
  
  [ 26 53 81 110 140] （第四行：26, 26+27=53, 53+28=81, ...）
  
  [ 31 63 96 130 165]]（第五行：31, 31+32=63, 63+33=96, ...）

6.乘法函数

（1） `numpy.prod`------ 计算数组元素的乘积

功能：返回数组元素在指定轴上的乘积。

函数：

复制代码

numpy.prod(a[, axis=None, dtype=None, out=None, ...])

参数说明：

a: 输入数组。
axis: 指定计算的轴。None表示对所有元素求乘积；axis=0按列求积；axis=1按行求积。
dtype: 输出数据类型。
out: 可选输出数组。

import numpy as np

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) # 3712525927079477248 （所有元素的乘积）

y = np.prod(x, axis=0)
print(y) # [2978976 3877632 4972968 6294624 7875000] （每列元素的乘积）

y = np.prod(x, axis=1)
print(y) # 每行元素的乘积（图中未显示完整，但逻辑如此）

`（2）numpy.cumprod`------ 计算数组元素的累乘

功能：返回沿指定轴的累积乘积。

函数：

复制代码

numpy.cumprod(a, axis=None, dtype=None, out=None)

参数说明：

a: 输入数组。
axis: 指定计算的轴。None表示展平后计算；axis=0按列累乘；axis=1按行累乘。

import numpy as np

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) # 展平后逐元素累乘的结果（图中显示了部分值）

y = np.cumprod(x, axis=0)
print(y) # 按列累乘，每列的当前元素乘以前面所有元素的乘积

y = np.cumprod(x, axis=1)
print(y) # 按行累乘，每行的当前元素乘以前面所有元素的乘积

`（3）numpy.diff`------ 计算数组的差值

功能：计算沿指定轴的离散差值（即相邻元素的差）。

函数：

复制代码

numpy.diff(a, n=1, axis=-1, prepend=np._NoValue, append=np._NoValue)

参数说明：

a: 输入数组。
n: 差值的阶数，默认是1（一阶差分）。
axis: 计算差值的轴，默认是最后一个轴（axis=-1）。
prepend/ append: 可选，用于在数组开头或结尾添加值后再计算差值。

一阶差分公式 ：out[i] = a[i+1] - a[i]

复制代码

import numpy as np

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]  （第一行：3-2, 4-3, 5-4）
#  [2 0 1]  （第二行：8-6, 8-8, 9-8）
#  [1 1 1]] （第三行：11-10, 12-11, 13-12）

print(np.diff(A, axis=0))
# [[4 5 4 4]]  （第一列：6-2, 10-6；第二列：8-3, 11-8；...）

7.四舍五入

`（1）numpy.around`------ 四舍五入（按小数位数舍入）

功能：将数组元素四舍五入到指定的小数位数。

函数：

复制代码

numpy.around(a, decimals=0, out=None)

a：输入数组。
decimals：可选，保留的小数位数（默认 0，即整数）。

import numpy as np

生成 3×3 随机数组（范围 0~10），并乘以 10

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

1. 默认 decimals=0（四舍五入到整数）

y = np.around(x)
print(y)

输出：

[[7. 4. 8.]

[2. 4. 8.]

[3. 10. 8.]]

2. 保留 2 位小数（decimals=2）

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

`（2）numpy.ceil`------ 向上取整（返回不小于输入的最小整数）

功能：对数组元素逐元素向上取整（即取比元素大的最小整数）。

函数：

复制代码

numpy.ceil(x, *args, **kwargs)

x：输入数组（可以是数值或数组）。

import numpy as np

生成 3×3 随机数组（范围 0~10），并乘以 10

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

`（3）numpy.floor`------ 向下取整（返回不大于输入的最大整数）

功能：对数组元素逐元素向下取整（即取比元素小的最大整数）。

函数：

复制代码

numpy.floor(x, *args, **kwargs)

x：输入数组（可以是数值或数组）。

import numpy as np

复用上面的随机数组 x

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.floor(x)
print(y)

输出：

[[0. 1. 4.]

[7. 5. 2.]

[8. 8. 5.]]

8.杂项

（1）`numpy.clip`：裁剪数组值到指定区间

功能

将数组中的值限制在指定的区间 [a_min, a_max]内：

小于 a_min的值会被替换为 a_min；
大于 a_max的值会被替换为 a_max；
在区间内的 values 保持不变。

语法

复制代码

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

a：输入数组；
a_min：最小值（区间下界）；
a_max：最大值（区间上界）；
out（可选）：输出数组，用于存储结果。

import numpy as np

创建一个二维数组

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

将数组值裁剪到 [20, 30] 区间

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]]
第一行原数组值均 <20，因此被替换为 20；
第五行原数组值均 >30，因此被替换为 30；
中间行（第三、四行）的部分值在 [20, 30]区间内，保持原值。

（2）`numpy.absolute`/ `numpy.abs`：逐元素计算绝对值

功能

对数组中的每个元素计算绝对值（正数保持不变，负数变为其相反数，0 保持 0）。

语法

numpy.absolute(x, *args, **kwargs)：完整函数名；
numpy.abs(x, *args, **kwargs)：简写形式，功能与 absolute完全一致。

import numpy as np

创建一个从 -5 到 4 的一维数组

x = np.arange(-5, 5)
print("原数组 x:", x) # 输出: [-5 -4 -3 -2 -1 0 1 2 3 4]

使用 np.abs 计算绝对值

y_abs = np.abs(x)
print("np.abs(x):", y_abs) # 输出: [5 4 3 2 1 0 1 2 3 4]

使用 np.absolute 计算绝对值（结果相同）

y_absolute = np.absolute(x)
print("np.absolute(x):", y_absolute) # 输出: [5 4 3 2 1 0 1 2 3 4]

（3） `numpy.sign`：逐元素返回数字的符号

功能

对数组中的每个元素返回其符号：

正数返回 1；
负数返回 -1；
0 返回 0。

语法

复制代码

numpy.sign(x, *args, **kwargs)

x：输入数组。

import numpy as np

创建一个从 -5 到 4 的一维数组

x = np.arange(-5, 5)
print("原数组 x:", x) # 输出: [-5 -4 -3 -2 -1 0 1 2 3 4]

计算符号

sign_result = np.sign(x)
print("np.sign(x):", sign_result) # 输出: [-1 -1 -1 -1 -1 0 1 1 1 1]
前 5 个元素（-5 ~ -1）为负数，返回 -1；
第 6 个元素（0）返回 0；
后 4 个元素（1 ~ 4）为正数，返回 1。

Numpy 第五章 数学函数

一.向量化和广播

广播的三大规则

二.算数运算

1.运算函数介绍：

输出：

[[12 14 16 18 20]

[17 19 21 23 25]

[22 24 26 28 30]

[27 29 31 33 35]

[32 34 36 38 40]]

输出：

[[10 10 10 10 10]

[15 15 15 15 15]

...（后续行类似，每行减去 y 的对应元素）]

2.numpy.sqrt（）函数和numpy.square（）函数

3.三角函数

（1）通用函数（ufunc）的概念

（2）三角函数与反三角函数列表

4.指数和对数

5.加法函数

（1）聚合函数：numpy.sum

1. 对所有元素求和（axis=None）

2. 沿纵轴（axis=0）求和（每列的和）

3. 沿横轴（axis=1）求和（每行的和）

（2）累加函数：numpy.cumsum

1. 对所有元素累加（axis=None）

输出: [ 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]

（解释：先加第一行[11,23,36,50,65]，再加第二行[81(65+16),98(81+17),...], 依此类推）

2. 沿纵轴（axis=0）累加（每列的累加和）

输出:

[[ 11 12 13 14 15]

[ 27 29 31 33 35] （第一行+第二行：11+16=27, 12+17=29, ...）

[ 48 51 54 57 60] （前两行+第三行：27+21=48, 29+22=51, ...）

[ 74 78 82 86 90] （前三行+第四行：48+26=74, 51+27=78, ...）

[105 110 115 120 125]]（前四行+第五行：74+31=105, 78+32=110, ...）

3. 沿横轴（axis=1）累加（每行的累加和）

输出:

[[ 11 23 36 50 65] （第一行：11, 11+12=23, 23+13=36, ...）

[ 16 33 51 70 90] （第二行：16, 16+17=33, 33+18=51, ...）

[ 21 43 66 90 115] （第三行：21, 21+22=43, 43+23=66, ...）

[ 26 53 81 110 140] （第四行：26, 26+27=53, 53+28=81, ...）

[ 31 63 96 130 165]]（第五行：31, 31+32=63, 63+33=96, ...）

6.乘法函数

（1） numpy.prod------ 计算数组元素的乘积

（2）numpy.cumprod------ 计算数组元素的累乘

（3）numpy.diff------ 计算数组的差值

7.四舍五入

（1）numpy.around------ 四舍五入（按小数位数舍入）

生成 3×3 随机数组（范围 0~10），并乘以 10

输出（示例）：

[[6.59144457 3.78566113 8.15321227]

[1.68241475 3.78753332 7.68886328]

[2.84255822 9.58106727 7.86678037]]

1. 默认 decimals=0（四舍五入到整数）

输出：

[[7. 4. 8.]

[2. 4. 8.]

[3. 10. 8.]]

2. 保留 2 位小数（decimals=2）

输出：

[[6.59 3.79 8.15]

[1.68 3.79 7.69]

[2.84 9.58 7.87]]

（2）numpy.ceil------ 向上取整（返回不小于输入的最小整数）

生成 3×3 随机数组（范围 0~10），并乘以 10

输出（示例）：

[[0.67847795 1.33073923 4.53920122]

[7.55724676 5.88854047 2.65502046]

[8.67640444 8.80110812 5.97528726]]

向上取整（每个元素取不小于它的最小整数）

输出：

[[1. 2. 5.]

[8. 6. 3.]

[9. 9. 6.]]

（3）numpy.floor------ 向下取整（返回不大于输入的最大整数）

复用上面的随机数组 x

输出（示例）：

[[0.67847795 1.33073923 4.53920122]

[7.55724676 5.88854047 2.65502046]

Numpy 第五章数学函数

2.`numpy.sqrt（）函数和numpy.square（）函数`

（1）聚合函数：`numpy.sum`

（2）累加函数：`numpy.cumsum`

（1） `numpy.prod`------ 计算数组元素的乘积

`（2）numpy.cumprod`------ 计算数组元素的累乘

`（3）numpy.diff`------ 计算数组的差值

`（1）numpy.around`------ 四舍五入（按小数位数舍入）

`（2）numpy.ceil`------ 向上取整（返回不小于输入的最小整数）

`（3）numpy.floor`------ 向下取整（返回不大于输入的最大整数）

（1）`numpy.clip`：裁剪数组值到指定区间

（2）`numpy.absolute`/ `numpy.abs`：逐元素计算绝对值

（3） `numpy.sign`：逐元素返回数字的符号