一、概念

●  算术运算：对 NumPy 数组进行加、减、乘、除、幂等基本数学运算。这些运算可以在数组与数组之间、数组与标量之间进行。

●  逻辑运算：对数组中的元素进行逻辑判断，如与（ & ）、或（ | ）、非（ ~ ）等运算。

●  比较运算：比较两个数组对应元素的大小关系，返回一个布尔值数组，常见的比较运算符有等于（ == ）、不等于（ != ）、大于（ > ）、小于（ < ）、大于等于（ >= ）、小于等于（ <= ）。

二、关键点

●  广播机制：当对形状不同的数组进行运算时，NumPy 会尝试使用广播机制来调整数组的形状，以便进行运算。广播机制使得数组之间的运算更加灵活，例如，一个标量可以与任意形状的数组进行运算，此时标量会被广播到数组的每个元素上；两个形状兼容的数组（如一个 1 维数组与一个 2 维数组，其中 1 维数组的长度与 2 维数组某一维度的长度相等）也可以进行运算。

●  元素级运算：NumPy 数组的运算通常是元素级的，即运算会对数组的每个对应元素进行操作，而不是像矩阵运算那样遵循特定的矩阵规则（除非使用专门的矩阵运算函数）。例如，两个数组相加，是将对应位置的元素相加。

●  运算函数：

NumPy 提供了许多内置的运算函数，如  np.add() 、 np.subtract() 、 np.multiply() 、 np.divide()  等，这些函数与运算符（ + 、 - 、 * 、 / ）的作用类似，但在一些情况下可以提供更灵活的参数设置和更好的性能。

三、注意点

●  形状匹配：在进行数组之间的运算时，要确保数组的形状符合广播规则或者完全一致。如果形状不匹配且无法广播，会抛出  ValueError  异常。

●  数据类型：运算结果的数据类型可能会根据参与运算的数组的数据类型而变化。例如，整数数组与浮点数数组进行运算，结果通常是浮点数数组。

●  逻辑运算的优先级：在进行多个逻辑运算时，要注意运算符的优先级， ~ （非）的优先级最高，然后是  & （与），最后是  | （或）。如果不确定优先级，可以使用括号明确运算顺序。

四、举例说明

1、 算术运算：

Python脚本

# 导入 NumPy 库，并将其重命名为 np，方便后续使用 NumPy 中的函数和对象
import numpy as np
# 使用 NumPy 的 array 函数创建一个一维数组 arr1，该数组包含元素 1、2、3
arr1 = np.array([1, 2, 3])
# 使用 NumPy 的 array 函数创建一个一维数组 arr2，该数组包含元素 4、5、6
arr2 = np.array([4, 5, 6])

# 数组与数组相加操作
# 当两个 NumPy 数组进行加法运算时，会将对应位置的元素相加
# 这里 arr1 和 arr2 对应位置元素相加后，会得到一个新的数组
# 打印该新数组，预期输出为 [5 7 9]
print(arr1 + arr2)    # 输出 [5 7 9]

# 数组与标量相乘操作
# 当 NumPy 数组与一个标量（单个数值）相乘时，数组中的每个元素都会与该标量相乘
# 这里 arr1 中的每个元素都乘以 2，得到一个新的数组
# 打印该新数组，预期输出为 [2 4 6]
print(arr1 * 2)    # 输出 [2 4 6]
# 使用 NumPy 的运算函数进行数组操作
# np.subtract 是 NumPy 提供的减法函数，用于计算两个数组对应元素的差值
# 这里计算 arr2 减去 arr1 对应位置元素的差值，得到一个新的数组
# 打印该新数组，预期输出为 [3 3 3]
print(np.subtract(arr2, arr1))    # 输出 [3 3 3]

2、逻辑运算：

Python脚本

# 导入 NumPy 库，并将其重命名为 np，方便后续使用 NumPy 相关功能
import numpy as np
# 使用 NumPy 的 array 函数创建一个一维布尔类型的数组 arr3
# 该数组包含三个布尔元素，分别是 True、False 和 True
arr3 = np.array([True, False, True])
# 使用 NumPy 的 array 函数创建另一个一维布尔类型的数组 arr4
# 此数组也包含三个布尔元素，分别是 False、True 和 True
arr4 = np.array([False, True, True])

逻辑与运算

Python脚本

# 导入 NumPy 库，并将其重命名为 np，方便后续使用 NumPy 中的函数和对象
import numpy as np
# 使用 NumPy 的 array 函数创建一个一维布尔数组 arr3
# 数组包含三个布尔元素，分别是 True、False、True
arr3 = np.array([True, False, True])
# 使用 NumPy 的 array 函数创建另一个一维布尔数组 arr4
# 数组包含三个布尔元素，分别是 False、True、True
arr4 = np.array([False, True, True])
# 对布尔数组 arr3 和 arr4 进行按元素的逻辑与（&）运算
# 逻辑与运算规则为：只有当两个对应位置的元素都为 True 时，结果才为 True，否则为 False
# 具体计算过程为：
#  - 第一个元素：True & False = False
#  - 第二个元素：False & True = False
#  - 第三个元素：True & True = True
# 打印运算结果，预期输出为 [False False True]
print(arr3 & arr4)  # 输出 [False False True]

