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

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

交易控制

Zipline 提供交易控制以确保算法按预期执行。这些函数有助于保护算法免受意外行为的不良后果，尤其是在使用真实资金进行交易时。

zipline.api.set_do_not_order_list(self, restricted_list, on_error='fail')

设置对哪些资产可以下单的限制。

参数：

restricted_list (container**[Asset*]**,* SecurityList) – 不能下单的资产。

zipline.api.set_long_only(self, on_error='fail')

设置规则，指定此算法不能持有空头头寸。

zipline.api.set_max_leverage(self, max_leverage)

设置算法最大杠杆的限制。

参数：

max_leverage (float) – 算法的最大杠杆。如果未提供，则不会有最大值。

zipline.api.set_max_order_count(self, max_count, on_error='fail')

设置单日内可以下达的订单数量的限制。

参数：

max_count (int) – 任何单日内可以下达的最大订单数量。

zipline.api.set_max_order_size(self, asset=None, max_shares=None, max_notional=None, on_error='fail')

对为 sid 下达的任何单个订单的股票数量和/或美元价值设置限制。限制被视为绝对值，并在算法尝试为 sid 下达订单时执行。

如果算法尝试下达的订单将导致超过这些限制之一，则引发 TradingControlException。

参数：

• asset (Asset*,* optional) – 如果提供，这仅对给定资产的持仓设置守卫。
  
• max_shares (int, optional) – 一次可以订购的最大股票数量。
  
• max_notional (float, optional) – 一次可以订购的最大价值。
  

zipline.api.set_max_position_size(self, asset=None, max_shares=None, max_notional=None, on_error='fail')

为给定的 sid 设置持有的股票数量和/或美元价值的限制。这些限制被视为绝对值，并在算法尝试为 sid 下达订单时执行。这意味着由于拆分/股息，可能会持有超过最大数量的股票，并且由于价格改善，可能会持有超过最大名义价值的股票。

如果算法尝试下达的订单会导致持有的股票/美元价值绝对值超过这些限制之一，则会引发 TradingControlException。

参数：

• asset (Asset*,* optional) – 如果提供，则仅对给定资产的持仓设置警卫。
  
• max_shares (int, optional) – 对于资产持有的最大股票数量。
  
• max_notional (float, optional) – 对于资产持有的最大价值。
  

模拟参数

zipline.api.set_benchmark(self, benchmark)

设置基准资产。

参数：

benchmark (zipline.assets.Asset) – 设置为新基准的资产。

注释

对于新的基准资产，任何支付的股息都将自动再投资。

佣金模型

zipline.api.set_commission(self, us_equities=None, us_futures=None)

设置模拟的佣金模型。

参数：

• us_equities (EquityCommissionModel) – 用于交易美国股票的佣金模型。
  
• us_futures (FutureCommissionModel) – 用于交易美国期货的佣金模型。
  

注释

此函数只能在initialize()期间调用。

参见

zipline.finance.commission.PerShare，zipline.finance.commission.PerTrade，zipline.finance.commission.PerDollar

class zipline.finance.commission.CommissionModel

佣金模型的抽象基类。

佣金模型负责接受订单/交易对，并计算应向算法的账户收取的每笔交易的佣金金额。

要实现新的佣金模型，请创建CommissionModel的子类并实现calculate()。

abstract calculate(order, transaction)

计算由于transaction而对order收取的佣金金额。

参数：

• order (zipline.finance.order.Order) –
  正在处理的订单。
  订单 的 佣金 字段是一个浮点数，表示该订单已收取的佣金金额。
  
• transaction (zipline.finance.transaction.Transaction) – 正在处理的交易所。如果单个订单在给定条形图中的交易量不足以填充所请求的全部金额，则可能会产生多个交易所。
  

返回：

已收取金额 – 我们应该归因于该订单的额外佣金，以美元计。

返回类型：

浮点数

class zipline.finance.commission.PerShare(cost=0.001, min_trade_cost=0.0)

根据每股的成本计算佣金，可选择每笔交易的最低成本。

参数：

• 成本 (浮点数, 可选) – 每笔股票交易支付的佣金金额。默认是每股十分之一美分。
  
• min_trade_cost (浮点数, 可选) – 每笔交易支付的最低佣金金额。默认没有最低限制。
  

注意

这是 zipline 对股票的默认佣金模型。

class zipline.finance.commission.PerTrade(cost=0.0)

根据每笔交易的成本计算佣金。

对于需要多次填充的订单，全额佣金将收取给第一次填充。

参数：

成本 (浮点数, 可选) – 每笔股票交易支付的佣金固定金额。

class zipline.finance.commission.PerDollar(cost=0.0015)

通过应用每美元交易固定成本来计算模型佣金。

参数：

成本 (浮点数, 可选) – 每笔股票交易支付的佣金固定金额。默认是每美元交易收取 $0.0015 的佣金。

滑点模型

zipline.api.set_slippage(self, us_equities=None, us_futures=None)

设置模拟的滑点模型。

参数：

• us_equities (EquitySlippageModel) – 用于交易美国股票的滑点模型。
  
• us_futures (FutureSlippageModel) – 用于交易美国期货的滑点模型。
  

注意

此函数只能在 initialize() 期间调用。

另请参阅

zipline.finance.slippage.SlippageModel

class zipline.finance.slippage.SlippageModel

滑点模型的抽象基类。

滑点模型负责模拟期间订单填充的费率和价格。

要实现一个新的滑点模型，创建一个 SlippageModel 的子类并实现 process_order()。

process_order(data, order)

volume_for_bar

当前分钟内，对于正在填充的资产，已经完成填充的股票数量。该属性由基类自动维护。如果单个资产有多个开放订单，子类可以使用它来跟踪总填充量。

类型：

int

笔记

定义自己的构造函数的子类应在执行其他初始化之前调用super(<子类名称>, self).__init__()。

abstract process_order(data, order)

计算当前分钟内为 订单 成交的股份数量和价格。

参数：

• 数据 (zipline.protocol.BarData) – 给定条形图的数据。
  
• 订单 (zipline.finance.order.Order) – 要模拟的订单。
  

返回：

• 执行价格 (float) – 成交的价格。
  
• 执行成交量 (int) – 应成交的股份数量。必须在0和订单.金额 - 订单.已成交之间。如果成交的数量少于剩余的数量，订单将保持开放状态，并在下一分钟再次传递给此方法。
  

引发：

zipline.finance.slippage.LiquidityExceeded – 如果在当前条形图期间不应再处理当前资产的更多订单，则可能会引发。

笔记

在调用此方法之前，volume_for_bar 将设置为当前分钟内已为 订单.资产 成交的股份数量。

process_order() 在基础类中不会为没有历史成交量的条形图调用。

class zipline.finance.slippage.FixedSlippage(spread=0.0)

简单模型假设所有资产的价差固定。

参数：

价差 (float, 可选) – 假设所有资产的价差大小。买入订单将以 收盘价 + (价差 / 2) 成交。卖出订单将以 收盘价 - (价差 / 2) 成交。

笔记

该模型不对成交规模设置限制。只要在订单资产中发生任何交易活动，无论订单规模是否大于历史成交量，订单都将立即成交。

class zipline.finance.slippage.VolumeShareSlippage(volume_limit=0.025, price_impact=0.1)

将滑点建模为历史成交量百分比的二次函数。

买入订单将以以下价格成交：

price * (1 + price_impact * (volume_share ** 2)) 

卖出订单将以以下价格成交：

price * (1 - price_impact * (volume_share ** 2)) 

其中价格是条形图的收盘价，成交量份额是每分钟成交量填充的百分比，最多可达成交量限制。

参数：

• 成交量限制 (float, 可选) – 每个条形图中可以成交的历史成交量的最大百分比。0.5 表示历史成交量的 50%。1.0 表示 100%。默认值为 0.025（即，2.5%）。
  
