Zipline 3.0 中文文档（二）

原文：zipline.ml4trading.io

日历

原文：zipline.ml4trading.io/trading-calendars.html

什么是交易日历？

交易日历代表单个市场交易所的时间信息。时间信息由两部分组成：时段和开/闭市时间。这由 Zipline 的TradingCalendar类表示，并作为所有新的TradingCalendar类的父类。

一个时段代表一组连续的分钟，并且有一个标签，该标签是 UTC 午夜。重要的是要注意，时段标签不应该被视为一个特定的时间点，而 UTC 午夜只是为了方便而使用。

对于纽约证券交易所的普通交易日，市场在上午 9:30 开市，下午 4:00 闭市。交易时段可能会根据交易所、一年中的某一天等因素而变化。

为什么你应该关注交易日历？

假设你想在周二买入某只股票，然后在周六卖出。如果你交易的那个股票所在的交易所周六不开放，那么在现实中你将无法在那个时间交易那只股票，你将不得不等到周六之后的某个其他天数。既然你无法在现实中进行交易，那么你的回测在周六进行交易也是不合理的。

为了让你能够回测你的策略，你的数据包中的日期和你的TradingCalendar中的日期应该匹配；如果日期不匹配，那么你将会在过程中遇到一些错误。这对分钟级和日级数据都适用。

TradingCalendar类

TradingCalendar类有许多属性，如果我们需要为自己的交易所构建一个TradingCalendar，我们应该考虑这些属性。这些属性包括：

• 交易所名称
• 时区
• 开市时间
• 闭市时间
• 常规与临时假日
• 特殊开市与闭市

以及其他一些。如果你想查看TradingCalendar API 提供的所有属性和方法，请查看API 参考。

现在我们将以伦敦证券交易所日历LSEExchangeCalendar为例进行说明：

class LSEExchangeCalendar(TradingCalendar):
  """
 Exchange calendar for the London Stock Exchange

 Open Time: 8:00 AM, GMT
 Close Time: 4:30 PM, GMT

 Regularly-Observed Holidays:
 - New Years Day (observed on first business day on/after)
 - Good Friday
 - Easter Monday
 - Early May Bank Holiday (first Monday in May)
 - Spring Bank Holiday (last Monday in May)
 - Summer Bank Holiday (last Monday in May)
 - Christmas Day
 - Dec. 27th (if Christmas is on a weekend)
 - Boxing Day
 - Dec. 28th (if Boxing Day is on a weekend)
 """

  @property
  def name(self):
    return "LSE"

  @property
  def tz(self):
    return timezone('Europe/London')

  @property
  def open_time(self):
    return time(8, 1)

  @property
  def close_time(self):
    return time(16, 30)

  @property
  def regular_holidays(self):
    return HolidayCalendar([
      LSENewYearsDay,
      GoodFriday,
      EasterMonday,
      MayBank,
      SpringBank,
      SummerBank,
      Christmas,
      WeekendChristmas,
      BoxingDay,
      WeekendBoxingDay
    ]) 

你可以使用pandas模块的pandas.tseries.holiday.Holiday来创建在def regular_holidays(self)中提到的Holiday对象。

以上面的LSEExchangeCalendar代码为例，同时也请查看下面的代码片段。

from pandas.tseries.holiday import (
    Holiday,
    DateOffset,
    MO
)

SomeSpecialDay = Holiday(
    "Some Special Day",
    month=1,
    day=9,
    offset=DateOffSet(weekday=MO(-1))
) 

构建自定义交易日历

现在我们将构建我们自己的自定义交易日历。这个日历将用于交易可以在 24/7 交易所日历上交易的资产。这意味着它将在周一、周二、周三、周四、周五、周六和周日开放，交易所将在 12AM 开放，并在 11:59PM 关闭。我们将使用的时区是 UTC。

首先，我们将开始导入一些对我们有用的模块。

# for setting our open and close times
from datetime import time
# for setting our start and end sessions
import pandas as pd
# for setting which days of the week we trade on
from pandas.tseries.offsets import CustomBusinessDay
# for setting our timezone
from pytz import timezone

# for creating and registering our calendar
from zipline.utils.calendar_utils import register_calendar, TradingCalendar
from zipline.utils.memoize import lazyval 

现在我们将实际构建这个日历，我们将其称为TFSExchangeCalendar。

class TFSExchangeCalendar(TradingCalendar):
  """
 An exchange calendar for trading assets 24/7.

 Open Time: 12AM, UTC
 Close Time: 11:59PM, UTC
 """

  @property
  def name(self):
  """
 The name of the exchange, which Zipline will look for
 when we run our algorithm and pass TFS to
 the --trading-calendar CLI flag.
 """
    return "TFS"

  @property
  def tz(self):
  """
 The timezone in which we'll be running our algorithm.
 """
    return timezone("UTC")

  @property
  def open_time(self):
  """
 The time in which our exchange will open each day.
 """
    return time(0, 0)

  @property
  def close_time(self):
  """
 The time in which our exchange will close each day.
 """
    return time(23, 59)

  @lazyval
  def day(self):
  """
 The days on which our exchange will be open.
 """
    weekmask = "Mon Tue Wed Thu Fri Sat Sun"
    return CustomBusinessDay(
      weekmask=weekmask
    ) 

结论

为了让你能够使用这个日历运行你的算法，你需要有一个数据包，其中你的资产的日期涵盖了一周的所有天数。你可以在本文档的编写新包部分了解如何创建自己的数据包，或者使用csvdir 包中的代码从 CSV 文件创建包。

什么是交易日历？

交易日历代表单个市场交易所的时间信息。时间信息由两部分组成：会话和开/关。这由 Zipline 的TradingCalendar类表示，并作为所有新的TradingCalendar类的父类使用。

一个会话代表一组连续的分钟，并且有一个标签是 UTC 午夜。重要的是要注意，会话标签不应该被视为一个特定的时间点，而 UTC 午夜只是为了方便而使用。

对于纽约证券交易所的普通交易日，市场在 9:30AM 开放，在 4PM 关闭。交易时段可能会根据交易所、一年中的某一天等而变化。

为什么你应该关心交易日历？

假设你想在周二购买某只股票的股份，然后在周六卖出。如果你交易的那个股票所在的交易所周六不开放，那么实际上在那个时间交易那只股票是不可能的，你将不得不等到周六之后的其他几天。由于你不能在现实中进行交易，因此你的回测在周六进行交易也是不合理的。

为了让你能够回测你的策略，你的数据包中的日期和你的TradingCalendar中的日期应该匹配；如果日期不匹配，那么你将会在过程中遇到一些错误。这对分钟数据和日数据都适用。

TradingCalendar 类

TradingCalendar类有许多属性，如果我们想为交易所构建自己的TradingCalendar，我们应该考虑这些属性。这些属性包括：

• 交易所名称
• 时区
• 开放时间
• 关闭时间
• 常规和特别假日
• 特别开放和关闭

以及其他几个。如果您想查看TradingCalendar API 提供的所有属性和方法，请查看API 参考。

现在我们将以下面的伦敦证券交易所日历LSEExchangeCalendar为例：

class LSEExchangeCalendar(TradingCalendar):
  """
 Exchange calendar for the London Stock Exchange

 Open Time: 8:00 AM, GMT
 Close Time: 4:30 PM, GMT

 Regularly-Observed Holidays:
 - New Years Day (observed on first business day on/after)
 - Good Friday
 - Easter Monday
 - Early May Bank Holiday (first Monday in May)
 - Spring Bank Holiday (last Monday in May)
 - Summer Bank Holiday (last Monday in May)
 - Christmas Day
 - Dec. 27th (if Christmas is on a weekend)
 - Boxing Day
 - Dec. 28th (if Boxing Day is on a weekend)
 """

  @property
  def name(self):
    return "LSE"

  @property
  def tz(self):
    return timezone('Europe/London')

  @property
  def open_time(self):
    return time(8, 1)

  @property
  def close_time(self):
    return time(16, 30)

  @property
  def regular_holidays(self):
    return HolidayCalendar([
      LSENewYearsDay,
      GoodFriday,
      EasterMonday,
      MayBank,
      SpringBank,
      SummerBank,
      Christmas,
      WeekendChristmas,
      BoxingDay,
      WeekendBoxingDay
    ]) 

