Zipline 3.0 中文文档（二）（3）

Zipline 3.0 中文文档（二）（2）https://developer.aliyun.com/article/1523923

该列是否生成以货币计价的数据。

类型：

布尔

注释

此类实例在访问DataSet的属性时动态创建。例如，close是此类的一个实例。管道 API 用户永远不应该直接构造此类实例。

property currency_aware

该列是否生成以货币计价的数据。

property currency_conversion

应用于该项的货币转换规范。

property dataset

该列所属的数据集。

fx(currency)

构造此列的货币转换版本。

参数：

货币 (字符串 或 zipline.currency.Currency) – 要将此列的数据转换成的货币。

返回：

列 – 生成与self相同数据的列，但货币转换为currency。

返回类型：

BoundColumn

graph_repr()

用于渲染管道图的简短表示。

property metadata

此列的元数据的副本。

property name

此列的名称。

property qualname

此列的全限定名称。

recursive_repr()

用于在递归上下文中渲染的简短表示。

specialize(domain)

将self特化为具体域。

unspecialize()

将列未特化为通用形式。

这等效于column.specialize(GENERIC)。

class zipline.pipeline.data.DataSetFamily

管道数据集家族的基类。

数据集家族用于表示行唯一标识符需要超过资产和日期坐标的场景。DataSetFamily也可以被视为DataSet对象的集合，每个对象都有相同的列、域和维度。

DataSetFamily对象通过一个或多个Column对象以及一个额外的字段extra_dims来定义。

extra_dims字段定义了除资产和日期之外必须固定的坐标，以生成逻辑时间序列。列对象决定了家族切片将共享的列。

extra_dims表示为有序字典，其中键是维度名称，值是沿该维度的唯一值集合。

要在管道表达式中使用DataSetFamily，必须使用slice()方法为每个额外维度选择特定值。例如，给定一个DataSetFamily：

class SomeDataSet(DataSetFamily):
    extra_dims = [
        ('dimension_0', {'a', 'b', 'c'}),
        ('dimension_1', {'d', 'e', 'f'}),
    ]
    column_0 = Column(float)
    column_1 = Column(bool) 

此数据集可能代表具有以下列的表：

sid :: int64
asof_date :: datetime64[ns]
timestamp :: datetime64[ns]
dimension_0 :: str
dimension_1 :: str
column_0 :: float64
column_1 :: bool 

在这里，我们可以看到隐含的sid、asof_date和timestamp列，以及额外的维度列。

这个DataSetFamily可以转换为常规的DataSet：

DataSetSlice = SomeDataSet.slice(dimension_0='a', dimension_1='e') 

这个切片数据集代表了在高维数据集中满足(dimension_0 == 'a') & (dimension_1 == 'e')条件的行。

classmethod slice(*args, **kwargs)

对 DataSetFamily 进行切片以生成按资产和日期索引的数据集。

参数：

• *args –
  
• **kwargs – 沿每个额外维度固定的坐标。
  

返回：

数据集 – 一个按资产和日期索引的常规管道数据集。

返回类型：

DataSet

注意

用于生成结果的额外维度坐标可在extra_coords属性下获得。

class zipline.pipeline.data.EquityPricing

DataSet包含每日交易价格和成交量。

close = EquityPricing.close::float64

high = EquityPricing.high::float64

low = EquityPricing.low::float64

open = EquityPricing.open::float64

volume = EquityPricing.volume::float64

内置因子

因子旨在以一种提取算法可交易信号的方式转换输入数据。

class zipline.pipeline.factors.AverageDollarVolume(inputs=sentinel('NotSpecified'), outputs=sentinel('NotSpecified'), window_length=sentinel('NotSpecified'), mask=sentinel('NotSpecified'), dtype=sentinel('NotSpecified'), missing_value=sentinel('NotSpecified'), ndim=sentinel('NotSpecified'), **kwargs)

平均每日美元交易量

默认输入：[EquityPricing.close, EquityPricing.volume]

默认窗口长度：无

compute(today, assets, out, close, volume)

通过编写一个将值写入 out 的函数来覆盖此方法。

class zipline.pipeline.factors.BollingerBands(inputs=sentinel('NotSpecified'), outputs=sentinel('NotSpecified'), window_length=sentinel('NotSpecified'), mask=sentinel('NotSpecified'), dtype=sentinel('NotSpecified'), missing_value=sentinel('NotSpecified'), ndim=sentinel('NotSpecified'), **kwargs)

布林带技术指标。en.wikipedia.org/wiki/Bollinger_Bands

默认输入：zipline.pipeline.data.EquityPricing.close

参数：

• inputs (长度为 1 的可迭代对象**[BoundColumn*]*) – 用于计算布林带表达式。
  
• window_length (int > 0) – 用于计算布林带的回溯窗口长度。
  
• k (float) – 用于创建上下带的添加或减去的标准差数量。
  

compute(today, assets, out, close, k)

通过编写一个将值写入 out 的函数来覆盖此方法。

class zipline.pipeline.factors.BusinessDaysSincePreviousEvent(inputs=sentinel('NotSpecified'), outputs=sentinel('NotSpecified'), window_length=sentinel('NotSpecified'), mask=sentinel('NotSpecified'), domain=sentinel('NotSpecified'), *args, **kwargs)

业务日自上一个事件的抽象类。返回每个资产自最近事件日期的业务日（非交易日！）数量。

这与 BusinessDaysUntilNextEarnings 保持对称，不使用交易日。

今天宣布或即将宣布事件的资产将产生 0.0 的值。在前一个工作日宣布事件的资产将产生 1.0 的值。

事件日期为 NaT 的资产将产生 NaN 值。

示例

BusinessDaysSincePreviousEvent可用于创建事件驱动的因子。例如，你可能只想交易最近 5 个工作日内有 asof_date 数据点的资产。为此，你可以创建一个BusinessDaysSincePreviousEvent因子，将数据集中相关的 asof_date 列作为输入，如下所示：

# Factor computing number of days since most recent asof_date
# per asset.
days_since_event = BusinessDaysSincePreviousEvent(
    inputs=[MyDataset.asof_date]
)
# Filter returning True for each asset whose most recent asof_date
# was in the last 5 business days.
recency_filter = (days_since_event <= 5) 

dtype = dtype('float64')

class zipline.pipeline.factors.BusinessDaysUntilNextEvent(inputs=sentinel('NotSpecified'), outputs=sentinel('NotSpecified'), window_length=sentinel('NotSpecified'), mask=sentinel('NotSpecified'), domain=sentinel('NotSpecified'), *args, **kwargs)

业务日直到下一个事件的抽象类。返回每个资产到下一个已知事件日期的业务日（非交易日！）数量。

这并不使用交易日，因为交易日历包含的信息可能在当时计算时对算法不可用。

例如，2001 年 9 月 11 日的 NYSE 收盘价，在 9 月 10 日时算法是无法知晓的。

今天宣布或即将宣布事件的资产将产生 0.0 的值。将在下一个工作日宣布事件的资产将产生 1.0 的值。

事件日期为 NaT 的资产将产生 NaN 值。

dtype = dtype('float64')

class zipline.pipeline.factors.DailyReturns(inputs=sentinel('NotSpecified'), outputs=sentinel('NotSpecified'), window_length=sentinel('NotSpecified'), mask=sentinel('NotSpecified'), dtype=sentinel('NotSpecified'), missing_value=sentinel('NotSpecified'), ndim=sentinel('NotSpecified'), **kwargs)

计算收盘价的日百分比变化。

默认输入：[EquityPricing.close]

class zipline.pipeline.factors.ExponentialWeightedMovingAverage(inputs=sentinel('NotSpecified'), outputs=sentinel('NotSpecified'), window_length=sentinel('NotSpecified'), mask=sentinel('NotSpecified'), dtype=sentinel('NotSpecified'), missing_value=sentinel('NotSpecified'), ndim=sentinel('NotSpecified'), **kwargs)

指数加权移动平均

默认输入：无

默认窗口长度：无

参数：

• 输入（长度为 1 的列表/元组 的 绑定列） – 用于计算平均值的表达式。
  
• 窗口长度（int > 0） – 用于计算平均值的回溯窗口的长度。
  
• 衰减率（浮点数, 0 < decay_rate <= 1） –
  用于折扣过去观测值的权重因子。
  在计算历史平均值时，行乘以序列：

decay_rate, decay_rate ** 2, decay_rate ** 3, ... 

注意

• 此类也可以通过名称EWMA导入。

另请参阅

pandas.DataFrame.ewm()

compute(today, assets, out, data, decay_rate)

通过一个函数重写此方法，该函数将一个值写入输出。