• 价格影响 (float, 可选) – 价格影响的缩放系数。较大的值将导致更多的模拟价格影响。较小的值将导致较少的模拟价格影响。默认值为 0.1。
  

管道

更多信息，请参阅 管道 API

zipline.api.attach_pipeline(self, pipeline, name, chunks=None, eager=True)

注册一个管道，以便在每天开始时进行计算。

参数：

• pipeline (Pipeline) – 要计算的管道。
  
• name (str) – 管道的名称。
  
• chunks (int or iterator*,* optional) – 要计算管道结果的天数。增加此数字将使获取第一个结果的时间更长，但可能会改善模拟的总运行时间。如果传递了迭代器，我们将根据迭代器的值运行分块。默认值为 True。
  
• eager (bool, optional) – 是否在 before_trading_start 之前计算此管道。
  

返回：

pipeline – 返回未更改的附加管道。

返回类型：

Pipeline

另请参阅

zipline.api.pipeline_output()

zipline.api.pipeline_output(self, name)

获取由名称name附加的管道的结果。

参数：

name (str) – 要从其中获取结果的管道的名称。

返回：

results – 包含当前模拟日期请求的管道的结果的数据框。

返回类型：

pd.DataFrame

引发：

NoSuchPipeline – 当未注册具有名称 name 的管道时引发。

另请参阅

zipline.api.attach_pipeline(), zipline.pipeline.engine.PipelineEngine.run_pipeline()

杂项

zipline.api.record(self, *args, **kwargs)

每天跟踪和记录值。

参数：

**kwargs – 要记录的名称和值。

注意

这些值将出现在性能数据包和传递给analyze的性能数据框中，以及从run_algorithm()返回的性能数据框中。

zipline.api.get_environment(self, field='platform')

查询执行环境。

参数：

• field ({‘platform’**, ‘arena’**, ‘data_frequency’**, ‘start’**, ‘end’**,) –
  
• ‘capital_base’ –
  
• ‘platform’ –
  
• ‘*’} –
  
• meanings (要查询的字段。选项包括以下内容) –
  
• arena (-) – 模拟参数的竞技场。这通常将是'backtest'，但某些系统可能使用它来区分实时交易和回测。
  
• data_frequency (-) – data_frequency 告诉算法它是使用每日数据还是分钟数据运行。
  
• start (-) – 模拟的开始日期。
  
• end (-) – 模拟的结束日期。
  
• capital_base (-) – 模拟的起始资本。
  
• -platform (str) – 代码运行的平台。默认情况下，这将是字符串‘zipline’。这可以让算法知道它们是否在 Quantopian 平台上运行。
  
• ***** (-) – 返回字典中的所有字段。
  

返回:

val – 查询字段的值。有关更多信息，请参见上文。

返回类型:

任何

引发:

ValueError – 当field不是有效选项时引发。

zipline.api.fetch_csv(self, url, pre_func=None, post_func=None, date_column='date', date_format=None, timezone='UTC', symbol=None, mask=True, symbol_column=None, special_params_checker=None, country_code=None, **kwargs)

从远程 URL 获取 CSV 文件并注册数据，以便可以从data对象查询数据。

参数:

• url (str) – 要加载的 CSV 文件的 URL。
  
• pre_func (callable*[pd.DataFrame -> pd.DataFrame]**,* optional) – 一个回调函数，允许在日期解析或符号映射之前对从 fetch_csv 返回的原始数据进行预处理。
  
• post_func (callable*[pd.DataFrame -> pd.DataFrame]**,* optional) – 一个回调函数，允许在日期和符号映射后对数据进行后处理。
  
• date_column (str, optional) – 预处理数据框中包含日期时间信息以映射数据的列的名称。
  
• date_format (str, optional) – date_column中日期的格式。如果未提供，fetch_csv将尝试推断格式。有关此字符串格式的信息，请参阅pandas.read_csv()。
  
• timezone (tzinfo or str, optional) – date_column中日期时间的时区。
  
• symbol (str, optional) – 如果数据是关于新资产或指数的，则此字符串将用于在data中标识值的名称。例如，可以使用fetch_csv加载 VIX 的数据，然后此字段可以是字符串'VIX'。
  
• mask (bool, optional) – 丢弃任何无法进行符号映射的行。
  
• symbol_column (str) – 如果数据正在为每个资产附加一些新属性，则此参数是包含符号的预处理数据框中的列的名称。这将连同日期信息一起用于映射资产查找器中的 sids。
  
• country_code (str, optional) – 用于消除符号查找歧义的国家代码。
  
• **kwargs – 转发给 pandas.read_csv()。
  

返回值：

csv_data_source – 将从指定 url 拉取数据的请求源。

返回类型：

zipline.sources.requests_csv.PandasRequestsCSV

Blotters

blotter 记录了一段时间内的交易及其细节，通常是一个交易日。交易细节包括时间、价格、订单大小以及是买入还是卖出订单等信息。它通常由记录通过数据源进行的交易的贸易软件创建。

class zipline.finance.blotter.blotter.Blotter(cancel_policy=None)

batch_order(order_arg_lists)

批量下单。

参数：

order_arg_lists (iterable*[tuple]*) – 订单期望的参数元组。

返回值：

order_ids – 每个已下（或未下）订单的唯一标识符（或 None）。

返回类型：

列表[字符串 或 None]

注意

这对于 Blotter 子类来说是必需的，以便能够批量下单，而不是一次只传递一个订单请求。

abstract cancel(order_id, relay_status=True)

取消单个订单

参数：

• order_id (int) – 订单的 id
  
• relay_status (bool) – 是否记录订单状态
  

abstract cancel_all_orders_for_asset(asset, warn=False, relay_status=True)

取消给定资产的所有未结订单。

abstract get_transactions(bar_data)

根据当前未结订单、滑点模型和佣金模型创建交易列表。

参数：

bar_data (zipline._protocol.BarData) –

注意

该方法记录了 blotter 的 open_orders 字典，以便

在我们处理完所有未结订单后，它能够准确无误。

返回值：

• transactions_list (List) – transactions_list: 由当前未结订单产生的交易列表。如果没有未结订单，则返回空列表。
  
• commissions_list (List) – commissions_list: 由填充未结订单产生的佣金列表。佣金是一个具有“资产”和“成本”参数的对象。
  
• closed_orders (List) – closed_orders: 已填充的所有订单列表。
  

abstract hold(order_id, reason='')

将具有 order_id 的订单标记为‘held’。Held 在功能上类似于‘open’。当填充（全部或部分）到达时，状态将自动变回 open/filled，视情况而定。

abstract order(asset, amount, style, order_id=None)

下单。

参数：

• asset (zipline.assets.Asset) – 该订单对应的资产。
  
• 金额 (int) – 要订购的股票数量。如果 金额 为正数，这是要购买或平仓的股票数量。如果 金额 为负数，这是要卖出或做空的股票数量。
  
• 样式 (zipline.finance.execution.ExecutionStyle) – 订单的执行样式。
  
• 订单 ID (str, 可选) – 此订单的唯一标识符。
  

返回：

订单 ID – 此订单的唯一标识符，如果没有下订单，则为 None。

返回类型：

str 或 None

注意

金额 > 0：买入/平仓 金额 < 0：卖出/做空 市价单：订单（资产，金额） 限价单：订单（资产，金额，样式=限价订单（限价）） 止损单：订单（资产，金额，样式=止损订单（止损价）） 止损限价单：订单（资产，金额，样式=止损限价订单（限价，止损价））

abstract process_splits(splits)

通过修改任何未结订单来处理拆分列表。

参数：

拆分 (list) – 拆分列表。每个拆分都是一个包含（资产，比率）的元组。

返回类型：

None

abstract prune_orders(closed_orders)

从交易记录的未结订单列表中删除所有给定订单。

参数：

已关闭订单 (已关闭订单的可迭代对象) –

返回类型：

None

abstract reject(order_id, reason='')