您可以使用pandas模块pandas.tseries.holiday.Holiday创建在def regular_holidays(self)中提到的Holiday对象。

请查看上面的LSEExchangeCalendar代码作为示例，以及下面的代码片段。

from pandas.tseries.holiday import (
    Holiday,
    DateOffset,
    MO
)

SomeSpecialDay = Holiday(
    "Some Special Day",
    month=1,
    day=9,
    offset=DateOffSet(weekday=MO(-1))
) 

构建自定义交易日历

现在，我们将构建我们自己的自定义交易日历。该日历将用于交易可以在 24/7 交易平台上交易的资产。这意味着它将在周一、周二、周三、周四、周五、周六和周日开放，交易平台将在凌晨 12 点开放，晚上 11:59 关闭。我们将使用的时区是 UTC。

首先，我们将导入一些对我们有用的模块。

# for setting our open and close times
from datetime import time
# for setting our start and end sessions
import pandas as pd
# for setting which days of the week we trade on
from pandas.tseries.offsets import CustomBusinessDay
# for setting our timezone
from pytz import timezone

# for creating and registering our calendar
from zipline.utils.calendar_utils import register_calendar, TradingCalendar
from zipline.utils.memoize import lazyval 

现在我们将实际构建这个日历，我们将其称为TFSExchangeCalendar：

class TFSExchangeCalendar(TradingCalendar):
  """
 An exchange calendar for trading assets 24/7.

 Open Time: 12AM, UTC
 Close Time: 11:59PM, UTC
 """

  @property
  def name(self):
  """
 The name of the exchange, which Zipline will look for
 when we run our algorithm and pass TFS to
 the --trading-calendar CLI flag.
 """
    return "TFS"

  @property
  def tz(self):
  """
 The timezone in which we'll be running our algorithm.
 """
    return timezone("UTC")

  @property
  def open_time(self):
  """
 The time in which our exchange will open each day.
 """
    return time(0, 0)

  @property
  def close_time(self):
  """
 The time in which our exchange will close each day.
 """
    return time(23, 59)

  @lazyval
  def day(self):
  """
 The days on which our exchange will be open.
 """
    weekmask = "Mon Tue Wed Thu Fri Sat Sun"
    return CustomBusinessDay(
      weekmask=weekmask
    ) 

结论

为了使您的算法能够使用此日历运行，您需要拥有一个数据包，其中您的资产日期涵盖了一周的所有天数。您可以在本文档的编写新包部分了解如何创建自己的数据包，或者使用csvdir 包中的代码从 CSV 文件创建包。

度量

原文：zipline.ml4trading.io/risk-and-perf-metrics.html

风险和性能度量是 Zipline 在运行模拟时计算的汇总值。这些度量可以是关于算法性能的，如回报或现金流，或者是算法的风险性，如波动性或贝塔。度量可以每分钟、每天或一次在模拟结束时报告。单个度量可以选择在适当的情况下在多个时间尺度上报。

度量集

Zipline 将风险和性能度量分组为称为“度量集”的集合。单个度量集定义了单个回测期间要跟踪的所有度量。度量集可以包含在不同时间尺度上报的度量。默认度量集将计算一系列度量，如算法回报、波动性、夏普比率和贝塔。

选择度量集

在运行模拟时，用户可以选择要报告的度量集。选择度量集的方式取决于运行算法的接口。

命令行和 IPython 魔术

在使用命令行或 IPython 魔术接口运行时，可以通过传递--metrics-set参数来选择度量集。例如：

$  zipline  run  algorithm.py  -s  2014-01-01  -e  2014-02-01  --metrics-set  my-metrics-set 

run_algorithm

在使用run_algorithm()接口运行时，可以通过metrics_set参数传递度量集。这可以是已注册度量集的名称，也可以是一组度量对象。例如：

run_algorithm(..., metrics_set='my-metrics-set')
run_algorithm(..., metrics_set={MyMetric(), MyOtherMetric(), ...}) 

不带度量运行

计算风险和性能度量并非免费，这会增加回测的总运行时间。在积极开发算法时，通常有助于跳过这些计算以加快调试周期。要禁用所有度量的计算和报告，用户可以选择内置度量集none。例如：

$  zipline  run  algorithm.py  -s  2014-01-01  -e  2014-02-01  --metrics-set  none 

定义新度量

度量是实现以下方法子集的任何对象：

• start_of_simulation
• end_of_simulation
• start_of_session
• end_of_session
• end_of_bar

这些函数将在其名称指示的时间被调用，此时度量对象可以收集任何所需信息，并可选地报告计算值。如果度量在某个时间不需要进行任何处理，则可以省略对该方法的定义。

度量应该是可重用的，这意味着单个度量类实例可以用于多个回测。度量不需要同时支持多个模拟，这意味着内部缓存和数据在start_of_simulation和end_of_simulation之间是一致的。

start_of_simulation

start_of_simulation方法应被视为每个模拟的构造函数。该方法应初始化单个模拟期间所需的任何缓存。

start_of_simulation方法应具有以下签名：

def start_of_simulation(self,
                        ledger,
                        emission_rate,
                        trading_calendar,
                        sessions,
                        benchmark_source):
    ... 

ledger 是 Ledger 的一个实例，它维护着模拟的状态。这可以用来查找算法的起始投资组合价值。

emission_rate 是一个表示度量报告的最小频率的字符串。emission_rate 将是 minute 或 daily。当 emission_rate 是 daily 时，end_of_bar 将根本不会被调用。

trading_calendar 是 TradingCalendar 的一个实例，它是模拟所使用的交易日历。

sessions 是一个 pandas.DatetimeIndex，它持有模拟将要执行的会话标签，按排序顺序。

benchmark_source 是 BenchmarkSource 的一个实例，它是 set_benchmark() 指定的基准回报的接口。

end_of_simulation

end_of_simulation 方法应具有以下签名：

def end_of_simulation(self,
                      packet,
                      ledger,
                      trading_calendar,
                      sessions,
                      data_portal,
                      benchmark_source):
    ... 

ledger 是 Ledger 的一个实例，它维护着模拟的状态。这可以用来查找算法的最终投资组合价值。

packet 是一个字典，用于写入给定度量的模拟结束值。

trading_calendar 是 TradingCalendar 的一个实例，它是模拟所使用的交易日历。

sessions 是一个 pandas.DatetimeIndex，它持有模拟已经执行的会话标签，按排序顺序。

data_portal 是 DataPortal 的一个实例，它是度量对定价数据的接口。

benchmark_source 是 BenchmarkSource 的一个实例，它是 set_benchmark() 指定的基准回报的接口。

start_of_session

start_of_session 方法可能会看到与之前的 end_of_session 略有不同的 ledger 或 data_portal 视图，如果拥有的任何期货的价格在交易会话之间移动或发生资本变动。

start_of_session 方法应具有以下签名：

def start_of_session(self,
                     ledger,
                     session_label,
                     data_portal):
    ... 

ledger 是 Ledger 的一个实例，它维护着模拟的状态。这可以用来查找算法的当前投资组合价值。

session_label 是一个 Timestamp，它是即将运行的会话的标签。

data_portal 是 DataPortal 的一个实例，它是度量与定价数据接口。

end_of_session

end_of_session 方法应具有以下签名：

def end_of_session(self,
                   packet,
                   ledger,
                   session_label,
                   session_ix,
                   data_portal): 