class zipline.pipeline.factors.ExponentialWeightedMovingStdDev(inputs=sentinel('NotSpecified'), outputs=sentinel('NotSpecified'), window_length=sentinel('NotSpecified'), mask=sentinel('NotSpecified'), dtype=sentinel('NotSpecified'), missing_value=sentinel('NotSpecified'), ndim=sentinel('NotSpecified'), **kwargs)

指数加权移动标准差

默认输入：无

默认窗口长度：无

参数：

• 输入（长度为 1 的列表/元组 的 绑定列） – 用于计算平均值的表达式。
  
• 窗口长度（int > 0） – 用于计算平均值的回溯窗口的长度。
  
• 衰减率（浮点数, 0 < decay_rate <= 1） –
  用于折扣过去观测值的权重因子。
  在计算历史平均值时，行乘以序列：

decay_rate, decay_rate ** 2, decay_rate ** 3, ... 

注意

• 此类也可以通过名称EWMSTD导入。

另请参阅

pandas.DataFrame.ewm()

compute(today, assets, out, data, decay_rate)

通过一个函数重写此方法，该函数将一个值写入输出。

class zipline.pipeline.factors.Latest(inputs=sentinel('NotSpecified'), outputs=sentinel('NotSpecified'), window_length=sentinel('NotSpecified'), mask=sentinel('NotSpecified'), dtype=sentinel('NotSpecified'), missing_value=sentinel('NotSpecified'), ndim=sentinel('NotSpecified'), **kwargs)

每天产生输入[0]的最新已知值的因素。

数据集列的.latest 属性返回此因素的实例。

compute(today, assets, out, data)

通过一个函数重写此方法，该函数将一个值写入输出。

zipline.pipeline.factors.MACDSignal

别名为MovingAverageConvergenceDivergenceSignal

class zipline.pipeline.factors.MaxDrawdown(inputs=sentinel('NotSpecified'), outputs=sentinel('NotSpecified'), window_length=sentinel('NotSpecified'), mask=sentinel('NotSpecified'), dtype=sentinel('NotSpecified'), missing_value=sentinel('NotSpecified'), ndim=sentinel('NotSpecified'), **kwargs)

最大回撤

默认输入：无

默认窗口长度：无

compute(today, assets, out, data)

通过一个函数重写此方法，该函数将一个值写入输出。

class zipline.pipeline.factors.Returns(inputs=sentinel('NotSpecified'), outputs=sentinel('NotSpecified'), window_length=sentinel('NotSpecified'), mask=sentinel('NotSpecified'), dtype=sentinel('NotSpecified'), missing_value=sentinel('NotSpecified'), ndim=sentinel('NotSpecified'), **kwargs)

计算给定窗口长度内收盘价的变化百分比。

默认输入：[EquityPricing.close]

compute(today, assets, out, close)

通过一个函数重写此方法，该函数将一个值写入输出。

class zipline.pipeline.factors.RollingPearson(base_factor, target, correlation_length, mask=sentinel('NotSpecified'))

计算给定因素的列与另一因素/绑定列的列或数据切片/单列之间的皮尔逊相关系数的因素。

参数：

• 基础因素（zipline.pipeline.Factor） – 用于计算其每个列与目标的相关性的因素。
  
• 目标（zipline.pipeline.Term with a numeric dtype） – 与基础因素产生的每个数据列计算相关性的项。该项可以是因素、绑定列或切片。如果目标为二维，则按资产计算相关性。
  
• 相关长度 (int) – 用于计算每个相关系数的回溯窗口长度。
  
• 掩码 (zipline.pipeline.Filter*,* 可选) – 描述每天应计算与目标相关性的基础因子资产（列）的过滤器。
  

参见

scipy.stats.pearsonr(), Factor.pearsonr(), zipline.pipeline.factors.RollingPearsonOfReturns

注意

大多数用户应该调用 Factor.pearsonr 而不是直接构造此类的一个实例。

compute(today, assets, out, base_data, target_data)

使用一个函数重写此方法，该函数将值写入输出。

class zipline.pipeline.factors.RollingSpearman(base_factor, target, correlation_length, mask=sentinel('NotSpecified'))

一个因子，用于计算给定因子各列与另一因子/绑定列或切片/单列数据的斯皮尔曼等级相关系数。

参数：

• 基础因子 (zipline.pipeline.Factor) – 用于计算其各列与目标相关性的因子。
  
• 目标 (zipline.pipeline.Term with a numeric dtype) – 与基础因子产生的数据每一列计算相关性的项。该项可以是因子、绑定列或切片。如果目标为二维，则按资产计算相关性。
  
• 相关长度 (int) – 用于计算每个相关系数的回溯窗口长度。
  
• 掩码 (zipline.pipeline.Filter*,* 可选) – 描述每天应计算与目标相关性的基础因子资产（列）的过滤器。
  

参见

scipy.stats.spearmanr(), Factor.spearmanr(), zipline.pipeline.factors.RollingSpearmanOfReturns

注意

大多数用户应该调用 Factor.spearmanr 而不是直接构造此类的一个实例。

compute(today, assets, out, base_data, target_data)

使用一个函数重写此方法，该函数将值写入输出。

class zipline.pipeline.factors.RollingLinearRegressionOfReturns(target, returns_length, regression_length, mask=sentinel('NotSpecified'))

执行普通最小二乘回归，预测给定资产的所有其他资产的回报。

参数：

• 目标 (zipline.assets.Asset) – 用于回归所有其他资产的资产。
  
• 回报长度 (int >= 2) – 用于计算回报的回溯窗口长度。日回报需要长度为 2 的窗口。
  
• regression_length（int >= 1）– 计算每个回归的回顾窗口长度。
  
• mask (zipline.pipeline.Filter*,* optional) – 描述每天应将哪些资产与目标资产进行回归的过滤器。
  

笔记

在许多资产上计算此因子可能耗时。建议使用掩码来限制计算回归的资产数量。

此因子旨在返回五个输出：

• alpha，一个计算每个回归截距的因子。
  
• beta，一个计算每个回归斜率的因子。
  
• r_value，一个计算每个回归相关系数的因子。
  
• p_value，一个计算每个回归的双侧 p 值的因子，用于假设检验的零假设是斜率为零。
  
• stderr，一个计算每个回归估计标准误差的因子。
  

有关具有多个输出的因子的更多帮助，请参阅zipline.pipeline.CustomFactor。

示例

让以下成为三个不同资产的 10 天回报示例：

SPY    MSFT     FB
2017-03-13    -.03     .03    .04
2017-03-14    -.02    -.03    .02
2017-03-15    -.01     .02    .01
2017-03-16       0    -.02    .01
2017-03-17     .01     .04   -.01
2017-03-20     .02    -.03   -.02
2017-03-21     .03     .01   -.02
2017-03-22     .04    -.02   -.02 

假设我们感兴趣的是预测每个股票在滚动 5 天回顾窗口内相对于 SPY 的回报。我们可以通过以下方式计算 2017-03-17 至 2017-03-22 的滚动回归系数（alpha 和 beta）：

regression_factor = RollingRegressionOfReturns(
    target=sid(8554),
    returns_length=10,
    regression_length=5,
)
alpha = regression_factor.alpha
beta = regression_factor.beta 

计算 2017-03-17 至 2017-03-22 的alpha的结果为：

SPY    MSFT     FB
2017-03-17       0    .011   .003
2017-03-20       0   -.004   .004
2017-03-21       0    .007   .006
2017-03-22       0    .002   .008 

计算 2017-03-17 至 2017-03-22 的beta的结果为：

SPY    MSFT     FB
2017-03-17       1      .3   -1.1
2017-03-20       1      .2     -1
2017-03-21       1     -.3     -1
2017-03-22       1     -.3    -.9 

注意，SPY 的 alpha 列全为 0，beta 列全为 1，因为 SPY 与其自身的回归线仅仅是函数 y = x。

要了解其他每个值是如何计算的，以 2017-03-17 MSFT 的alpha和beta值（分别为.011 和.3）为例。这些值是通过运行线性回归预测 MSFT 的回报来自 SPY 的回报，使用从 2017-03-17 开始并回顾 5 天的值。也就是说，回归是在 x = [-.03, -.02, -.01, 0, .01]和 y = [.03, -.03, .02, -.02, .04]上运行的，并产生了一个斜率.3 和一个截距.011。

另请参阅

zipline.pipeline.factors.RollingPearsonOfReturns, zipline.pipeline.factors.RollingSpearmanOfReturns

class zipline.pipeline.factors.RollingPearsonOfReturns(target, returns_length, correlation_length, mask=sentinel('NotSpecified'))

计算给定资产的回报与所有其他资产的回报之间的皮尔逊积矩相关系数。

