向量化介绍

向量化与广播操作

小象实战讲义 · Python数据分析实战

在上一节我们学习了NumPy数组的基本操作。但NumPy真正的威力在于其高效的向量化计算能力。本节将深入讲解向量化（Vectorization）和广播（Broadcasting）这两个核心概念，它们是NumPy高效处理数据的基础，也是后续进行数据分析时必备的思维方式。

💡 核心导读

• 向量化：一种避免显式循环，对整个数组进行一次性操作的高效编程范式。
• 向量化的优势：代码更简洁、执行速度更快（底层由C语言实现）。
• 广播机制：NumPy处理不同形状数组间运算的规则，能够自动扩展小数组以匹配大数组的形状。
• 广播的应用场景：标量与数组运算、不同维度数组间的运算。

什么是向量化（Vectorization）

向量化，英文为Vectorization，是NumPy中一种核心的操作思想。它的目标是通过避免在Python层面编写显式的for循环，来获得执行速度更快、代码更紧凑的程序。

基本思路：将操作“一次性”应用在整个数组（或其它复杂对象）上，而不是通过循环逐个处理数组中的元素。

我们通过一个简单的例子来理解这种思维方式的转变。假设有两个列表（或数组）A = [1, 2, 3, 4]和B = [6, 7, 8, 9]，我们需要计算它们对应元素的乘积。

传统Python循环方式：

A = [1, 2, 3, 4]
B = [6, 7, 8, 9]
result = []
for a, b in zip(A, B):
    result.append(a * b)
print(result)

[6, 14, 24, 36]

NumPy向量化方式：

import numpy as np

A = np.array([1, 2, 3, 4])
B = np.array([6, 7, 8, 9])
result = A * B  # 一次性对整个数组进行乘法运算
print(result)

[ 6 14 24 36]

可以看到，向量化操作只用了一行代码 A * B 就完成了任务。在向量化的思维方式中，我们把 A 和 B 各自看作一个整体（向量），操作是在两个整体之间进行的，而不是分别处理它们内部的每个元素。

这种方式的优势非常明显：

1. 代码简洁：逻辑清晰，更易于阅读和维护。
2. 性能卓越：NumPy的向量化操作底层由高度优化的C代码实现，其执行速度远快于纯Python的循环。对于大规模数据，这种性能差异是数量级的。

因此，在学习数据分析时，有意识地培养自己的“向量化思维”至关重要。

广播机制（Broadcasting）

向量化操作通常要求数组形状完全一致。那么，当我们需要对不同形状的数组进行运算时，该怎么办呢？NumPy通过广播机制来解决这个问题。

广播的核心规则是：将形状较小的数组（或标量）“广播”到与形状较大的数组具有兼容的维度，以便进行元素级的运算。

标量与数组的广播

这是最简单的广播形式。一个标量（单个数值）可以与任意形状的数组进行运算。

import numpy as np

arr = np.arange(3)  # 数组形状为 (3,)，值为 [0, 1, 2]
result = arr + 5    # 标量5被广播成形状(3,)的数组[5, 5, 5]
print("arr:", arr)
print("arr + 5:", result)

arr: [0 1 2]
arr + 5: [5 6 7]

运算过程可以理解为：标量5被复制成了一个与arr形状相同的临时数组[5, 5, 5]，然后执行元素相加[0+5, 1+5, 2+5]。

一维数组与二维数组的广播

当数组维度不同时，广播会尝试从它们的形状元组末尾开始对齐，并满足以下两个条件之一：

1. 维度大小相等。
2. 其中一个维度大小为1。

import numpy as np

# 示例1：二维数组 + 一维行数组
arr_2d = np.ones((3, 3))  # 形状 (3, 3)
arr_1d_row = np.arange(3) # 形状 (3,)，可视为(1, 3)
result1 = arr_2d + arr_1d_row
print("3x3全1数组 + [0,1,2]:")
print(result1)

# 示例2：二维数组 + 一维列数组
arr_1d_col = np.arange(3).reshape(3, 1)  # 形状 (3, 1)
result2 = arr_2d + arr_1d_col
print("\n3x3全1数组 + [[0],[1],[2]]:")
print(result2)

3x3全1数组 + [0,1,2]:
[[1. 2. 3.]
 [1. 2. 3.]
 [1. 2. 3.]]

3x3全1数组 + [[0],[1],[2]]:
[[1. 1. 1.]
 [2. 2. 2.]
 [3. 3. 3.]]

解释：

• arr_2d形状为(3,3)，arr_1d_row形状为(3,)。对齐时，arr_1d_row被视为(1,3)。由于在第一个维度上大小为1，它被广播（复制）成(3,3)，然后相加。
• arr_1d_col形状为(3,1)。在第二个维度上大小为1，它被广播（复制）成(3,3)，然后相加。

综合示例：两个一维数组的广播

当两个数组形状不完全相同但都包含大小为1的维度时，它们可以相互广播到一个共同的形状。

import numpy as np