packet 是一个用于写入会话结束值的字典。该字典包含两个子字典：daily_perf 和 cumulative_perf。在适用的情况下，daily_perf 应包含当前日的价值，而 cumulative_perf 应包含到当前时间为止的整个模拟的累积价值。

ledger 是 Ledger 的一个实例，它维护着模拟的状态。这可以用来查找算法的当前投资组合价值。

session_label 是一个 Timestamp，它是刚刚完成的会话的标签。

session_ix 是一个 int，它是当前正在运行的交易会话的索引。这提供了通过 ledger.daily_returns_array[:session_ix + 1] 高效访问每日回报的方式。

data_portal 是 DataPortal 的一个实例，它是度量与定价数据接口。

end_of_bar

注意

end_of_bar 仅在 emission_mode 为 minute 时调用。

end_of_bar 方法应具有以下签名：

def end_of_bar(self,
               packet,
               ledger,
               dt,
               session_ix,
               data_portal): 

packet 是一个用于写入会话结束值的字典。该字典包含两个子字典：minute_perf 和 cumulative_perf。在适用的情况下，minute_perf 应包含当前部分日的价值，而 cumulative_perf 应包含到当前时间为止的整个模拟的累积价值。

ledger 是 Ledger 的一个实例，它维护着模拟的状态。这可以用来查找算法的当前投资组合价值。

dt 是一个 Timestamp，它是刚刚完成的条形的标签。

session_ix是一个int，它是当前正在运行的交易会话的索引。这提供了通过ledger.daily_returns_array[:session_ix + 1]高效访问每日回报的方式。

data_portal是DataPortal的一个实例，它是度量对定价数据的接口。

定义新的度量集

用户可以使用zipline.finance.metrics.register()注册新的度量集。这可以用于装饰一个不带参数的函数，该函数返回一组新的度量对象实例。例如：

from zipline.finance import metrics

@metrics.register('my-metrics-set')
def my_metrics_set():
    return {MyMetric(), MyOtherMetric(), ...} 

这可以嵌入用户的extension.py中。

将度量集定义为生成一组的函数，而不是仅仅是一组，是因为用户可能想要获取外部数据或资源来构建他们的度量。通过将此置于可调用对象后面，用户不需要在未使用度量集时获取资源。

度量集

Zipline 将风险和性能度量分组到称为“度量集”的集合中。单个度量集定义了在单个回测期间要跟踪的所有度量。度量集可以包含在不同时间尺度上报的度量。默认度量集将计算一系列度量，如算法回报、波动性、夏普比率和贝塔。

选择度量集

在运行模拟时，用户可以选择要报告的度量集。如何选择度量集取决于用于运行算法的接口。

命令行和 IPython 魔法

当通过命令行或 IPython 魔法接口运行时，可以通过传递--metrics-set参数来选择度量集。例如：

$  zipline  run  algorithm.py  -s  2014-01-01  -e  2014-02-01  --metrics-set  my-metrics-set 

run_algorithm

当通过run_algorithm()接口运行时，可以通过metrics_set参数传递度量集。这可以是已注册度量集的名称，也可以是一组度量对象。例如：

run_algorithm(..., metrics_set='my-metrics-set')
run_algorithm(..., metrics_set={MyMetric(), MyOtherMetric(), ...}) 

命令行和 IPython 魔法

当通过命令行或 IPython 魔法接口运行时，可以通过传递--metrics-set参数来选择度量集。例如：

$  zipline  run  algorithm.py  -s  2014-01-01  -e  2014-02-01  --metrics-set  my-metrics-set 

run_algorithm

当通过run_algorithm()接口运行时，可以通过metrics_set参数传递度量集。这可以是已注册度量集的名称，也可以是一组度量对象。例如：

run_algorithm(..., metrics_set='my-metrics-set')
run_algorithm(..., metrics_set={MyMetric(), MyOtherMetric(), ...}) 

不带度量运行

计算风险和性能指标不是免费的，它会增加回测的总运行时间。在积极开发算法时，通常有助于跳过这些计算以加快调试周期。要禁用所有指标的计算和报告，用户可以选择内置的指标集 none。例如：

$  zipline  run  algorithm.py  -s  2014-01-01  -e  2014-02-01  --metrics-set  none 

定义新指标

指标是实现以下方法子集的任何对象：

• start_of_simulation
• end_of_simulation
• start_of_session
• end_of_session
• end_of_bar

这些函数将在其名称指示的时间被调用，届时指标对象可以收集任何所需信息，并可选择报告计算值。如果某个指标在这些时间不需要进行任何处理，则可以省略对该方法的定义。

指标应该是可重用的，这意味着单个指标类实例应该能够用于多个回测。指标不需要同时支持多个模拟，这意味着内部缓存和数据在 start_of_simulation 和 end_of_simulation 之间是一致的。

start_of_simulation

应将 start_of_simulation 方法视为每个模拟的构造函数。该方法应初始化单个模拟期间所需的任何缓存。

start_of_simulation 方法应具有以下签名：

def start_of_simulation(self,
                        ledger,
                        emission_rate,
                        trading_calendar,
                        sessions,
                        benchmark_source):
    ... 

ledger 是 Ledger 的一个实例，它维护着模拟的状态。这可以用来查找算法的起始投资组合价值。

emission_rate 是一个字符串，表示指标应报告的最小频率。emission_rate 将是 minute 或 daily。当 emission_rate 为 daily 时，end_of_bar 将根本不会被调用。

trading_calendar 是 TradingCalendar 的一个实例，它是模拟所使用的交易日历。

sessions 是一个 pandas.DatetimeIndex，它保存了模拟将执行的会话标签，按排序顺序排列。

benchmark_source 是 BenchmarkSource 的一个实例，它是指定基准的回报接口，由 set_benchmark() 指定。

end_of_simulation

end_of_simulation 方法应具有以下签名：

def end_of_simulation(self,
                      packet,
                      ledger,
                      trading_calendar,
                      sessions,
                      data_portal,
                      benchmark_source):
    ... 

ledger 是 Ledger 的一个实例，它维护着模拟的状态。这可以用来查找算法的最终投资组合价值。

packet 是一个字典，用于写入给定指标的模拟结束值。

trading_calendar 是 TradingCalendar 的一个实例，它是模拟使用的交易日历。

sessions 是一个 pandas.DatetimeIndex，它保存了模拟已执行的交易时段标签，按排序顺序排列。

data_portal 是 DataPortal 的一个实例，它是度量标准对定价数据的接口。

benchmark_source 是 BenchmarkSource 的一个实例，它是返回由 set_benchmark() 指定的基准的接口。

start_of_session

start_of_session 方法可能会看到与之前的 end_of_session 略有不同的 ledger 或 data_portal 视图，如果拥有的任何期货的价格在交易时段之间移动或发生资本变动。

方法 start_of_session 应该具有以下签名：

def start_of_session(self,
                     ledger,
                     session_label,
                     data_portal):
    ... 

ledger 是 Ledger 的一个实例，它维护模拟的状态。这可以用来查找算法的当前投资组合价值。

session_label 是一个 Timestamp，表示即将运行的交易时段的标签。

data_portal 是 DataPortal 的一个实例，它是度量标准对定价数据的接口。

end_of_session

方法 end_of_session 应该具有以下签名：

def end_of_session(self,
                   packet,
                   ledger,
                   session_label,
                   session_ix,
                   data_portal): 

packet 是一个用于写入交易时段结束值的字典。该字典包含两个子字典：daily_perf 和 cumulative_perf。在适用的情况下，daily_perf 应包含当天的值，而 cumulative_perf 应包含到当前时间为止的整个模拟的累积值。

ledger 是 Ledger 的一个实例，它维护模拟的状态。这可以用来查找算法的当前投资组合价值。

session_label 是一个 Timestamp，表示刚刚完成的交易时段的标签。

session_ix 是一个 int，表示当前正在运行的交易时段的索引。提供这个索引是为了通过 ledger.daily_returns_array[:session_ix + 1] 高效访问每日回报。