皮尔逊相关系数是大多数人所说的“相关系数”或“R 值”。

参数：

• target (zipline.assets.Asset) – 与所有其他资产相关的资产。
  
• 回报长度 (int >= 2) – 计算回报的回溯窗口长度。每日回报需要 2 的窗口长度。
  
• 相关性长度 (int >= 1) – 计算每个相关系数的回溯窗口长度。
  
• 掩码 (zipline.pipeline.Filter*,* 可选) – 描述每天应计算哪些资产与目标资产的相关性的过滤器。
  

注意

计算许多资产的这一因子可能耗时。建议使用掩码以限制计算相关性的资产数量。

示例

让以下成为三个不同资产的 10 天回报示例：

SPY    MSFT     FB
2017-03-13    -.03     .03    .04
2017-03-14    -.02    -.03    .02
2017-03-15    -.01     .02    .01
2017-03-16       0    -.02    .01
2017-03-17     .01     .04   -.01
2017-03-20     .02    -.03   -.02
2017-03-21     .03     .01   -.02
2017-03-22     .04    -.02   -.02 

假设我们感兴趣的是 2017-03-17 至 2017-03-22 期间 SPY 的滚动回报与每只股票的相关性，使用 5 天的回溯窗口（即，我们计算每个相关系数的数据跨越 5 天）。我们可以通过以下方式实现：

rolling_correlations = RollingPearsonOfReturns(
    target=sid(8554),
    returns_length=10,
    correlation_length=5,
) 

从 2017-03-17 到 2017-03-22 计算rolling_correlations的结果给出：

SPY   MSFT     FB
2017-03-17       1    .15   -.96
2017-03-20       1    .10   -.96
2017-03-21       1   -.16   -.94
2017-03-22       1   -.16   -.85 

请注意，SPY 的列全为 1，因为任何数据系列与其自身的相关性始终为 1。要了解其他每个值是如何计算的，以 MSFT 列中的.15 为例。这是从 2017-03-17 回溯的 SPY 回报（-.03, -.02, -.01, 0, .01）与 MSFT 回报（.03, -.03, .02, -.02, .04）之间的相关系数。

另请参阅

zipline.pipeline.factors.RollingSpearmanOfReturns, zipline.pipeline.factors.RollingLinearRegressionOfReturns

class zipline.pipeline.factors.RollingSpearmanOfReturns(target, returns_length, correlation_length, mask=sentinel('NotSpecified'))

计算给定资产的回报与所有其他资产的回报之间的斯皮尔曼等级相关系数。

参数：

• 目标 (zipline.assets.Asset) – 与所有其他资产进行相关的资产。
  
• 回报长度 (int >= 2) – 计算回报的回溯窗口长度。每日回报需要 2 的窗口长度。
  
• 相关性长度 (int >= 1) – 计算每个相关系数的回溯窗口长度。
  
• 掩码 (zipline.pipeline.Filter*,* 可选) – 描述每天应计算哪些资产与目标资产的相关性的过滤器。
  

注意

计算许多资产的这一因子可能耗时。建议使用掩码以限制计算相关性的资产数量。

另请参阅

zipline.pipeline.factors.RollingPearsonOfReturns, zipline.pipeline.factors.RollingLinearRegressionOfReturns

class zipline.pipeline.factors.SimpleBeta(target, regression_length, allowed_missing_percentage=0.25)

产生斜率的因子，即每个资产的日回报率与单一“目标”资产的日回报率之间的回归线斜率。

参数：

• 目标（zipline.Asset）- 其他资产应与之回归的资产。
  
• 回归长度（整数）- 用于回归的日回报天数。
  
• 允许缺失百分比（浮点数，可选）- 在计算贝塔值时允许缺失的回报观察值的百分比（介于 0 和 1 之间）。具有超过此百分比的回报观察值缺失的资产将产生 NaN 值。默认行为是允许 25%的输入缺失。
  

compute(today, assets, out, all_returns, target_returns, allowed_missing_count)

重写此方法，使用一个函数将值写入输出。

dtype = dtype('float64')

graph_repr()

简短的表示形式，用于渲染管道图。

property target

获取贝塔计算的目标

class zipline.pipeline.factors.RSI(inputs=sentinel('NotSpecified'), outputs=sentinel('NotSpecified'), window_length=sentinel('NotSpecified'), mask=sentinel('NotSpecified'), dtype=sentinel('NotSpecified'), missing_value=sentinel('NotSpecified'), ndim=sentinel('NotSpecified'), **kwargs)

相对强弱指数

默认输入：zipline.pipeline.data.EquityPricing.close

默认窗口长度：15

compute(today, assets, out, closes)

重写此方法，使用一个函数将值写入输出。

class zipline.pipeline.factors.SimpleMovingAverage(inputs=sentinel('NotSpecified'), outputs=sentinel('NotSpecified'), window_length=sentinel('NotSpecified'), mask=sentinel('NotSpecified'), dtype=sentinel('NotSpecified'), missing_value=sentinel('NotSpecified'), ndim=sentinel('NotSpecified'), **kwargs)

任意列的平均值

默认输入：无

默认窗口长度：无

compute(today, assets, out, data)

重写此方法，使用一个函数将值写入输出。

class zipline.pipeline.factors.VWAP(inputs=sentinel('NotSpecified'), outputs=sentinel('NotSpecified'), window_length=sentinel('NotSpecified'), mask=sentinel('NotSpecified'), dtype=sentinel('NotSpecified'), missing_value=sentinel('NotSpecified'), ndim=sentinel('NotSpecified'), **kwargs)

成交量加权平均价格

默认输入：[EquityPricing.close, EquityPricing.volume]

默认窗口长度：无

class zipline.pipeline.factors.WeightedAverageValue(inputs=sentinel('NotSpecified'), outputs=sentinel('NotSpecified'), window_length=sentinel('NotSpecified'), mask=sentinel('NotSpecified'), dtype=sentinel('NotSpecified'), missing_value=sentinel('NotSpecified'), ndim=sentinel('NotSpecified'), **kwargs)

VWAP 类计算的辅助工具

默认输入：无

默认窗口长度：无

compute(today, assets, out, base, weight)

重写此方法，使用一个函数将值写入输出。

class zipline.pipeline.factors.PercentChange(inputs=sentinel('NotSpecified'), outputs=sentinel('NotSpecified'), window_length=sentinel('NotSpecified'), mask=sentinel('NotSpecified'), dtype=sentinel('NotSpecified'), missing_value=sentinel('NotSpecified'), ndim=sentinel('NotSpecified'), **kwargs)

计算百分比变化，超过给定的window_length。

默认输入：无

默认窗口长度：无

注释

百分比变化计算为(new - old) / abs(old)。

compute(today, assets, out, values)

重写此方法，使用一个函数将值写入输出。

class zipline.pipeline.factors.PeerCount(inputs=sentinel('NotSpecified'), outputs=sentinel('NotSpecified'), window_length=sentinel('NotSpecified'), mask=sentinel('NotSpecified'), dtype=sentinel('NotSpecified'), missing_value=sentinel('NotSpecified'), ndim=sentinel('NotSpecified'), **kwargs)

同类计数，即给定分类器中不同类别的数量。此因子由分类器的实例方法 peer_count()返回。

默认输入：无

默认窗口长度：1

compute(today, assets, out, classifier_values)

重写此方法，使用一个函数将值写入输出。

内置过滤器

class zipline.pipeline.filters.All(inputs=sentinel('NotSpecified'), outputs=sentinel('NotSpecified'), window_length=sentinel('NotSpecified'), mask=sentinel('NotSpecified'), dtype=sentinel('NotSpecified'), missing_value=sentinel('NotSpecified'), ndim=sentinel('NotSpecified'), **kwargs)

过滤器，要求资产在window_length连续天内产生 True。

默认输入：无

默认窗口长度：无

compute(today, assets, out, arg)

重写此方法，使用一个函数将值写入输出。

class zipline.pipeline.filters.AllPresent(inputs=sentinel('NotSpecified'), outputs=sentinel('NotSpecified'), window_length=sentinel('NotSpecified'), mask=sentinel('NotSpecified'), dtype=sentinel('NotSpecified'), missing_value=sentinel('NotSpecified'), ndim=sentinel('NotSpecified'), **kwargs)

管道过滤器，指示输入项在给定窗口内具有数据。

compute(today, assets, out, value)

重写此方法，使用一个函数将值写入输出。

class zipline.pipeline.filters.Any(inputs=sentinel('NotSpecified'), outputs=sentinel('NotSpecified'), window_length=sentinel('NotSpecified'), mask=sentinel('NotSpecified'), dtype=sentinel('NotSpecified'), missing_value=sentinel('NotSpecified'), ndim=sentinel('NotSpecified'), **kwargs)

