查看全课大纲（第 35 / 52 节）

Pandas DataFrame：构建多只股票行情面板

约 8 分钟

小象实战讲义 · 量化交易Python入门：从咖啡馆到华尔街

Pandas 是量化交易员最核心的武器。本章你将通过 Series 和 DataFrame 深度处理时间序列行情数据，掌握 loc/iloc 定位筛选、缺失值与重复值清洗、以及最大回撤与年化波动率等核心指标统计计算。

💡 核心导读

DataFrame 是 Pandas 中最核心的二维表格型数据结构，本章将深入解析其设计原理与操作技巧。通过本节学习，您将掌握：DataFrame 的底层存储机制、行列索引操作、数据类型转换等核心技能，并能够熟练使用 Pandas 进行表格数据的增删改查。重点包括：多级索引创建、向量化运算优化以及内存高效处理方法。

DataFrame 核心特性

数据结构解析

DataFrame 由以下三部分组成：

数据块(Block): 按列存储的连续内存区域
索引(Index): 行标签（默认RangeIndex）
列标签(Columns): 列名序列

import pandas as pd
import numpy as np

data = {
    '产品': ['A101', 'B205', 'C307'],
    '库存': [120, 85, 210],
    '单价': [29.9, 45.0, 12.5]
}
df = pd.DataFrame(data, index=['仓库1', '仓库2', '仓库3'])

print("数据结构示例：")
print(df)

执行输出：

数据结构示例：
       产品   库存    单价
仓库1  A101  120  29.9
仓库2  B205   85  45.0
仓库3  C307  210  12.5

内存优化技巧

使用memory_usage()方法检查内存占用：

import pandas as pd
import numpy as np

data = {
    '产品': ['A101', 'B205', 'C307'],
    '库存': [120, 85, 210],
    '单价': [29.9, 45.0, 12.5]
}
df = pd.DataFrame(data, index=['仓库1', '仓库2', '仓库3'])

print("原始内存占用：")
print(df.memory_usage())

df['库存'] = pd.to_numeric(df['库存'], downcast='unsigned')
df['单价'] = pd.to_numeric(df['单价'], downcast='float')

print("\n优化后内存占用：")
print(df.memory_usage())

原始内存占用：
Index    24
产品       24
库存       24
单价       24
dtype: int64

优化后内存占用：
Index    24
产品       24
库存        3
单价       12
dtype: int64

核心操作实战

数据选择与过滤

import pandas as pd
import numpy as np

data = {
    '产品': ['A101', 'B205', 'C307'],
    '库存': [120, 85, 210],
    '单价': [29.9, 45.0, 12.5]
}
df = pd.DataFrame(data, index=['仓库1', '仓库2', '仓库3'])

high_value = df[df['单价'] > 30]
print("高价商品：\n", high_value)

condition = (df['库存'] > 100) & (df['单价'] < 20)
print("\n高库存低价商品：\n", df[condition])

高价商品：
        产品  库存    单价
仓库2  B205  85  45.0

高库存低价商品：
        产品   库存    单价
仓库3  C307  210  12.5

表格变形操作

import pandas as pd
import numpy as np

data = {
    '产品': ['A101', 'B205', 'C307'],
    '库存': [120, 85, 210],
    '单价': [29.9, 45.0, 12.5]
}
df = pd.DataFrame(data, index=['仓库1', '仓库2', '仓库3'])

df['总价值'] = df['库存'] * df['单价']
print("添加计算列后：\n", df)

print("\n转置结果：\n", df.T)

添加计算列后：
        产品   库存    单价     总价值
仓库1  A101  120  29.9  3588.0
仓库2  B205   85  45.0  3825.0
仓库3  C307  210  12.5  2625.0

转置结果：
         仓库1     仓库2     仓库3
产品     A101    B205    C307
库存      120      85     210
单价     29.9    45.0    12.5
总价值  3588.0  3825.0  2625.0

多级索引示例

import pandas as pd
import numpy as np

multi_df = pd.DataFrame({
    '销售额': [1200, 1800, 950, 2100],
    '成本': [800, 1200, 600, 1500]
}, index=pd.MultiIndex.from_tuples([
    ('苹果公司', '一季度'), ('苹果公司', '二季度'),
    ('谷歌公司', '一季度'), ('谷歌公司', '二季度')
], names=['股票标的', '季度']))

print("\n分层索引DataFrame：")
print(multi_df)

分层索引DataFrame：
           销售额    成本
股票标的 季度
苹果公司 一季度  1200   800
     二季度  1800  1200
谷歌公司 一季度   950   600
     二季度  2100  1500

性能优化策略

向量化运算对比

import pandas as pd
import numpy as np

data = {
    '产品': ['A101', 'B205', 'C307'],
    '库存': [120, 85, 210],
    '单价': [29.9, 45.0, 12.5]
}
df = pd.DataFrame(data, index=['仓库1', '仓库2', '仓库3'])

# 循环方法
results_loop = []
for i in range(len(df)):
    results_loop.append(df.iloc[i]['库存'] * 1.1)

# 向量化方法
results_vec = df['库存'] * 1.1

print("循环结果:", results_loop)
print("向量化结果:", results_vec.values)
print("结果是否一致:", (results_loop == results_vec.values).all())

循环结果: [np.float64(132.0), np.float64(93.50000000000001), np.float64(231.00000000000003)]
向量化结果: [132.   93.5 231. ]
结果是否一致: True

大数据集处理

import pandas as pd
import numpy as np