data_portal 是 DataPortal 的一个实例，它是度量标准与定价数据接口的接口。

end_of_bar

注意

end_of_bar 仅在 emission_mode 为 minute 时被调用。

end_of_bar 方法应具有以下签名：

def end_of_bar(self,
               packet,
               ledger,
               dt,
               session_ix,
               data_portal): 

packet 是一个字典，用于写入会话结束时的值。该字典包含两个子字典：minute_perf 和 cumulative_perf。在适用的情况下，minute_perf 应包含当前部分日的值，而 cumulative_perf 应包含到当前时间为止的整个模拟的累积值。

ledger 是 Ledger 的一个实例，它维护模拟的状态。这可以用来查找算法当前的资产组合值。

dt 是一个 Timestamp，它是刚刚完成的条形的标签。

session_ix 是一个 int，它是当前正在运行的交易会话的索引。这提供给允许通过 ledger.daily_returns_array[:session_ix + 1] 高效访问每日回报。

data_portal 是 DataPortal 的一个实例，它是度量标准与定价数据接口的接口。

start_of_simulation

start_of_simulation 方法应被视为每个模拟的构造函数。该方法应初始化单个模拟期间所需的任何缓存。

start_of_simulation 方法应具有以下签名：

def start_of_simulation(self,
                        ledger,
                        emission_rate,
                        trading_calendar,
                        sessions,
                        benchmark_source):
    ... 

ledger 是 Ledger 的一个实例，它维护模拟的状态。这可以用来查找算法起始的资产组合值。

emission_rate 是一个字符串，表示度量标准应报告的最小频率。emission_rate 将是 minute 或 daily 之一。当 emission_rate 为 daily 时，end_of_bar 根本不会被调用。

trading_calendar 是 TradingCalendar 的一个实例，它是模拟使用的交易日历。

sessions 是一个 pandas.DatetimeIndex，它保存模拟将执行的会话标签，按排序顺序排列。

benchmark_source 是 BenchmarkSource 的一个实例，它是 set_benchmark() 指定的基准的回报接口。

end_of_simulation

end_of_simulation 方法应该具有以下签名：

def end_of_simulation(self,
                      packet,
                      ledger,
                      trading_calendar,
                      sessions,
                      data_portal,
                      benchmark_source):
    ... 

ledger 是 Ledger 的一个实例，它维护模拟的状态。这可以用来查找算法的最终投资组合值。

packet 是一个字典，用于将给定度量的模拟结束值写入。

trading_calendar 是 TradingCalendar 的一个实例，它是模拟使用的交易日历。

sessions 是一个 pandas.DatetimeIndex，它保存了模拟执行的会话标签，按排序顺序排列。

data_portal 是 DataPortal 的一个实例，它是度量与定价数据接口的接口。

benchmark_source 是 BenchmarkSource 的一个实例，它是与 set_benchmark() 指定的基准的回报接口。

start_of_session

start_of_session 方法可能会看到与之前的 end_of_session 略有不同的 ledger 或 data_portal 视图，如果任何拥有的期货的价格在交易会话之间移动或发生资本变动。

start_of_session 方法应该具有以下签名：

def start_of_session(self,
                     ledger,
                     session_label,
                     data_portal):
    ... 

ledger 是 Ledger 的一个实例，它维护模拟的状态。这可以用来查找算法的当前投资组合值。

session_label 是一个 Timestamp，它是即将运行的会话的标签。

data_portal 是 DataPortal 的一个实例，它是度量与定价数据接口的接口。

end_of_session

end_of_session 方法应该具有以下签名：

def end_of_session(self,
                   packet,
                   ledger,
                   session_label,
                   session_ix,
                   data_portal): 

packet 是一个字典，用于写入会话结束值。该字典包含两个子字典：daily_perf 和 cumulative_perf。在适用的情况下，daily_perf 应包含当天的当前值，而 cumulative_perf 应包含截至当前时间的整个模拟的累积值。

ledger 是 Ledger 的一个实例，它维护模拟的状态。这可以用来查找算法的当前投资组合值。

session_label 是一个 Timestamp，它是刚刚完成的会话的标签。

session_ix 是一个 int，它是当前正在运行的交易会话的索引。提供这个参数是为了通过 ledger.daily_returns_array[:session_ix + 1] 高效访问每日回报。

data_portal 是 DataPortal 的一个实例，它是度量与定价数据接口。

end_of_bar

注意

end_of_bar 仅在 emission_mode 为 minute 时被调用。

end_of_bar 方法应该具有以下签名：

def end_of_bar(self,
               packet,
               ledger,
               dt,
               session_ix,
               data_portal): 

packet 是一个字典，用于写入会话结束时的值。该字典包含两个子字典：minute_perf 和 cumulative_perf。在适用的情况下，minute_perf 应包含当前部分日的值，而 cumulative_perf 应包含到当前时间为止的整个模拟的累积值。

ledger 是 Ledger 的一个实例，它维护着模拟的状态。这可以用来查找算法当前的资产组合价值。

dt 是一个 Timestamp，它是刚刚完成的条形的标签。

session_ix 是一个 int，它是当前正在运行的交易会话的索引。提供这个参数是为了通过 ledger.daily_returns_array[:session_ix + 1] 高效访问每日回报。

data_portal 是 DataPortal 的一个实例，它是度量与定价数据接口。

定义新的度量集

用户可以使用 zipline.finance.metrics.register() 来注册一个新的度量集。这可以用来装饰一个不接受参数并返回一组新的度量对象实例的函数。例如：

from zipline.finance import metrics

@metrics.register('my-metrics-set')
def my_metrics_set():
    return {MyMetric(), MyOtherMetric(), ...} 

这可以嵌入到用户的 extension.py 中。

将度量集定义为生成一组度量的函数，而不是直接定义一组度量，是因为用户可能想要获取外部数据或资源来构建他们的度量。通过将这个过程放在一个可调用的对象后面，用户不需要在度量集未被使用时获取资源。

开发

原文：zipline.ml4trading.io/development-guidelines.html

本页面旨在为 Zipline 的开发者、希望为 Zipline 代码库或文档做出贡献的人，或希望从源代码安装并对其 Zipline 副本进行本地更改的人提供指导。

我们欢迎所有贡献，包括错误报告、错误修复、文档改进、增强功能和想法。我们在GitHub上跟踪问题，并且还有一个邮件列表，您可以在那里提问。

创建开发环境

首先，您需要通过运行以下命令克隆 Zipline：

$  git  clone  git@github.com:stefan-jansen/zipline-reloaded.git 

然后检出到一个新分支，您可以在那里进行更改：

$  cd  zipline-reloaded
$  git  checkout  -b  some-short-descriptive-name 

如果您还没有这些依赖，您将需要一些 C 库依赖。您可以按照安装指南获取适当的依赖。

一旦您创建并激活了一个虚拟环境

$  python3  -m  venv  venv
$  source  venv/bin/activate 

或者，使用virtualenvwrapper：

$  mkvirtualenv  zipline 

运行pip install -e .[test]以安装：

安装后，您应该能够从虚拟环境中使用zipline命令行界面：

$  zipline  --help 

最后，确保测试通过。

在开发过程中，您可以通过运行以下命令重新构建 C 扩展：

$  ./rebuid-cython.sh 

风格指南与运行测试

我们使用flake8来检查风格要求，使用black进行代码格式化，并使用pytest来运行 Zipline 测试。我们的持续集成工具将运行这些命令。

在提交补丁或拉取请求之前，请确保您的更改在运行以下命令时通过：

$  flake8  src/zipline  tests 

为了在本地运行测试，您需要TA-lib，您可以通过运行以下命令在 Linux 上安装：

$  wget  http://prdownloads.sourceforge.net/ta-lib/ta-lib-0.4.0-src.tar.gz
$  tar  -xvzf  ta-lib-0.4.0-src.tar.gz
$  cd  ta-lib/
$  ./configure  --prefix=/usr
$  make
$  sudo  make  install 