过滤器，要求资产在最近window_length天内至少有一天产生 True。

默认输入：无

默认窗口长度： 无

compute(today, assets, out, arg)

通过一个函数重写此方法，该函数将值写入 out。

class zipline.pipeline.filters.AtLeastN(inputs=sentinel('NotSpecified'), outputs=sentinel('NotSpecified'), window_length=sentinel('NotSpecified'), mask=sentinel('NotSpecified'), dtype=sentinel('NotSpecified'), missing_value=sentinel('NotSpecified'), ndim=sentinel('NotSpecified'), **kwargs)

一个过滤器，要求资产在过去window_length天内至少连续 N 天为真。

默认输入： 无

默认窗口长度： 无

compute(today, assets, out, arg, N)

通过一个函数重写此方法，该函数将值写入 out。

class zipline.pipeline.filters.SingleAsset(asset)

一个仅对给定资产计算为真的过滤器。

graph_repr()

用于渲染 GraphViz 图表时的简短表示。

class zipline.pipeline.filters.StaticAssets(assets)

一个仅对预先确定的一组资产计算为真的过滤器。

StaticAssets 主要用于调试或在已知一组固定资产的情况下交互式计算管道术语。

参数：

assets (iterable**[Asset*]*) – 要过滤的资产的可迭代对象。

class zipline.pipeline.filters.StaticSids(sids)

一个仅对预先确定的一组 sids 计算为真的过滤器。

StaticSids 主要用于调试或在已知一组固定 sids 的情况下交互式计算管道术语。

参数：

sids (iterable*[int]*) – 要过滤的 sids 的可迭代对象。

管道引擎

执行Pipeline的计算引擎定义了核心计算算法。

主要入口点是 SimplePipelineEngine.run_pipeline，它实现了以下执行管道的算法：

1. 确定管道的域。
   
2. 构建管道中所有术语的依赖关系图，并提供每个术语从其输入中需要额外行数的信息。
   
3. 将（2）中计算的域与我们的 AssetFinder 结合，生成一个“生命周期矩阵”。生命周期矩阵是一个布尔值的 DataFrame，其标签为日期 x 资产。每个条目对应于一个（日期，资产）对，并指示在给定日期该资产是否可交易。
   
4. 生成一个包含缓存或预先计算术语的“工作区”字典。
   
5. 对（1）中构建的图进行拓扑排序，以生成未预填充的任何术语的执行顺序。
   
6. 按照（5）中计算的顺序遍历术语。对于每个术语：

1. 从工作区获取术语的输入。
   
2. 计算每个术语并将结果存储在工作区中。
   
3. 如果结果不再需要，则从工作区中移除以减少执行期间的内存使用。
   

7. 从工作区提取管道的输出，并将其转换为“窄”格式，输出标签由管道的屏幕决定。
   

class zipline.pipeline.engine.PipelineEngine

abstract run_pipeline(pipeline, start_date, end_date, hooks=None)

从start_date到end_date计算pipeline的值。

参数：

• pipeline (zipline.pipeline.Pipeline) – 要运行的管道。
  
• start_date (pd.Timestamp) – 计算矩阵的起始日期。
  
• end_date (pd.Timestamp) – 计算矩阵的结束日期。
  
• hooks (列表[实现(PipelineHooks)], 可选) – 用于对管道执行进行检测的钩子。
  

返回：

result – 计算结果的框架。

result列对应于 pipeline.columns 的条目，它应该是一个将字符串映射到zipline.pipeline.Term实例的字典。

对于start_date和end_date之间的每一天，result将包含通过管道筛选的每个资产的行。筛选条件为None表示应该为每一天存在的每个资产返回一行。

返回类型：

pd.DataFrame

abstract run_chunked_pipeline(pipeline, start_date, end_date, chunksize, hooks=None)

计算从start_date到end_date的pipeline值，以chunksize大小的日期块执行。

分块执行减少了内存消耗，并且根据您的管道内容，可能会减少计算时间。

参数：

• pipeline (Pipeline) – 要运行的管道。
  
• start_date (pd.Timestamp) – 运行管道的开始日期。
  
• end_date (pd.Timestamp) – 运行管道的结束日期。
  
• chunksize (整数) – 每次执行的天数。
  
• hooks (列表[实现(PipelineHooks)], 可选) – 用于对管道执行进行检测的钩子。
  

返回：

result – 计算结果的框架。

result列对应于 pipeline.columns 的条目，它应该是一个将字符串映射到zipline.pipeline.Term实例的字典。

对于start_date和end_date之间的每一天，result将包含通过管道筛选的每个资产的行。筛选条件为None表示应该为每一天存在的每个资产返回一行。

返回类型：

pd.DataFrame

另请参阅

zipline.pipeline.engine.PipelineEngine.run_pipeline()

class zipline.pipeline.engine.SimplePipelineEngine(get_loader, asset_finder, default_domain=GENERIC, populate_initial_workspace=None, default_hooks=None)

计算每个术语独立的 PipelineEngine 类。

参数：

• get_loader (可调用) – 一个函数，它接收一个可加载的术语并返回一个 PipelineLoader，用于检索该术语的原始数据。
  
• asset_finder (zipline.assets.AssetFinder) – 一个 AssetFinder 实例。我们依赖 AssetFinder 来确定在任何时间点哪些资产在顶级宇宙中。
  
• populate_initial_workspace (callable*,* optional) – 用于在计算管道时填充初始工作区的函数。有关更多信息，请参阅 zipline.pipeline.engine.default_populate_initial_workspace()。
  
• default_hooks (list, optional) – 应该用于检测此引擎执行的所有管道的钩子列表。
  

（另请参阅）

zipline.pipeline.engine.default_populate_initial_workspace()

__init__(get_loader, asset_finder, default_domain=GENERIC, populate_initial_workspace=None, default_hooks=None)

run_chunked_pipeline(pipeline, start_date, end_date, chunksize, hooks=None)

从 开始日期 到 结束日期 计算 pipeline 的值，每次计算 chunksize 大小的日期块。

分块执行减少了内存消耗，并且可能会根据管道内容减少计算时间。

（参数：）

• pipeline (Pipeline) – 要运行的管道。
  
• 开始日期 (pd.Timestamp) – 运行管道的开始日期。
  
• 结束日期 (pd.Timestamp) – 运行管道的结束日期。
  
• chunksize (int) – 每次执行的天数。
  
• hooks (list[implements(PipelineHooks)], optional) – 用于检测管道执行的钩子。
  

（返回：）

结果 – 计算结果的框架。

结果 列对应于 pipeline.columns 的条目，它应该是将字符串映射到 zipline.pipeline.Term 实例的字典。

对于 开始日期 和 结束日期 之间的每个日期，结果 将包含每个通过 pipeline.screen 的资产的行。None 的屏幕表示应该为每天存在的每个资产返回一行。

（返回类型：）

pd.DataFrame

（另请参阅）

zipline.pipeline.engine.PipelineEngine.run_pipeline()

run_pipeline(pipeline, start_date, end_date, hooks=None)

从 开始日期 到 结束日期 计算 pipeline 的值。

（参数：）

• pipeline (zipline.pipeline.Pipeline) – 要运行的管道。
  
• 开始日期 (pd.Timestamp) – 计算矩阵的开始日期。
  
• 结束日期 (pd.Timestamp) – 计算矩阵的结束日期。
  
• hooks (list[implements(PipelineHooks)], optional) – 用于检测管道执行的钩子。
  

（返回：）

结果 – 计算结果的框架。

result列对应于 pipeline.columns 的条目，它应该是一个字典，将字符串映射到zipline.pipeline.Term的实例。

对于start_date和end_date之间的每个日期，result将包含每个通过 pipeline.screen 的资产的行。None的屏幕表示应该为每天存在的每个资产返回一行。

返回类型：

pd.DataFrame

zipline.pipeline.engine.default_populate_initial_workspace(initial_workspace, root_mask_term, execution_plan, dates, assets)

populate_initial_workspace的默认实现。此函数返回initial_workspace参数，不做任何修改。

参数：

• 初始工作区 (字典[类似数组]) – 在我们填充任何缓存项之前的初始工作区。
  
• 根掩码术语 (Term) – 根掩码术语，通常是AssetExists()。这是为了计算各个术语的日期所必需的。
  
• 执行计划 (ExecutionPlan) – 正在运行的管道的执行计划。
  
• 日期 (pd.DatetimeIndex) – 此管道运行中请求的所有日期，包括用于回溯窗口的额外日期。
  
• 资产 (pd.Int64Index) – 计算窗口中存在的所有资产。
  

返回：

填充的初始工作区 – 开始计算的工作区。