将给定订单标记为‘拒绝’，其功能类似于取消。区别在于拒绝是强制性的（通常包括经纪人指示订单被拒绝原因的消息），而取消通常是用户驱动的。

class zipline.finance.blotter.SimulationBlotter(equity_slippage=None, future_slippage=None, equity_commission=None, future_commission=None, cancel_policy=None)

cancel(order_id, relay_status=True)

取消单个订单

参数：

• 订单 ID (int) – 订单的 ID
  
• relay_status (bool) – 是否记录订单状态
  

cancel_all_orders_for_asset(asset, warn=False, relay_status=True)

取消给定资产的所有未结订单。

get_transactions(bar_data)

根据当前的未结订单、滑点模型和佣金模型创建交易列表。

参数：

bar_data (zipline._protocol.BarData) –

注意

此方法记录交易记录的未结订单字典，以便

在我们处理完未结订单时，它是准确的。

返回：

• 交易列表 (List) – 交易列表：由当前未结订单产生的交易列表。如果没有未结订单，则返回空列表。
  
• 佣金列表 (List) – 佣金列表：由填充未结订单产生的佣金列表。佣金是一个具有“资产”和“成本”参数的对象。
  
• 已关闭订单 (List) – 已关闭订单：已填充的所有订单的列表。
  

hold(order_id, reason='')

将具有 order_id 的订单标记为‘held’。Held 功能上类似于‘open’。当填充（全部或部分）到达时，状态将自动变回 open/filled，必要时。

order(asset, amount, style, order_id=None)

下订单。

参数：

• asset (zipline.assets.Asset) – 该订单对应的资产。
  
• amount (int) – 要订购的股票数量。如果amount为正数，这是要购买或覆盖的股票数量。如果amount为负数，这是要出售或做空的股票数量。
  
• style (zipline.finance.execution.ExecutionStyle) – 订单的执行风格。
  
• order_id (str, optional) – 该订单的唯一标识符。
  

返回：

order_id – 该订单的唯一标识符，如果没有下订单，则为 None。

返回类型：

str或 None

笔记

amount > 0 :: 买入/覆盖 金额 < 0 :: 卖出/做空 市价单：order(asset, amount) 限价单：order(asset, amount, style=LimitOrder(limit_price)) 止损单：order(asset, amount, style=StopOrder(stop_price)) 止损限价单：order(asset, amount, style=StopLimitOrder(limit_price, stop_price))

process_splits(splits)

处理一系列拆分，根据需要修改任何未完成订单。

参数：

splits (list) – 拆分列表。每个拆分是一个(资产, 比率)的元组。

返回类型：

无

prune_orders(closed_orders)

从 blotter 的 open_orders 列表中删除所有给定订单。

参数：

closed_orders (iterable of 已关闭的订单) –

返回类型：

无

reject(order_id, reason='')

将给定订单标记为‘rejected’，其功能类似于取消。区别在于，拒绝是非自愿的（通常包含经纪人指示订单被拒绝原因的消息），而取消通常是用户驱动的。

管道 API

Pipeline通过在回测期间优化因子的计算，实现了更快速和更节省内存的执行。

class zipline.pipeline.Pipeline(columns=None, screen=None, domain=GENERIC)

管道对象表示一组要由管道引擎编译和执行的命名表达式。

管道有两个重要属性：‘columns’，一个命名Term实例的字典，和‘screen’，一个Filter，表示将资产包含在管道结果中的标准。

要在 TradingAlgorithm 的上下文中计算管道，用户必须在initialize函数中调用attach_pipeline来注册该管道应在每个交易日进行计算。可以通过从handle_data、before_trading_start或计划函数调用pipeline_output来检索附加管道的最新输出。

参数：

• 列（dict, 可选） – 初始列。
  
• 屏幕（zipline.pipeline.Filter*,* 可选） – 初始屏幕。
  

add(term, name, overwrite=False)

添加一列。

计算term的结果将作为一列显示在运行此管道生成的 DataFrame 中。

参数：

• 列（zipline.pipeline.Term） – 要添加到管道中的过滤器、因子或分类器。
  
• 名称（str) – 要添加的列的名称。
  
• 覆盖（bool) – 如果已经有一个名为 name 的列，是否覆盖现有条目。
  

domain(default)

获取此管道的域。

• 如果在构造时提供了显式域，则使用它。
  
• 否则，从已注册的列中推断出一个域。
  
• 如果无法推断出域，则返回默认。
  

参数：

默认（zipline.pipeline.domain.Domain） – 如果无法通过此管道本身推断出域，则使用的域。

返回：

域 – 管道的域。

返回类型：

zipline.pipeline.domain.Domain

引发：

• AmbiguousDomain –
  
• ValueError – 如果self中的项与 self._domain 冲突。
  

remove(name)

移除一列。

参数：

名称（str) – 要移除的列的名称。

引发：

KeyError – 如果名称不在 self.columns 中。

返回：

已移除 – 已移除的项。

返回类型：

zipline.pipeline.Term

set_screen(screen, overwrite=False)

在此 Pipeline 上设置一个屏幕。

参数：

• 过滤器（zipline.pipeline.Filter） – 要作为屏幕应用的过滤器。
  
• 覆盖（bool) – 是否覆盖任何现有的屏幕。如果覆盖为 False 且 self.screen 不为 None，我们将引发错误。
  

show_graph(format='svg')

将此 Pipeline 渲染为 DAG。

参数：

格式（{‘svg’,* ‘png’,* ‘jpeg’}） – 要渲染的图像格式。默认值为‘svg’。

to_execution_plan(domain, default_screen, start_date, end_date)

编译为 ExecutionPlan。

参数：

• 域（zipline.pipeline.domain.Domain） – 管道将在其上执行的域。
  
• default_screen (zipline.pipeline.Term) – 如果 self.screen 为 None，则使用作为筛选条件的项。
  
• all_dates (pd.DatetimeIndex) – 用于计算每个项的起始和结束的日期日历。
  
• start_date (pd.Timestamp) – 所需输出的第一个日期。
  
• end_date (pd.Timestamp) – 所需输出的最后一个日期。
  

返回：

graph – 编码项依赖关系的图，包括有关额外行要求的元数据。

返回类型：

zipline.pipeline.graph.ExecutionPlan

to_simple_graph(default_screen)

编译成一个没有额外行元数据的简单 TermGraph。

参数：

default_screen (zipline.pipeline.Term) – 如果 self.screen 为 None，则使用作为筛选条件的项。

返回：

graph – 编码项依赖关系的图。

返回类型：

zipline.pipeline.graph.TermGraph

property columns

此管道的输出列。

返回：

columns – 从列名到计算该列输出的表达式的映射。

返回类型：

dict[str, zipline.pipeline.ComputableTerm]

property screen

此管道的筛选条件。

返回：

screen – 定义此管道筛选条件的项。如果 screen 是一个筛选器，则不通过筛选器的行（即，对于该行，筛选器计算结果为 False）将从该管道的输出中删除，然后再返回结果。

返回类型：

zipline.pipeline.Filter 或 None

注意

在 Pipeline 上设置筛选条件不会改变任何行的值：它只影响是否返回给定行。使用筛选条件计算管道的逻辑等效于不使用筛选条件计算管道，然后作为后处理步骤，过滤掉任何计算结果为 False 的行。

用户定义因子的基类。

参数：

• inputs (iterable*,* 可选) – BoundColumn 实例的可迭代对象（例如 USEquityPricing.close），描述要加载并传递给 self.compute 的数据。如果未将此参数传递给 CustomFactor 构造函数，我们将查找名为 inputs 的类级属性。
  
• outputs (iterable*[str]**,* 可选) – 表示此因子应计算并返回的每个输出的名称的字符串的可迭代对象。如果未将此参数传递给 CustomFactor 构造函数，我们将查找名为 outputs 的类级属性。
  
• window_length (int, 可选) – 每个输入要传递的行数。如果未将此参数传递给 CustomFactor 构造函数，我们将查找名为 window_length 的类级属性。
  