对于 OS X 上的TA-lib，您只需运行：

$  brew  install  ta-lib 

然后运行pip install TA-lib：

您现在应该可以自由运行测试：

$  pytest  tests 

持续集成

[TODO]

打包

[TODO]

为文档做出贡献

如果您想为 zipline.io 上的文档做出贡献，您可以导航到docs/source/，其中每个reStructuredText（.rst）文件都是一个单独的部分。要添加一个部分，创建一个名为some-descriptive-name.rst的新文件，并将some-descriptive-name添加到appendix.rst中。要编辑一个部分，只需打开现有的文件，进行更改，然后保存。

我们使用Sphinx为 Zipline 生成文档，您需要通过运行以下命令来安装：

如果您想使用 Anaconda，请按照安装指南创建并激活一个环境，然后运行上述命令。

要构建并在本地查看文档，请运行：

# assuming you're in the Zipline root directory
$  cd  docs
$  make  html
$  {BROWSER}  build/html/index.html 

提交消息

标准的前缀来开始一个提交消息：

BLD: change related to building Zipline
BUG: bug fix
DEP: deprecate something, or remove a deprecated object
DEV: development tool or utility
DOC: documentation
ENH: enhancement
MAINT: maintenance commit (refactoring, typos, etc)
REV: revert an earlier commit
STY: style fix (whitespace, PEP8, flake8, etc)
TST: addition or modification of tests
REL: related to releasing Zipline
PERF: performance enhancements 

一些提交样式指南：

提交行不应超过72 个字符。提交的第一行应包含上述前缀之一。提交主题和提交正文之间应有空行。通常，消息应以祈使语气编写。最佳实践是不仅包括更改的内容，还包括更改的原因。

示例：

MAINT: Remove unused calculations of max_leverage, et al.

In the performance period the max_leverage, max_capital_used,
cumulative_capital_used were calculated but not used.

At least one of those calculations, max_leverage, was causing a
divide by zero error.

Instead of papering over that error, the entire calculation was
a bit suspect so removing, with possibility of adding it back in
later with handling the case (or raising appropriate errors) when
the algorithm has little cash on hand. 

格式化文档字符串

在为类、函数等添加或编辑文档字符串时，我们使用numpy作为权威参考。

更新 Whatsnew

我们有一套Whatsnew文件，用于记录 Zipline 不同版本之间发生的更改。一旦你对 Zipline 进行了更改，在你的拉取请求中，请更新最近的Whatsnew文件，并添加一条关于你所做更改的评论。你可以在之前的Whatsnew文件中找到示例。

创建开发环境

首先，你需要通过运行以下命令来克隆 Zipline：

$  git  clone  git@github.com:stefan-jansen/zipline-reloaded.git 

然后切换到一个新分支，你可以在那里进行更改：

$  cd  zipline-reloaded
$  git  checkout  -b  some-short-descriptive-name 

如果你还没有它们，你需要一些 C 库依赖项。你可以按照安装指南来获取适当的依赖项。

一旦你创建并激活了一个虚拟环境

$  python3  -m  venv  venv
$  source  venv/bin/activate 

或者，使用virtualenvwrapper：

$  mkvirtualenv  zipline 

运行pip install -e .[test]来安装：

安装完成后，你应该能够从虚拟环境中使用zipline命令行界面：

$  zipline  --help 

最后，确保测试通过。

在开发过程中，你可以通过运行以下命令来重建 C 扩展：

$  ./rebuid-cython.sh 

样式指南与运行测试

我们使用flake8来检查样式要求，使用black来格式化代码，并使用pytest来运行 Zipline 测试。我们的持续集成工具将执行这些命令。

在提交补丁或拉取请求之前，请确保你的更改在运行时通过：

$  flake8  src/zipline  tests 

要在本地运行测试，你需要TA-lib，在 Linux 上你可以通过运行以下命令来安装：

$  wget  http://prdownloads.sourceforge.net/ta-lib/ta-lib-0.4.0-src.tar.gz
$  tar  -xvzf  ta-lib-0.4.0-src.tar.gz
$  cd  ta-lib/
$  ./configure  --prefix=/usr
$  make
$  sudo  make  install 

对于 OS X 上的TA-lib，你只需运行：

$  brew  install  ta-lib 

然后运行pip install TA-lib：

你现在应该可以自由运行测试了：

$  pytest  tests 

持续集成

[TODO]

打包

[TODO]

贡献文档

如果你想为 zipline.io 上的文档做出贡献，你可以导航到docs/source/，其中每个reStructuredText（.rst）文件都是一个单独的部分。要添加一个部分，创建一个名为some-descriptive-name.rst的新文件，并将some-descriptive-name添加到appendix.rst中。要编辑一个部分，只需打开现有的文件，进行更改，然后保存。

我们使用Sphinx来为 Zipline 生成文档，你需要通过运行以下命令来安装它：

如果你想要使用 Anaconda，请按照安装指南创建并激活一个环境，然后运行上述命令。

要在本地构建并查看文档，运行：

# assuming you're in the Zipline root directory
$  cd  docs
$  make  html
$  {BROWSER}  build/html/index.html 

提交消息

开始提交消息的标准前缀：

BLD: change related to building Zipline
BUG: bug fix
DEP: deprecate something, or remove a deprecated object
DEV: development tool or utility
DOC: documentation
ENH: enhancement
MAINT: maintenance commit (refactoring, typos, etc)
REV: revert an earlier commit
STY: style fix (whitespace, PEP8, flake8, etc)
TST: addition or modification of tests
REL: related to releasing Zipline
PERF: performance enhancements 

一些提交样式指南：

提交行的长度不应超过72 个字符。提交的第一行应包含上述前缀之一。提交主题和提交正文之间应有空行。通常，消息应以祈使语气编写。最佳实践是不仅包括更改的内容，还应包括更改的原因。

示例：

MAINT: Remove unused calculations of max_leverage, et al.

In the performance period the max_leverage, max_capital_used,
cumulative_capital_used were calculated but not used.

At least one of those calculations, max_leverage, was causing a
divide by zero error.

Instead of papering over that error, the entire calculation was
a bit suspect so removing, with possibility of adding it back in
later with handling the case (or raising appropriate errors) when
the algorithm has little cash on hand. 

文档字符串格式化

在为类、函数等添加或编辑文档字符串时，我们使用numpy作为权威参考。

更新 Whatsnew

我们有一套whatsnew文件，用于记录 Zipline 不同版本之间的变化。一旦你对 Zipline 进行了更改，在你的拉取请求中，请更新最近的whatsnew文件，并添加关于你所做更改的评论。你可以在之前的whatsnew文件中找到示例。

API

原文：zipline.ml4trading.io/api-reference.html

运行回测

run_algorithm()函数创建一个TradingAlgorithm实例，该实例代表一个交易策略和执行该策略的参数。

zipline.run_algorithm(...)

运行交易算法。

参数：