返回类型：

字典[术语, 类似数组]

数据加载器

有几种加载器需要向Pipeline提供数据，这些加载器需要实现由PipelineLoader定义的接口。

class zipline.pipeline.loaders.base.PipelineLoader(*args, **kwargs)

管道加载器的接口。

load_adjusted_array(domain, columns, dates, sids, mask)

加载columns的数据作为 AdjustedArrays。

参数：

• 域 (zipline.pipeline.domain.Domain) – 必须加载请求数据的管道的域。
  
• 列 (列表*[zipline.pipeline.data.dataset.BoundColumn]*) – 请求数据的列。
  
• 日期 (pd.DatetimeIndex) – 请求数据的日期。
  
• sid (pd.Int64Index) – 请求数据的资产标识符。
  
• 掩码 (np.array*[ndim=2,* dtype=bool*]*) – 形状为(len(dates), len(sids))的布尔数组，指示我们认为请求的资产在哪些日期是活动的/可交易的。某些加载器使用此进行优化。
  

返回：

数组 – 从列到表示请求日期和请求 sid 的点在时间滚动视图的 AdjustedArray 的映射。

返回类型：

字典[BoundColumn -> zipline.lib.adjusted_array.AdjustedArray]

__init__()

class zipline.pipeline.loaders.frame.DataFrameLoader(column, baseline, adjustments=None)

从 DataFrame 读取输入的 PipelineLoader。

主要用于测试，但如果数据适合内存，也可用于实际工作。

参数：

• 列（zipline.pipeline.data.BoundColumn） – 该列的数据可由该加载器加载。
  
• 基线（pandas.DataFrame） – 具有 DatetimeIndex 类型索引和 Int64Index 类型列的 DataFrame。日期应标记为算法可获得值的第一个日期。这意味着 OHLCV 数据在提供给此类之前通常应向后移动一个交易日。
  
• 调整（pandas.DataFrame, 默认=None） –
  具有以下列的 DataFrame：
  sid : int value : any kind : int (zipline.pipeline.loaders.frame.ADJUSTMENT_TYPES) start_date : datetime64 (可以为 NaT) end_date : datetime64 (必须设置) apply_date : datetime64 (必须设置)
  默认的 None 被解释为“不对基线进行调整”。
  

__init__(column, baseline, adjustments=None)

format_adjustments(dates, assets)

构建 AdjustedArray 期望格式的 Adjustment 对象字典。

