Zipline 3.0 中文文档（二）（1）-阿里云开发者社区

什么是交易日历？

交易日历代表单个市场交易所的时间信息。时间信息由两部分组成：时段和开/闭市时间。这由 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):

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文件中找到示例。

运行回测

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：

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

参数：

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 3.0 中文文档（二）（2）https://developer.aliyun.com/article/1523923

探索云世界

热门

云计算

大数据

云原生

人工智能

数据库

开发与运维

活动广场

任务中心

训练营

直播

乘风者计划

下载

镜像站

技术资料

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

什么是交易日历？

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

TradingCalendar类

构建自定义交易日历

结论

什么是交易日历？

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

TradingCalendar 类

构建自定义交易日历

结论

度量

度量集

选择度量集

命令行和 IPython 魔术

run_algorithm

不带度量运行

定义新度量

start_of_simulation

end_of_simulation

start_of_session

end_of_session

end_of_bar

定义新的度量集

度量集

选择度量集

命令行和 IPython 魔法

run_algorithm

命令行和 IPython 魔法

run_algorithm

不带度量运行

定义新指标

start_of_simulation

end_of_simulation

start_of_session

end_of_session

end_of_bar

start_of_simulation

end_of_simulation

start_of_session

end_of_session

end_of_bar

定义新的度量集

开发

创建开发环境

风格指南与运行测试

持续集成

打包

为文档做出贡献

提交消息

格式化文档字符串

更新 Whatsnew

创建开发环境

样式指南与运行测试

持续集成

打包

贡献文档

提交消息

文档字符串格式化

更新 Whatsnew

运行回测

交易算法 API

数据对象

调度函数

`TradingCalendar`类

`run_algorithm`

`start_of_simulation`

`end_of_simulation`

`start_of_session`

`end_of_session`

`end_of_bar`

`run_algorithm`

`run_algorithm`

`start_of_simulation`

`end_of_simulation`

`start_of_session`

`end_of_session`

`end_of_bar`

`start_of_simulation`

`end_of_simulation`

`start_of_session`

`end_of_session`

`end_of_bar`