• 开始 (datetime) – 回测的开始日期。
• 结束 (datetime) – 回测的结束日期。
• 初始化 (可调用*[上下文 -> None]*) – 用于算法的初始化函数。在回测开始时调用一次，用于设置算法所需的状态。
• 资本基础 (float) – 回测的起始资本。
• 处理数据 (可调用***(上下文,* [BarData*)* -> None*]**,* 可选) – 用于算法的处理数据函数。当data_frequency == 'minute'时，每分钟调用一次；当data_frequency == 'daily'时，每天调用一次。
• 交易开始前 (可调用***(上下文,* [BarData*)* -> None*]**,* 可选) – 算法的交易开始前函数。在每个交易日开始前调用一次（在初始化的第一天之后）。
• 分析 (可调用*[(上下文,* pd.DataFrame)* -> None]**,* 可选) – 用于算法的分析函数。该函数在回测结束时被调用一次，并传入上下文和性能数据。
• 数据频率 ({‘daily’**, ‘minute’}**, 可选) – 算法运行的数据频率。
• 捆绑包 (str, 可选) – 用于加载回测数据的捆绑包名称。默认为‘quantopian-quandl’。
• 捆绑时间戳 (datetime*,* 可选) – 查找捆绑数据的日期时间。默认为当前时间。
• 交易日历 (TradingCalendar*,* 可选) – 用于回测的交易日历。
• 指标集 (可迭代*[Metric]或* str, 可选) – 模拟中要计算的指标集。如果传递了字符串，则使用zipline.finance.metrics.load()解析集合。
• 基准收益 (pd.Series*,* 可选) – 用作基准的收益序列。
• 默认扩展 (bool, 可选) – 是否加载默认的 zipline 扩展。该扩展位于$ZIPLINE_ROOT/extension.py。
• extensions (iterable*[str]**,* optional) – 要加载的任何其他扩展的名称。每个元素可以是像a.b.c这样的点分隔模块路径，也可以是像a/b/c.py这样的 python 文件路径，以.py结尾。
• strict_extensions (bool, optional) – 如果任何扩展加载失败，运行是否应该失败。如果此参数为 False，则会发出警告。
• environ (mapping*[str -> str]**,* optional) – 要使用的操作系统环境。许多扩展使用此参数来获取参数。默认值为os.environ。
• blotter (str or zipline.finance.blotter.Blotter*,* optional) – 要与此算法一起使用的 blotter。如果作为字符串传递，我们会在zipline.extensions.register中查找 blotter 构造函数并调用它，不带任何参数。默认值是一个永远不会取消订单的zipline.finance.blotter.SimulationBlotter。

返回：

perf – 算法的日表现。

返回类型：

pd.DataFrame

另请参阅

zipline.data.bundles.bundles

可用的数据包。

交易算法 API

在initialize、handle_data和before_trading_start API 函数中可用的方法如下。

在所有列出的函数中，self参数指的是当前执行的TradingAlgorithm实例。

数据对象

class zipline.protocol.BarData

提供从算法 API 函数访问每分钟和每日价格/成交量数据的方法。

还提供实用方法来确定资产是否存活，以及它是否有最近的成交数据。

此对象的实例作为data传递给handle_data()和before_trading_start()。

参数：

• data_portal (DataPortal) – 提供条形价格数据的提供者。
• simulation_dt_func (callable) – 返回当前模拟时间的函数。这通常绑定到 TradingSimulation 的方法。
• data_frequency ({‘minute’**, ‘daily’}) – 条形数据的频率；即数据是每日还是分钟条形图
• restrictions (zipline.finance.asset_restrictions.Restrictions) – 结合并返回来自多个来源的受限列表信息的对象

can_trade()

对于给定的资产或资产迭代器，如果满足以下所有条件，则返回 True：

1. 资产在当前模拟时间的会话中存活（如果当前模拟时间不是市场分钟，我们使用下一个会话）。
2. 资产的交易所当前模拟时间或模拟日历的下一个市场分钟是开放的。
3. 资产有一个已知的最后价格。

参数：

assets (zipline.assets.Asset 或 iterable of zipline.assets.Asset) – 确定可交易性的资产。

注意

上述第二个条件需要进一步解释：

• 如果资产的交易所日历与模拟日历相同，则此条件始终返回 True。
• 如果在模拟日历中有市场分钟不在该资产交易所的交易时间内（例如，如果模拟运行在 CMES 日历上，但资产是 MSFT，它在 NYSE 交易），在这些分钟内，这个条件将返回 False（例如，东部时间工作日早上 3:15，此时 CMES 开放但 NYSE 关闭）。

返回：

can_trade – 布尔值或布尔序列，指示在当前分钟内请求的资产是否可以交易。

返回类型：

bool 或 pd.Series[bool]

current()

返回给定资产在当前模拟时间下给定字段的“当前”值。

参数：

• assets (zipline.assets.Asset 或 iterable of zipline.assets.Asset) – 请求数据的资产。
• fields (str 或 iterable[str]**) – 请求的数据字段。有效的字段名称包括：“价格”、“最后交易”、“开盘”、“最高”、“最低”、“收盘”和“成交量”。

返回：

current_value – 见下文注释。

返回类型：

标量、pandas Series 或 pandas DataFrame。

注意

此函数的返回类型取决于其输入的类型：

• 如果请求的是单个资产和一个字段，返回的值是一个标量（根据字段不同，可能是浮点数或pd.Timestamp）。
• 如果请求的是单个资产和一组字段，返回的值是一个pd.Series，其索引是请求的字段。
• 如果请求的是一组资产和一个字段，返回的值是一个pd.Series，其索引是资产。
• 如果请求的是一组资产和一组字段，返回的值是一个pd.DataFrame。返回的框架的列将是请求的字段，索引将是请求的资产。

对于fields产生的值如下：

• 请求“价格”将产生该资产的最新收盘价格，如果该分钟没有交易，则从更早的一分钟前向填充。如果没有最新已知值（可能是因为该资产从未交易过，或者已经退市），则返回 NaN。如果找到值，并且我们必须跨越调整边界（拆分、股息等）才能获得它，则在返回之前将该值调整为当前模拟时间。
• 请求“开盘”、“最高”、“最低”或“收盘”将产生当前分钟的开盘、最高、最低或收盘价。如果该分钟没有交易发生，则返回NaN。
• 请求“成交量”将产生当前分钟的成交量。如果该分钟没有交易发生，则返回 0。
• 请求“最后交易”将产生该资产最后一次交易的分钟时间，即使该资产已经停止交易。如果没有最后一次已知值，则返回pd.NaT。

如果当前模拟时间对于某个资产不是有效的市场时间，我们将使用最近的市场收盘价代替。

history()

返回一个长度为bar_count的尾随窗口，其中包含给定资产、字段和频率的数据，并根据当前模拟时间调整了拆分、股息和合并。

缺失数据的行为与current()的注释中描述的行为相同。

参数：

• assets（zipline.assets.Asset 或 可迭代 的 zipline.assets.Asset）——请求数据的资产。
• fields（字符串 或 可迭代 的 字符串）——请求的数据字段。有效的字段名称包括：“价格”、“最后交易”、“开盘”、“最高”、“最低”、“收盘”和“成交量”。
• bar_count（int）——请求的数据观测值数量。
• 频率（str）——指示是否加载每日或每分钟数据观测值的字符串。传递’1m’表示每分钟数据，'1d’表示每日数据。

返回：

历史 – 请参见下面的注释。

返回类型：

pd.Series 或 pd.DataFrame 或 pd.Panel

笔记

此函数的返回类型取决于assets和fields的类型：

• 如果请求了一个资产和一个字段，返回的值是一个长度为bar_count的pd.Series，其索引是pd.DatetimeIndex。
• 如果请求了一个资产和多个字段，返回的值是一个具有形状(bar_count, len(fields))的pd.DataFrame。该数据框的索引将是一个pd.DatetimeIndex，其列将是fields。
• 如果请求了多个资产和一个字段，返回的值是一个具有形状(bar_count, len(assets))的pd.DataFrame。该数据框的索引将是一个pd.DatetimeIndex，其列将是assets。
• 如果请求了多个资产和多个字段，则返回值是具有 pd.MultiIndex 的 pd.DataFrame，其中包含 pd.DatetimeIndex 和 assets 的对，而列将包含字段（s）。它具有形状 (bar_count * len(assets), len(fields))。pd.MultiIndex 的名称是
  • date 如果频率 == ‘1d’ 或 `date_time` 如果频率 == ‘1m, 和
  • asset

如果当前模拟时间不是有效的市场时间，我们将使用上次市场收盘时间代替。

is_stale()

对于给定的资产或资产迭代器，如果资产存活且当前模拟时间没有交易数据，则返回 True。