• mask（zipline.pipeline.Filter，可选）– 一个过滤器，描述我们应该在哪些资产上每天进行计算。每次调用CustomFactor.compute将只接收在调用compute的日期上mask产生 True 的资产。
  

笔记

实现自己的因子的用户应该继承 CustomFactor 并实现一个名为 compute 的方法，其签名如下：

def compute(self, today, assets, out, *inputs):
   ... 

在每个模拟日期，compute将被调用，传递当前日期、一个 sid 数组、一个输出数组以及一个输入数组，每个表达式作为输入传递给 CustomFactor 构造函数。

传递给compute的值的具体类型如下：

today : np.datetime64[ns]
    Row label for the last row of all arrays passed as `inputs`.
assets : np.array[int64, ndim=1]
    Column labels for `out` and`inputs`.
out : np.array[self.dtype, ndim=1]
    Output array of the same shape as `assets`.  `compute` should write
    its desired return values into `out`. If multiple outputs are
    specified, `compute` should write its desired return values into
    `out.<output_name>` for each output name in `self.outputs`.
*inputs : tuple of np.array
    Raw data arrays corresponding to the values of `self.inputs`. 

compute函数应该预期会传递 NaN 值，这些值代表在某个资产没有可用数据的日期。这可能包括资产尚未存在的日期。

例如，如果一个 CustomFactor 需要 10 行收盘价数据，而资产 A 从 2014 年 6 月 2 日星期一开始交易，那么在 2014 年 6 月 3 日星期二，资产 A 的输入数据列将会有 9 个领先的 NaN 值，因为这些日期的数据尚未可用。

示例

具有预先声明默认值的 CustomFactor：

class TenDayRange(CustomFactor):
  """
 Computes the difference between the highest high in the last 10
 days and the lowest low.
 Pre-declares high and low as default inputs and `window_length` as
 10.
 """
    inputs = [USEquityPricing.high, USEquityPricing.low]
    window_length = 10
    def compute(self, today, assets, out, highs, lows):
        from numpy import nanmin, nanmax
        highest_highs = nanmax(highs, axis=0)
        lowest_lows = nanmin(lows, axis=0)
        out[:] = highest_highs - lowest_lows
# Doesn't require passing inputs or window_length because they're
# pre-declared as defaults for the TenDayRange class.
ten_day_range = TenDayRange() 

没有默认值的 CustomFactor：

class MedianValue(CustomFactor):
  """
 Computes the median value of an arbitrary single input over an
 arbitrary window..
 Does not declare any defaults, so values for `window_length` and
 `inputs` must be passed explicitly on every construction.
 """
    def compute(self, today, assets, out, data):
        from numpy import nanmedian
        out[:] = data.nanmedian(data, axis=0)
# Values for `inputs` and `window_length` must be passed explicitly to
# MedianValue.
median_close10 = MedianValue([USEquityPricing.close], window_length=10)
median_low15 = MedianValue([USEquityPricing.low], window_length=15) 

具有多个输出的 CustomFactor：

class MultipleOutputs(CustomFactor):
    inputs = [USEquityPricing.close]
    outputs = ['alpha', 'beta']
    window_length = N
    def compute(self, today, assets, out, close):
        computed_alpha, computed_beta = some_function(close)
        out.alpha[:] = computed_alpha
        out.beta[:] = computed_beta
# Each output is returned as its own Factor upon instantiation.
alpha, beta = MultipleOutputs()
# Equivalently, we can create a single factor instance and access each
# output as an attribute of that instance.
multiple_outputs = MultipleOutputs()
alpha = multiple_outputs.alpha
beta = multiple_outputs.beta 

注意：如果一个 CustomFactor 有多个输出，所有输出必须具有相同的 dtype。例如，在上面的例子中，如果 alpha 是浮点数，那么 beta 也必须是浮点数。

dtype = dtype('float64')

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

计算布尔输出的管道表达式。

过滤器最常用于描述要包含或排除的资产集合，以用于特定目的。许多 Pipeline API 函数接受一个mask参数，该参数可以提供一个过滤器，指示只有通过过滤器的值才应被考虑用于请求的计算。例如，zipline.pipeline.Factor.top()接受一个掩码，指示只应在通过指定过滤器的资产上计算排名。

构建过滤器最常见的方法之一是通过比较运算符（<，<=，!=，eq，>，>=）之一。例如，一个自然的方式来构建一个过滤器，对于 10 天加权平均价格小于$20.0 的股票，首先构建一个计算 10 天加权平均价格的因子，然后将其与标量值 20.0 进行比较：

>>> from zipline.pipeline.factors import VWAP
>>> vwap_10 = VWAP(window_length=10)
>>> vwaps_under_20 = (vwap_10 <= 20) 

过滤器也可以通过两个因子之间的比较来构造。例如，要构造一个过滤器，对于资产/日期对，其中资产的 10 天加权平均价格大于其 30 天加权平均价格，则产生 True：

>>> short_vwap = VWAP(window_length=10)
>>> long_vwap = VWAP(window_length=30)
>>> higher_short_vwap = (short_vwap > long_vwap) 

过滤器可以通过&（与）和|（或）运算符组合。

&两个过滤器组合产生一个新的过滤器，如果两个输入都产生 True，则新过滤器产生 True。

|两个过滤器组合产生一个新的过滤器，如果任何一个输入产生 True，则新过滤器产生 True。

~运算符可用于反转过滤器，将所有 True 值与 Falses 互换。

过滤器可以作为screen属性设置在管道中，指示应排除过滤器产生 False 的资产/日期对。这既有助于减少管道输出的噪声，也有助于减少管道结果的内存消耗。

__and__(other)

二进制运算符：‘&’

__or__(other)

二进制运算符：‘|’

if_else(if_true, if_false)

创建一个从两个选择中选择值的项。

参数：

• if_true (zipline.pipeline.term.ComputableTerm) – 在过滤器输出 True 的位置应使用的表达式的值。
  
• if_false (zipline.pipeline.term.ComputableTerm) – 在过滤器输出 False 的位置应使用的表达式的值。
  

返回值：

merged – 一个项，根据self产生的值从if_true或if_false中取值进行计算。

返回的项在self产生 True 的位置从if_true取值，在self产生 False 的位置从if_false取值。

返回类型：

zipline.pipeline.term.ComputableTerm

示例

设f为产生以下输出的因子：

AAPL   MSFT    MCD     BK
2017-03-13    1.0    2.0    3.0    4.0
2017-03-14    5.0    6.0    7.0    8.0 

设g为另一个产生以下输出的因子：

AAPL   MSFT    MCD     BK
2017-03-13   10.0   20.0   30.0   40.0
2017-03-14   50.0   60.0   70.0   80.0 

最后，设condition为产生以下输出的过滤器：

AAPL   MSFT    MCD     BK
2017-03-13   True  False   True  False
2017-03-14   True   True  False  False 

那么，表达式condition.if_else(f, g)产生以下输出：

AAPL   MSFT    MCD     BK
2017-03-13    1.0   20.0    3.0   40.0
2017-03-14    5.0    6.0   70.0   80.0 

另请参阅

numpy.where， Factor.fillna

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

管道 API 表达式，产生数值或日期值输出。

因子是最常用的管道项，代表任何产生数值结果的计算结果。

因子可以通过任何内置数学运算符（+，-，*等）与其他因子以及标量值组合。

这使得编写结合多个因子的复杂表达式变得容易。例如，构建一个计算两个其他因子平均值的因子非常简单：

>>> f1 = SomeFactor(...)  
>>> f2 = SomeOtherFactor(...)  
>>> average = (f1 + f2) / 2.0 

因子还可以通过比较运算符转换为zipline.pipeline.Filter对象：（<，<=，!=，eq，>，>=）。

