5.1 元素级运算 (Element-wise Operations)

5.1 元素级运算 (Element-wise Operations)

NumPy 数组的元素级运算 (Element-wise Operations)

5.1 元素级运算 (Element-wise Operations)

元素级运算指的是对 NumPy 数组中的每个元素独立地应用某种操作。这意味着操作的结果数组的形状与原始数组相同（在广播规则允许的情况下）。 NumPy 提供了广泛的内置函数和运算符来执行这些操作，涵盖了算术、比较和逻辑运算。

5.1.1 算术运算

NumPy 提供了标准的算术运算符（+、-、*、/、//、%、**）以及相应的函数（np.add、np.subtract、np.multiply、np.divide、np.floor_divide、np.mod、np.power）来执行元素级的算术运算。

加法 (+, np.add):

import numpy as np
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
# 使用运算符
result1 = a + b
print("a + b:", result1)  # 输出: a + b: [5 7 9]
# 使用函数
result2 = np.add(a, b)
print("np.add(a, b):", result2)  # 输出: np.add(a, b): [5 7 9]
​

减法 (-, np.subtract):

a = np.array([10, 20, 30])
b = np.array([4, 5, 6])
# 使用运算符
result1 = a - b
print("a - b:", result1)  # 输出: a - b: [ 6 15 24]
# 使用函数
result2 = np.subtract(a, b)
print("np.subtract(a, b):", result2)  # 输出: np.subtract(a, b): [ 6 15 24]
​

乘法 (*, np.multiply):

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
# 使用运算符
result1 = a * b
print("a * b:", result1)  # 输出: a * b: [ 4 10 18]
# 使用函数
result2 = np.multiply(a, b)
print("np.multiply(a, b):", result2)  # 输出: np.multiply(a, b): [ 4 10 18]
​

除法 (/, np.divide):

a = np.array([10, 20, 30])
b = np.array([2, 4, 5])
# 使用运算符
result1 = a / b
print("a / b:", result1)  # 输出: a / b: [5. 5. 6.]
# 使用函数
result2 = np.divide(a, b)
print("np.divide(a, b):", result2)  # 输出: np.divide(a, b): [5. 5. 6.]
​

