批量查询返回多个 DataFrame，如何统一合并和处理？

关注

原创 2026-11-04 06:20:41 627 阅读 AI 写同款· GEO 优化 ›

Pandas中DataFrame数据的常用操作（创建、转置、查询、排序、缺失、运算、合并、追加、修改、分组、压缩等） 1. 导包 In [1]: import numpy as np In [2]: import pandas as pd ... 阅读详情

一句话回答

批量查询返回多个 DataFrame 时，建议先将数据统一为“标的代码 + 交易时间 + 行情字段”的标准结构，再进行合并、排序和指标计算。这样可以避免不同标的数据互相混淆，也能减少重复编写处理逻辑。在量化开发中，可以通过 QuantDash Python SDK 批量获取历史 K 线，再使用 Pandas 完成数据结构标准化和后续计算。

为什么会有这个问题 / 传统做法有什么问题？

在量化选股或多标的回测中，经常需要同时获取几十只甚至几百只股票的历史行情。

例如，需要查询以下两只股票最近 20 根日 K 线：

600519.SH
000001.SZ

如果分别调用接口，每只股票会得到一个独立的 DataFrame。

这种结构本身没有问题，但后续处理会比较麻烦。

假设需要计算两只股票的 5 日收益率，最直接的方法是分别处理：

df_a["return_5d"] = df_a["close"].pct_change(5)
df_b["return_5d"] = df_b["close"].pct_change(5)

当股票数量增加到 100 只时，就需要重复执行相同的逻辑。

实际开发通常会使用循环处理，但又会遇到几个问题：

第一，不同 DataFrame 可能缺少统一的标的标识。

如果直接使用 pd.concat() 纵向拼接，合并后的数据可能无法区分来自哪只股票。

第二，交易时间可能没有对齐。

不同股票可能存在停牌、上市时间不同等情况，不能简单假设每个 DataFrame 的行数和日期都一致。

第三，字段类型可能不一致。

例如，某些价格列可能需要先转换为数值类型，才能参与收益率计算。

第四，合并后直接计算指标可能产生跨标的污染。

假设将两只股票的行情合并后直接调用 pct_change()，第二只股票的第一条数据可能会错误地引用第一只股票的最后一条价格。

因此，解决问题的关键不只是将多个 DataFrame 拼在一起，而是建立统一的数据处理结构。

一种比较实用的方案是：

批量获取数据 → 统一标的标识 → 验证字段 → 合并 DataFrame → 按标的分组计算。

分步骤解决：使用 QuantDash 进行实践

第 1 步：安装 SDK 并初始化客户端

首先安装 QuantDash Python SDK：

# 在终端执行：pip install quantdash

初始化客户端时，建议通过环境变量读取 API Key，避免将密钥直接写入代码。

import os
import pandas as pd
from quantdash import QuantDash

api_key = os.getenv("QUANTDASH_API_KEY")

if not api_key:
    raise RuntimeError(
        "请先设置 QUANTDASH_API_KEY 环境变量"
    )

qd = QuantDash(api_key=api_key)

后续使用这个客户端获取行情数据。

第 2 步：批量获取历史 K 线

本例使用 qd.klines.batch() 获取多只股票的日 K 线。

symbols = [
    "600519.SH",
    "000001.SZ",
]

try:
    batch_result = qd.klines.batch(
        symbols,
        period="1d",
        count=20,
        to_dataframe=True,
        show_progress=True,
    )
except Exception as exc:
    raise RuntimeError(
        "批量获取历史 K 线失败"
    ) from exc

if batch_result is None:
    raise ValueError("批量查询返回空结果")

print("返回对象类型：", type(batch_result))

这里使用了四个关键参数：

symbols：需要查询的标的代码列表。
period=“1d”：查询日 K 线。
count=20：请求最近 20 根 K 线。
to_dataframe=True：请求使用 DataFrame 相关的返回形式。
show_progress=True：启用批量查询进度展示。

需要特别说明：to_dataframe=True 不应被理解为批量接口一定返回单个 DataFrame，也不能直接认定返回的是字典或列表。

批量返回对象的具体组织方式需要根据当前 SDK 版本和实际返回结果确认。