除了基本的数值运算符外，因子还定义了许多自然运算符。这些包括识别缺失或极端值输出的方法（isnull()，notnull()，isnan()，notnan()），输出归一化的方法（rank()，demean()，zscore()），以及基于结果的秩次序属性构建过滤器的方法（top()，bottom()，percentile_between()）。

eq(other)

构建一个Filter，计算self == other。

参数：

其他（zipline.pipeline.Factor，float） – 表达式的右侧。

返回：

filter – 过滤器，计算self == other，使用self和other的输出。

返回类型：

zipline.pipeline.Filter

demean(mask=sentinel('NotSpecified'), groupby=sentinel('NotSpecified'))

构建一个因子，计算self并从结果的每一行中减去均值。

如果提供了mask，则在计算行均值时忽略mask返回 False 的值，并在mask为 False 的任何地方输出 NaN。

如果提供了groupby，则根据groupby产生的值对每一行进行分区，去均值分区数组，并将子结果重新组合。

参数：

• mask（zipline.pipeline.Filter，可选） – 一个过滤器，定义了计算均值时忽略的值。
  
• groupby（zipline.pipeline.Classifier，可选） – 一个分类器，定义了计算均值的分区。
  

示例

设f为一个因子，将产生以下输出：

AAPL   MSFT    MCD     BK
2017-03-13    1.0    2.0    3.0    4.0
2017-03-14    1.5    2.5    3.5    1.0
2017-03-15    2.0    3.0    4.0    1.5
2017-03-16    2.5    3.5    1.0    2.0 

设c为一个分类器，产生以下输出：

AAPL   MSFT    MCD     BK
2017-03-13      1      1      2      2
2017-03-14      1      1      2      2
2017-03-15      1      1      2      2
2017-03-16      1      1      2      2 

设m为一个过滤器，产生以下输出：

AAPL   MSFT    MCD     BK
2017-03-13  False   True   True   True
2017-03-14   True  False   True   True
2017-03-15   True   True  False   True
2017-03-16   True   True   True  False 

那么f.demean()将从f产生的每一行中减去均值。

AAPL   MSFT    MCD     BK
2017-03-13 -1.500 -0.500  0.500  1.500
2017-03-14 -0.625  0.375  1.375 -1.125
2017-03-15 -0.625  0.375  1.375 -1.125
2017-03-16  0.250  1.250 -1.250 -0.250 

f.demean(mask=m)将从每一行中减去均值，但均值计算将忽略对角线上的值，并在输出中将对角线上的值写为 NaN。对角线上的值被忽略，因为它们是m产生 False 的位置。

AAPL   MSFT    MCD     BK
2017-03-13    NaN -1.000  0.000  1.000
2017-03-14 -0.500    NaN  1.500 -1.000
2017-03-15 -0.166  0.833    NaN -0.666
2017-03-16  0.166  1.166 -1.333    NaN 

f.demean(groupby=c)将从 AAPL/MSFT 和 MCD/BK 的相应条目中减去它们的组均值。AAPL/MSFT 被分组在一起，因为这两个资产在分类器c的输出中总是产生 1。同样，MCD/BK 被分组在一起，因为它们总是产生 2。

AAPL   MSFT    MCD     BK
2017-03-13 -0.500  0.500 -0.500  0.500
2017-03-14 -0.500  0.500  1.250 -1.250
2017-03-15 -0.500  0.500  1.250 -1.250
2017-03-16 -0.500  0.500 -0.500  0.500 

f.demean(mask=m, groupby=c) 也会减去 AAPL/MSFT 和 MCD/BK 的组均值，但计算均值时会忽略对角线上的值，并在输出中将对角线上的值写为 NaN。

AAPL   MSFT    MCD     BK
2017-03-13    NaN  0.000 -0.500  0.500
2017-03-14  0.000    NaN  1.250 -1.250
2017-03-15 -0.500  0.500    NaN  0.000
2017-03-16 -0.500  0.500  0.000    NaN 

注意

均值对异常值的大小很敏感。在处理可能产生较大异常值的因素时，使用mask参数来排除分布极端的值通常很有用：

>>> base = MyFactor(...)  
>>> normalized = base.demean(
...     mask=base.percentile_between(1, 99),
... ) 

demean() 仅支持 dtype 为 float64 的因素。

另请参阅

pandas.DataFrame.groupby()

zscore(mask=sentinel('NotSpecified'), groupby=sentinel('NotSpecified'))

构建一个对每天的结果进行 Z 分数标准化的因素。

行的 Z 分数定义为：

(row - row.mean()) / row.stddev() 

如果提供了mask，则在计算行均值和标准差时忽略mask返回 False 的值，并在mask为 False 的任何地方输出 NaN。

如果提供了groupby，则根据groupby生成的值对每行进行分区，对分区数组进行 z 分数标准化，并将子结果重新组合起来。

参数：

• mask（zipline.pipeline.Filter*,* 可选) – 定义在计算 Z 分数时要忽略的值的过滤器。
  
• groupby（zipline.pipeline.Classifier*,* 可选) – 定义用于计算 Z 分数的分区的分类器。
  

返回：

zscored – 一个对自身输出进行 Z 分数标准化的因素。

返回类型：

zipline.pipeline.Factor

注意

均值和标准差对异常值的大小很敏感。在处理可能产生较大异常值的因素时，使用mask参数来排除分布极端的值通常很有用：

>>> base = MyFactor(...)  
>>> normalized = base.zscore(
...    mask=base.percentile_between(1, 99),
... ) 

zscore() 仅支持 dtype 为 float64 的因素。

示例

请参阅demean() 以获取关于mask和groupby的语义的深入示例。

另请参阅

pandas.DataFrame.groupby()

rank(method='ordinal', ascending=True, mask=sentinel('NotSpecified'), groupby=sentinel('NotSpecified'))

构建一个新的因素，表示每行内各列的排序排名。

参数：

• 方法（str, {‘ordinal’**, ‘min’**, ‘max’**, ‘dense’**, ‘average’}) – 用于给相同元素分配排名的方法。请参阅 scipy.stats.rankdata 以获取每种排名方法的完整描述。默认值为‘ordinal’。
  
• 升序（bool, 可选) – 是否以升序或降序返回排序后的排名。默认值为 True。
  
• 掩码 (zipline.pipeline.Filter*,* 可选) – 表示在计算排名时要考虑的资产的过滤器。如果提供了掩码，则在计算排名时忽略掩码产生 False 值的任何资产/日期对。
  
• groupby (zipline.pipeline.Classifier*,* 可选) – 定义排序的分类器。
  

返回：

排名 – 将计算由 self 生成的数据排名的新的因子。

返回类型：

zipline.pipeline.Factor

注意

方法的默认值与 scipy.stats.rankdata 的默认值不同。请参阅该函数的文档以获取方法的有效输入的完整描述。

在给定日期的缺失或不存在数据将导致资产在该日获得 NaN 排名。

另请参阅

scipy.stats.rankdata()

pearsonr(target, correlation_length, mask=sentinel('NotSpecified'))

构造一个新的因子，计算目标与self的列之间的滚动皮尔逊相关系数。

参数：

• 目标 (zipline.pipeline.Term) – 用于计算与 self 生成的每个数据列的相关性的术语。这可以是因子、BoundColumn 或切片。如果目标为二维，则按资产计算相关性。
  
• 相关长度 (int) – 计算每个相关系数的回溯窗口的长度。
  
• 掩码 (zipline.pipeline.Filter*,* 可选) – 描述每天应计算与目标切片相关性的资产的过滤器。
  

返回：

相关性 – 将计算目标与self的列之间的相关性的新因子。

返回类型：

zipline.pipeline.Factor

注意

此方法只能在对作为窗口化Factor对象输入安全的表达式上调用。此类表达式的示例包括BoundColumn Returns以及从rank()或zscore()创建的任何因子。

示例

假设我们想要创建一个因子，计算 AAPL 的 10 天回报与所有其他资产的 10 天回报之间的相关性，每个相关性计算超过 30 天。这可以通过以下方式实现：