向下取整除法 (//, np.floor_divide):

a = np.array([10, 20, 30])
b = np.array([3, 6, 7])
# 使用运算符
result1 = a // b
print("a // b:", result1)  # 输出: a // b: [3 3 4]
# 使用函数
result2 = np.floor_divide(a, b)
print("np.floor_divide(a, b):", result2)  # 输出: np.floor_divide(a, b): [3 3 4]
​

取模 (%, np.mod):

a = np.array([10, 20, 30])
b = np.array([3, 6, 7])
# 使用运算符
result1 = a % b
print("a % b:", result1)  # 输出: a % b: [1 2 2]
# 使用函数
result2 = np.mod(a, b)
print("np.mod(a, b):", result2)  # 输出: np.mod(a, b): [1 2 2]
​

幂运算 (**, np.power):

a = np.array([2, 3, 4])
b = np.array([2, 3, 2])
# 使用运算符
result1 = a ** b
print("a ** b:", result1)  # 输出: a ** b: [ 4 27 16]
# 使用函数
result2 = np.power(a, b)
print("np.power(a, b):", result2)  # 输出: np.power(a, b): [ 4 27 16]
​

这些运算符和函数都能够处理标量和数组之间的运算，NumPy 会自动将标量广播到数组的形状，然后执行元素级运算。

示例：标量和数组的运算

a = np.array([1, 2, 3])
scalar = 2
result1 = a + scalar
print("a + scalar:", result1)  # 输出: a + scalar: [3 4 5]
result2 = a * scalar
print("a * scalar:", result2)  # 输出: a * scalar: [2 4 6]
​

5.1.2 比较运算

NumPy 提供了标准的比较运算符（==、!=、<、>、<=、>=）来执行元素级的比较运算。 这些运算符返回一个布尔数组，其中每个元素指示相应的比较结果。

a = np.array([1, 2, 3, 4, 5])
b = np.array([2, 2, 4, 3, 5])
# 等于
equal = a == b
print("a == b:", equal)  # 输出: a == b: [False  True False False  True]
# 不等于
not_equal = a != b
print("a != b:", not_equal)  # 输出: a != b: [ True False  True  True False]
# 小于
less_than = a < b
print("a < b:", less_than)  # 输出: a < b: [ True False  True False False]
# 大于
greater_than = a > b
print("a > b:", greater_than)  # 输出: a > b: [False False False  True False]
# 小于等于
less_equal = a <= b
print("a <= b:", less_equal)  # 输出: a <= b: [ True  True  True False  True]
# 大于等于
greater_equal = a >= b
print("a >= b:", greater_equal)  # 输出: a >= b: [False  True False  True  True]
​

5.1.3 逻辑运算

NumPy 提供了逻辑运算符（&、|、~）以及相应的函数（np.logical_and、np.logical_or、np.logical_not）来执行元素级的逻辑运算。 这些运算符和函数通常用于处理布尔数组。

a = np.array([True, False, True, False])
b = np.array([False, True, True, False])
# 与 (&, np.logical_and)
result_and1 = a & b
print("a & b:", result_and1)  # 输出: a & b: [False False  True False]
result_and2 = np.logical_and(a, b)
print("np.logical_and(a, b):", result_and2)  # 输出: np.logical_and(a, b): [False False  True False]
# 或 (|, np.logical_or)
result_or1 = a | b
print("a | b:", result_or1)  # 输出: a | b: [ True  True  True False]
result_or2 = np.logical_or(a, b)
print("np.logical_or(a, b):", result_or2)  # 输出: np.logical_or(a, b): [ True  True  True False]
# 非 (~, np.logical_not)
result_not1 = ~a
print("~a:", result_not1)  # 输出: ~a: [False  True False  True]
result_not2 = np.logical_not(a)
print("np.logical_not(a):", result_not2)  # 输出: np.logical_not(a): [False  True False  True]
​

逻辑运算在与比较运算结合时非常有用，可以用于根据特定条件选择数组元素。

示例：使用逻辑运算选择数组元素

a = np.array([1, 2, 3, 4, 5])
# 选择大于 2 且小于 5 的元素
condition = (a > 2) & (a < 5)
selected_elements = a[condition]
print("Selected elements:", selected_elements)  # 输出: Selected elements: [3 4]
​

5.1.4 其他常用元素级函数

除了基本的算术、比较和逻辑运算，NumPy 还提供了许多其他有用的元素级函数，例如：

• np.abs(): 计算绝对值。

• np.sqrt(): 计算平方根。

• np.exp(): 计算指数。

• np.log(): 计算自然对数。

• np.sin(), np.cos(), np.tan(): 计算三角函数。

• np.round(): 四舍五入。

• np.floor(): 向下取整。

• np.ceil(): 向上取整。

a = np.array([-1, 2, -3, 4])
abs_a = np.abs(a)
print("Absolute values:", abs_a)  # 输出: Absolute values: [1 2 3 4]
b = np.array([1, 4, 9, 16])
sqrt_b = np.sqrt(b)
print("Square roots:", sqrt_b)  # 输出: Square roots: [1. 2. 3. 4.]
c = np.array([0, 1, 2, 3])
exp_c = np.exp(c)
print("Exponentials:", exp_c)  # 输出: Exponentials: [ 1.          2.71828183  7.3890561  20.08553692]
​

5.1.5 广播 (Broadcasting)

广播是 NumPy 中一种强大的机制，允许不同形状的数组进行算术运算。 NumPy 会自动扩展较小数组的形状，使其与较大数组的形状兼容，然后执行元素级运算。

广播规则:

1. 如果两个数组的维度数不同，则在维度较小的数组的形状前面添加 1，直到两个数组的维度数相同。

2. 如果两个数组的形状在任何维度上都不匹配，并且其中一个数组在该维度上的大小为 1，则该数组在该维度上进行扩展以匹配另一个数组的形状。

3. 如果两个数组的形状在任何维度上都不匹配，并且两个数组在该维度上的大小都不为 1，则会引发错误。

示例：广播

a = np.array([1, 2, 3])  # shape (3,)
b = np.array([[10], [20], [30]])  # shape (3, 1)
result = a + b
print("a + b:\n", result)
# 输出:
# a + b:
# [[11 12 13]
#  [21 22 23]
#  [31 32 33]]
​

在这个例子中，数组 a 的形状是 (3,)，数组 b 的形状是 (3, 1)。 NumPy 会自动将 a 广播到形状 (3, 3)，将 b 广播到形状 (3, 3)，然后执行元素级加法。

5.1.6 性能优势

NumPy 的元素级运算利用了向量化操作，这使得它们比使用 Python 循环更快。 向量化操作将操作应用于整个数组，而不是逐个元素，从而可以利用底层硬件的并行处理能力。

示例：性能比较

import time
# 使用 NumPy
a = np.random.rand(1000000)
b = np.random.rand(1000000)
start_time = time.time()
result_numpy = a + b
end_time = time.time()
print("NumPy time:", end_time - start_time)
# 使用 Python 循环
a_list = list(a)
b_list = list(b)
start_time = time.time()
result_python = [x + y for x, y in zip(a_list, b_list)]
end_time = time.time()
print("Python loop time:", end_time - start_time)
​

通常情况下，NumPy 的元素级运算比 Python 循环快几个数量级。

5.1.7 流程图

以下是一个简单的流程图，说明了元素级运算的过程：

详细流程:

1. 输入数组 A: 这是进行元素级运算的第一个数组。

2. 输入数组 B (可选): 如果需要二元运算 (例如加法, 乘法)，则需要第二个输入数组。 如果是单元运算 (例如取绝对值)，则不需要。

3. 元素级操作: 这是应用到数组 (或数组们) 的具体操作，例如加法、减法、比较、逻辑运算等。 NumPy 会将操作应用于数组的每个元素 (或对应位置的元素)。

4. 输出数组: 这是包含元素级运算结果的新数组。 输出数组的形状通常与输入数组相同 (在广播允许的情况下)。

总结

NumPy 的元素级运算是其核心功能之一，它提供了一种高效且简洁的方式来对数组执行各种操作。 通过掌握这些运算，可以极大地简化数值计算，并提高代码的性能。 广播机制进一步增强了 NumPy 的灵活性，允许不同形状的数组进行运算。 熟练运用 NumPy 的元素级运算是进行高效数据分析和科学计算的关键。