运算与对齐

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

在数据分析中，我们经常需要对不同来源、不同结构的数据进行合并与计算。Pandas 的强大之处在于，它能够智能地处理这些操作，而“对齐”正是其核心机制。本节我们将深入探讨 Pandas 中 Series 和 DataFrame 进行算术运算时，索引是如何决定计算结果的，以及如何处理未对齐的数据。

💡 核心导读

• 索引是运算的“导航图”：Pandas 的运算不是基于数据的位置，而是基于索引标签的匹配。
• Series 间的对齐：发生在索引上，相同索引的值进行计算，未对齐的位置补 NaN。
• DataFrame 间的对齐：同时发生在行索引和列索引两个维度上。
• Series 与 DataFrame 的混合运算：规则特殊，Series 的索引会被视为列，与 DataFrame 的列进行匹配计算。

理解索引对齐机制

Pandas 的设计哲学是“带标签的数据计算”。这意味着，当对两个 Pandas 对象进行运算时，Pandas 不会简单地将第一个对象的第一行与第二个对象的第一行相加，而是会去寻找两个对象中索引标签相同的位置，并对这些位置上的值进行计算。

如果某个索引标签只存在于一个对象中，而在另一个对象中找不到对应的标签，那么该位置在计算结果中将被填充为 NaN（Not a Number，表示缺失值）。这种自动对齐的特性，使得我们可以安全地对不同形状、不同来源的数据进行运算，而无需手动对齐。

Series 间的运算与对齐

我们通过一个具体的例子来理解 Series 间的对齐。假设有两个 Series：

import pandas as pd
import numpy as np

# 创建 Series 1: 索引 0-9，值 10-19
ser1 = pd.Series(range(10, 20), index=range(10))
print("Series 1:")
print(ser1)
print()

# 创建 Series 2: 索引 0-4，值 20-24
ser2 = pd.Series(range(20, 25), index=range(5))
print("Series 2:")
print(ser2)
print()

# Series 间的加法运算
result = ser1 + ser2
print("ser1 + ser2 的结果:")
print(result)

Series 1:
0    10
1    11
2    12
3    13
4    14
5    15
6    16
7    17
8    18
9    19
dtype: int64

Series 2:
0    20
1    21
2    22
3    23
4    24
dtype: int64

ser1 + ser2 的结果:
0    30.0
1    32.0
2    34.0
3    36.0
4    38.0
5     NaN
6     NaN
7     NaN
8     NaN
9     NaN
dtype: float64

运算过程解析：

1. 对齐：Pandas 首先找到两个 Series 共有的索引标签：0, 1, 2, 3, 4。
2. 计算：对共有索引位置的值进行相加：10+20=30, 11+21=32, …, 14+24=38。
3. 处理未对齐项：ser1 中索引 5 到 9 在 ser2 中找不到对应项。因此，结果中索引 5 到 9 的位置被填充为 NaN。
4. 数据类型：由于引入了 NaN（在 Pandas 中属于浮点类型），整个结果 Series 的数据类型从 int64 自动提升为 float64。

这个例子清晰地展示了 “索引对齐优先于位置顺序” 的原则。

DataFrame 间的运算与对齐

DataFrame 是二维表格，其对齐发生在两个维度：行索引（index）和列索引（columns）。只有行和列标签都匹配的位置，才会进行计算。

import pandas as pd
import numpy as np

# 创建 DataFrame 1: 2行2列，值全为1
df1 = pd.DataFrame(np.ones((2, 2)), columns=['a', 'b'], index=[0, 1])
print("DataFrame 1:")
print(df1)
print()

# 创建 DataFrame 2: 3行3列，值全为1
df2 = pd.DataFrame(np.ones((3, 3)), columns=['a', 'b', 'c'], index=[0, 1, 2])
print("DataFrame 2:")
print(df2)
print()

# DataFrame 间的加法运算
df_result = df1 + df2
print("df1 + df2 的结果:")
print(df_result)

DataFrame 1:
     a    b
0  1.0  1.0
1  1.0  1.0

DataFrame 2:
     a    b    c
0  1.0  1.0  1.0
1  1.0  1.0  1.0
2  1.0  1.0  1.0

df1 + df2 的结果:
     a    b   c
0  2.0  2.0 NaN
1  2.0  2.0 NaN
2  NaN  NaN NaN

运算过程解析：

1. 行列对齐：Pandas 寻找两个 DataFrame 行和列标签的交集。
   • 行交集：[0, 1]
   • 列交集：[‘a‘, ‘b‘]
2. 计算：仅对行标签和列标签都匹配的单元格进行计算，即 (0,a), (0,b), (1,a), (1,b) 这四个位置。每个位置都是 1.0 + 1.0 = 2.0。
3. 处理未对齐项：
   • 对于行2和列c，因为它们在 df1 中不存在，所以对应行/列的所有位置都是 NaN。
   • 结果 DataFrame 的形状由两个输入对象的行、列标签的并集决定。

Series 与 DataFrame 的混合运算

这是最容易令人困惑的部分。核心规则是：当 Series 与 DataFrame 进行运算时，Series 的索引（index）会被匹配到 DataFrame 的列（columns）上。然后，Series 的值会沿着 DataFrame 的行方向进行广播（即每一行都会与这个 Series 进行运算）。

情况一：Series 的索引与 DataFrame 的列完全不匹配