returns = Returns(window_length=10)
returns_slice = returns[sid(24)]
aapl_correlations = returns.pearsonr(
    target=returns_slice, correlation_length=30,
) 

这等效于执行：

aapl_correlations = RollingPearsonOfReturns(
    target=sid(24), returns_length=10, correlation_length=30,
) 

另请参阅

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

spearmanr(target, correlation_length, mask=sentinel('NotSpecified'))

构建一个新的因子，计算target与self列之间的滚动 spearman 等级相关系数。

参数：

• target (zipline.pipeline.Term) – 用于计算与self产生的每个数据列相关性的术语。这可能是一个因子、一个 BoundColumn 或一个切片。如果目标是一个二维的，相关性是按资产计算的。
  
• correlation_length (int) – 计算每个相关系数的回溯窗口长度。
  
• mask (zipline.pipeline.Filter*,* optional) – 一个 Filter，描述了哪些资产应该每天计算其与目标切片的相关性。
  

返回：

correlations – 一个新的因子，将计算target与self列之间的相关性。

返回类型：

zipline.pipeline.Factor

注意

此方法仅能用于被认为是安全的、可作为窗口化Factor对象输入的表达式。此类表达式的例子包括BoundColumn Returns以及由rank()或zscore()创建的任何因子。

示例

假设我们想要创建一个因子，计算 AAPL 的 10 天回报率与所有其他资产的 10 天回报率之间的相关性，每个相关性计算周期为 30 天。这可以通过以下步骤实现：

returns = Returns(window_length=10)
returns_slice = returns[sid(24)]
aapl_correlations = returns.spearmanr(
    target=returns_slice, correlation_length=30,
) 

这相当于执行以下操作：

aapl_correlations = RollingSpearmanOfReturns(
    target=sid(24), returns_length=10, correlation_length=30,
) 

另请参阅

scipy.stats.spearmanr(), Factor.pearsonr()

linear_regression(target, regression_length, mask=sentinel('NotSpecified'))

构建一个新的因子，执行从目标预测self列的普通最小二乘回归。

参数：

• target (zipline.pipeline.Term) – 在每个回归中用作预测器/自变量的术语。这可能是一个因子、一个 BoundColumn 或一个切片。如果目标是一个二维的，回归是按资产计算的。
  
• regression_length (int) – 用于计算每个回归的回溯窗口长度。
  
• mask (zipline.pipeline.Filter*,* 可选) – 描述每天应与目标切片进行回归的资产的过滤器。
  

返回：

regressions – 一个新因子，将计算目标与自身列的线性回归。

返回类型：

zipline.pipeline.Factor

注意

此方法只能在对作为窗口化Factor对象输入使用的表达式被认为是安全的情况下调用。此类表达式的例子包括BoundColumn Returns以及任何由rank()或zscore()创建的因子。

示例

假设我们想要创建一个因子，该因子将 AAPL 的 10 天回报率与所有其他资产的 10 天回报率进行回归，每个回归计算周期为 30 天。这可以通过以下步骤实现：

returns = Returns(window_length=10)
returns_slice = returns[sid(24)]
aapl_regressions = returns.linear_regression(
    target=returns_slice, regression_length=30,
) 

这等效于执行以下操作：

aapl_regressions = RollingLinearRegressionOfReturns(
    target=sid(24), returns_length=10, regression_length=30,
) 

另请参阅

scipy.stats.linregress()

winsorize(min_percentile, max_percentile, mask=sentinel('NotSpecified'), groupby=sentinel('NotSpecified'))

构建一个新的因子，该因子对由此因子得到的结果进行截尾。

截尾改变排名低于最小百分位的值为最小百分位的值。同样，排名高于最大百分位的值被改变为最大百分位的值。

截尾对于限制极端数据点的影响而不完全移除这些点是有用的。

如果提供了mask，则在计算百分位数截止点时忽略mask返回 False 的值，并在mask为 False 的任何地方输出 NaN。

如果提供了groupby，则将截尾分别应用于由groupby定义的每个组。

参数：

• min_percentile (float, int) – 值位于或低于此百分位的条目将被替换为第(len(input) * min_percentile)个最低值。如果不应剪辑低值，请使用 0。
  
• max_percentile (float, int) – 值位于或高于此百分位的条目将被替换为第(len(input) * max_percentile)个最低值。如果不应剪辑高值，请使用 1。
  
• mask (zipline.pipeline.Filter*,* optional) – 定义在截尾时要忽略的值的过滤器。
  
• groupby (zipline.pipeline.Classifier*,* optional) – 定义截尾分区的分类器。
  

返回：

winsorized – 一个因子，产生一个经过截尾处理的自我版本。

返回类型：

zipline.pipeline.Factor

示例

price = USEquityPricing.close.latest
columns={
    'PRICE': price,
    'WINSOR_1: price.winsorize(
        min_percentile=0.25, max_percentile=0.75
    ),
    'WINSOR_2': price.winsorize(
        min_percentile=0.50, max_percentile=1.0
    ),
    'WINSOR_3': price.winsorize(
        min_percentile=0.0, max_percentile=0.5
    ),
} 

给定一个具有上述定义的列的管道，对于给定的一天，结果可能看起来像：

'PRICE' 'WINSOR_1' 'WINSOR_2' 'WINSOR_3'
Asset_1    1        2          4          3
Asset_2    2        2          4          3
Asset_3    3        3          4          3
Asset_4    4        4          4          4
Asset_5    5        5          5          4
Asset_6    6        5          5          4 

另请参阅

scipy.stats.mstats.winsorize(), pandas.DataFrame.groupby()

quantiles(bins, mask=sentinel('NotSpecified'))

构建一个计算self输出分位数的分类器。

对于每个非 NaN 数据点，输出都标有一个从 0 到（bins - 1）的整数值。NaN 数据点标有-1。

如果提供了mask，则在mask产生 False 的位置忽略数据点，并在这些位置发出-1 的标签。

参数：

• bins (int) – 要计算的标签的箱数。
  
• mask (zipline.pipeline.Filter*,* optional) – 计算分位数时忽略的值的掩码。
  

返回：

分位数 – 一个分类器，产生从 0 到（bins - 1）的整数标签。

返回类型：

zipline.pipeline.Classifier

quartiles(mask=sentinel('NotSpecified'))

构建一个在self输出上计算四分位数的分类器。

对于每个非 NaN 数据点，输出都标有一个值，分别为 0、1、2 或 3，对应于每行中的第一、第二、第三或第四四分位数。NaN 数据点标有-1。

如果提供了mask，则在mask产生 False 的位置忽略数据点，并在这些位置发出-1 的标签。

参数：

mask (zipline.pipeline.Filter*,* optional) – 计算四分位数时忽略的值的掩码。

返回：

四分位数 – 一个分类器，产生从 0 到 3 的整数标签。

返回类型：

zipline.pipeline.Classifier

quintiles(mask=sentinel('NotSpecified'))

构建一个在self上计算五分位数标签的分类器。

对于每个非 NaN 数据点，输出都标有一个值，分别为 0、1、2 或 3、4，对应于每行中的五分位数。NaN 数据点标有-1。

如果提供了mask，则在mask产生 False 的位置忽略数据点，并在这些位置发出-1 的标签。

参数：

mask (zipline.pipeline.Filter*,* optional) – 计算五分位数时忽略的值的掩码。

返回：

五分位数 – 一个分类器，产生从 0 到 4 的整数标签。

返回类型：

zipline.pipeline.Classifier

deciles(mask=sentinel('NotSpecified'))

构造一个分类器，计算self的十分位标签。

输出中的每个非 NaN 数据点都标有一个从 0 到 9 的值，对应于每行的十分位数。NaN 数据点标记为-1。

如果提供了mask，则在mask产生 False 的位置忽略数据点，并在这些位置发出-1 的标签。

参数：