# 创建一个3行1列的数组和一个1行3列的数组
col_vector = np.arange(3).reshape(3, 1)  # 形状 (3, 1)，值 [[0],[1],[2]]
row_vector = np.arange(3).reshape(1, 3)  # 形状 (1, 3)，值 [[0, 1, 2]]

result = col_vector + row_vector
print("列向量 (3,1):")
print(col_vector)
print("\n行向量 (1,3):")
print(row_vector)
print("\n广播相加结果 (3,3):")
print(result)

列向量 (3,1):
[[0]
 [1]
 [2]]

行向量 (1,3):
[[0 1 2]]

广播相加结果 (3,3):
[[0 1 2]
 [1 2 3]
 [2 3 4]]

广播过程：col_vector在第二个维度上从1广播到3，row_vector在第一个维度上从1广播到3。最终两者都变成(3,3)的形状再进行相加。

向量化与广播实战

为了巩固理解，我们用一个模拟的销售数据小例子，结合Pandas（其底层也依赖NumPy的向量化）来演示这些概念的实际应用。

import pandas as pd
import numpy as np

# 创建一个模拟的每日产品销售额DataFrame（单位：元）
# 行索引为日期，列名为产品
data = {
    '产品A': [120, 150, 130],
    '产品B': [300, 280, 320],
    '产品C': [80, 95, 88]
}
df_sales = pd.DataFrame(data, index=['Day1', 'Day2', 'Day3'])
print("原始销售数据:")
print(df_sales)
print()

# 1. 向量化操作：所有产品价格打9折
df_sales_discount = df_sales * 0.9
print("所有产品打9折后:")
print(df_sales_discount)
print()

# 2. 广播操作：计算每日总销售额（各产品销售额之和）
daily_total = df_sales.sum(axis=1)  # axis=1 对每行（每天）的各列（产品）求和
print("每日总销售额:")
print(daily_total)
print()

# 3. 广播操作：计算每种产品销售额与自身平均值的差值
product_mean = df_sales.mean(axis=0)  # axis=0 对每列（产品）的各行（天）求平均
print("每种产品的平均销售额:")
print(product_mean)
print()

# 将产品平均值（一个一维Series）广播到与df_sales相同的形状，然后做减法
deviation = df_sales - product_mean  # Pandas会自动沿行广播product_mean
print("每日销售额与产品平均值的差值:")
print(deviation)

原始销售数据:
      产品A  产品B  产品C
Day1  120  300   80
Day2  150  280   95
Day3  130  320   88

所有产品打9折后:
        产品A    产品B   产品C
Day1  108.0  270.0  72.0
Day2  135.0  252.0  85.5
Day3  117.0  288.0  79.2

每日总销售额:
Day1    500
Day2    525
Day3    538
dtype: int64

每种产品的平均销售额:
产品A    133.333333
产品B    300.000000
产品C     87.666667
dtype: float64

每日销售额与产品平均值的差值:
            产品A   产品B       产品C
Day1 -13.333333   0.0 -7.666667
Day2  16.666667 -20.0  7.333333
Day3  -3.333333  20.0  0.333333

📝 动手练一练

1. 概念辨析：向量化操作和Python的for循环在处理数组运算时的主要区别是什么？至少列出两点。

2. 动手实践：给定一个二维NumPy数组 arr = np.array([[1, 2, 3], [4, 5, 6]])，请不显式使用循环，完成以下操作： a) 计算数组每一行的和。 b) 将数组的每个元素减去其所在列的平均值。

import numpy as np

arr = np.array([[1, 2, 3],
                [4, 5, 6]])

# a) 计算每一行的和
row_sums = arr.sum(axis=1)
print("每一行的和:", row_sums)  # 输出: [ 6 15]

# b) 计算每一列的平均值，然后广播相减
col_means = arr.mean(axis=0)  # 形状为 (3,)
arr_centered = arr - col_means  # 广播：arr (2,3) - col_means (3,)
print("\n减去列平均值后的数组:")
print(arr_centered)

每一行的和: [ 6 15]

减去列平均值后的数组:
[[-1.5 -1.5 -1.5]
 [ 1.5  1.5  1.5]]

本章小结

本节我们深入学习了NumPy中提升计算效率和代码简洁性的两大法宝：向量化与广播。

• 向量化让我们摆脱了低效的显式循环，能够以接近数学表达式的形式对整体数据进行操作，代码更清晰，运行更快速。
• 广播机制则赋予了向量化操作极大的灵活性，使得不同形状的数组（包括标量）之间能够智能地进行运算，它是NumPy众多强大功能得以实现的基础。

理解并熟练运用这两个概念，是迈向高效数据分析的关键一步。

📋 行动清单

• 尝试将一段使用for循环处理列表的Python代码，改写成使用NumPy数组的向量化形式。
• 创建一个二维数组和一个一维数组，手动推演它们进行加法运算时的广播过程，并用代码验证你的推演。
• 在Pandas中选取一列数据（Series），对其进行向量化的数学运算（如加、减、乘、除一个标量），观察结果。

—— 小象教研组