返回一个字典，形式如下：{ # 我们应应用调整列表的日期在日期中的整数索引。 1 : [ Float64Multiply(first_row=2, last_row=4, col=3, value=0.5), Float64Overwrite(first_row=3, last_row=5, col=1, value=2.0), … ], … }

load_adjusted_array(domain, columns, dates, sids, mask)

从我们存储的基线加载数据。

class zipline.pipeline.loaders.equity_pricing_loader.EquityPricingLoader(raw_price_reader, adjustments_reader, fx_reader)

加载每日 OHLCV 数据的 PipelineLoader。

参数：

• 原始价格读取器（zipline.data.session_bars.SessionBarReader） – 提供原始价格的读取器。
  
• 调整读取器（zipline.data.adjustments.SQLiteAdjustmentReader） – 提供价格/成交量调整的读取器。
  
• 外汇读取器（zipline.data.fx.FXRateReader） – 提供货币转换的读取器。
  

__init__(raw_price_reader, adjustments_reader, fx_reader)

zipline.pipeline.loaders.equity_pricing_loader.USEquityPricingLoader

别名为 EquityPricingLoader

class zipline.pipeline.loaders.events.EventsLoader(events, next_value_columns, previous_value_columns)

支持加载事件字段下一个和上一个值的 PipelineLoaders 的基类。

目前不支持调整。

参数：

• 事件（pd.DataFrame） –
  表示与特定公司相关的事件（例如股票回购或盈利公告）的 DataFrame。
  事件 必须至少包含三列：
  sidint64
  与每个事件关联的资产 ID。
  事件日期 datetime64[ns]
  事件发生的日期。
  时间戳 datetime64[ns]
  我们得知该事件的日期。
  
• next_value_columns (dict[BoundColumn -> str]) – 从数据集列到原始字段名称的映射，用于在搜索下一个事件值时应使用的字段名称。
  
• previous_value_columns (dict[BoundColumn -> str]) – 从数据集列到原始字段名称的映射，用于在搜索上一个事件值时应使用的字段名称。
  

__init__(events, next_value_columns, previous_value_columns)

class zipline.pipeline.loaders.earnings_estimates.EarningsEstimatesLoader(estimates, name_map)

一个抽象的估计数据管道加载器，可以根据列数据集的 num_announcements 属性，从日历日期向前/向后加载可变数量的季度数据。如果需要应用拆分调整，必须提供加载器、拆分调整后的列和拆分调整后的 asof 日期。

参数：

• estimates (pd.DataFrame) –
  原始估计数据；必须至少包含 5 列：
  sidint64
  与每个估计关联的资产 ID。
  event_datedatetime64[ns]
  估计所针对的事件将/已经发生的日期。
  timestampdatetime64[ns]
  我们得知估计值的日期时间。
  fiscal_quarterint64
  事件发生/将发生的季度。
  fiscal_yearint64
  事件发生/将发生的年份。
  
• name_map (dict[str -> str]) – 此加载器将加载的 BoundColumns 的名称映射到事件中相应列的名称。
  

__init__(estimates, name_map)

交易所和资产元数据

class zipline.assets.ExchangeInfo(name, canonical_name, country_code)

资产交易的交易所。

参数：

• name (str or None) – 交易所的全名，例如‘NEW YORK STOCK EXCHANGE’或‘NASDAQ GLOBAL MARKET’。
  
• canonical_name (str) – 交易所的标准名称，例如‘NYSE’或‘NASDAQ’。如果为 None，则将与名称相同。
  
• country_code (str) – 交易所所在的国家代码。
  

name

交易所的全名，例如‘NEW YORK STOCK EXCHANGE’或‘NASDAQ GLOBAL MARKET’。

类型：

str 或 None

canonical_name

交易所的标准名称，例如‘NYSE’或‘NASDAQ’。如果为 None，则将与名称相同。

类型：

str

country_code

交易所所在的国家代码。

类型：

str

calendar

交易所使用的交易日历。

类型：

TradingCalendar

property calendar

该交易所使用的交易日历。

class zipline.assets.Asset

可以被交易算法拥有的实体的基类。

sid

分配给资产的持久唯一标识符。

类型：

int

symbol

资产最近交易的最新股票代码。如果资产更改股票代码，此字段可能会在没有警告的情况下更改。如果需要持久标识符，请使用sid。

类型：

字符串

asset_name

资产的全名。

类型：

字符串

exchange

资产交易的交易所的规范简称（例如，‘NYSE’）。

类型：

字符串

exchange_full

资产交易的交易所的全名（例如，‘纽约证券交易所’）。

类型：

字符串

exchange_info

有关该资产上市的交易所的信息。

类型：

zipline.assets.ExchangeInfo

country_code

表示资产交易国家的两个字符代码。

类型：

字符串

start_date

资产首次交易日期。

类型：

pd.Timestamp

end_date

资产交易的最后日期。在 Quantopian 上，对于仍在交易的资产，此值设置为当前（实时）日期。

类型：

pd.Timestamp

tick_size

该资产价格变动的最小金额。

类型：

浮点数

auto_close_date

在模拟中，此资产的仓位将在该日期自动清算为现金。默认情况下，这是end_date之后的三天。

类型：

pd.Timestamp

from_dict()

从字典构建资产实例。

is_alive_for_session()

返回资产在给定时间点是否存活。

参数：

会话标签 (pd.Timestamp) – 要检查的期望会话标签。（UTC 午夜）

返回：

布尔值

返回类型：

检查资产在给定时间点是否存活。

is_exchange_open()

参数：

dt_ 分钟 (pd.Timestamp (UTC, 时区感知*)*) – 要检查的分钟。

返回：

布尔值

返回类型：

检查资产的交易所是否在给定分钟内开放。

to_dict()

转换为包含资产所有属性的 python 字典。

这在调试时通常很有用。

返回：

as_dict

返回类型：

字典

class zipline.assets.Equity

资产子类，代表公司、信托或合伙企业的部分所有权。

class zipline.assets.Future

资产子类，代表期货合约的所有权。

to_dict()

转换为 python 字典。

class zipline.assets.AssetConvertible

ABC，用于可转换为资产整数表示的类型。

包括资产、字符串和整数

交易日历 API

算法执行的时间线事件遵循特定的TradingCalendar。

数据 API

写入器

class zipline.data.bcolz_daily_bars.BcolzDailyBarWriter(filename, calendar, start_session, end_session)

能够将每日 OHLCV 数据写入磁盘的类，以便可以高效地由 BcolzDailyOHLCVReader 读取。

参数：

• 文件名 (字符串) – 我们应该写入输出的位置。
  
• 日历 (zipline.utils.calendar.trading_calendar) – 用于计算资产日历偏移的日历。
  
• start_session (pd.Timestamp) – 午夜 UTC 会话标签。
  
• end_session (pd.Timestamp) – 午夜 UTC 会话标签。
  

另请参阅

zipline.data.bcolz_daily_bars.BcolzDailyBarReader

write(data, assets=None, show_progress=False, invalid_data_behavior='warn')

参数：

• data (iterable*[tuple[int,* pandas.DataFrame or bcolz.ctable*]**]*) – 要写入的数据块。每个块应为 sid 和该资产数据的元组。
  
• assets (set[int]**, optional) – 应包含在data中的资产。如果提供了这个，我们将检查data与资产，并提供更好的进度信息。
  
• show_progress (bool, optional) – 是否在写入时显示进度条。
  
• invalid_data_behavior ({‘warn’**, ‘raise’**, ‘ignore’}**, optional) – 当遇到超出 uint32 范围的数据时，应采取的措施。
  

返回：

table – 新写入的表。

返回类型：

bcolz.ctable

write_csvs(asset_map, show_progress=False, invalid_data_behavior='warn')

从我们的资产映射中读取 CSV 作为 DataFrame。

参数：

• asset_map (dict[int -> str]) – 资产 id 到包含该资产 CSV 数据的文件路径的映射
  
• show_progress (bool) – 是否在写入时显示进度条。
  
• invalid_data_behavior ({‘warn’**, ‘raise’**, ‘ignore’}) – 当遇到超出 uint32 范围的数据时，应采取的措施。
  

class zipline.data.adjustments.SQLiteAdjustmentWriter(conn_or_path, equity_daily_bar_reader, overwrite=False)

用于由 SQLiteAdjustmentReader 读取的数据的写入器

参数：

• conn_or_path (str or sqlite3.Connection) – 目标 sqlite 数据库的句柄。
  
• equity_daily_bar_reader (SessionBarReader) – 用于股息写入的日柱读取器。
  
• overwrite (bool, optional*,* default=False) – 如果为 True 且 conn_or_path 是字符串，则在连接之前删除给定路径上的任何现有文件。
  

另请参阅

zipline.data.adjustments.SQLiteAdjustmentReader

calc_dividend_ratios(dividends)

计算应用于股票的比率，以便在查看定价历史时平滑价格，在 ex_date 时，市场调整股票价值的变化，因为即将到来的股息。

返回：

与拆分和合并相同的格式的框架，键包括 - sid，股票的 ID - effective_date，应用比率的日期（以秒为单位）。 - ratio，应用于向后查看定价数据的比率。

返回类型：

DataFrame

write(splits=None, mergers=None, dividends=None, stock_dividends=None)

将数据写入 SQLite 文件，供 SQLiteAdjustmentReader 读取。

参数：

• splits (pandas.DataFrame, optional) –
  包含拆分数据的 DataFrame。该 DataFrame 的格式为：
  effective_dateint
  调整应应用的日期，表示为自 Unix 纪元以来的秒数。
  ratiofloat
  对于有效日期之前的所有数据应用的值。对于开盘价、最高价、最低价和收盘价，这些值乘以比率。成交量除以该值。
  sidint
  与此调整相关的资产 ID。
  
• mergers (pandas.DataFrame, optional) –
  包含合并数据的 DataFrame。该 DataFrame 的格式为：
  effective_dateint
  调整应应用的日期，表示为自 Unix 纪元以来的秒数。
  ratiofloat
  对于有效日期之前的所有数据应用的值。对于开盘价、最高价、最低价和收盘价，这些值乘以比率。成交量不受影响。
  sidint
  与此调整相关的资产 ID。
  
• dividends (pandas.DataFrame, optional) –
  包含股息数据的 DataFrame。DataFrame 的格式为：
  sidint
  与此调整相关的资产 ID。
  ex_datedatetime64
  必须持有股票以有资格接收付款的日期。
  declared_datedatetime64
  股息向公众宣布的日期。
  pay_datedatetime64
  股息分配的日期。
  record_datedatetime64
  检查股票所有权以确定股息分配的日期。
  amountfloat
  每股支付的现金金额。
  股息比率计算方式为：1.0 - (dividend_value / "ex_date 前一天的收盘价")
  
• stock_dividends (pandas.DataFrame, optional) –
  包含股票股息数据的 DataFrame。DataFrame 的格式为：

sidint

与此调整相关的资产 ID。

ex_datedatetime64

必须持有股票以有资格接收付款的日期。

declared_datedatetime64

股息向公众宣布的日期。

pay_datedatetime64

股息分配的日期。

记录日期时间 64

检查股票所有权以确定股息分配的日期。

支付 sid 整数

应支付的股份的资产 id。

比率浮点数

当前持有的 sid 中应使用 payment_sid 的新股份支付的股份比率。

另请参阅

zipline.data.adjustments.SQLiteAdjustmentReader

write_dividend_data(dividends, stock_dividends=None)

同时写入股息支付和派生价格调整比率。

write_dividend_payouts(frame)

将股息支付数据写入 SQLite 表 dividend_payouts。

class zipline.assets.AssetDBWriter(engine)

用于向资产数据库写入数据的类。

参数：

engine (Engine 或 str) – SQLAlchemy 引擎或 SQL 数据库的路径。

init_db(txn=None)

连接到数据库并创建表。

参数：

txn (sa.engine.Connection, 可选) – 要执行的事务块。如果未提供，将使用提供的引擎启动新事务。

返回：

metadata – 描述新资产数据库的元数据。

返回类型：

sa.MetaData

write(equities=None, futures=None, exchanges=None, root_symbols=None, equity_supplementary_mappings=None, chunk_size=999)

将资产元数据写入 sqlite 数据库。

参数：

• equities (pd.DataFrame, 可选) –
  股票元数据。该数据框的列包括：

符号字符串

该股票的代码。

资产名称字符串

该资产的全称。

开始日期时间

该资产创建的日期。

结束日期时间，可选

我们拥有该资产的最后交易数据的日期。

首次交易日期时间，可选

我们拥有该资产的首个交易数据的日期。

自动关闭日期时间，可选

关闭该资产中任何持仓的日期。

交易所字符串

该资产交易的交易所。

• 该数据框的索引应包含 sids。
• 期货 (pd.DataFrame, 可选) –
  期货合约元数据。该数据框的列包括：

符号字符串

该期货合约的代码。

根符号字符串

根符号，或去除到期日的符号。

资产名称字符串

该资产的全称。

开始日期时间，可选

该资产创建的日期。

结束日期时间，可选

我们拥有该资产的最后交易数据的日期。

首次交易日期时间，可选

我们拥有该资产的首个交易数据的日期。

交易所字符串

该资产交易的交易所。

通知日期时间

合约所有者可能被迫接受合约资产实物交割的日期。

到期日期时间

合约到期日期。

自动关闭日期时间

经纪商将自动关闭该合约中任何持仓的日期。

最小价格变动浮点数

合约的最小价格变动。

乘数：浮点数

该合约代表的底层资产的数量。

• 交易所 (pd.DataFrame, 可选) –
  资产可交易的交易所。该数据框的列包括：

交易所字符串

交易所的全称。

规范名称字符串

交易所的规范名称。

国家代码字符串

交易所的 ISO 3166 alpha-2 国家代码。

• 根符号（pd.DataFrame*，可选）-
  期货合约的根符号。该数据框的列包括：

根符号字符串

根符号名称。

根符号 ID 整数

该根符号的唯一 ID。

部门字符串，可选

该根符号的部门。

描述字符串，可选

该根符号的简短描述。

交易所字符串

该根符号交易的交易所。

• 股票补充映射（pd.DataFrame*，可选）- 将任意类型的值映射到资产的额外映射。
  
• 块大小（int*，可选）- 一次写入 SQLite 表的行数。这默认为 sqlite 中绑定参数的默认数量。如果您使用更多或更少的参数编译 sqlite3，您可能希望在此传递该值。
  

另请参阅

zipline.assets.asset_finder

write_direct(equities=None, equity_symbol_mappings=None, equity_supplementary_mappings=None, futures=None, exchanges=None, root_symbols=None, chunk_size=999)

以资产数据库中存储的格式将资产元数据写入 sqlite 数据库。

参数：

• 股票（pd.DataFrame*，可选）-
  股票元数据。该数据框的列包括：

代码字符串

该股票的代码。

资产名称字符串

该资产的全名。

开始日期时间

该资产创建的日期。

结束日期时间，可选

我们拥有该资产交易数据的最后一个日期。

首次交易日期时间，可选

我们拥有该资产交易数据的第一个日期。

自动关闭日期时间，可选

关闭该资产中任何头寸的日期。

交易所字符串

该资产交易的交易所。

• 该数据框的索引应包含 sids。
• 期货（pd.DataFrame*，可选）-
  期货合约元数据。该数据框的列包括：

代码字符串

该期货合约的代码。

根符号字符串

根符号，或去除到期日的符号。

资产名称字符串

该资产的全名。

开始日期时间，可选

该资产创建的日期。

结束日期时间，可选

我们拥有该资产交易数据的最后一个日期。

首次交易日期时间，可选

我们拥有该资产交易数据的第一个日期。

交易所字符串

该资产交易的交易所。

通知日期时间

合约持有人可能被迫接受合约资产实物交割的日期。

到期日期时间

合约到期日期。

自动关闭日期时间

经纪人将自动关闭该合约中任何头寸的日期。

最小价格变动浮点数

合约的最小价格变动。

乘数：浮点数

该合约代表的底层资产数量。

• 交易所（pd.DataFrame*，可选）-
  资产可以交易的交易所。该数据框的列包括：

交易所字符串

交易所的全名。

规范名称字符串

交易所的规范名称。

国家代码字符串

交易所的 ISO 3166 alpha-2 国家代码。

• 根符号 (pd.DataFrame, 可选) –
  期货合约的根符号。这个数据框的列包括：

根符号字符串

根符号名称。

根符号标识符整数

这个根符号的唯一标识符。

部门字符串，可选

这个根符号的部门。

描述字符串，可选

这个根符号的简短描述。

交易所字符串

这个根符号交易的交易所。

• 股票补充映射 (pd.DataFrame, 可选) – 从任意类型的值到资产的额外映射。
  
• 块大小 (整数, 可选) – 一次写入 SQLite 表的行数。这默认为 sqlite 中默认的绑定参数数量。如果你编译的 sqlite3 有更多或更少的绑定参数，你可能想在这里传递那个值。
  

阅读器

class zipline.data.bcolz_daily_bars.BcolzDailyBarReader(table, read_all_threshold=3000)

用于读取由 BcolzDailyOHLCVWriter 编写的原始定价数据的阅读器。

参数：

• 表 (bcolz.ctable) – 包含定价数据的 ctable，其属性对应于下面的属性列表。
  
• 读取所有阈值 (整数) – 股票数量；低于此数量，数据通过从 carray 中读取每个资产的切片来读取。高于此数量，数据通过将所有资产的数据拉入内存，然后为每个日期和资产对索引到该数组来读取。用于调整使用少量或大量股票时的读取性能。
  

The table with which this loader interacts contains the following

attributes

first_row

从资产标识符到具有该标识符的数据集中第一行的索引的映射。

类型：

字典

last_row

从资产标识符到具有该标识符的数据集中最后一行的索引的映射。

类型：

字典

calendar_offset

从资产标识符到数据集中第一行的日历索引的映射。

类型：

字典

start_session_ns

这个数据集中使用的第一个会话的纪元纳秒。

类型：

整数

end_session_ns

这个数据集中使用的最后一个会话的纪元纳秒。

类型：

整数

calendar_name

使用的交易日历的字符串标识符（例如，“NYSE”）。

类型：

字符串

We use first_row and last_row together to quickly find ranges of rows to

load when reading an asset's data into memory.

We use calendar_offset and calendar to orient loaded blocks within a

range of queried dates.

注释

Bcolz CTable 由列和属性组成。这个加载器与之交互的表包含以下列：

[‘开盘’, ‘最高’, ‘最低’, ‘收盘’, ‘成交量’, ‘日期’, ‘标识符’]。

这些列中的数据被解释如下：

• 价格列（‘开盘’, ‘最高’, ‘最低’, ‘收盘’）被解释为 1000 * 交易美元价值。
  
• 成交量被解释为交易成交量。
  
• 日期被解释为自 1970 年 1 月 1 日 UTC 午夜以来的秒数。
  
• 标识符是行的资产标识符。
  

每个列中的数据按资产分组，然后在每个资产块内按日期排序。

该表旨在表示长时间范围的数据，例如十年的股票数据，因此每个资产块的长度并不相等。这些块被剪辑到每个资产的已知开始和结束日期，以减少需要包含的空值数量，以便制作常规/立方数据集。

当在同一索引上读取开盘、最高、最低、收盘和成交量时，应表示相同的资产和日期。

另请参阅

zipline.data.bcolz_daily_bars.BcolzDailyBarWriter

currency_codes(sids)

获取请求的 sids 的价格报价货币。

假设 sid 的价格始终以单一货币报价。

参数：

sids (np.array*[int64]*) – 需要货币的 sids 数组。

返回值：

currency_codes – 用于列出sids货币的货币代码数组。实现应为货币未知的 sids 返回 None。

返回类型：

np.array[object]

get_last_traded_dt(asset, day)

获取asset在或之前交易的最新分钟dt。

如果在或之前没有交易dt，则返回pd.NaT。

参数：

• asset (zipline.asset.Asset) – 获取最后交易分钟的资产。
  
• dt (pd.Timestamp) – 开始搜索最后交易分钟的时间。
  

返回值：

last_traded – 使用输入 dt 作为视点的给定资产的最后交易 dt。

返回类型：

pd.Timestamp

get_value(sid, dt, field)

参数：

• sid (int) – 资产标识符。
  
• day (datetime64-like) – 请求数据的日期的午夜。
  
• colname (string) – 价格字段。例如：(‘open’, ‘high’, ‘low’, ‘close’, ‘volume’)
  

返回值：

给定 sid 在给定日期的 colname 的现货价格。如果给定的日期和 sid 在股票的日期范围之前或之后，则引发 NoDataOnDate 异常。如果日期在日期范围内，但价格为 0，则返回-1。

返回类型：

float

property last_available_dt

返回值：dt – 读者可以提供数据的最后一个会话。 :rtype: pd.Timestamp

load_raw_arrays(columns, start_date, end_date, assets)

参数：

• columns (list of str) – ‘open’, ‘high’, ‘low’, ‘close’, 或 ‘volume’
  
• start_date (Timestamp) – 窗口范围的开始。
  
• end_date (Timestamp) – 窗口范围的结束。
  
• assets (list of int) – 窗口中的资产标识符。
  

返回值：

一个列表，每个字段都有一个 ndarrays 条目，形状为(范围内的分钟数, sids)，dtype 为 float64，包含开始和结束 dt 范围内各自字段的值。

返回类型：

list of np.ndarray

sid_day_index(sid, day)

参数：

• sid (int) – 资产标识符。
  
• 日期 (datetime64-like) – 请求数据的日期的午夜。
  

返回：

为给定的 sid 和日期索引数据磁带。如果在给定日期和 sid 之前或之后，则引发 NoDataOnDate 异常。

返回类型：

int

class zipline.data.adjustments.SQLiteAdjustmentReader(conn)

根据公司行为从 SQLite 数据库加载调整。

期望以 SQLiteAdjustmentWriter 输出的格式编写的数据。

参数：

连接 (str 或 sqlite3.Connection) – 用于加载数据的连接。

另请参阅

zipline.data.adjustments.SQLiteAdjustmentWriter

load_adjustments(dates, assets, should_include_splits, should_include_mergers, should_include_dividends, adjustment_type)

从底层调整数据库加载调整对象集合。

参数：

• 日期 (pd.DatetimeIndex) – 需要调整的日期。
  
• 资产 (pd.Int64Index) – 需要调整的资产。
  
• 应包含拆分 (bool) – 是否应包含拆分调整。
  
• 应包含合并 (bool) – 是否应包含合并调整。
  
• 应包含股息 (bool) – 是否应包含股息调整。
  
• 调整类型 (str) – 是否应在输出中包含价格调整、数量调整或两者。
  

返回：

调整 – 一个字典，包含从索引到调整对象的价格和/或数量调整映射，以在该索引处应用。

返回类型：

dict[str -> dict[int -> Adjustment]]

unpack_db_to_component_dfs(convert_dates=False)

返回调整文件中已知表的集合，以 DataFrame 形式。

参数：

转换日期 (bool, 可选) – 默认情况下，日期以自 EPOCH 以来的秒数返回。如果 convert_dates 为 True，则日期列中的所有整数都将转换为日期时间。

返回：

dfs – 一个字典，将表名映射到相应表的 DataFrame 版本，其中所有日期列都已从 int 强制转换回 datetime。

返回类型：

dict{str->DataFrame}

class zipline.assets.AssetFinder(engine, future_chain_predicates={'AD': functools.partial(<built-in function delivery_predicate>, {'Z', 'U', 'H', 'M'}), 'BP': functools.partial(<built-in function delivery_predicate>, {'Z', 'U', 'H', 'M'}), 'CD': functools.partial(<built-in function delivery_predicate>, {'Z', 'U', 'H', 'M'}), 'EL': functools.partial(<built-in function delivery_predicate>, {'Z', 'U', 'H', 'M'}), 'GC': functools.partial(<built-in function delivery_predicate>, {'M', 'Z', 'Q', 'V', 'G', 'J'}), 'JY': functools.partial(<built-in function delivery_predicate>, {'Z', 'U', 'H', 'M'}), 'ME': functools.partial(<built-in function delivery_predicate>, {'Z', 'U', 'H', 'M'}), 'PA': functools.partial(<built-in function delivery_predicate>, {'Z', 'U', 'H', 'M'}), 'PL': functools.partial(<built-in function delivery_predicate>, {'J', 'F', 'V', 'N'}), 'SV': functools.partial(<built-in function delivery_predicate>, {'H', 'N', 'Z', 'U', 'K'}), 'XG': functools.partial(<built-in function delivery_predicate>, {'M', 'Z', 'Q', 'V', 'G', 'J'}), 'YS': functools.partial(<built-in function delivery_predicate>, {'H', 'N', 'Z', 'U', 'K'})})

AssetFinder 是一个接口，用于访问由AssetDBWriter编写的资产元数据数据库。

该类提供了通过唯一整数 id 或符号查找资产的方法。出于历史原因，我们称这些唯一 id 为“sids”。

参数：

• engine (str or SQLAlchemy.engine) – 一个连接到资产数据库的引擎，或者可以被 SQLAlchemy 解析为 URI 的字符串。
  
• future_chain_predicates (dict) – 一个字典，将未来根符号映射到接受参数的谓词函数
  
• be (作为参数的合约并返回是否 或 不合约应该) –
  
• 链。 (包含在) –
  

另请参阅

zipline.assets.AssetDBWriter

property equities_sids

资产查找器中所有股票的 sids。

equities_sids_for_country_code(country_code)

返回给定国家的所有 sids。

参数：

country_code (str) – 一个 ISO 3166 alpha-2 国家代码。

返回：

在这个国家进行交易的 sids。

返回类型：

tuple[int]

equities_sids_for_exchange_name(exchange_name)

返回给定 exchange_name 的所有 sids。

参数：

exchange_name (str) –

返回：

其交易所位于这个国家的 sids。

返回类型：

tuple[int]

property futures_sids

资产查找器中所有期货合约的 sids。

get_supplementary_field(sid, field_name, as_of_date)

获取资产的补充字段的值。

参数：

• sid (int) – 要查询的资产的 sid。
  
• field_name (str) – 补充字段的名称。
  
• as_of_date (pd.Timestamp*,* None) – 返回该日期上的最后一个已知值。如果为 None，则仅当我们只为这个 sid 提供一个值时才返回值。如果为 None 且我们有多个值，则引发 MultipleValuesFoundForSid。
  

引发：

• NoValueForSid – 如果我们没有这个资产的值，或者在 as_of_date 时不知道值。
  
• MultipleValuesFoundForSid – 如果我们有这个资产的多个值，并且为 as_of_date 传递了 None。
  

group_by_type(sids)

按资产类型对 sids 列表进行分组。

参数：

sids (列表[整数]) –

返回：

types – 一个字典，将唯一的资产类型映射到从 sids 中提取的 sids 列表。如果我们无法查找资产，则为其分配一个 None 键。

返回类型：

字典[字符串或无 -> 列表[整数]]

lifetimes(dates, include_start_date, country_codes)

计算指定日期范围内资产 lifetimes 的 DataFrame。

参数：

• dates (pd.DatetimeIndex) – 计算 lifetimes 的日期。
  
• include_start_date (布尔值) –
  是否将资产在其 start_date 当天视为存活。
  这在回测环境中很有用，其中 lifetimes 用于表示“我是否有该资产在当天早晨的数据？”对于许多金融指标（例如每日收盘价），直到资产的第一天结束时才可获得该资产的数据。
  
• country_codes (可迭代[字符串]*) – 要获取 lifetimes 的国家代码。
  

返回：

lifetimes – 一个布尔类型的框架，日期作为索引，资产作为 Int64Index 的列。在 lifetimes.loc[date, asset]处的值为 True，当且仅当资产在 date 存在。如果 include_start_date 为 False，则当 date == asset.start_date 时，lifetimes.loc[date, asset]将为 false。

返回类型：

pd.DataFrame

另请参阅

numpy.putmask, zipline.pipeline.engine.SimplePipelineEngine._compute_root_mask

lookup_asset_types(sids)

检索一组 sids 的资产类型。

参数：

sids (列表[整数]) –

返回：

types – 提供的 sids 的资产类型。

返回类型：

字典[sid -> 字符串或无]

lookup_future_symbol(symbol)

通过符号查找未来合约。

参数：

symbol (字符串) – 所需合约的符号。

返回：

future – 由symbol引用的未来合约。

返回类型：

未来

引发：

SymbolNotFound – 当找不到名为‘symbol’的合约时引发。

lookup_generic(obj, as_of_date, country_code)

将对象转换为资产或资产序列。

此方法主要作为实现用户界面 API 的便利工具，该 API 可以处理多种输入类型。在内部代码中，如果我们已经知道输入的预期类型，则不应使用它。

参数：

• obj (整数, 字符串, Asset*,* ContinuousFuture*, 或* iterable) – 要转换为一个或多个资产的对象。整数被解释为 sids。字符串被解释为股票代码。资产和 ContinuousFutures 保持不变。
  
• as_of_date (pd.Timestamp 或 None) – 用于消除股票查找歧义的时间戳。与 lookup_symbol 中的语义相同。
  
• 国家代码 (字符串 或 None) – 用于消除股票查找歧义的 ISO-3166 国家代码。与 lookup_symbol 中的语义相同。
  

返回值：

matches, missing –

matches是转换的结果。missing是一个列表

包含任何无法解析的值。如果obj不是可迭代的，则missing将是一个空列表。

返回类型：

元组

lookup_symbol(symbol, as_of_date, fuzzy=False, country_code=None)

通过符号查找股票。

参数：

• symbol (字符串) – 要解析的股票代码。
  
• as_of_date (datetime.datetime 或 None) – 查找此符号的最后所有者，直到这个日期时间。如果as_of_date为 None，则只能解析股票，如果只有一个股票曾经拥有该股票代码。
  
• 模糊 (布尔, 可选) – 是否应使用模糊符号匹配？模糊符号匹配尝试解决股份类别表示的差异。例如，有些人可能将BRK的A股份类别表示为BRK.A，而其他人可能写成BRK_A。
  
• country_code (字符串 或 None*, 可选) – 要限制搜索的国家。如果未提供，搜索将跨越所有国家，这增加了查找含糊不清的可能性。
  

返回：

股票 – 在给定的as_of_date上持有symbol的股票，或者如果as_of_date为 None，则只有持有symbol的股票。

返回类型：

Equity

引发：

• SymbolNotFound – 当没有任何股票持有给定的符号时引发。
  
• MultipleSymbolsFound – 当没有给出as_of_date且超过一个股票持有symbol时引发。当fuzzy=True且在as_of_date上有多个给定symbol的候选时也会引发。当没有给出country_code且符号在多个国家之间含糊不清时也会引发。
  

lookup_symbols(symbols, as_of_date, fuzzy=False, country_code=None)

通过符号查找股票列表。

等效于：

[finder.lookup_symbol(s, as_of, fuzzy) for s in symbols] 

但可能更快，因为重复查找被缓存了。

参数：

• symbols (sequence*[str]*) – 要解析的 ticker 符号序列。
  
• as_of_date (pd.Timestamp) – 转发到lookup_symbol。
  
• fuzzy (bool, 可选) – 转发到lookup_symbol。
  
• country_code (str 或 None*,* 可选) – 限制搜索的国家。如果不提供，搜索将跨越所有国家，这增加了模糊查找的可能性。
  

返回：

equities

返回类型：

list[Equity]

retrieve_all(sids, default_none=False)

检索 sids 中的所有资产。

参数：

• sids (iterable of int) – 要检索的资产。
  
• default_none (bool) – 如果为 True，对于失败的查找返回 None。如果为 False，引发 SidsNotFound。
  

Zipline 3.0 中文文档（二）（4）https://developer.aliyun.com/article/1523979