mask (zipline.pipeline.Filter*,* 可选) – 计算十分位数时要忽略的值的掩码。

返回：

deciles – 产生从 0 到 9 的整数标签的分类器。

返回类型：

zipline.pipeline.Classifier

top(N, mask=sentinel('NotSpecified'), groupby=sentinel('NotSpecified'))

构造一个过滤器，匹配每天自身资产值的最高 N 个。

如果提供了groupby，则返回一个过滤器，匹配每个组的最高 N 个资产值。

参数：

• N (int) – 每天通过返回的过滤器的资产数量。
  
• mask (zipline.pipeline.Filter*,* 可选) – 表示计算排名时要考虑的资产的过滤器。如果提供了 mask，则在计算最高值时忽略 mask 产生 False 的任何资产/日期对。
  
• groupby (zipline.pipeline.Classifier, 可选) – 定义排序分区的一个分类器。
  

返回：

filter

返回类型：

zipline.pipeline.Filter

bottom(N, mask=sentinel('NotSpecified'), groupby=sentinel('NotSpecified'))

构造一个过滤器，匹配每天自身资产值的最低 N 个。

如果提供了groupby，则返回一个过滤器，匹配groupby定义的每个组的最低 N 个资产值。

参数：

• N (int) – 每天通过返回的过滤器的资产数量。
  
• mask (zipline.pipeline.Filter*,* 可选) – 表示计算排名时要考虑的资产的过滤器。如果提供了 mask，则在计算最低值时忽略 mask 产生 False 的任何资产/日期对。
  
• groupby (zipline.pipeline.Classifier, 可选) – 定义排序分区的一个分类器。
  

返回：

filter

返回类型：

zipline.pipeline.Filter

percentile_between(min_percentile, max_percentile, mask=sentinel('NotSpecified'))

构造一个过滤器，匹配自身值落在min_percentile和max_percentile定义范围内的值。

参数：

• min_percentile (float [0.0, 100.0*]*) – 对于数据中高于此百分位的资产返回 True。
  
• max_percentile (float [0.0, 100.0*]*) – 对于数据中低于此百分位的资产返回 True。
  
• 掩码 (zipline.pipeline.Filter*,* 可选) – 表示在计算百分位阈值时要考虑的资产的过滤器。如果提供了掩码，则每天仅使用掩码返回 True 的资产来计算百分位截止点。对于掩码产生 False 的资产，此因子的输出也将产生 False。
  

返回：

out – 将计算指定百分位范围掩码的新过滤器。

返回类型：

zipline.pipeline.Filter

isnan()

对于此因子中所有 NaN 值，产生 True 的过滤器。

返回：

nanfilter

返回类型：

zipline.pipeline.Filter

notnan()

对于此因子中非 NaN 的值，产生 True 的过滤器。

返回：

nanfilter

返回类型：

zipline.pipeline.Filter

isfinite()

对于此因子中除 NaN、inf 或-inf 之外的任何值，产生 True 的过滤器。

clip(min_bound, max_bound, mask=sentinel('NotSpecified'))

剪裁（限制）因子中的值。

给定一个区间，区间外的值被剪裁到区间边缘。例如，如果指定了[0, 1]的区间，小于 0 的值变为 0，大于 1 的值变为 1。

参数：

• 最小边界 (浮点数) – 使用的最小值。
  
• 最大边界 (浮点数) – 使用的最大值。
  
• 掩码 (zipline.pipeline.Filter*,* 可选) – 表示在剪裁时要考虑的资产的过滤器。
  

注意

若只想在一侧剪裁值，可以传递-np.inf和np.inf。例如，只想剪裁最大值而不剪裁最小值：

factor.clip(min_bound=-np.inf, max_bound=user_provided_max) 

另请参阅

numpy.clip

clip(min_bound, max_bound, mask=sentinel('NotSpecified'))

剪裁（限制）因子中的值。

给定一个区间，区间外的值被剪裁到区间边缘。例如，如果指定了[0, 1]的区间，小于 0 的值变为 0，大于 1 的值变为 1。

参数：

• 最小边界 (浮点数) – 使用的最小值。
  
• 最大边界 (浮点数) – 使用的最大值。
  
• 掩码 (zipline.pipeline.Filter*,* 可选) – 表示在剪裁时要考虑的资产的过滤器。
  

注意

若只想在一侧剪裁值，可以传递-np.inf和np.inf。例如，只想剪裁最大值而不剪裁最小值：

factor.clip(min_bound=-np.inf, max_bound=user_provided_max) 

另请参阅

numpy.clip

__add__(other)

构建一个因子，计算self + other。

参数：

其他 (zipline.pipeline.Factor*,* 浮点数) – 表达式的右侧。

返回：

因子 – 计算self + other的因子，输出self和other的结果。

返回类型：

zipline.pipeline.Factor

__sub__(other)

构建一个因子，计算self - other。

参数：

其他 (zipline.pipeline.Factor*,* 浮点数) – 表达式的右侧。

返回：

因子 – 计算self - other的因子，输出self和other的结果。

返回类型：

zipline.pipeline.Factor

__mul__(other)

构建一个因子，计算self * other。

参数：

其他 (zipline.pipeline.Factor*,* 浮点数) – 表达式的右侧。

返回：

因子 – 计算self * other的因子，输出self和other的结果。

返回类型：

zipline.pipeline.Factor

__div__(other)

构建一个因子，计算self / other。

参数：

其他 (zipline.pipeline.Factor*,* 浮点数) – 表达式的右侧。

返回：

因子 – 计算self / other的因子，输出self和other的结果。

返回类型：

zipline.pipeline.Factor

__mod__(other)

构建一个因子，计算self % other。

参数：

其他 (zipline.pipeline.Factor*,* 浮点数) – 表达式的右侧。

返回：

因子 – 计算self % other的因子，输出self和other的结果。

返回类型：

zipline.pipeline.Factor

__pow__(other)

构建一个因子，计算self ** other。

参数：

其他 (zipline.pipeline.Factor*,* 浮点数) – 表达式的右侧。

返回：

因子 – 计算self ** other的因子，输出self和other的结果。

返回类型：

zipline.pipeline.Factor

__lt__(other)

构建一个计算self < other的Filter。

参数：

other (zipline.pipeline.Factor*,* float) – 表达式的右侧。

返回：

过滤器 – 计算self < other的过滤器，使用self和other的输出结果。

返回类型：

zipline.pipeline.Filter

__le__(other)

构建一个计算self <= other的Filter。

参数：

other (zipline.pipeline.Factor*,* float) – 表达式的右侧。

返回：

过滤器 – 计算self <= other的过滤器，使用self和other的输出结果。

返回类型：

zipline.pipeline.Filter

__ne__(other)

构建一个计算self != other的Filter。

参数：

other (zipline.pipeline.Factor*,* float) – 表达式的右侧。

返回：

过滤器 – 计算self != other的过滤器，使用self和other的输出结果。

返回类型：

zipline.pipeline.Filter

__ge__(other)

构建一个计算self >= other的Filter。

参数：

other (zipline.pipeline.Factor*,* float) – 表达式的右侧。

返回：

过滤器 – 计算self >= other的过滤器，使用self和other的输出结果。

返回类型：

zipline.pipeline.Filter

__gt__(other)

构建一个计算self > other的Filter。

参数：

other (zipline.pipeline.Factor*,* float) – 表达式的右侧。

返回：

过滤器 – 计算self > other的过滤器，使用self和other的输出结果。

返回类型：

zipline.pipeline.Filter

fillna(fill_value)

创建一个新项，该项用fill_value填充此项输出的缺失值。

参数：

fill_value (zipline.pipeline.ComputableTerm*, or* object.) –

用于替换缺失值的对象。

如果传入的是可计算项（例如因子），则将使用该项的结果作为填充值。

如果传递了一个标量（例如一个数字），该标量将用作填充值。

示例

用标量填充：

设f是一个因子，它将产生以下输出：