逻辑或运算

Python脚本

# 导入 NumPy 库，将其重命名为 np，后续使用 NumPy 功能时能更简洁方便
import numpy as np
# 利用 NumPy 的 array 函数构建一个一维布尔数组 arr3
# 该数组有三个布尔类型的元素，分别是 True、False、True
arr3 = np.array([True, False, True])
# 同样使用 NumPy 的 array 函数创建另一个一维布尔数组 arr4
# 此数组包含的三个布尔元素为 False、True、True
arr4 = np.array([False, True, True])
# 对布尔数组 arr3 和 arr4 执行按元素的逻辑或（|）运算
# 逻辑或运算的规则是：只要两个对应位置的元素中有一个为 True，结果就为 True；只有当两个元素都为 False 时，结果才为 False
# 具体的运算过程如下：
#  - 第一个元素：True | False = True
#  - 第二个元素：False | True = True
#  - 第三个元素：True | True = True
# 打印逻辑或运算后的结果，预期输出是 [ True  True  True]
print(arr3 | arr4)  # 输出 [ True  True  True]

逻辑非运算

Python脚本

# 导入 NumPy 库，并重命名为 np，方便后续调用 NumPy 相关功能
import numpy as np
# 使用 NumPy 的 array 函数创建一个一维布尔数组 arr3
# 该数组包含三个布尔元素，分别是 True、False、True
arr3 = np.array([True, False, True])
# 对布尔数组 arr3 进行按元素的逻辑非（~）运算
# 逻辑非运算规则是：将 True 变为 False，将 False 变为 True
# 具体计算过程为：
#  - 第一个元素：对 True 进行逻辑非运算，结果为 False
#  - 第二个元素：对 False 进行逻辑非运算，结果为 True
#  - 第三个元素：对 True 进行逻辑非运算，结果为 False
# 打印逻辑非运算后的结果，预期输出为 [False  True False]
print(~arr3)  # 输出 [False  True False]

3、比较运算：

Python脚本

# 导入 NumPy 库，并将其重命名为 np，方便后续使用 NumPy 提供的功能
import numpy as np
# 使用 NumPy 的 array 函数创建一个一维数组 arr5，数组中包含元素 10、20、30
arr5 = np.array([10, 20, 30])
# 使用 NumPy 的 array 函数创建一个一维数组 arr6，数组中包含元素 10、15、30
arr6 = np.array([10, 15, 30])

# 对数组 arr5 和 arr6 进行按元素的相等比较操作
# NumPy 会逐个比较 arr5 和 arr6 中对应位置的元素
# 若对应位置元素相等，则结果数组中该位置为 True，否则为 False
# 这里 10 等于 10 为 True，20 不等于 15 为 False，30 等于 30 为 True
# 打印比较后的布尔类型结果数组，预期输出为 [ True False  True]
print(arr5 == arr6)  # 输出 [ True False  True]

# 对数组 arr5 和 arr6 进行按元素的大于比较操作
# NumPy 会逐个比较 arr5 和 arr6 中对应位置的元素
# 若 arr5 对应位置元素大于 arr6 对应位置元素，则结果数组中该位置为 True，否则为 False
# 这里 10 不大于 10 为 False，20 大于 15 为 True，30 不大于 30 为 False
# 打印比较后的布尔类型结果数组，预期输出为 [False  True False]
print(arr5 > arr6)  # 输出 [False  True False]

4、广播机制示例：

Python脚本

# 导入 NumPy 库，并重命名为 np，方便后续使用 NumPy 的函数和对象
import numpy as np
# 创建一个二维 NumPy 数组 arr7，该数组为 2 行 3 列，包含元素 1 到 6
arr7 = np.array([[1, 2, 3],
                 [4, 5, 6]])
# 定义一个标量 scalar，其值为 2
scalar = 2
# 对数组 arr7 和标量 scalar 进行加法运算
# 在 NumPy 中，标量会被广播到数组的每个元素上，即数组 arr7 中的每个元素都会加上 scalar 的值
# 计算结果为：
# [[1 + 2, 2 + 2, 3 + 2],
#  [4 + 2, 5 + 2, 6 + 2]] = [[3, 4, 5],
#                            [6, 7, 8]]
# 打印运算结果
print(arr7 + scalar)  
# 输出结果：
# [[3 4 5]
#  [6 7 8]]

# 创建一个一维 NumPy 数组 arr8，包含元素 1、2、3
arr8 = np.array([1, 2, 3])
# 对数组 arr7 和 arr8 进行加法运算
# 这里会发生广播机制，一维数组 arr8 会沿着二维数组 arr7 的行方向进行广播
# 即 arr7 的每一行都会和 arr8 对应元素相加
# 计算结果为：
# [[1 + 1, 2 + 2, 3 + 3],
#  [4 + 1, 5 + 2, 6 + 3]] = [[2, 4, 6],
#                            [5, 7, 9]]
# 打印运算结果
print(arr7 + arr8)
# 输出结果：
# [[2 4 6]
#  [5 7 9]]

 通过以上介绍和示例，你可以更好地理解和运用 NumPy 数组的运算功能。