如果返回的是多个 DataFrame，后续就需要建立统一的处理方式。

第 3 步：将多个 DataFrame 统一为标准结构

为了让后续代码不依赖具体接口结构，可以先编写一个标准化函数。

本例约定，标准化后的 DataFrame 包含：

symbol：标的代码。
trade_time：交易时间。
close：收盘价格。

其中，close 和交易时间字段的实际名称需要先检查。下面的 close 仅作为配置示例，不代表对 SDK 返回字段的保证。

先实现单个 DataFrame 的标准化。

def normalize_kline(
    symbol,
    frame,
    time_column,
    close_column,
):
    if not isinstance(frame, pd.DataFrame):
        raise TypeError(
            f"{symbol} 的数据不是 DataFrame"
        )

    if frame.empty:
        raise ValueError(
            f"{symbol} 的行情数据为空"
        )

    required = [time_column, close_column]

    missing = [
        col for col in required
        if col not in frame.columns
    ]

    if missing:
        raise ValueError(
            f"{symbol} 缺少字段：{missing}"
        )

    result = frame[
        [time_column, close_column]
    ].copy()

    result = result.rename(
        columns={
            time_column: "trade_time",
            close_column: "close",
        }
    )

    result["symbol"] = symbol

    result["trade_time"] = pd.to_datetime(
        result["trade_time"],
        errors="coerce",
    )

    result["close"] = pd.to_numeric(
        result["close"],
        errors="coerce",
    )

    if result["trade_time"].isna().any():
        raise ValueError(
            f"{symbol} 存在无效交易时间"
        )

    if (
        result["close"].isna().any()
        or not result["close"].gt(0).all()
    ):
        raise ValueError(
            f"{symbol} 存在无效收盘价格"
        )

    result = result.sort_values(
        "trade_time"
    )

    if result["trade_time"].duplicated().any():
        raise ValueError(
            f"{symbol} 存在重复交易时间"
        )

    return result[
        ["symbol", "trade_time", "close"]
    ].reset_index(drop=True)

这段函数并不依赖 QuantDash 的具体返回容器，只负责处理已经确认归属某个标的的 DataFrame。

如果实际批量返回结果经过检查后，确认是以标的代码为键、DataFrame 为值的字典，可以这样调用：

if not isinstance(batch_result, dict):
    raise TypeError(
        "当前示例要求返回结果为标的字典；"
        "请检查实际结构后调整适配逻辑"
    )

time_column = "time"
close_column = "close"

# 上述字段名是配置示例，必须根据实际列名修改。
normalized_frames = []

for symbol in symbols:
    frame = batch_result.get(symbol)

    if frame is None:
        raise ValueError(
            f"{symbol} 没有对应的查询结果"
        )

    normalized = normalize_kline(
        symbol=symbol,
        frame=frame,
        time_column=time_column,
        close_column=close_column,
    )

    normalized_frames.append(normalized)

merged_df = pd.concat(
    normalized_frames,
    ignore_index=True,
)

merged_df = merged_df.sort_values(
    ["symbol", "trade_time"]
).reset_index(drop=True)

print(merged_df.head())

这里的 time_column=“time” 和 close_column=“close” 是需要根据实际结果确认的配置项。如果返回的是列表或其他结构，应先按实际接口约定建立标的与 DataFrame 的对应关系，再调用标准化函数。

不要在没有确认顺序契约的情况下，直接使用 zip(symbols, batch_result) 假定列表顺序与请求顺序一致。

完成上述步骤后，数据就统一成了长表结构。

长表的优势是每一行都有明确的标的代码和交易时间，非常适合后续分组处理。

第 4 步：统一计算多只股票的收益率

当所有数据都具备统一结构后，就不需要分别为每只股票编写计算代码。

例如，计算每只股票的 5 个交易观测间隔的收盘价收益率：

merged_df["return_5d"] = (
    merged_df
    .groupby("symbol")["close"]
    .pct_change(5)
)

result = merged_df[
    [
        "symbol",
        "trade_time",
        "close",
        "return_5d",
    ]
]

print(result.tail(10))