AAPL   MSFT    MCD     BK
2017-03-13    1.0    NaN    3.0    4.0
2017-03-14    1.5    2.5    NaN    NaN 

那么f.fillna(0)产生以下输出：

AAPL   MSFT    MCD     BK
2017-03-13    1.0    0.0    3.0    4.0
2017-03-14    1.5    2.5    0.0    0.0 

用术语填充：

设f如上所述，设g是另一个将产生以下输出的因子：

AAPL   MSFT    MCD     BK
2017-03-13   10.0   20.0   30.0   40.0
2017-03-14   15.0   25.0   35.0   45.0 

那么，f.fillna(g)产生以下输出：

AAPL   MSFT    MCD     BK
2017-03-13    1.0   20.0    3.0    4.0
2017-03-14    1.5    2.5   35.0   45.0 

返回值：

填充的 – 一个计算与self相同结果的术语，但使用fill_value的值填充缺失值。

返回类型：

zipline.pipeline.ComputableTerm

mean(mask=sentinel('NotSpecified'))

创建一个 1 维因子，每天计算自身平均值。

参数：

掩码 (zipline.pipeline.Filter*,* 可选) – 一个表示在计算结果时要考虑的资产的 Filter。如果提供，我们将忽略mask产生False的资产/日期对。

返回值：

结果

返回类型：

zipline.pipeline.Factor

stddev(mask=sentinel('NotSpecified'))

创建一个 1 维因子，每天计算自身标准差。

参数：

掩码 (zipline.pipeline.Filter*,* 可选) – 一个表示在计算结果时要考虑的资产的 Filter。如果提供，我们将忽略mask产生False的资产/日期对。

返回值：

结果

返回类型：

zipline.pipeline.Factor

max(mask=sentinel('NotSpecified'))

创建一个 1 维因子，每天计算自身最大值。

参数：

掩码 (zipline.pipeline.Filter*,* 可选) – 一个表示在计算结果时要考虑的资产的 Filter。如果提供，我们将忽略mask产生False的资产/日期对。

返回值：

结果

返回类型：

zipline.pipeline.Factor

min(mask=sentinel('NotSpecified'))

创建一个 1 维因子，每天计算自身最小值。

参数：

掩码 (zipline.pipeline.Filter*,* 可选) – 一个表示在计算结果时要考虑的资产的 Filter。如果提供，我们将忽略mask产生False的资产/日期对。

返回值：

结果

返回类型：

zipline.pipeline.Factor

median(mask=sentinel('NotSpecified'))

创建一个 1 维因子，每天计算自身中位数。

参数：

掩码 (zipline.pipeline.Filter*,* 可选) – 一个表示在计算结果时要考虑的资产的 Filter。如果提供，我们将忽略mask产生False的资产/日期对。

返回值：

结果

返回类型：

zipline.pipeline.Factor

sum(mask=sentinel('NotSpecified'))

创建一个 1 维因子，每天计算自身总和。

参数：

掩码（zipline.pipeline.Filter*,* 可选) – 一个表示在计算结果时要考虑的资产的过滤器。如果提供，我们忽略mask产生False的资产/日期对。

返回：

结果

返回类型：

zipline.pipeline.Factor

class zipline.pipeline.Term(domain=sentinel('NotSpecified'), dtype=sentinel('NotSpecified'), missing_value=sentinel('NotSpecified'), window_safe=sentinel('NotSpecified'), ndim=sentinel('NotSpecified'), *args, **kwargs)

可以出现在zipline.pipeline.Pipeline的计算图中的对象的基类。

注意

大多数管道 API 用户只通过子类与Term交互：

• BoundColumn
  
• Factor
  
• Filter
  
• 分类器
  

Term的实例是记忆化的。如果您使用相同的参数两次调用一个 Term 的构造函数，那么两次调用都将返回相同的对象：

示例：

>>> from zipline.pipeline.data import EquityPricing
>>> from zipline.pipeline.factors import SimpleMovingAverage
>>> x = SimpleMovingAverage(inputs=[EquityPricing.close], window_length=5)
>>> y = SimpleMovingAverage(inputs=[EquityPricing.close], window_length=5)
>>> x is y
True 

警告

术语的记忆化意味着在构造后修改术语的属性通常是不安全的。

graph_repr()

在渲染 GraphViz 图形时使用的简短 repr。

recursive_repr()

在递归渲染具有输入的术语时使用的简短 repr。

class zipline.pipeline.data.DataSet

管道数据集的基类。

一个DataSet由两部分定义：

1. 描述数据集可查询属性的Column对象集合。
   
2. 描述由DataSet表示的数据的资产和日历的Domain。
   

要创建新的管道数据集，请定义DataSet的子类，并将一个或多个Column对象设置为类级属性。每个列都需要一个np.dtype，它描述了数据集的加载器应该生成的数据类型。整数列还必须提供一个“缺失值”，用于在给定的资产/日期组合中没有可用值时使用。

默认情况下，数据集的领域是特殊的单例值GENERIC，这意味着它们可以在运行于任何领域的管道中使用。

在某些情况下，可能更希望将数据集限制为仅支持单个领域。例如，数据集可能描述仅覆盖美国的供应商的数据。要将数据集限制为特定领域，请在类作用域中定义一个领域属性。

您还可以通过调用通用数据集的specialize方法并指定感兴趣的领域，来定义特定领域的数据集版本。

示例

内置的 EquityPricing 数据集定义如下：

class EquityPricing(DataSet):
    open = Column(float)
    high = Column(float)
    low = Column(float)
    close = Column(float)
    volume = Column(float) 

内置的 USEquityPricing 数据集是 EquityPricing 的一个特化。它定义为：

from zipline.pipeline.domain import US_EQUITIES
USEquityPricing = EquityPricing.specialize(US_EQUITIES) 

列可以具有除浮点数之外的其他类型。包含各种公司元数据的数据集可能这样定义：

class CompanyMetadata(DataSet):
    # Use float for semantically-numeric data, even if it's always
    # integral valued (see Notes section below). The default missing
    # value for floats is NaN.
    shares_outstanding = Column(float)
    # Use object for string columns. The default missing value for
    # object-dtype columns is None.
    ticker = Column(object)
    # Use integers for integer-valued categorical data like sector or
    # industry codes. Integer-dtype columns require an explicit missing
    # value.
    sector_code = Column(int, missing_value=-1)
    # Use bool for boolean-valued flags. Note that the default missing
    # value for bool-dtype columns is False.
    is_primary_share = Column(bool) 

注释

由于 numpy 没有原生支持带有缺失值的整数，强烈建议用户对任何语义上为数值的数据使用浮点数。这样做可以使用 NaN 作为自然的缺失值，具有有用的传播语义。

classmethod get_column(name)

按名称查找列。

参数：

名称 (字符串) – 要查找的列的名称。

返回：

列 – 具有给定名称的列。

返回类型：

zipline.pipeline.data.BoundColumn

引发：

AttributeError – 如果给定名称的列不存在。

class zipline.pipeline.data.Column(dtype, missing_value=sentinel('NotSpecified'), doc=None, metadata=None, currency_aware=False)

一个抽象的数据列，尚未与数据集关联。

bind(name)

将列对象绑定到其名称。

class zipline.pipeline.data.BoundColumn(dtype, missing_value, dataset, name, doc, metadata, currency_conversion, currency_aware)

一个具体绑定到特定数据集的数据列。

dtype

加载此列时生成的数据的 dtype。

类型：

numpy.dtype

latest

一个Filter、Factor或Classifier，计算该列在每个日期的最近已知值。有关更多详细信息，请参阅zipline.pipeline.mixins.LatestMixin。

类型：

zipline.pipeline.LoadableTerm

dataset

该列所属的数据集。

类型：

zipline.pipeline.data.DataSet

name

该列的名称。

类型：

字符串

metadata

与该列相关的额外元数据。

类型：

字典

currency_aware

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