import pandas as pd
import numpy as np

# 创建 DataFrame 1
df1 = pd.DataFrame(np.ones((2, 2)), columns=['a', 'b'], index=[0, 1])
# 创建 Series 2 (索引为数字0-4)
ser2 = pd.Series(range(20, 25), index=range(5))

print("DataFrame 1 (列为字母‘a‘,‘b‘):")
print(df1)
print()
print("Series 2 (索引为数字0-4):")
print(ser2)
print()

mixed_result_1 = ser2 + df1
print("ser2 + df1 的结果:")
print(mixed_result_1)

DataFrame 1 (列为字母‘a‘,‘b‘):
     a    b
0  1.0  1.0
1  1.0  1.0

Series 2 (索引为数字0-4):
0    20
1    21
2    22
3    23
4    24
dtype: int64

ser2 + df1 的结果:
    a   b   0   1   2   3   4
0 NaN NaN NaN NaN NaN NaN NaN
1 NaN NaN NaN NaN NaN NaN NaN

结果分析： 运算时，ser2 的索引 [0,1,2,3,4] 被当作列标签去匹配 df1 的列 [‘a‘, ‘b‘]。由于没有一列能匹配上，所以所有交叉位置都产生 NaN。同时，结果 DataFrame 的列是两者列标签的并集 [0,1,2,3,4,‘a‘,‘b‘]，行与 df1 相同 [0,1]。

情况二：Series 的索引与 DataFrame 的列部分匹配

import pandas as pd
import numpy as np

# 创建 DataFrame 1
df1 = pd.DataFrame(np.ones((2, 2)), columns=['a', 'b'], index=[0, 1])
# 创建 Series 3 (索引为字母‘a‘,‘b‘,‘c‘)
ser3 = pd.Series([1, 2, 3], index=['a', 'b', 'c'])

print("DataFrame 1:")
print(df1)
print()
print("Series 3 (索引为字母‘a‘,‘b‘,‘c‘):")
print(ser3)
print()

mixed_result_2 = ser3 + df1
print("ser3 + df1 的结果:")
print(mixed_result_2)

DataFrame 1:
     a    b
0  1.0  1.0
1  1.0  1.0

Series 3 (索引为字母‘a‘,‘b‘,‘c‘):
a    1
b    2
c    3
dtype: int64

ser3 + df1 的结果:
     a    b   c
0  2.0  3.0 NaN
1  2.0  3.0 NaN

结果分析：

1. 列对齐：ser3 的索引 [‘a‘, ‘b‘, ‘c‘] 与 df1 的列进行匹配。‘a‘ 和 ‘b‘ 匹配成功。
2. 广播与计算：对于匹配成功的列，ser3 中该列对应的值会与 df1 中该列的每一行进行计算。
   • 列 a: df1 中所有行的值都是 1.0，加上 ser3[‘a‘]=1，结果该列所有行变为 2.0。
   • 列 b: 1.0 + 2 = 3.0。
3. 处理未匹配项：ser3 中的 ‘c‘ 在 df1 中没有对应列，因此结果中新增一列 c，其值全部为 NaN。

本章小结

Pandas 的运算与对齐机制是其数据处理能力的基石。它让我们能够以声明式的方式操作数据，而无需陷入繁琐的循环和条件判断中。

• 对齐是核心：所有运算都基于索引标签的匹配，而非数据的位置。
• NaN 是安全符：未对齐的数据用 NaN 填充，避免了计算错误，也明确标识了数据缺失的情况。
• 维度决定规则：
  • Series vs Series：在索引维度对齐。
  • DataFrame vs DataFrame：在行和列两个维度对齐。
  • Series vs DataFrame：Series 的索引对齐 DataFrame 的列，然后沿行广播。

📋 行动清单

• 尝试创建两个索引部分重叠的 Series，手动预测它们相加的结果，再用代码验证。
• 构造一个 Series 和一个 DataFrame，确保 Series 的索引与 DataFrame 的列部分一致，观察广播计算的效果。
• 在遇到包含 NaN 的计算结果时，思考这些 NaN 产生的原因是由于行索引、列索引，还是两者都不匹配导致的。

📝 动手练一练

1. 概念辨析：如果两个 DataFrame 具有完全相同的行索引，但列索引完全不同，它们相加的结果会是什么形状？结果中会有非 NaN 的值吗？

2. 动手实验：参考视频中的思考题，将 ser2 的索引从 [0,1,2,3,4] 改为 [0,2,4,6,8]，然后计算 ser1 + ser2。请先手动推理结果，再用以下代码验证你的想法。

import pandas as pd

# 创建 Series 1
ser1 = pd.Series(range(10, 20), index=range(10))
# 创建修改索引后的 Series 2
ser2_modified = pd.Series(range(20, 25), index=[0, 2, 4, 6, 8])

print("修改后的 Series 2:")
print(ser2_modified)
print()
print("ser1 + 修改后的ser2 的结果:")
print(ser1 + ser2_modified)

修改后的 Series 2:
0    20
2    21
4    22
6    23
8    24
dtype: int64

ser1 + 修改后的ser2 的结果:
0    30.0
1     NaN
2    33.0
3     NaN
4    36.0
5     NaN
6    39.0
7     NaN
8    42.0
9     NaN
dtype: float64

—— 小象教研组