如果资产从未交易，则返回 False。

如果当前模拟时间不是有效的市场时间，我们使用当前时间检查资产是否存活，但我们使用上次市场分钟/日进行交易数据检查。

参数：

assets (zipline.assets.Asset 或 iterable of zipline.assets.Asset) – 应确定其过时性的资产。

返回：

is_stale – 布尔值或布尔序列，指示请求的资产是否过时。

返回类型：

bool 或 pd.Series[bool]

调度函数

zipline.api.schedule_function(self, func, date_rule=None, time_rule=None, half_days=True, calendar=None)

安排一个函数在未来重复调用。

参数：

• func (callable) – 当规则触发时要执行的函数。func 应该与 handle_data 具有相同的签名。
• date_rule (zipline.utils.events.EventRule*,* optional) – 用于执行 func 的日期规则。如果未传递，则函数将在每个交易日运行。
• time_rule (zipline.utils.events.EventRule*,* optional) – 用于执行 func 的时间规则。如果未传递，则函数将在一天的第一个市场分钟的末尾执行。
• half_days (bool, optional) – 此规则是否应在半天内触发？默认为 True。
• calendar (Sentinel*,* optional) – 用于计算依赖于交易日的规则的日历。

另请参阅

zipline.api.date_rules, zipline.api.time_rules

class zipline.api.date_rules

基于日期的工厂 schedule_function() 规则。

另请参阅

schedule_function()

static every_day()

创建一个每天触发的规则。

返回：

rule

返回类型：

zipline.utils.events.EventRule

static month_end(days_offset=0)

创建一个规则，该规则在每个月末之前的固定数量的交易日触发。

参数：

days_offset (int, optional) – 触发前距离月末的交易天数。默认值为 0，即在月末最后一天触发。

返回：

规则

返回类型：

zipline.utils.events.EventRule

static month_start(days_offset=0)

创建一个在每月开始后固定交易天数触发的规则。

参数：

days_offset (int, optional) – 每月触发前等待的交易天数。默认值为 0，即在每月第一个交易日触发。

返回：

规则

返回类型：

zipline.utils.events.EventRule

static week_end(days_offset=0)

创建一个在每周结束前固定交易天数触发的规则。

参数：

days_offset (int, optional) – 触发前距离周末的交易天数。默认值为 0，即在周末最后一个交易日触发。

static week_start(days_offset=0)

创建一个在每周开始后固定交易天数触发的规则。

参数：

days_offset (int, optional) – 每周触发前等待的交易天数。默认值为 0，即在每周第一个交易日触发。

class zipline.api.time_rules

基于时间的 schedule_function() 规则的工厂。

另请参阅

schedule_function()

every_minute

别名：Always

static market_close(offset=None, hours=None, minutes=None)

创建一个在市场收盘后固定时间触发的规则。

偏移量可以指定为 datetime.timedelta，或者指定为小时和分钟数。

参数：

• offset (datetime.timedelta, optional) – 如果传递，触发的时间距离收盘的偏移量。必须至少为 1 分钟。
• hours (int, optional) – 如果传递，则在收盘前等待的小时数。
• minutes (int, optional) – 如果传递，则在收盘前等待的分钟数。

返回：

规则

返回类型：

zipline.utils.events.EventRule

注意

如果没有传递参数，默认偏移量是收盘前一分钟。

如果传递了offset，则不能传递hours和minutes。相反，如果传递了hours或minutes，则不能传递offset。

static market_open(offset=None, hours=None, minutes=None)

创建一个在市场开盘后固定时间触发的规则。

偏移量可以指定为 datetime.timedelta，或者指定为小时和分钟数。

参数：

• 偏移量 (datetime.timedelta, 可选) – 如果传递，触发时的开盘市场偏移量。必须至少为 1 分钟。
• 小时数 (整数, 可选) – 如果传递，市场开盘后等待的小时数。
• 分钟数 (整数, 可选) – 如果传递，市场开盘后等待的分钟数。

返回：

规则

返回类型：

zipline.utils.events.EventRule

注意

如果没有参数传递，默认偏移量为市场开盘后一分钟。

如果传递了offset，则不得传递hours和minutes。相反，如果传递了hours或minutes，则不得传递offset。

订单

zipline.api.order(self, asset, amount, limit_price=None, stop_price=None, style=None)

下固定数量的股票订单。

参数：

• 资产 (资产) – 要下单的资产。
• 数量 (整数) – 要下单的股票数量。如果amount为正数，这是要购买或平仓的股票数量。如果amount为负数，这是要卖出或做空的股票数量。
• 限价 (浮点数, 可选) – 订单的限价。
• 止损价 (浮点数, 可选) – 订单的止损价。
• 风格 (执行风格*,* 可选) – 订单的执行风格。

返回：

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

返回类型：

字符串 或 None

注意

limit_price和stop_price参数提供了传递常见执行风格的简写方式。传递limit_price=N等同于style=LimitOrder(N)。类似地，传递stop_price=M等同于style=StopOrder(M)，传递limit_price=N和stop_price=M等同于style=StopLimitOrder(N, M)。同时传递style和limit_price或stop_price是错误的。

另请参阅

zipline.finance.execution.ExecutionStyle, zipline.api.order_value(), zipline.api.order_percent()

zipline.api.order_value(self, asset, value, limit_price=None, stop_price=None, style=None)

下固定金额的订单。

等同于order(asset, value / data.current(asset, 'price'))。

参数：

• 资产 (资产) – 要下单的资产。
• 价值 (浮点数) – 要交易的资产的价值量。买入或卖出的股票数量将等于价值 / 当前价格。
• 限价 (浮点数, 可选) – 订单的限价。
• 止损价 (浮点数, 可选) – 订单的止损价。
• 类型 (ExecutionStyle) – 订单的执行类型。

返回：

订单 ID – 此订单的唯一标识符。

返回类型：

字符串

注意

有关限价、止损价和类型的更多信息，请参阅zipline.api.order()

参见

zipline.finance.execution.ExecutionStyle, zipline.api.order(), zipline.api.order_percent()

zipline.api.order_percent(self, asset, percent, limit_price=None, stop_price=None, style=None)

在指定的资产中下订单，对应于当前投资组合价值的给定百分比。

参数：

• 资产 (Asset) – 此订单所针对的资产。
• 百分比 (浮点数) – 分配给资产的投资组合价值的百分比。以小数形式指定，例如：0.50 表示 50%。
• 限价 (浮点数, 可选) – 订单的限价。
• 止损价 (浮点数, 可选) – 订单的止损价。
• 类型 (ExecutionStyle) – 订单的执行类型。

返回：

订单 ID – 此订单的唯一标识符。

返回类型：

字符串

注意

有关限价、止损价和类型的更多信息，请参阅zipline.api.order()

参见

zipline.finance.execution.ExecutionStyle, zipline.api.order(), zipline.api.order_value()

zipline.api.order_target(self, asset, target, limit_price=None, stop_price=None, style=None)

下达订单以调整持仓至目标股数。如果持仓不存在，这等同于下达新订单。如果持仓已存在，这等同于为当前股数与目标股数之差下达订单。

参数：

• asset (Asset) – 此订单所针对的资产。
• target (int) – asset的期望股数。
• limit_price (float, optional) – 订单的限价。
• stop_price (float, optional) – 订单的止损价格。
• style (ExecutionStyle) – 订单的执行风格。

返回：

order_id – 此订单的唯一标识符。

返回类型：

str

注释

order_target不考虑任何未完成订单。例如：

order_target(sid(0), 10)
order_target(sid(0), 10) 

这段代码将导致sid(0)的 20 股，因为第一次调用order_target时，第二次order_target调用尚未完成。

有关limit_price、stop_price和style的更多信息，请参阅zipline.api.order()。

另请参阅

zipline.finance.execution.ExecutionStyle，zipline.api.order()，zipline.api.order_target_percent()，zipline.api.order_target_value()