# 模拟一个大数据集的分块处理演示
# 首先在内存中构造一个小数据集来模拟分块逻辑
data = {
    '日期': pd.date_range('2023-01-01', periods=30, freq='D'),
    '收盘价': [100 + i * 0.5 for i in range(30)],
    '成交量': [1000000 + i * 50000 for i in range(30)]
}
df_large = pd.DataFrame(data)

# 模拟分块读取和处理
chunk_size = 10
chunks = []
for start in range(0, len(df_large), chunk_size):
    chunk = df_large.iloc[start:start + chunk_size]
    # 模拟处理：计算每日收益率
    chunk['收益率'] = chunk['收盘价'].pct_change()
    chunks.append(chunk)

result_df = pd.concat(chunks, ignore_index=True)
print("分块处理后的数据形状:", result_df.shape)
print("前5行数据:")
print(result_df.head())

分块处理后的数据形状: (30, 4)
前5行数据:
          日期    收盘价      成交量       收益率
0 2023-01-01  100.0  1000000       NaN
1 2023-01-02  100.5  1050000  0.005000
2 2023-01-03  101.0  1100000  0.004975
3 2023-01-04  101.5  1150000  0.004950
4 2023-01-05  102.0  1200000  0.004926

📝 动手练一练

第 1 题 · 概念应用

你正在构建一个包含多只股票日度收盘价的行情面板 DataFrame price_df，其列名为股票代码 [‘AAPL’， ‘GOOG’， ‘MSFT’]，行索引为日期。为了计算投资组合的日度收益率，你需要对每一列（即每一只股票）应用 pct_change() 函数。以下哪种操作是最直接且正确的实现方式？

A. price_df.pct_change(axis=‘columns’)
B. price_df.apply(lambda col: col.pct_change())
C. price_df[‘AAPL’].pct_change() + price_df[‘GOOG’].pct_change() + price_df[‘MSFT’].pct_change()
D. for ticker in price_df.columns: price_df[ticker] = price_df[ticker].diff() / price_df[ticker].shift(1)

👉 点击查看参考答案

答案：B（price_df.apply(lambda col: col.pct_change())）

解析：

A：pct_change(axis=‘columns’) 计算的是行方向（跨列）的百分比变化，即比较同一日期下不同股票的价格，这不符合计算每只股票自身时间序列收益率的需求。
B：DataFrame.apply() 默认对每一列（Series）应用函数。lambda col: col.pct_change() 对每一列独立计算其时间序列的百分比变化，这正是我们需要的。
C：此操作将三只股票的收益率直接相加，得到的是一个无意义的标量序列，而非一个包含各股收益率的 DataFrame。
D：虽然通过循环和手动差分也能计算出收益率，但这不是“最直接”的 Pandas 方式。Pandas 的向量化操作和内置方法（如 pct_change）在代码简洁性和性能上通常更优。

第 2 题 · 代码填空

你从数据源获取了某只股票一段时间内的日度行情数据，并存储在 DataFrame df 中。现在需要筛选出收盘价高于其20日简单移动平均线的交易日数据。请补全以下代码中的关键步骤。

import pandas as pd
import numpy as np

# 模拟数据
np.random.seed(42)
dates = pd.date_range('2024-01-01', periods=30, freq='D')
prices = [100 + i * 0.5 + np.random.randn() * 2 for i in range(30)]  # 带噪声的上涨趋势
df = pd.DataFrame({'close': prices}, index=dates)

# 计算20日简单移动平均线
df['sma_20'] = df['close'].______(window=20).mean()

# 筛选出收盘价上穿均线的交易日
above_sma_df = df[df['close'] > df['sma_20']]

print(f"共有 {len(above_sma_df)} 个交易日收盘价在20日均线之上。")
print("前5条符合条件的记录：")
print(above_sma_df.head())

👉 点击查看参考答案

空位应填：rolling

完整可运行代码：

import pandas as pd
import numpy as np

# 模拟数据
np.random.seed(42)
dates = pd.date_range('2024-01-01', periods=30, freq='D')
prices = [100 + i * 0.5 + np.random.randn() * 2 for i in range(30)]  # 带噪声的上涨趋势
df = pd.DataFrame({'close': prices}, index=dates)

# 计算20日简单移动平均线
df['sma_20'] = df['close'].rolling(window=20).mean()

# 筛选出收盘价上穿均线的交易日
above_sma_df = df[df['close'] > df['sma_20']]

print(f"共有 {len(above_sma_df)} 个交易日收盘价在20日均线之上。")
print("前5条符合条件的记录：")
print(above_sma_df.head())

共有 11 个交易日收盘价在20日均线之上。
前5条符合条件的记录：
                 close      sma_20
2024-01-20  106.675393  104.407403
2024-01-21  112.931298  105.004296
2024-01-22  110.048447  105.495545
2024-01-23  111.135056  105.937529
2024-01-24  108.650504  106.142751

代码解释：

df[‘close’].rolling(window=20) 创建一个滚动窗口对象，窗口大小为20个交易日。
对滚动窗口对象调用 .mean() 方法，计算每个窗口内收盘价的平均值，即得到20日简单移动平均线。
将计算结果赋值给新列 ‘sma_20’。
通过布尔索引 df[‘close’] > df[‘sma_20’] 筛选出收盘价高于均线的行。

注意：由于前19天数据不足以计算20日均线，sma_20 列的前19个值为 NaN，因此 above_sma_df 的记录数会少于30。

本章小结

📋 行动清单

创建一个包含5万行随机数据的DataFrame，比较iterrows()与itertuples()的性能差异
使用pd.cut()对连续价格数据进行离散化分箱，生成新的分类列
对分层索引DataFrame执行交叉查询，练习xs()和query()方法的使用

—— 小象教研组