create-dwy 0.12.1 → 0.13.0

package/templates/claude-global/skills//346/225/260/346/215/256/345/272/223/dwy-dolphindb/references/official/tutorials/DolphinDB_VS_PythonFile_Storage.md

@@ -0,0 +1,361 @@
+---
+source_url: https://docs.dolphindb.cn/zh/tutorials/DolphinDB_VS_PythonFile_Storage.html
+fetched_at: 2026-05-19T09:51:10Z
+category: tutorials
+title: Python + 文件存储与 DolphinDB 因子计算性能比较
+sha1: 922c9c4012f6588202ff624205189ad62809e2e0
+---
+
+# Python + 文件存储与 DolphinDB 因子计算性能比较
+
+在量化交易中，基于金融市场 L1/L2 报价和交易高频数据进行高频因子计算是一项常见的投研需求。随着金融市场数据量的不断增加，传统的关系数据库已经难以满足大规模数据的存储和查询需求。为了应对这一挑战，一部分用户选择了分布式文件系统，并使用 Pickle、Feather、Npz、Hdf5、以及 Parquet 等格式来存储数据，并结合 Python 进行量化金融计算。
+
+虽然这些存储方案可以支持海量的高频数据，但也存在一些问题，例如数据权限管理困难、不同数据关联不便、检索和查询不便，以及需要通过数据冗余来提高性能等。此外，通过 Python 来读取计算，也需要耗费一些时间在数据传输上。
+
+为解决这些问题，越来越多的券商和私募机构开始采用 DolphinDB 作为分析型的分布式时序数据库。DolphinDB 提供高效的数据存储和计算能力，使得高频数据的因子计算变得更加便捷和高效。
+
+因此，本文将分别介绍如何基于 DolphinDB + 各类文件存储实现因子计算，旨在对比 DolphinDB 一体化因子计算方案与 Python + 各类文件存储的性能差异。通过本文的对比，读者可以了解 DolphinDB 一体化因子计算的优势，并在实际应用中做出更加明智的选择。
+
+## 1. 测试基础环境
+
+### 1.1. 软硬件信息
+
+本次测试对比了通过 Python + 文件存储 和 DolphinDB 实现的因子计算。其中：
+
+- Python + 文件存储因子计算方案依赖 Numpy, Pandas, DolphinDB, Multiprocessing 等库。
+- DolphinDB 一体化因子计算方案以 DolphinDB Server 作为计算平台，本次测试使用了单节点部署方式 。
+
+测试所需硬件、软件环境信息如下：
+
+- **硬件环境**
+
+  | **硬件名称** | **配置信息** |
+  | --- | --- |
+  | CPU | Intel(R) Xeon(R) Silver 4216 CPU @ 2.10GHz |
+  | 内存 | 128G |
+  | 硬盘 | SSD 500G |
+- **软件环境**
+
+  | **软件名称** | **版本信息** |
+  | --- | --- |
+  | 操作系统 | CentOS Linux release 7.9.2009 (Core) |
+  | DolphinDB | V 2.00.9.8 |
+  | Python | V 3.7.6 |
+  | Numpy | V 1.20.2 |
+  | Pandas | V 1.3.5 |
+
+### 1.2. 测试数据
+
+Level 2 行情数据是目前国内证券市场上最为完整，颗粒度最为精细的交易信息数据。其涵盖了在沪深两市上市的股票、可交易型基金、沪深交易所指数等投资标的。
+
+本次测试选取了全市场 2021.02.01 这一个交易日的全部 Level2 历史行情快照数据，该数据包含 26632 支标的，总数据量约为 3100 万条。初始数据存于 DolphinDB 中，Pickle、Parquet 等格式的数据文件均可从 DolphinDB 中导出生成。
+
+快照表测试数据在 DolphinDB 中共55个字段，部分字段展示如下：
+
+|  | **字段名** | **数据类型** |
+| --- | --- | --- |
+| **1** | SecurityID | SYMBOL |
+| **2** | DateTime | TIMESTAMP |
+| **3** | BidPrice | DOUBLE |
+| **4** | BidOrderQty | INT |
+| **5** | …… | …… |
+
+部分数据示例如下：
+
+| **SecurityID** | **DateTime** | **BidPrice** | **BidOrderQty** |
+| --- | --- | --- | --- |
+| 000155 | 2021.12.01T09:41:00.000 | [29.3000,29.2900,29.2800,29.2700,29.2600,29.2500,29.2400,29.2300,29.2200,29.2100] | [3700,11000,1400,1700,300,600,3800,200,600,1700] |
+| 000688 | 2021.12.01T09:40:39.000 | [13.5300,13.5100,13.5000,13.4800,13.4700,13.4500,13.4400,13.4200,13.4000,13.3800] | [500,1200,102200,5500,700,47000,1000,6500,18400,1000] |
+
+## 2. 测试场景
+
+本次测试使用的数据是全市场 2021.12.01 这一个交易日的全部 Level2 历史行情快照数据，其中 Pickle，Parquet，Feather，Hdf5 四种格式的数据都按标的代码分组存储，而 Npz 格式的数据是将所有数据均匀分成十二组后进行存储。以上的这些存储方式都是为了达到计算性能的最优，而暂不考虑存储性能。在实践过程中，可以自己选择不同的存储方式，如 `HDFStore( )` 函数可将多个 dataframe 存储为一个 hdf5 文件，压缩比的表现较好，然而并发读写的效率会有所下降。
+
+### 2.1. 因子计算与代码实现
+
+本小节主要分为三个部分：高频因子（十档买卖委托均价线性回归斜率、十档净委买增额）介绍、在DolphinDB 中因子实现和 Python 中因子实现。
+
+#### 2.1.1. 高频因子
+
+- 十档买卖委托均价线性回归斜率
+
+  十档买卖委托均价即为十档买卖委托额之和除以十档买卖委托量之和：
+
+    
+  ![images/DolphinDB_VS_Python+File_Storage/DolphinDB_VS_Python+File_Storage_1.png](images/DolphinDB_VS_Python+File_Storage/DolphinDB_VS_Python+File_Storage_1.png)  
+
+  十档买卖委托均价线性回归斜率为十档买卖委托均价对时间 t 的线性回归的斜率。
+- 十档净委买增额
+
+  十档净委买增额因子指的是在有效十档范围内买方资金总体增加量，即所有买价变化量的总和：
+
+    
+  ![images/DolphinDB_VS_Python+File_Storage/DolphinDB_VS_Python+File_Storage_2.png](images/DolphinDB_VS_Python+File_Storage/DolphinDB_VS_Python+File_Storage_2.png)  
+
+  有效十档范围内表示不考虑已不在十档范围内的档位，即表示只考虑以下区间的档位：
+
+    
+  ![images/DolphinDB_VS_Python+File_Storage/DolphinDB_VS_Python+File_Storage_3.png](images/DolphinDB_VS_Python+File_Storage/DolphinDB_VS_Python+File_Storage_3.png)
+
+#### 2.1.2. DolphinDB 中因子实现
+
+- 十档买卖委托均价线性回归斜率
+
+  十档买卖委托均价线性回归斜率的计算需要的参数分别为 OfferOrderQty、BidOrderQty、OfferPrice、BidPrice 四个字段，均为数组向量数据类型，分别为买卖十档价格和十档委托数量。使用 `rowSum` 这一内建聚合函数提高了因子的计算效率。通过 `linearTimeTrend` 函数获取因子值对时间 t 的滑动线性回归斜率，该函数返回线性回归的截距和斜率。`price.ffill().linearTimeTrend(lag1-1).at(1).nullFill(0).mavg(lag2, 1).nullFill(0)`  表示获取十档买卖委托均价对时间t的线性回归的斜率。
+
+  ```dolphindb
+  @state
+  def level10_InferPriceTrend(bid, ask, bidQty, askQty, lag1=60, lag2=20){
+  	inferPrice = (rowSum(bid*bidQty)+rowSum(ask*askQty))\(rowSum(bidQty)+rowSum(askQty))
+  	price = iif(bid[0] <=0 or ask[0]<=0, NULL, inferPrice)
+  	return price.ffill().linearTimeTrend(lag1-1).at(1).nullFill(0).mavg(lag2, 1).nullFill(0)
+  }
+  ```
+- 十档净委买增额
+
+  十档净委买增额的计算需要的参数分别为 BidOrderQty、BidPrice 两个字段，均为数组向量数据类型。首先通过行对齐函数 `rowAlign` 实现当前十档价格和前一个十档价格进行行对齐，然后通过 `rowAt` 和 `nullFill` 函数分别获取对应档位的委托量和实现价格进行对齐，最后计算总的变化额。
+
+  ```dolphindb
+  @state
+  def level10_Diff(price, qty, buy, lag=20){
+          prevPrice = price.prev()
+          left, right = rowAlign(price, prevPrice, how=iif(buy, "bid", "ask"))
+          qtyDiff = (qty.rowAt(left).nullFill(0) - qty.prev().rowAt(right).nullFill(0)) 
+          amtDiff = rowSum(nullFill(price.rowAt(left), prevPrice.rowAt(right)) * qtyDiff)
+          return msum(amtDiff, lag, 1).nullFill(0)
+  }
+  ```
+
+#### 2.1.3. Python 中因子实现
+
+- 十档买卖委托均价线性回归斜率
+
+  ```dolphindb
+  def level10_InferPriceTrend(df, lag1=60, lag2=20):
+      '''
+      十档买卖委托均价线性回归斜率
+      :param df:
+      :param lag1:
+      :param lag2:
+      :return:
+      '''
+      temp = df[["SecurityID","DateTime"]]
+      temp["amount"] = 0.
+      temp["qty"] = 0.
+      for i in range(10):
+          temp[f"bidAmt{i+1}"] = df[f"BidPrice{i+1}"].fillna(0.) * df[f"BidOrderQty{i+1}"].fillna(0.)
+          temp[f"askAmt{i+1}"] = df[f"OfferPrice{i+1}"].fillna(0.) * df[f"OfferOrderQty{i+1}"].fillna(0.)
+          temp["amount"] += temp[f"bidAmt{i+1}"] + temp[f"askAmt{i+1}"]
+          temp["qty"] += df[f"BidOrderQty{i+1}"].fillna(0.) + df[f"OfferOrderQty{i+1}"].fillna(0.)
+      temp["inferprice"] = temp["amount"] / temp["qty"]
+      temp.loc[(temp.bidAmt1 <= 0) | (temp.askAmt1 <= 0), "inferprice"] = np.nan
+      temp["inferprice"] = temp["inferprice"].fillna(method='ffill').fillna(0.)
+
+      def f(x):
+          n = len(x)
+          x = np.array(x)
+          y = np.array([i for i in range(1, n+1)])
+          return (n*sum(x*y) - sum(x)*sum(y)) / (n*sum(y*y) - sum(y)*sum(y))
+
+      temp["inferprice"] = temp.groupby("SecurityID")["inferprice"].apply(lambda x: x.rolling(lag1 - 1, 1).apply(f))
+      temp["inferprice"] = temp["inferprice"].fillna(0)
+      temp["inferprice"] = temp.groupby("SecurityID")["inferprice"].apply(lambda x: x.rolling(lag2, 1).mean())
+      return temp[["SecurityID","DateTime", "inferprice"]].fillna(0)
+  ```
+- 十档净委买增额
+
+  ```dolphindb
+  def level10_Diff(df, lag=20):
+      '''
+      十档委买增额
+      :param df:
+      :param lag:
+      :return:
+      '''
+      temp = df[["SecurityID","DateTime"]]
+
+      for i in range(10):
+          temp[f"bid{i+1}"] = df[f"BidPrice{i+1}"].fillna(0)
+          temp[f"bidAmt{i+1}"] = df[f"BidOrderQty{i+1}"].fillna(0) * df[f"BidPrice{i+1}"].fillna(0)
+          temp[f"prevbid{i+1}"] = temp[f"bid{i+1}"].shift(1).fillna(0)
+          temp[f"prevbidAmt{i+1}"] = temp[f"bidAmt{i+1}"].shift(1).fillna(0)
+
+      temp["bidMin"] = temp[[f"bid{i+1}" for i in range(10)]].min(axis=1)
+      temp["bidMax"] = temp[[f"bid{i+1}" for i in range(10)]].max(axis=1)
+      temp["prevbidMin"] = temp[[f"prevbid{i+1}" for i in range(10)]].min(axis=1)
+      temp["prevbidMax"] = temp[[f"prevbid{i+1}" for i in range(10)]].max(axis=1)
+      temp["pmin"] = temp[["bidMin", "prevbidMin"]].max(axis=1)
+      temp["pmax"] = temp[["bidMax", "prevbidMax"]].max(axis=1)
+
+      temp["amtDiff"] = 0.0
+      for i in range(10):
+          temp["amtDiff"] += temp[f"bidAmt{i+1}"]*((temp[f"bid{i+1}"] >= temp["pmin"])&(temp[f"bid{i+1}"] <= temp["pmax"])).astype(int) - \
+                          temp[f"prevbidAmt{i+1}"]*((temp[f"prevbid{i+1}"] >= temp["pmin"])&(temp[f"prevbid{i+1}"] <= temp["pmax"])).astype(int)
+      temp["amtDiff"] = temp.groupby("SecurityID")["amtDiff"].apply(lambda x: x.rolling(lag, 1).sum())
+      return temp[["SecurityID","DateTime", "amtDiff"]].fillna(0)
+  ```
+
+## 3. 计算结果对比
+
+### 3.1. 计算性能对比
+
+Level 2 行情快照数据一天的数据量超过 10 G，因此金融量化工程师们非常关注 Level 2 行情快照数据的高频因子计算性能。基于前述内容，本节我们从（1）不同并行度（2）不同的文件存储形式两个角度进行 “十档买卖委托均价线性回归斜率” 和 “十档净委买增额” 因子计算的性能对比。计算数据为 26632 支标的，1 天共计3100 万行。我们调节不同的并行度，测试在使用不同 CPU 核数的情况下，每种存储方式计算因子的耗时，并与 DolphinDB 的库内一体化计算耗时比较。所有测试均在清除操作系统缓存后进行。测试结果如下列各表：
+
+- **表一 16 核心计算性能比较**：
+
+  | **存储方式\因子** | **十档买卖委托均价线性回归斜率(s)/性能提升（倍数）** | **十档净委买增额(s)/性能提升（倍数）** |
+  | --- | --- | --- |
+  | **DolphinDB** | 2.4 | 2.3 |
+  | **Python+pickle** | 254.3/**104.8** | 105.9/**45.4** |
+  | **Python+parquet** | 309.4/**127.5** | 147.9/**63.4** |
+  | **Python+feather** | 291.1/**120.0** | 130.6/**56.0** |
+  | **Python+Hdf5** | 281.4/**116.0** | 132.0/**56.6** |
+  | **Python+Npz** | 346.7/**142.9** | 175.2/**75.1** |
+- **表二 8 核心计算性能比较**：
+
+  | **存储方式\因子** | **十档买卖委托均价线性回归斜率(s)/性能提升（倍数）** | **十档净委买增额(s)/性能提升（倍数）** |
+  | --- | --- | --- |
+  | **DolphinDB** | 4.5 | 4.4 |
+  | **Python+pickle** | 489.3/**102.8** | 231.6/**60.0** |
+  | **Python+parquet** | 638.7/**143.0** | 296.3/**67.9** |
+  | **Python+feather** | 594.2/**133.1** | 261.9/**60.0** |
+  | **Python+Hdf5** | 563.4/**126.2** | 294.6/**67.5** |
+  | **Python+Npz** | 648.7/**145.3** | 334.3/**76.6** |
+- **表三 4 核心计算性能比较**：
+
+  | **存储方式\因子** | **十档买卖委托均价线性回归斜率(s)/性能提升（倍数）** | **十档净委买增额(s)/性能提升（倍数）** |
+  | --- | --- | --- |
+  | **DolphinDB** | 6.5 | 6.8 |
+  | **Python+pickle** | 1014.9/**155.6** | 363.9/**53.6** |
+  | **Python+parquet** | 1134.9/**174.0** | 560.9/**82.6** |
+  | **Python+feather** | 1040.6/**159.6** | 479.7/**70.7** |
+  | **Python+Hdf5** | 1021.2/**156.6** | 437.4/**64.4** |
+  | **Python+Npz** | 1260.3/**193.2** | 638.8/**94.1** |
+- **表四 1 核心计算性能比较**：
+
+  | **存储方式\因子** | **十档买卖委托均价线性回归斜率(s)/性能提升（倍数）** | **十档净委买增额(s)/性能提升（倍数）** |
+  | --- | --- | --- |
+  | **DolphinDB** | 21.8 | 22.0 |
+  | **Python+pickle** | 3638.2/**166.5** | 1461.8/**66.3** |
+  | **Python+parquet** | 4450.4/**203.7** | 1759.3/**79.8** |
+  | **Python+feather** | 3994.0/**182.8** | 1773.7/**80.5** |
+  | **Python+Hdf5** | 3996.9/**182.9** | 1774.5/**80.5** |
+  | **Python+Npz** | 5031.4/**230.3** | 2437.3/**110.6** |
+
+从比对结果可以看到，本次测试中，在不同 CPU 核数和不同文件存储形式维度下，对于十档买卖委托均价线性回归斜率，DolphinDB 一体化计算比 Python+ 各类存储文件最高可达近200倍提升，平均约100倍左右的提升。考虑两种计算方式的特点，原因大概如下：
+
+- DolphinDB 自有的数据存储系统的读取效率远优于 Python 读取使用通用存储方式的各类文件存储。
+- DolphinDB 具有 `rowSum`，`LinearTimeTrend` 等内置函数，在计算因子时避免了繁冗的 for 循环计算方式，从而节省了大量的计算耗时。
+
+尽管 Pickle，Parquet 等格式的数据文件读取可以从技术层面进行针对性冗余存储或者其他针对性优化，但同时会带来额外硬件资源成本、数据使用和管理成本等。相比之下，DolphinDB 自有数据存储系统在使用上更为高效、方便和简单。 因此 DolphinDB 库内一体化因子计算在完整的因子数据读取、计算全过程上的计算速度是远优于 Python + 各类文件存储的因子计算方式。
+
+从计算性能的对比中，不难发现以下现象：
+
+- 代码实现方面，DolphinDB 的库内 SQL计算更易于实现因子计算调用及并行调用。
+- 并行计算方面，DolphinDB 可以自动使用当前可用的 CPU 资源，而Python 脚本需要通过并行调度代码实现，但更易于控制并发度。
+- 计算速度方面，DolphinDB 的库内计算比 Python + 各类文件存储 的计算方式快 50 至 200 倍之间。
+
+### 3.2. 计算准确性对比
+
+上一节中，我们比对了不同计算方式的计算性能。DolphinDB 的库内因子计算在计算速度上要远优于 Python + 各类文件存储的因子计算方式。但是计算快的前提是计算结果要正确一致。本文将 Python +各类文件存储 和 DolphinDB 因子计算结果分别导入为 pandas 中 Dataframe 进行对比。以Python + Pickle 为例，计算结果比对展示如下图，显示的全部结果完全一致。
+
+```dolphindb
+from pandas.testing import assert_frame_equal
+df_ddb = df_dolphindb.sort_values(by=["SecurityID","DateTime","amtDiff"]).reset_index(drop=True)
+df_py = res_combined.sort_values(by=["SecurityID","DateTime","amtDiff"]).reset_index(drop=True)
+df_ddb = df_ddb.round(4)
+df_py = df_py.round(4)
+assert_frame_equal(df_ddb, df_py, check_exact=False, rtol=1, atol=1e-06)
+print(assert_frame_equal)
+"""
+对于assert_frame_equal函数，对比结果一致时不输出任何结果，不一致时返回报错信息
+"""
+```
+
+## 4. 常见问题解答
+
+### 4.1. 如何复现本文的代码？
+
+根据如下步骤部署项目：
+
+- **第一步 DolphinDB 部署**
+
+  首先我们需要下载 DolphinDB 并完成单节点 server 部署搭建，这一步骤在 Linux 系统和 Windows 系统中均可以完成，详情可以参考下面的链接：
+
+  [单节点部署与升级](standalone_server.html)
+- **第二步 DolphinDB 客户端安装**
+
+  安装并启动 GUI 或者 VSCode，连接到 server 后即可复现 DolphinDB 脚本，详情参考下面的链接：
+
+  [使用DolphinDB数据库及客户端](../getstarted/use_clients_server.html)
+
+  [DolphinDB VS Code 插件](../db_distr_comp/vscode.html)
+- **第三步 上传压缩包并解压代码**
+
+  将 [Python\_plus\_file\_VS\_dolphindb\_on\_factor\_calc.zip](script/DolphinDB_VS_Python+File_Storage/python_plus_file_VS_dolphindb_on_factor_calc.zip) 上传至服务器。注意：此处服务器路径为：/home/ddb/workfile/demo/，用户需根据实际情况修改路径。
+
+  在 Linux 中运行如下命令，将压缩包移动到对应文件夹并解压缩：
+
+  ```dolphindb
+  cd /home/ddb/workfile/demo/
+
+  unzip python_plus_file_VS_dolphindb_on_factor_calc.zip -d ./
+  ```
+- **第四步 依次运行 DolphinDB 代码和 Python 代码**
+
+  - 运行 00\_dolphindb\_script/00\_genSimulatedData.dos，生成模拟数据
+
+    ![images/DolphinDB_VS_Python+File_Storage/DolphinDB_VS_Python+File_Storage_4.png](images/DolphinDB_VS_Python+File_Storage/DolphinDB_VS_Python+File_Storage_4.png)  
+
+    图 1. snapshot模拟数据生成
+  - 运行 00\_dolphindb\_script/01\_saveAsCsv.dos，将模拟数据保存为csv文件
+
+    ![images/DolphinDB_VS_Python+File_Storage/DolphinDB_VS_Python+File_Storage_5.png](images/DolphinDB_VS_Python+File_Storage/DolphinDB_VS_Python+File_Storage_5.png)  
+
+    图 2. snapshot数据导出
+  - 运行 00\_dolphindb\_script/02\_level10Diff.dos，在 DolphinDB 中计算因子1
+
+    ![images/DolphinDB_VS_Python+File_Storage/DolphinDB_VS_Python+File_Storage_6.png](images/DolphinDB_VS_Python+File_Storage/DolphinDB_VS_Python+File_Storage_6.png)  
+
+    图 3. 计算因子1
+  - 运行 00\_dolphindb\_script/03\_level10InferPriceTrend.dos，在 dolphindb 中计算因子2
+
+    ![images/DolphinDB_VS_Python+File_Storage/DolphinDB_VS_Python+File_Storage_7.png](images/DolphinDB_VS_Python+File_Storage/DolphinDB_VS_Python+File_Storage_7.png)  
+
+    图 4. 计算因子2
+  - 运行 00\_python\_script/save\_given\_format\_file/04\_save\_pickle.py，将 csv 文件保存为 pickle 文件
+
+    ![images/DolphinDB_VS_Python+File_Storage/DolphinDB_VS_Python+File_Storage_8.png](images/DolphinDB_VS_Python+File_Storage/DolphinDB_VS_Python+File_Storage_8.png)  
+
+    图 5. pickle文件
+  - 运行 00\_python\_script/calc\_factor/05\_level10Diff\_pickle.py，在 python 中计算因子1
+
+    ![images/DolphinDB_VS_Python+File_Storage/DolphinDB_VS_Python+File_Storage_9.png](images/DolphinDB_VS_Python+File_Storage/DolphinDB_VS_Python+File_Storage_9.png)  
+
+    图 6. py计算因子1
+  - 运行 00\_python\_script/calc\_factor/06\_level10InferPriceTrend\_pickle.py，在 python 中计算因子2
+
+    ![images/DolphinDB_VS_Python+File_Storage/DolphinDB_VS_Python+File_Storage_10.png](images/DolphinDB_VS_Python+File_Storage/DolphinDB_VS_Python+File_Storage_10.png)  
+
+    图 7. py计算因子2
+
+此处以 pickle 为例，若希望测试其他文件形式，请先运行对应脚本保存对应格式的文件，再运行因子计算的脚本。
+
+## 5. 总结
+
+本篇文章的比较结果显示，在使用相同核数 CPU 前提下，DolphinDB 库内一体化计算性能约为使用Python计算因子的方案的 50 至 200 倍左右，计算结果和 Python 方式完全一样。
+
+- 在数据的管理和读取方面：
+  - DolphinDB 是一个专门为大数据分析和处理设计的分布式数据系统，它使用了一种高效的列式存储格式来优化 I/O 操作。因此，DolphinDB 在大数据集的读取和写入方面具有非常高的性能，而 Python Pandas 库虽然也能处理大型数据集，但在处理极大规模数据时可能面临性能挑战。
+  - DolphinDB 内存管理非常高效，可以处理超过内存大小的数据集，而且在内存使用上非常节省。这使得在处理大型数据集时，DolphinDB 可以提供更稳定和更高的性能。而在 Python 中，处理大型数据集时可能需要更多的内存管理和优化工作。
+  - DolphinDB 作为一个底层数据库产品，集成丰富API接口、拥有完善版本兼容特性以及权限管控功能，而文件存储在跨平台使用困难、前后版本兼容性差以及缺失权限管控功能，DolphinDB 在运维方面大大优于文件存储方式。
+- 在代码实现方面，DolphinDB 的库内 SQL 计算更易于实现因子计算调用及并行调用。与此同时，DolphinDB 因为使用了成熟的内置函数极大地提升了因子计算的性能，整体代码量可以缩减到一半及以上。
+- 在并行计算方面，DolphinDB 可以自动使用当前可用的 CPU 资源，而 Python 脚本需要通过并行调度代码实现，但更易于控制并发度。
+
+综合而言，在生产环境中，使用 DolphinDB 进行因子计算和存储远比使用 Python + 各类文件存储形式的计算方式更加高效。
+
+## 6. 附录
+
+本教程中的对比测试使用了以下测试脚本：
+
+[Python+ 文件存储与 DolphinDB 因子计算性能比较.zip](script/DolphinDB_VS_Python+File_Storage/python_plus_file_VS_dolphindb_on_factor_calc.zip)

package/templates/claude-global/skills//346/225/260/346/215/256/345/272/223/dwy-dolphindb/references/official/tutorials/FxSwapValuation.md

@@ -0,0 +1,190 @@
+---
+source_url: https://docs.dolphindb.cn/zh/tutorials/FxSwapValuation.html
+fetched_at: 2026-05-19T09:51:03Z
+category: tutorials
+title: 外汇掉期估值计算
+sha1: bd51c9cf8f3e91341288bb36e6c7e6f258e7fd02
+---
+
+# 外汇掉期估值计算
+
+在金融领域，合约的估值计算是个常见需求。几百万个合约，由于到期时间和期限长短不同，计算时往往对应不同的利率。合约匹配利率，最常见的做法是通过循环语句对每一个合约做计算。而 DolphinDB 中，可以通过强大的表连接函数，将需要的信息关联后，再通过 SQL向量编程 进行计算。该优化方法相比循环的方法，性能提升超 400 倍。
+
+本文将从以下几个部分来阐述对于此类计算的优化过程。本文中的脚本在 DolphinDB 1.30.18/2.00.6 及以上版本的环境中测试通过。
+
+## 1. 外汇掉期估值的计算逻辑及数据准备
+
+### 1.1. 外汇掉期估值的计算逻辑
+
+本次的计算整体逻辑如下图：
+
+![](images/FxSwapValuation/fx_swap_b.png)  
+
+本次外汇掉期估值计算的逻辑，参考[中国外汇交易中心](https://www.chinamoney.com.cn/chinese/rdgz/20190402/1275734.html)2019年4月2日在官网推出的外汇掉期估值服务中的估值算法，即通过掉期曲线计算当日的远端全价汇率折算，并与约定交易的全价汇率生成的现金流轧差得到净值，再用当日的 Shibor3M(Shanghai Interbank Offered Rate) 利率互换收盘曲线进行贴现，最后得到合约净额的贴现值即为合约估值。
+
+### 1.2. 数据准备
+
+外汇掉期估值的计算需要用到掉期曲线利率以及利率互换曲线两张表。以上两张表的数据直接采集于2021年12月14日中国外汇掉期[USD.CNY外汇掉期曲线](https://www.chinamoney.com.cn/chinese/bkcurvfsw/)及[Shibor3M利率互换行情曲线](https://www.chinamoney.com.cn/chinese/bkcurvfx/)。
+
+数据结构分别为：
+
+- USD.CNY外汇掉期曲线:
+
+| name | typeString | comment |
+| --- | --- | --- |
+| Date | DATE | 日期 |
+| timeminute | MINUTE | 时间 |
+| currencyPair | STRING | 货币对 |
+| termToMaturity | STRING | 期限品种 |
+| swapRate\_Pips | DOUBLE | 掉期点 |
+| exchangeRate | DOUBLE | 全价汇率 |
+| maturityDate | DATE | 远端起息日 |
+
+- Shibor3M利率互换行情曲线：
+
+| name | typeString | comment |
+| --- | --- | --- |
+| Maturity | STRING | 标准期限 |
+| buying\_rate | DOUBLE | 报买（%） |
+| average\_rate | DOUBLE | 均值（%） |
+| selling\_rate | DOUBLE | 报卖（%） |
+
+本教程用到的合约数据为自行模拟的100万个不同到期期限的合约数据，数据结构为：
+
+| name | typeString | comment |
+| --- | --- | --- |
+| contract\_no | INT | 合约编号 |
+| contract\_date | DATE | 合约日 |
+| trade\_date | DATE | 近端起息日 |
+| maturity\_date | DATE | 远端起息日 |
+| buy\_sell | STRING | 买卖方向 |
+| period | STRING | 期限 |
+| near\_leg\_currency | STRING | 近端交易货币 |
+| near\_leg\_amount | INT | 交易量 |
+| near\_leg\_spot\_rate | DOUBLE | 近端掉期全价汇率 |
+| far\_leg\_currency | STRING | 远端清算货币 |
+| far\_leg\_spot\_rate | DOUBLE | 远端掉期全价汇率 |
+
+上述利率数据以及模拟合约数据的脚本请参阅[数据准备脚本](script/FxSwapValuation/fxValuationPreparation.dos)。
+
+## 2. 开发环境配置
+
+### 2.1. DolphinDB server服务器环境
+
+- CPU 类型：Intel(R) Xeon(R) Silver 4216 CPU @ 2.10GHz
+- 逻辑 CPU 总数：8
+- 内存：64GB
+- OS：64位 CentOS Linux 7 (Core)
+
+### 2.2. DolphinDB server部署
+
+- server版本：1.30.18 或 2.00.6
+- server部署模式：单节点
+- 配置文件：dolphindb.cfg
+
+```dolphindb
+localSite=localhost:8848:local8848
+mode=single
+maxMemSize=64
+maxConnections=512
+workerNum=8
+newValuePartitionPolicy=add
+webWorkerNum=2
+dataSync=1
+```
+
+单节点部署教程：[单节点部署](standalone_server.html)
+
+## 3. 外汇掉期估值的普通实现
+
+由于每一个合约有不同的起息日和合约期限，因此会对应不同的互换利率以及全价汇率。普通的实现方法是自定义一个包含估值计算逻辑的函数，通过循环语句，将每个合约与对应利率进行计算。
+
+包含三表的估值函数定义如下：
+
+```dolphindb
+def valuationDtmRate(today, swap_rate, IR_swap, maturity_date,far_leg_spot_rate, near_leg_amount){
+	target_swap_rate_next = select * from swap_rate where Date=today, currencyPair = `USD.CNY, maturityDate >=maturity_date limit 1
+	target_swap_rate_prev = select * from swap_rate where Date=today, currencyPair = `USD.CNY, maturityDate <=maturity_date order by maturityDate desc limit 1
+	tartget_IR_swap = select * from IR_swap where Maturity in (target_swap_rate_prev.termToMaturity[0],target_swap_rate_next.termToMaturity[0])
+	fex = target_swap_rate_prev.exchangeRate +(maturity_date - target_swap_rate_prev.maturityDate)\ (target_swap_rate_next.maturityDate-target_swap_rate_prev.maturityDate) * (target_swap_rate_next.exchangeRate - target_swap_rate_prev.exchangeRate)
+	sir = tartget_IR_swap.selling_rate[0] + (maturity_date - target_swap_rate_prev.maturityDate)\ (target_swap_rate_next.maturityDate-target_swap_rate_prev.maturityDate) * ( tartget_IR_swap.selling_rate[1] -  tartget_IR_swap.selling_rate[0])
+	dicount_factor = exp(-sir \ 100 * (maturity_date-today)\365)
+	valuation = (fex - far_leg_spot_rate) * dicount_factor * near_leg_amount
+	return valuation
+}
+```
+
+由于涉及到多表间的信息提取，函数看起来会相对复杂。做完这一步之后，就可以对所有的合约进行循环计算。100万个合约在测试环境下做计算耗时约3分20秒。
+
+for循环写法的代码示例如下：
+
+```dolphindb
+today = 2021.12.14
+k = array(DOUBLE, 0)
+for (x in fx_contract){
+	k.append!(valuationDtmRate(today, swap_rate, IR_swap,x.maturity_date, x.far_leg_spot_rate, x.near_leg_amount))
+}
+result = fx_contract join table(k as valuation)
+```
+
+或用loop函数的写法示例如下：
+
+```dolphindb
+k = loop(valuationDtmRate{today, swap_rate, IR_swap},fx_contract.maturity_date, fx_contract.far_leg_spot_rate, fx_contract.near_leg_amount).flatten()
+result = fx_contract join table(k as valuation)
+```
+
+利用多线程并行计算，可以在同样的计算逻辑上做进一步优化，将原本的单线程循环改成多线程并行计算，最后将结果进行拼接。DolphinDB 提供了 `ploop`/`peach` 函数，可以很方便的把这类循环语句内存计算转换成多线程任务。
+
+此例用了8个并行度做计算，最后耗时大约20秒：
+
+```dolphindb
+k = ploop(valuationDtmRate{today, swap_rate, IR_swap},fx_contract.maturity_date, fx_contract.far_leg_spot_rate, fx_contract.near_leg_amount).flatten()
+result = fx_contract join table(k as valuation)
+```
+
+**注意**：在批流一体的因子实现中，不建议使用 `ploop`/`peach` 并行加速。具体并行策略可以参考因子最佳实践中的[并行计算章节](best_practice_for_factor_calculation.html)。
+
+## 4. 外汇掉期估值的优化实现
+
+DolphinDB 中提供了许多表关联函数，故原本的两张小表 swap\_rate 和 IR\_rate 以及合约大表，可以先通过表关联函数将有效信息提取出来，继而直接通过 SQL 做计算即可。如此一来，避免了循环语句重复消耗资源，也减少了代码的开发量。
+
+做外汇掉期估值计算时，可以用 `equal join` , `asof join` 及 `window join` 将需要的远端利率等信息通过三表关联得到，代码如下：
+
+```dolphindb
+today = 2021.12.14
+tmp = select * from ej(swap_rate,IR_swap,`termToMaturity, `Maturity) where Date = today
+res_aj=aj(fx_contract,tmp, `maturity_date, `maturityDate)
+res_wj=wj(res_aj,tmp, 0d:366d,<[first(termToMaturity) as next_termToMaturity, first(exchangeRate) as next_exchangeRate, first(maturityDate) as next_maturityDate,first(buying_rate) as next_buying_rate, first(average_rate) as next_average_rate, first(selling_rate) as next_selling_rate]>, `maturity_date, `maturityDate)
+```
+
+由于关联后的信息可以在一张表( res\_wj )中得到，故计算逻辑也可以得到简化，可以直观地翻译原公式逻辑进行向量化计算：
+
+```dolphindb
+def valuationSQL(exchangeRate,maturity_date, maturityDate, next_maturityDate, next_exchangeRate, far_leg_spot_rate, selling_rate, next_selling_rate,today, near_leg_amount){
+	return (exchangeRate + (maturity_date - maturityDate)\ (next_maturityDate-maturityDate) * (next_exchangeRate - exchangeRate) - far_leg_spot_rate) * exp(-(selling_rate +  (maturity_date - maturityDate)\ (next_maturityDate-maturityDate) * (next_selling_rate - selling_rate))\100 * (maturity_date-today)\365) * near_leg_amount
+}
+```
+
+用优化后的表关联逻辑做外汇掉期估值计算，整体耗时只需0.5秒左右，性能相比最初提升了超400倍。
+
+```dolphindb
+timer{
+	today = 2021.12.14
+	tmp = select * from ej(swap_rate,IR_swap,`termToMaturity, `Maturity) where Date = today
+	res_aj=aj(fx_contract,tmp, `maturity_date, `maturityDate)
+	res_wj=wj(res_aj,tmp, 0d:366d,<[first(termToMaturity) as next_termToMaturity, first(exchangeRate) as next_exchangeRate, first(maturityDate) as next_maturityDate,first(buying_rate) as next_buying_rate, first(average_rate) as next_average_rate, first(selling_rate) as next_selling_rate]>, `maturity_date, `maturityDate)
+	
+	result = select contract_no,contract_date,trade_date,maturity_date,buy_sell, period, near_leg_currency, near_leg_amount, near_leg_spot_rate, far_leg_currency, far_leg_spot_rate, valuationSQL(exchangeRate,maturity_date, maturityDate, next_maturityDate, next_exchangeRate, far_leg_spot_rate, selling_rate, next_selling_rate,today, near_leg_amount) as valuation from res_wj
+}
+```
+
+## 5. 总结
+
+对于需要用到多表数据计算的任务，用循环语句的方式性能较差。建议先用 DolphinDB 优化的 `asof join` 等**表关联函数将需要的信息提取**。`asof join` 等表关联函数亦支持分布式关联，对于存储于数据库中的分布式表也可以多线程并行关联，性能卓越。计算部分**建议使用 SQL 向量化编程的方式**做计算，不仅可以减少代码开发量（基本可以直观地翻译计算公式），也避免了循环语句重复消耗 CPU 资源。
+
+## 6. 代码附录
+
+- [数据准备脚本](script/FxSwapValuation/fxValuationPreparation.dos)
+- [外汇掉期估值的优化实现脚本](script/FxSwapValuation/fxValuationOptimal.dos)
+- [完整优化过程](script/FxSwapValuation/fxValuation.dos)