zipline.api.order_target_value(self, asset, target, limit_price=None, stop_price=None, style=None)

下达订单以调整持仓至目标价值。如果持仓不存在，这等同于下达新订单。如果持仓已存在，这等同于为当前价值与目标价值之差下达订单。如果所订购的资产是期货，则计算的“目标价值”实际上是目标敞口，因为期货没有“价值”。

参数：

• asset (Asset) – 此订单所针对的资产。
• target (float) – asset的期望总价值。
• limit_price (float, optional) – 订单的限价。
• stop_price (float, optional) – 订单的止损价格。
• 风格 (执行风格) – 订单的执行风格。

返回：

订单 ID – 该订单的唯一标识符。

返回类型：

str

注意

order_target_value 不考虑任何未完成订单。例如：

order_target_value(sid(0), 10)
order_target_value(sid(0), 10) 

这段代码将导致sid(0)的 20 美元，因为第一次调用order_target_value时，第二次order_target_value调用尚未完成。

有关limit_price、stop_price和style的更多信息，请参阅 zipline.api.order()

另请参阅

zipline.finance.execution.ExecutionStyle, zipline.api.order(), zipline.api.order_target(), zipline.api.order_target_percent()

zipline.api.order_target_percent(self, asset, target, limit_price=None, stop_price=None, style=None)

下订单以调整持仓至当前投资组合价值的预定百分比。如果持仓不存在，则等同于下新订单。如果持仓已存在，则等同于下订单以调整目标百分比与当前百分比之间的差额。

参数：

• 资产 (资产) – 该订单所针对的资产。
• 目标 (浮点数) – 希望分配给资产的投资组合价值的百分比。以小数形式指定，例如：0.50 表示 50%。
• 限价 (浮点数, 可选) – 订单的限价。
• 止损价 (浮点数, 可选) – 订单的止损价。
• 风格 (执行风格) – 订单的执行风格。

返回：

订单 ID – 该订单的唯一标识符。

返回类型：

str

注意

order_target_value 不考虑任何未完成订单。例如：

order_target_percent(sid(0), 10)
order_target_percent(sid(0), 10) 

这段代码将导致投资组合的 20%分配给sid(0)，因为第一次调用order_target_percent时，第二次order_target_percent调用尚未完成。

有关limit_price、stop_price和style的更多信息，请参阅 zipline.api.order()

另请参阅

zipline.finance.execution.ExecutionStyle, zipline.api.order(), zipline.api.order_target(), zipline.api.order_target_value()

class zipline.finance.execution.ExecutionStyle

订单执行风格的基类。

property exchange

此订单应被路由到的交易所。

abstract get_limit_price(is_buy)

获取此订单的限价。返回值为 None 或一个大于等于 0 的数值。

abstract get_stop_price(is_buy)

获取此订单的止损价格。返回值为 None 或一个大于等于 0 的数值。

class zipline.finance.execution.MarketOrder(exchange=None)

以当前市场价格成交的订单的执行风格。

这是使用order()下达的订单的默认设置。

class zipline.finance.execution.LimitOrder(limit_price, asset=None, exchange=None)

以等于或优于指定限价的价格成交的订单的执行风格。

参数：

限价 (float) – 买入的最高价格，或卖出的最低价格，订单应在该价格成交。

class zipline.finance.execution.StopOrder(stop_price, asset=None, exchange=None)

以市场价格达到阈值时下达的市场订单的执行风格。

参数：

止损价格 (float) – 订单应被下达的价格阈值。对于卖出，如果市场价格跌至该值以下，则下达订单。对于买入，如果市场价格升至该值以上，则下达订单。

class zipline.finance.execution.StopLimitOrder(limit_price, stop_price, asset=None, exchange=None)

执行风格，表示在市场价格达到阈值时下达的限价订单。

参数：

• 限价 (float) – 买入的最高价格，或卖出的最低价格，订单应在该价格或更好的价格成交。
• 止损价格 (float) – 订单应被下达的价格阈值。对于卖出，如果市场价格跌至该值以下，则下达订单。对于买入，如果市场价格升至该值以上，则下达订单。

zipline.api.get_order(self, order_id)

根据订单函数返回的订单 ID 查找订单。

参数：

订单 ID (str) – 订单的唯一标识符。

返回：

订单 – 订单对象。

返回类型：

订单

zipline.api.get_open_orders(self, asset=None)

检索所有当前的未结订单。

参数：

资产 (Asset) – 如果传递且不为 None，则仅返回给定资产的未结订单，而不是所有未结订单。

返回：

未结订单 – 如果没有传递资产，这将返回一个字典，将资产映射到包含该资产所有未结订单的列表。如果传递了资产，则这将返回该资产的未结订单列表。

返回类型：

字典[列表[Order]] 或 列表[Order]

zipline.api.cancel_order(self, order_param)

取消一个未完成的订单。

参数：

order_param (str 或 Order) – 要取消的订单 ID 或订单对象。

订单取消政策

zipline.api.set_cancel_policy(self, cancel_policy)

设置模拟的订单取消政策。

参数：

cancel_policy (CancelPolicy) – 要使用的取消政策。

另请参阅

zipline.api.EODCancel, zipline.api.NeverCancel

class zipline.finance.cancel_policy.CancelPolicy

抽象的取消政策接口。

abstract should_cancel(event)

是否应取消所有未完成的订单？

参数：

event (枚举值) –

事件类型之一：

• zipline.gens.sim_engine.BAR
• zipline.gens.sim_engine.DAY_START
• zipline.gens.sim_engine.DAY_END
• zipline.gens.sim_engine.MINUTE_END

返回：

should_cancel – 是否应取消所有未完成的订单？

返回类型：

布尔值

zipline.api.EODCancel(warn_on_cancel=True)

该政策在一天结束时取消未完成的订单。目前，Zipline 仅将此政策应用于每分钟模拟。

参数：

warn_on_cancel (bool, 可选) – 如果这导致订单被取消，是否应发出警告？

zipline.api.NeverCancel()

订单永远不会自动取消。

资产

zipline.api.symbol(self, symbol_str, country_code=None)

通过股票代码查找股票。

参数：

• symbol_str (str) – 要查找的股票的股票代码。
• 国家代码 (str 或 None*,* 可选) – 限制符号搜索的国家。

返回：

股票 – 在当前符号查找日期持有股票代码的股票。

返回类型：

zipline.assets.Equity

引发：

SymbolNotFound – 当符号在当前查找日期未被持有时引发。

另请参阅

zipline.api.set_symbol_lookup_date()

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

查找多个股票作为一个列表。

参数：

• args (iterable[str]*) – 要查找的股票代码。
• 国家代码 (str 或 None*,* 可选) – 限制符号搜索的国家。

返回：

股票 – 在当前符号查找日期持有给定股票代码的股票。

返回类型：

list[zipline.assets.Equity]

引发：

SymbolNotFound – 当在当前查找日期未持有其中一个符号时引发。

另请参阅

zipline.api.set_symbol_lookup_date()

zipline.api.future_symbol(self, symbol)

查找具有给定符号的期货合约。

参数：

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

返回：

future – 以symbol名称交易的期货。

返回类型：

zipline.assets.Future

引发：

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

zipline.api.set_symbol_lookup_date(self, dt)

设置符号将被解析为其资产的日期（符号可能在不同时间映射到不同的公司或底层资产）

参数：

dt (datetime) – 新的符号查找日期。

zipline.api.sid(self, sid)

通过其唯一资产标识符查找资产。

参数：

sid (int) – 标识资产的唯一整数。

返回：

asset – 具有给定sid的资产。

返回类型：

zipline.assets.Asset

引发：

SidsNotFound – 当请求的sid未映射到任何资产时。

交易控制

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 的行。

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

用户定义因子的基类。

参数：

• 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

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

类型：

布尔

注释

此类实例在访问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)

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