PyAlgoTrade 0.20 中文文档（二）

经纪人 - 订单管理类

原文：gbeced.github.io/pyalgotrade/docs/v0.20/html/broker.html

基础模块和类

类 pyalgotrade.broker.``Order（type_，action，instrument，quantity，instrumentTraits）

基类：object

订单的基类。

参数：

type（Order.Type）– 订单类型
action（Order.Action）– 订单操作。
instrument (string.) – 工具标识符。
quantity（int/float.）– 订单数量。

注

这是一个基类，不应直接使用。

有效的type参数值为：

Order.Type.MARKET
Order.Type.LIMIT
Order.Type.STOP
Order.Type.STOP_LIMIT

有效的action参数值为：

Order.Action.BUY
Order.Action.BUY_TO_COVER
Order.Action.SELL
Order.Action.SELL_SHORT

getId()

返回订单 ID。

注

如果订单未提交，则此值将为 None。

getType()

返回订单类型。有效的订单类型为：

Order.Type.MARKET
Order.Type.LIMIT
Order.Type.STOP
Order.Type.STOP_LIMIT

getSubmitDateTime()

返回订单提交的日期时间。

getAction()

返回订单操作。有效的订单操作包括：

Order.Action.BUY
Order.Action.BUY_TO_COVER
Order.Action.SELL
Order.Action.SELL_SHORT

getState()

返回订单状态。有效的订单状态为：

Order.State.INITIAL（初始状态）。
Order.State.SUBMITTED
Order.State.ACCEPTED
Order.State.CANCELED
Order.State.PARTIALLY_FILLED
Order.State.FILLED

isActive()

如果订单处于活动状态，则返回 True。

isInitial()

如果订单状态为 Order.State.INITIAL，则返回 True。

isSubmitted()

如果订单状态为 Order.State.SUBMITTED，则返回 True。

isAccepted()

如果订单状态为 Order.State.ACCEPTED，则返回 True。

isCanceled()

如果订单状态为 Order.State.CANCELED，则返回 True。

isPartiallyFilled()

如果订单状态为 Order.State.PARTIALLY_FILLED，则返回 True。

isFilled()

如果订单状态为 Order.State.FILLED，则返回 True。

getInstrument()

返回工具标识符。

getQuantity()

返回数量。

getFilled()

返回已执行的股票数量。

getRemaining()

返回仍未完成的股票数量。

getAvgFillPrice()

返回已执行的股票的平均价格，如果没有填充，则返回 None。

getGoodTillCanceled()

如果订单有效直到取消，则返回 True。

setGoodTillCanceled(goodTillCanceled)

设置订单是否应保持有效直到取消。如果在会话关闭时订单尚未填充，则未填充的订单将自动取消，如果它们未设置为有效直到取消

参数：	goodTillCanceled (boolean.) – 如果订单应保持有效直到取消，则为 True。

注

一旦订单提交，就无法更改。

getAllOrNone()

如果订单应完全执行，则返回 True，否则取消。

setAllOrNone(allOrNone)

设置此订单的全部或无属性。

参数：	allOrNone (boolean.) – 如果订单应完全填充，则为 True。

注意

一旦提交订单，就无法更改。

getExecutionInfo()

返回此订单的最后执行信息，如果到目前为止没有填充任何内容，则返回 None。每次订单或其部分被填充时，这将不同。

返回类型：	OrderExecutionInfo.

class pyalgotrade.broker.``MarketOrder(action, instrument, quantity, onClose, instrumentTraits)

基类：pyalgotrade.broker.Order

市价订单的基类。

注意

这是一个基类，不应直接使用。

getFillOnClose()

如果订单应尽可能接近收盘价填充（市价收盘订单），则返回 True。

class pyalgotrade.broker.``LimitOrder(action, instrument, limitPrice, quantity, instrumentTraits)

基类：pyalgotrade.broker.Order

限价单的基类。

注意

这是一个基类，不应直接使用。

getLimitPrice()

返回限价。

class pyalgotrade.broker.``StopOrder(action, instrument, stopPrice, quantity, instrumentTraits)

基类：pyalgotrade.broker.Order

停止订单的基类。

注意

这是一个基类，不应直接使用。

getStopPrice()

返回止损价格。

class pyalgotrade.broker.``StopLimitOrder(action, instrument, stopPrice, limitPrice, quantity, instrumentTraits)

基类：pyalgotrade.broker.Order

停止限价订单的基类。

注意

这是一个基类，不应直接使用。

getStopPrice()

返回止损价格。

getLimitPrice()

返回限价。

class pyalgotrade.broker.``OrderExecutionInfo(price, quantity, commission, dateTime)

基类：object

订单的执行信息。

getPrice()

返回填充价格。

getQuantity()

返回数量。

getCommission()

返回应用的佣金。

getDateTime()

返回订单执行的datatime.datetime。

class pyalgotrade.broker.``Broker

基类：pyalgotrade.observer.Subject

经纪人的基类。

注意

这是一个基类，不应直接使用。

getCash(includeShort=True)

返回可用现金。

参数：	includeShort (boolean.) – 包括空头头寸的现金。

getShares(instrument)

返回工具的股票数量。

getPositions()

返回一个将工具映射到股票的字典。

getActiveOrders(instrument=None)

返回仍然活跃的订单序列。

参数：	instrument (string.) – 一个可选的工具标识符，用于仅返回给定工具的活动订单。

submitOrder(order)

提交一个订单。

参数：	order (Order.) – 要提交的订单。

注意

调用此后，订单处于已提交状态，并且不会为此转换触发事件。
对同一订单调用两次将引发异常。

createMarketOrder(action, instrument, quantity, onClose=False)

创建一个市价订单。市价订单是以最佳可用价格买入或卖出股票的订单。通常，这种类型的订单将立即执行。但是，市价订单的执行价格不受保证。

参数：

action (Order.Action.BUY，或 Order.Action.BUY_TO_COVER，或 Order.Action.SELL 或 Order.Action.SELL_SHORT.) – 订单操作。
instrument (字符串.) – 工具标识符。
quantity (int/float.) – 订单数量。
onClose (布尔值.) – 如果订单应尽可能接近收盘价成交（市价收盘单）。默认为 False。

返回类型：	一个MarketOrder子类。

createLimitOrder(action, instrument, limitPrice, quantity)

创建一个限价订单。限价订单是以特定价格或更好的价格买入或卖出股票的订单。买入限价订单只能以限价或更低价格执行，卖出限价订单只能以限价或更高价格执行。

参数：

action (Order.Action.BUY，或 Order.Action.BUY_TO_COVER，或 Order.Action.SELL 或 Order.Action.SELL_SHORT.) – 订单操作。
instrument (字符串.) – 工具标识符。
limitPrice (float) – 订单价格。
quantity (int/float.) – 订单数量。

返回类型：	一个LimitOrder子类。

createStopOrder(action, instrument, stopPrice, quantity)

创建一个止损订单。止损订单，也称为止损单，是一种在股价达到指定价格（止损价格）时买入或卖出股票的订单。当止损价格达到时，止损订单变成市价订单。买入止损订单以高于当前市场价格的止损价格输入。投资者通常使用买入止损订单来限制亏损或保护已卖空的股票的利润。卖出止损订单以低于当前市场价格的止损价格输入。投资者通常使用卖出止损订单来限制亏损或保护他们拥有的股票的利润。

参数：

action (Order.Action.BUY，或 Order.Action.BUY_TO_COVER，或 Order.Action.SELL 或 Order.Action.SELL_SHORT.) – 订单操作。
instrument (字符串.) – 工具标识符。
stopPrice (float) – 触发价格。
quantity (int/float.) – 订单数量。

返回类型：	一个StopOrder子类。

createStopLimitOrder(action, instrument, stopPrice, limitPrice, quantity)

创建一个停止限价订单。停止限价订单是一种买入或卖出股票的订单，结合了停止订单和限价订单的特点。一旦触发了停止价格，停止限价订单就变成了一个限价订单，以指定的价格（或更好）执行。停止限价订单的好处在于投资者可以控制订单执行的价格。

参数：

action (Order.Action.BUY, or Order.Action.BUY_TO_COVER, or Order.Action.SELL or Order.Action.SELL_SHORT.) – 订单动作。
instrument (string.) – 工具标识符。
stopPrice (float) – 触发价格。
limitPrice (float) – 限价订单的价格。
quantity (int/float.) – 订单数量。

返回类型：	一个 StopLimitOrder 的子类。

cancelOrder(order)

请求取消订单。如果订单已成交，则会引发异常。

| 参数： | order (Order.) – 要取消的订单。 | ## 回测模块和类

类 pyalgotrade.broker.backtesting.``Commission

基类：object

实现不同佣金方案的基类。

注意

这是一个基类，不应直接使用。

calculate(order, price, quantity)

计算订单执行的佣金。

参数：

order (pyalgotrade.broker.Order.) – 执行的订单。
price (float.) – 每股价格。
quantity (float.) – 订单数量。

返回类型：	float。

类 pyalgotrade.broker.backtesting.``NoCommission

基类：pyalgotrade.broker.backtesting.Commission

一个 Commission 类，始终返回 0。

类 pyalgotrade.broker.backtesting.``FixedPerTrade(amount)

基类：pyalgotrade.broker.backtesting.Commission

一个 Commission 类，针对整个交易收取固定金额的手续费。

参数：	amount (float.) – 一笔订单的手续费。

类 pyalgotrade.broker.backtesting.``TradePercentage(percentage)

基类：pyalgotrade.broker.backtesting.Commission

一个 Commission 类，按整个交易的百分比收取手续费。

参数:	percentage (float.) – 要收取的百分比。0.01 表示 1%，以此类推。必须小于 1。

class pyalgotrade.broker.backtesting.``Broker(cash, barFeed, commission=None)

基类: pyalgotrade.broker.Broker

回测经纪人。

参数:

cash (int/float.) – 初始现金金额。
barFeed (pyalgotrade.barfeed.BarFeed) – 将提供条形的 bar feed。
commission (Commission) – 负责计算订单佣金的对象。

getCommission()

返回用于计算订单佣金的策略。

返回类型:	Commission.

getEquity()

返回组合价值（现金股票 * 价格）。

getFillStrategy()

返回当前设置的 pyalgotrade.broker.fillstrategy.FillStrategy。

setCommission(commission)

设置用于计算订单佣金的策略。

参数:	commission (Commission.) – 负责计算订单佣金的对象。

setFillStrategy(strategy)

设置要使用的 pyalgotrade.broker.fillstrategy.FillStrategy。

setShares(instrument, quantity, price)

在策略开始执行之前设置现有股份。

参数:

instrument – 仪器标识符。
quantity – 给定仪器的股票数量。
price – 每股的价格。

class pyalgotrade.broker.slippage.``SlippageModel

基类: object

滑点模型的基类。

注意

这是一个基类，不应直接使用。

calculatePrice(order, price, quantity, bar, volumeUsed)

返回订单的每股滑点价格。

参数:

order (pyalgotrade.broker.Order.) – 被填充的订单。
price (float.) – 滑点之前每股的价格。
quantity (float.) – 此次订单将填充的股票数量。
bar (pyalgotrade.bar.Bar.) – 当前的 bar。
volumeUsed (float.) – 到目前为止从当前 bar 获取的体积大小。

返回类型:	float.

class pyalgotrade.broker.slippage.``NoSlippage

基类: pyalgotrade.broker.slippage.SlippageModel

无滑点模型。

class pyalgotrade.broker.slippage.``VolumeShareSlippage(priceImpact=0.1)

基类：pyalgotrade.broker.slippage.SlippageModel

定义在 Zipline 的 VolumeShareSlippage 模型中的成交量份额滑点模型。滑点是通过将价格影响常数乘以订单与总成交量比率的平方来计算的。

查看 www.quantopian.com/help#ide-slippage 获取更多详细信息。

参数：	priceImpact (float.) – 定义您的订单对回测价格计算的影响程度。

class pyalgotrade.broker.fillstrategy.``FillStrategy

基类：object

用于回测的订单填充策略的基类。

fillLimitOrder(broker_, order, bar)

覆盖以返回限价订单的成交价格和数量，如果在给定时间无法成交订单，则返回 None。

参数：

broker (Broker) – 经纪人。
order (pyalgotrade.broker.LimitOrder) – 订单。
bar (pyalgotrade.bar.Bar) – 当前柱形图。

返回类型：	一个 FillInfo 或者如果订单不应该被填充则返回 None。

fillMarketOrder(broker_, order, bar)

覆盖以返回市价订单的成交价格和数量，如果在给定时间无法成交订单，则返回 None。

参数：

broker (Broker) – 经纪人。
order (pyalgotrade.broker.MarketOrder) – 订单。
bar (pyalgotrade.bar.Bar) – 当前柱形图。

返回类型：	一个 FillInfo 或者如果订单不应该被填充则返回 None。

fillStopLimitOrder(broker_, order, bar)

覆盖以返回停止限价订单的成交价格和数量，如果在给定时间无法成交订单，则返回 None。

参数：

broker (Broker) – 经纪人。
order (pyalgotrade.broker.StopLimitOrder) – 订单。
bar (pyalgotrade.bar.Bar) – 当前柱形图。

返回类型：	一个 FillInfo 或者如果订单不应该被填充则返回 None。

fillStopOrder(broker_, order, bar)

覆盖以返回停止订单的成交价格和数量，如果在给定时间无法成交订单，则返回 None。

参数：

broker (Broker) – 经纪人。
order (pyalgotrade.broker.StopOrder) – 订单。
bar (pyalgotrade.bar.Bar) – 当前柱形图。

返回类型：	一个 FillInfo 或者如果订单不应该被填充则返回 None。

onBars(broker_, bars)

覆盖（可选）以在经纪人处理新柱形图时收到通知。

参数：

broker（Broker）- 经纪人。
bars（pyalgotrade.bar.Bars）- 当前的条形图。

onOrderFilled（broker_, order）

重写（可选）以在订单被填充或部分填充时收到通知。

参数：

broker（Broker）- 经纪人。
order（pyalgotrade.broker.Order）- 填充的订单。

class pyalgotrade.broker.fillstrategy.``DefaultStrategy（volumeLimit=0.25）

基类：pyalgotrade.broker.fillstrategy.FillStrategy

默认填充策略。

参数：	volumeLimit（float）- 订单在一根条中可以占用的交易量的比例。必须> 0 且<= 1。如果为 None，则不检查交易量限制。

此策略的工作方式如下：

一个pyalgotrade.broker.MarketOrder始终使用开盘/收盘价填充。
一个pyalgotrade.broker.LimitOrder将会被如下方式填充：
- 如果限价已与开盘价突破，则使用开盘价。
- 如果该条包含限价，则使用限价。
- 请注意，在买入时，如果价格达到或低于限价，则价格会被突破，而在卖出时，如果价格达到或超过限价，则价格会被突破。
一个pyalgotrade.broker.StopOrder将会被如下方式填充：
- 如果止损价已与开盘价突破，则使用开盘价。
- 如果该条包含止损价，则使用止损价。
- 请注意，在买入时，如果价格达到或超过止损价，则价格会被突破，而在卖出时，如果价格达到或低于止损价，则价格会被突破。
一个pyalgotrade.broker.StopLimitOrder将会被如下方式填充：
- 如果止损价已与开盘价突破，或者如果该条包含止损价，则限价单将变为活动状态。
- 如果限价单处于活动状态：
  - 如果在同一根条中激活了限价单，并且限价也被突破，则使用止损价和限价填充价格中较好的那个（如前所述）。
  - 如果限价单在先前的条中激活，则使用限价填充价格（如前所述）。

注意

这是经纪人使用的默认策略。
默认情况下，它使用pyalgotrade.broker.slippage.NoSlippage滑点模型。
如果 volumeLimit 为 0.25，而某个条的交易量为 100，则在该条处理的所有订单中最多只能使用 25 股。
如果使用交易条形图，则该条的所有交易量都可以使用。

setSlippageModel（slippageModel）

设置滑点模型以使用。

参数:	slippageModel (pyalgotrade.broker.slippage.SlippageModel) – 滑点模型。

setVolumeLimit(volumeLimit)

设定体积限制。

参数:	volumeLimit (float) – 订单在柱状图中可以占用的体积比例。必须 > 0 且 <= 1。如果为 None，则不检查体积限制。

strategy – 基本策略类

原文：gbeced.github.io/pyalgotrade/docs/v0.20/html/strategy.html

策略是您定义的类，实现交易逻辑，何时买入，何时卖出等。

买卖可以通过两种方式进行：

使用以下任何方法进行个别订单的下单：
pyalgotrade.strategy.BaseStrategy.marketOrder()
pyalgotrade.strategy.BaseStrategy.limitOrder()
pyalgotrade.strategy.BaseStrategy.stopOrder()
pyalgotrade.strategy.BaseStrategy.stopLimitOrder()
使用包装一对进入/退出订单的更高级别接口：
pyalgotrade.strategy.BaseStrategy.enterLong()
pyalgotrade.strategy.BaseStrategy.enterShort()
pyalgotrade.strategy.BaseStrategy.enterLongLimit()
pyalgotrade.strategy.BaseStrategy.enterShortLimit()

位置是用于下单的高级抽象。它们本质上是一对进入-退出订单，并提供比使用个别订单更容易跟踪回报和损益的方式。

策略

class pyalgotrade.strategy.``BaseStrategy(barFeed, broker)

基类： object

策略的基类。

参数：

barFeed (pyalgotrade.barfeed.BaseBarFeed.) – 将提供 bars 的 bar feed。
broker (pyalgotrade.broker.Broker.) – 处理订单的经纪人。

注意

这是一个基类，不应直接使用。

getFeed()

返回此策略正在使用的pyalgotrade.barfeed.BaseBarFeed。

getBroker()

返回用于处理订单执行的pyalgotrade.broker.Broker。

getCurrentDateTime()

返回当前pyalgotrade.bar.Bars的datetime.datetime。

marketOrder(instrument, quantity, onClose=False, goodTillCanceled=False, allOrNone=False)

提交市价订单。

参数：

instrument（字符串.） – 工具标识符。
quantity（int/float.） – 股票数量。正数表示买入，负数表示卖出。
onClose（布尔值.） – 如果订单应尽可能接近收盘价成交（市价收盘订单），则为 True。默认值为 False。
goodTillCanceled（布尔值.） – 如果订单有效直至取消，则为 True。如果为 False，则订单在会话关闭时自动取消。
allOrNone（布尔值.） – 如果订单应完全成交或根本不成交，则为 True。

返回类型：	提交的pyalgotrade.broker.MarketOrder。

limitOrder（instrument, limitPrice, quantity, goodTillCanceled=False, allOrNone=False）

提交一个限价订单。

参数：

instrument（字符串.） – 工具标识符。
limitPrice（浮点数.） – 限价。
quantity（int/float.） – 股票数量。正数表示买入，负数表示卖出。
goodTillCanceled（布尔值.） – 如果订单有效直至取消，则为 True。如果为 False，则订单在会话关闭时自动取消。
allOrNone（布尔值.） – 如果订单应完全成交或根本不成交，则为 True。

返回类型：	提交的pyalgotrade.broker.LimitOrder。

stopOrder（instrument, stopPrice, quantity, goodTillCanceled=False, allOrNone=False）

提交一个止损订单。

参数：

instrument（字符串.） – 工具标识符。
stopPrice（浮点数.） – 止损价格。
quantity（int/float.） – 股票数量。正数表示买入，负数表示卖出。
goodTillCanceled（布尔值.） – 如果订单有效直至取消，则为 True。如果为 False，则订单在会话关闭时自动取消。
allOrNone（布尔值.） – 如果订单应完全成交或根本不成交，则为 True。

返回类型：	提交的pyalgotrade.broker.StopOrder。

stopLimitOrder（instrument, stopPrice, limitPrice, quantity, goodTillCanceled=False, allOrNone=False）

提交一个市价订单。

参数：

instrument（字符串.） – 工具标识符。
stopPrice（浮点数.） – 止损价格。
limitPrice（浮点数.） – 限价。
quantity（int/float.） – 股票数量。正数表示买入，负数表示卖出。
goodTillCanceled（布尔值.） – 如果订单有效直至取消，则为 True。如果为 False，则订单在会话关闭时自动取消。
allOrNone（布尔值.） – 如果订单应完全成交或根本不成交，则为 True。

返回类型：	提交的pyalgotrade.broker.StopLimitOrder。

enterLong（instrument, quantity, goodTillCanceled=False, allOrNone=False）

生成一个购买pyalgotrade.broker.MarketOrder以进入多头头寸。

参数：

instrument (字符串。) – 工具标识符。
quantity (整数。) – 入场订单数量。
goodTillCanceled (布尔值。) – 如果入场订单有效期直到取消，则为 True。如果为 False，则当会话关闭时订单会自动取消。
allOrNone (布尔值。) – 如果订单应完全成交或根本不成交，则为 True。

返回类型：	进入pyalgotrade.strategy.position.Position。

enterShort(instrument, quantity, goodTillCanceled=False, allOrNone=False)

生成一个卖空pyalgotrade.broker.MarketOrder以进入空头头寸。

参数：

instrument (字符串。) – 工具标识符。
quantity (整数。) – 入场订单数量。
goodTillCanceled (布尔值。) – 如果入场订单有效期直到取消，则为 True。如果为 False，则当会话关闭时订单会自动取消。
allOrNone (布尔值。) – 如果订单应完全成交或根本不成交，则为 True。

返回类型：	进入pyalgotrade.strategy.position.Position。

enterLongLimit(instrument, limitPrice, quantity, goodTillCanceled=False, allOrNone=False)

生成一个购买pyalgotrade.broker.LimitOrder以进入多头头寸。

参数：

instrument (字符串。) – 工具标识符。
limitPrice (浮点数。) – 限价。
quantity (整数。) – 入场订单数量。
goodTillCanceled (布尔值。) – 如果入场订单有效期直到取消，则为 True。如果为 False，则当会话关闭时订单会自动取消。
allOrNone (布尔值。) – 如果订单应完全成交或根本不成交，则为 True。

返回类型：	进入pyalgotrade.strategy.position.Position。

enterShortLimit(instrument, limitPrice, quantity, goodTillCanceled=False, allOrNone=False)

生成一个卖空pyalgotrade.broker.LimitOrder以进入空头头寸。

参数：

instrument (字符串。) – 工具标识符。
limitPrice (浮点数。) – 限价。
quantity (整数。) – 入场订单数量。
goodTillCanceled (布尔值。) – 如果入场订单有效期直到取消，则为 True。如果为 False，则当会话关闭时订单会自动取消。
allOrNone (布尔值。) – 如果订单应完全成交或根本不成交，则为 True。

返回类型：	输入的pyalgotrade.strategy.position.Position。

enterLongStop（instrument，stopPrice，quantity，goodTillCanceled=False，allOrNone=False）

生成一个购买pyalgotrade.broker.StopOrder以进入多头头寸。

参数：

instrument（字符串.） - 工具标识符。
stopPrice（float.） - 停止价格。
quantity（整数.） - 进入订单数量。
goodTillCanceled（布尔值.） - 如果进入订单有效直至取消，则为 True。如果为 False，则订单在交易会话结束时自动取消。
allOrNone（布尔值.） - 如果订单应完全填充或根本不填充，则为 True。

返回类型：	输入的pyalgotrade.strategy.position.Position。

enterShortStop（instrument，stopPrice，quantity，goodTillCanceled=False，allOrNone=False）

生成一个卖空pyalgotrade.broker.StopOrder以进入空头头寸。

参数：

instrument（字符串.） - 工具标识符。
stopPrice（float.） - 停止价格。
quantity（整数.） - 进入订单数量。
goodTillCanceled（布尔值.） - 如果进入订单有效直至取消，则为 True。如果为 False，则订单在交易会话结束时自动取消。
allOrNone（布尔值.） - 如果订单应完全填充或根本不填充，则为 True。

返回类型：	输入的pyalgotrade.strategy.position.Position。

enterLongStopLimit（instrument，stopPrice，limitPrice，quantity，goodTillCanceled=False，allOrNone=False）

生成一个购买pyalgotrade.broker.StopLimitOrder订单以进入多头头寸。

参数：

instrument（字符串.） - 工具标识符。
stopPrice（float.） - 停止价格。
limitPrice（float.） - 限价。
quantity（整数.） - 进入订单数量。
goodTillCanceled（布尔值.） - 如果进入订单有效直至取消，则为 True。如果为 False，则订单在交易会话结束时自动取消。
allOrNone（布尔值.） - 如果订单应完全填充或根本不填充，则为 True。

返回类型：	输入的pyalgotrade.strategy.position.Position。

enterShortStopLimit（instrument，stopPrice，limitPrice，quantity，goodTillCanceled=False，allOrNone=False）

生成一个卖空pyalgotrade.broker.StopLimitOrder订单以进入空头头寸。

参数：

instrument（字符串） - 仪器标识符。
stopPrice（浮点数） - 停止价格。
limitPrice（浮点数） - 限价。
quantity（整数） - 入市订单数量。
goodTillCanceled（布尔值） - 如果入市订单有效直到取消，则为 True。如果为 False，则订单在交易日结束时自动取消。
allOrNone（布尔值） - 如果订单应完全成交或根本不成交，则为 True。

返回类型:	输入的pyalgotrade.strategy.position.Position。

onEnterOk（position）

覆盖（可选）以在提交用于进入持仓的订单被成交时收到通知。默认实现为空。

参数:	position（pyalgotrade.strategy.position.Position.） - 由任何 enterLongXXX 或 enterShortXXX 方法返回的持仓。

onEnterCanceled（position）

覆盖（可选）以在提交用于进入持仓的订单被取消时收到通知。默认实现为空。

参数:	position（pyalgotrade.strategy.position.Position.） - 由任何 enterLongXXX 或 enterShortXXX 方法返回的持仓。

onExitOk（position）

覆盖（可选）以在提交用于退出持仓的订单被成交时收到通知。默认实现为空。

参数:	position（pyalgotrade.strategy.position.Position.） - 由任何 enterLongXXX 或 enterShortXXX 方法返回的持仓。

onExitCanceled（position）

覆盖（可选）以在提交用于退出持仓的订单被取消时收到通知。默认实现为空。

参数:	position（pyalgotrade.strategy.position.Position.） - 由任何 enterLongXXX 或 enterShortXXX 方法返回的持仓。

onStart（）

覆盖（可选）以在策略开始执行时收到通知。默认实现为空。

onFinish（bars）

覆盖（可选）以在策略完成执行时收到通知。默认实现为空。

参数:	bars（pyalgotrade.bar.Bars.） - 最后处理的 Bars。

onIdle（）

覆盖（可选）以在没有事件时收到通知。

注意

在纯回测情景中，此方法不会被调用。

onBars（bars）

覆盖（强制）以在有新 Bars 可用时收到通知。默认实现引发异常。

这是要覆盖的方法，以输入您的交易逻辑并输入/退出持仓。

参数：	bars (pyalgotrade.bar.Bars.) – 当前的 K 线数据。

onOrderUpdated(order)

覆盖（可选）以在订单更新时收到通知。

参数：	order (pyalgotrade.broker.Order.) – 更新的订单。

run()

仅调用一次（仅一次）以运行策略。

stop()

停止正在运行的策略。

attachAnalyzer(strategyAnalyzer)

添加一个 pyalgotrade.stratanalyzer.StrategyAnalyzer。

debug(msg)

在策略记录器上以 DEBUG 级别记录消息。

info(msg)

在策略记录器上以 INFO 级别记录消息。

warning(msg)

在策略记录器上以 WARNING 级别记录消息。

error(msg)

在策略记录器上以 ERROR 级别记录消息。

critical(msg)

在策略记录器上以 CRITICAL 级别记录消息。

resampleBarFeed(frequency, callback)

构建一个通过特定频率分组的重采样 K 线数据源。

参数：

frequency – 分组频率（以秒为单位）。必须大于 0。
callback – 一个类似于 onBars 的函数，当有新的 K 线数据可用时将被调用。

返回类型：	pyalgotrade.barfeed.BaseBarFeed.

class pyalgotrade.strategy.``BacktestingStrategy(barFeed, cash_or_brk=1000000)

基类：pyalgotrade.strategy.BaseStrategy

策略回测的基类。

参数：

barFeed (pyalgotrade.barfeed.BaseBarFeed.) – 用于策略回测的 K 线数据源。
cash_or_brk（int/float 或 pyalgotrade.broker.Broker.） – 起始资本或经纪人实例。

注意

这是一个基类，不应该直接使用。

setDebugMode(debugOn)

启用/禁用策略和回测经纪人中的调试级别消息。默认情况下启用。 ## 头寸

class pyalgotrade.strategy.position.``Position(strategy, entryOrder, goodTillCanceled, allOrNone)

基类： object

头寸的基类。

头寸是更高级别的抽象，用于下订单。它们基本上是一对进出订单，并且允许跟踪回报和利润更容易地比手动下订单。

参数：

strategy (pyalgotrade.strategy.BaseStrategy.) – 属于该头寸的策略。
entryOrder (pyalgotrade.broker.Order) – 用于进入头寸的订单。
goodTillCanceled (boolean.) – 如果应将进入订单设置为有效直至取消，则为 True。
allOrNone (boolean.) – 如果订单应完全成交或根本不成交，则为 True。

注意

这是一个基类，不应直接使用。

getShares()

返回股票数量。对于多头头寸，这将是正数，对于空头头寸，这将是负数。

注意

如果进入订单未成交，或者如果头寸已关闭，则股票数量将为 0。

entryActive()

如果进入订单有效，则返回 True。

entryFilled()

如果进入订单已成交，则返回 True。

exitActive()

如果退出订单有效，则返回 True。

exitFilled()

如果退出订单已成交，则返回 True。

getEntryOrder()

返回用于进入该头寸的pyalgotrade.broker.Order。

getExitOrder()

返回用于退出该头寸的pyalgotrade.broker.Order。如果此头寸尚未关闭，则返回 None。

getInstrument()

返回用于此头寸的工具。

getReturn(includeCommissions=True)

计算到目前为止的累积百分比收益。如果头寸未关闭，则这些将是未实现的收益。

getPnL(includeCommissions=True)

计算到目前为止的损益。如果头寸未关闭，则这些将是未实现的损益。

cancelEntry()

如果进入订单有效，则会请求取消。

cancelExit()

如果退出订单有效，则会请求取消。

exitMarket(goodTillCanceled=None)

提交市价订单以关闭此头寸。

参数:	goodTillCanceled (boolean.) – 如果退出订单有效直到取消，则为 True。如果为 False，则当会话关闭时订单会自动取消。如果为 None，则与进入订单匹配。

注意

如果头寸已关闭（进入取消或退出成交），则此操作不会产生任何影响。
如果此头寸的退出订单处于挂起状态，则会引发异常。应先取消退出订单。
如果进入订单有效，则会请求取消。

exitLimit(limitPrice, goodTillCanceled=None)

提交限价订单以关闭此头寸。

参数:

limitPrice (float.) – 限价。
goodTillCanceled (boolean.) – 如果退出订单有效直到取消，则为 True。如果为 False，则当会话关闭时订单会自动取消。如果为 None，则与进入订单匹配。

注意

如果头寸已关闭（进入取消或退出成交），则此操作不会产生任何影响。
如果此头寸的退出订单处于挂起状态，则会引发异常。应先取消退出订单。
如果进入订单有效，则会请求取消。

exitStop(stopPrice, goodTillCanceled=None)

提交停止订单以关闭此头寸。

参数:

stopPrice (float.) – 停止价格。
goodTillCanceled（boolean.）– 如果退出订单有效期长达取消，则为 True。如果为 False，则在会话关闭时订单会自动取消。如果为 None，则会与进入订单匹配。

注意

如果持仓已关闭（进入取消或退出已填充），则不会产生任何影响。
如果此持仓的退出订单仍在等待中，则会引发异常。必须首先取消退出订单。
如果进入订单仍然有效，则将请求取消。

exitStopLimit（stopPrice, limitPrice, goodTillCanceled=None）

提交一个停止限价订单以关闭此持仓。

参数：

stopPrice（float.）– 止损价。
limitPrice（float.）– 限价。
goodTillCanceled（boolean.）– 如果退出订单有效期长达取消，则为 True。如果为 False，则在会话关闭时订单会自动取消。如果为 None，则会与进入订单匹配。

注意

如果持仓已关闭（进入取消或退出已填充），则不会产生任何影响。
如果此持仓的退出订单仍在等待中，则会引发异常。必须首先取消退出订单。
如果进入订单仍然有效，则将请求取消。

isOpen()

如果持仓是打开的，则返回 True。

getAge()

返回处于打开状态的持续时间。

返回类型：	datetime.timedelta。

注意

如果持仓是打开的，则返回进入日期和最后一根 K 线日期之间的差异。
如果持仓已关闭，则返回进入日期和退出日期之间的差异。

stratanalyzer – 策略分析器

原文：gbeced.github.io/pyalgotrade/docs/v0.20/html/stratanalyzer.html

策略分析器提供了一种可扩展的方式，用于将不同的计算附加到策略执行上。

类 pyalgotrade.stratanalyzer.``StrategyAnalyzer

基类: object

策略分析器的基类。

注意

这是一个基类，不应直接使用。

类 pyalgotrade.stratanalyzer.returns.``Returns(maxLen=None)

基类: pyalgotrade.stratanalyzer.StrategyAnalyzer

一个 pyalgotrade.stratanalyzer.StrategyAnalyzer ，用于计算整个投资组合的时间加权收益。

参数:	maxLen (整数.) – 在净和累积收益数据序列中保留的最大值数。一旦有界长度已满，当添加新项时，相应数量的项将从相反端丢弃。如果为 None，则使用 dataseries.DEFAULT_MAX_LEN。

getCumulativeReturns()

返回一个pyalgotrade.dataseries.DataSeries ，其中包含每个条的累积收益。

getReturns()

返回一个pyalgotrade.dataseries.DataSeries ，其中包含每个条的收益。 ## 夏普比率

类 pyalgotrade.stratanalyzer.sharpe.``SharpeRatio(useDailyReturns=True)

基类: pyalgotrade.stratanalyzer.StrategyAnalyzer

一个 pyalgotrade.stratanalyzer.StrategyAnalyzer ，用于计算整个投资组合的夏普比率。

参数:	useDailyReturns (布尔类型.) – 如果应使用每日收益而不是每个条的收益，则为 True。

getSharpeRatio(riskFreeRate, annualized=True)

返回策略执行的夏普比率。如果波动率为 0，则返回 0。

参数:

riskFreeRate (整数/浮点数.) – 每年的无风险利率。
annualized (布尔类型.) – 如果夏普比率应年化，则为 True。

| ## 最大回撤

类 pyalgotrade.stratanalyzer.drawdown.``DrawDown

基类: pyalgotrade.stratanalyzer.StrategyAnalyzer

一个 pyalgotrade.stratanalyzer.StrategyAnalyzer ，用于计算投资组合的最大回撤和最长回撤持续时间。

getLongestDrawDownDuration()

返回最长回撤的持续时间。

返回类型:	datetime.timedelta.

注意

请注意，这是最长回撤的持续时间，不一定是最深的回撤。

getMaxDrawDown()

返回最大（最深）回撤。## 交易

类 pyalgotrade.stratanalyzer.trades.``Trades

基类：pyalgotrade.stratanalyzer.StrategyAnalyzer

一个pyalgotrade.stratanalyzer.StrategyAnalyzer，记录每笔已完成交易的利润/损失和回报。

注意

此分析器对单个已完成交易进行操作。例如，假设您从1000 现金开始，然后以10 购买 XYZ 的 1 股，后来以

该交易的利润为$10。
即使您的整个投资组合从1000 增加到1020，该交易的回报率为 100%。

getCount()

返回交易总数。

getProfitableCount()

返回盈利交易的数量。

getUnprofitableCount()

返回不盈利交易的数量。

getEvenCount()

返回净利润为 0 的交易数量。

getAll()

返回一个 numpy.array，其中包含每个交易的利润/损失。

getProfits()

返回一个 numpy.array，其中包含每个盈利交易的利润。

getLosses()

返回一个 numpy.array，其中包含每个亏损交易的损失。

getAllReturns()

返回一个 numpy.array，其中包含每个交易的回报。

getPositiveReturns()

返回一个 numpy.array，其中包含每个交易的正回报。

getNegativeReturns()

返回一个 numpy.array，其中包含每个交易的负回报。

getCommissionsForAllTrades()

返回一个 numpy.array，其中包含每个交易的佣金。

getCommissionsForProfitableTrades()

返回一个 numpy.array，其中包含每个盈利交易的佣金。

getCommissionsForUnprofitableTrades()

返回一个 numpy.array，其中包含每个亏损交易的佣金。

getCommissionsForEvenTrades()

返回一个 numpy.array，其中包含净利润为 0 的每个交易的佣金。

示例

将此代码保存为 sma_crossover.py：

代码语言：javascript复制

from pyalgotrade import strategy
from pyalgotrade.technical import ma
from pyalgotrade.technical import cross

class SMACrossOver(strategy.BacktestingStrategy):
    def __init__(self, feed, instrument, smaPeriod):
        super(SMACrossOver, self).__init__(feed)
        self.__instrument = instrument
        self.__position = None
        # We'll use adjusted close values instead of regular close values.
        self.setUseAdjustedValues(True)
        self.__prices = feed[instrument].getPriceDataSeries()
        self.__sma = ma.SMA(self.__prices, smaPeriod)

    def getSMA(self):
        return self.__sma

    def onEnterCanceled(self, position):
        self.__position = None

    def onExitOk(self, position):
        self.__position = None

    def onExitCanceled(self, position):
        # If the exit was canceled, re-submit it.
        self.__position.exitMarket()

    def onBars(self, bars):
        # If a position was not opened, check if we should enter a long position.
        if self.__position is None:
            if cross.cross_above(self.__prices, self.__sma) > 0:
                shares = int(self.getBroker().getCash() * 0.9 / bars[self.__instrument].getPrice())
                # Enter a buy market order. The order is good till canceled.
                self.__position = self.enterLong(self.__instrument, shares, True)
        # Check if we have to exit the position.
        elif not self.__position.exitActive() and cross.cross_below(self.__prices, self.__sma) > 0:
            self.__position.exitMarket()

并将此代码保存在不同的文件中：

代码语言：javascript复制

from __future__ import print_function

from pyalgotrade.barfeed import yahoofeed
from pyalgotrade.stratanalyzer import returns
from pyalgotrade.stratanalyzer import sharpe
from pyalgotrade.stratanalyzer import drawdown
from pyalgotrade.stratanalyzer import trades

from . import sma_crossover

# Load the bars. This file was manually downloaded from Yahoo Finance.
feed = yahoofeed.Feed()
feed.addBarsFromCSV("orcl", "orcl-2000-yahoofinance.csv")

# Evaluate the strategy with the feed's bars.
myStrategy = sma_crossover.SMACrossOver(feed, "orcl", 20)

# Attach different analyzers to a strategy before executing it.
retAnalyzer = returns.Returns()
myStrategy.attachAnalyzer(retAnalyzer)
sharpeRatioAnalyzer = sharpe.SharpeRatio()
myStrategy.attachAnalyzer(sharpeRatioAnalyzer)
drawDownAnalyzer = drawdown.DrawDown()
myStrategy.attachAnalyzer(drawDownAnalyzer)
tradesAnalyzer = trades.Trades()
myStrategy.attachAnalyzer(tradesAnalyzer)

# Run the strategy.
myStrategy.run()

print("Final portfolio value: $%.2f" % myStrategy.getResult())
print("Cumulative returns: %.2f  %%" % (retAnalyzer.getCumulativeReturns()[-1] * 100))
print("Sharpe ratio: %.2f" % (sharpeRatioAnalyzer.getSharpeRatio(0.05)))
print("Max. drawdown: %.2f  %%" % (drawDownAnalyzer.getMaxDrawDown() * 100))
print("Longest drawdown duration: %s" % (drawDownAnalyzer.getLongestDrawDownDuration()))

print("")
print("Total trades: %d" % (tradesAnalyzer.getCount()))
if tradesAnalyzer.getCount() > 0:
    profits = tradesAnalyzer.getAll()
    print("Avg. profit: $%2.f" % (profits.mean()))
    print("Profits std. dev.: $%2.f" % (profits.std()))
    print("Max. profit: $%2.f" % (profits.max()))
    print("Min. profit: $%2.f" % (profits.min()))
    returns = tradesAnalyzer.getAllReturns()
    print("Avg. return: %2.f %%" % (returns.mean() * 100))
    print("Returns std. dev.: %2.f %%" % (returns.std() * 100))
    print("Max. return: %2.f %%" % (returns.max() * 100))
    print("Min. return: %2.f %%" % (returns.min() * 100))

print("")
print("Profitable trades: %d" % (tradesAnalyzer.getProfitableCount()))
if tradesAnalyzer.getProfitableCount() > 0:
    profits = tradesAnalyzer.getProfits()
    print("Avg. profit: $%2.f" % (profits.mean()))
    print("Profits std. dev.: $%2.f" % (profits.std()))
    print("Max. profit: $%2.f" % (profits.max()))
    print("Min. profit: $%2.f" % (profits.min()))
    returns = tradesAnalyzer.getPositiveReturns()
    print("Avg. return: %2.f %%" % (returns.mean() * 100))
    print("Returns std. dev.: %2.f %%" % (returns.std() * 100))
    print("Max. return: %2.f %%" % (returns.max() * 100))
    print("Min. return: %2.f %%" % (returns.min() * 100))

print("")
print("Unprofitable trades: %d" % (tradesAnalyzer.getUnprofitableCount()))
if tradesAnalyzer.getUnprofitableCount() > 0:
    losses = tradesAnalyzer.getLosses()
    print("Avg. loss: $%2.f" % (losses.mean()))
    print("Losses std. dev.: $%2.f" % (losses.std()))
    print("Max. loss: $%2.f" % (losses.min()))
    print("Min. loss: $%2.f" % (losses.max()))
    returns = tradesAnalyzer.getNegativeReturns()
    print("Avg. return: %2.f %%" % (returns.mean() * 100))
    print("Returns std. dev.: %2.f %%" % (returns.std() * 100))
    print("Max. return: %2.f %%" % (returns.max() * 100))
    print("Min. return: %2.f %%" % (returns.min() * 100))

输出应如下所示：

代码语言：javascript复制

Final portfolio value: $1295462.60
Cumulative returns: 29.55 %
Sharpe ratio: 0.70
Max. drawdown: 24.58 %
Longest drawdown duration: 277 days, 0:00:00

Total trades: 13
Avg. profit: $14391
Profits std. dev.: $127520
Max. profit: $420782
Min. profit: $-89317
Avg. return:  2 %
Returns std. dev.: 13 %
Max. return: 46 %
Min. return: -7 %

Profitable trades: 3
Avg. profit: $196972
Profits std. dev.: $158985
Max. profit: $420782
Min. profit: $66466
Avg. return: 21 %
Returns std. dev.: 18 %
Max. return: 46 %
Min. return:  6 %

Unprofitable trades: 10
Avg. loss: $-40383
Losses std. dev.: $23579
Max. loss: $-89317
Min. loss: $-4702
Avg. return: -3 %
Returns std. dev.:  2 %
Max. return: -0 %
Min. return: -7 %

目录的表

策略分析器 – 策略分析器
- 回报
- 夏普比率
- 回撤
- 交易
- 示例

plotter – 策略绘图器

原文：gbeced.github.io/pyalgotrade/docs/v0.20/html/plotter.html

class pyalgotrade.plotter.``Subplot

基类: object

addCallback(label, callback, defaultClass=<class ‘pyalgotrade.plotter.LineMarker’>)

添加一个在每个 bar 上调用的回调。

参数:

label (string.) – 系列值的名称。
callback – 一个接收pyalgotrade.bar.Bars实例作为参数并返回一个数字或 None 的函数。

addDataSeries(label, dataSeries, defaultClass=<class ‘pyalgotrade.plotter.LineMarker’>)

将一个 DataSeries 添加到 subplot 中。

参数:

label (string.) – DataSeries 值的名称。
dataSeries (pyalgotrade.dataseries.DataSeries.) – 要添加的 DataSeries。

addLine(label, level)

将水平线添加到绘图中。

参数:

label (string.) – 一个标签。
level (int/float.) – 线的位置。

class pyalgotrade.plotter.``InstrumentSubplot(instrument, plotBuySell)

基类: pyalgotrade.plotter.Subplot

负责绘制一个仪器的 Subplot。

class pyalgotrade.plotter.``StrategyPlotter(strat, plotAllInstruments=True, plotBuySell=True, plotPortfolio=True)

基类: object

负责绘制策略执行的类。

参数:

strat (pyalgotrade.strategy.BaseStrategy.) – 要绘制的策略。
plotAllInstruments (boolean.) – 设置为 True 以获取每个可用仪器的子图。
plotBuySell (boolean.) – 设置为 True 以绘制每个可用仪器的买入/卖出事件。
plotPortfolio (boolean.) – 设置为 True 以绘制投资组合价值（股票现金）。

buildFigureAndSubplots(fromDateTime=None, toDateTime=None, postPlotFun=<function _post_plot_fun at 0x108da0b18>)

使用子图构建一个 matplotlib.figure.Figure。必须在运行策略后调用。

参数:

fromDateTime (datetime.datetime) – 可选的开始 datetime.datetime。之前的所有内容都不会被绘制。
toDateTime (datetime.datetime) – 可选的结束 datetime.datetime。之后的所有内容都不会被绘制。

返回类型:	一个包含 matplotlib.figure.Figure 和 subplots 的二元组。

getInstrumentSubplot(instrument)

返回给定仪器的 InstrumentSubplot

返回类型:	InstrumentSubplot.

getOrCreateSubplot(name)

根据名称返回 Subplot。如果子图不存在，则会创建。

参数:	name (字符串.) – 要获取或创建的子图的名称。
返回类型:	子图.

getPortfolioSubplot()

返回投资组合价值被绘制的子图。

返回类型:	子图.

plot(fromDateTime=None, toDateTime=None, postPlotFun=<function _post_plot_fun at 0x108da0b18>)

绘制策略执行。必须在运行策略后调用。

参数:

fromDateTime (datetime.datetime) – 可选的起始日期时间。该日期时间之前的所有内容都不会被绘制。
toDateTime (datetime.datetime) – 可选的结束日期时间。该日期时间之后的所有内容都不会被绘制。

savePlot(filename, dpi=None, format=‘png’, fromDateTime=None, toDateTime=None)

将策略执行绘制到文件中。必须在运行策略后调用。

参数:

filename – 文件名。
dpi – 每英寸点数（dots per inch）的分辨率。
format – 文件扩展名。
fromDateTime (datetime.datetime) – 可选的起始日期时间。该日期时间之前的所有内容都不会被绘制。
toDateTime (datetime.datetime) – 可选的结束日期时间。该日期时间之后的所有内容都不会被绘制。

优化器 – 并行优化器

原文：gbeced.github.io/pyalgotrade/docs/v0.20/html/optimizer.html

类 pyalgotrade.optimizer.server.``Results（parameters, result）

基类：object

策略执行的结果。

getParameters()

返回参数值序列。

getResult()

返回给定参数集的结果。

pyalgotrade.optimizer.server.``serve(barFeed, strategyParameters, address, port, batchSize=200)

执行一个服务器，该服务器将为工作者提供 K 线数据和策略参数。

参数：

barFeed（pyalgotrade.barfeed.BarFeed）– 每个工作者将用于回测策略的 K 线数据源。
strategyParameters – 用于回测的参数集。一个可迭代对象，其中每个元素都是一个保存参数值的元组。
address（string.）– 监听传入工作连接的地址。
端口（int.）– 监听传入工作连接的端口。
batchSize（int.）– 交付给每个工作者的策略执行数量。

返回类型：	一个Results实例，其中包含找到的最佳结果，如果没有获得结果，则为 None。

pyalgotrade.optimizer.worker.``run(strategyClass, address, port, workerCount=None, workerName=None)

执行一个或多个工作进程，这些进程将使用服务器提供的 K 线数据和参数运行策略。

参数：

strategyClass – 策略类。
address（string.）– 服务器地址。
port（int.）– 服务器监听传入连接的端口。
workerCount（int.）– 要运行的工作者进程数。如果为 None，则使用与 CPU 数量相同的工作者。
workerName（string.）– 工作者的名称。标识工作者的名称。如果为 None，则使用主机名。

pyalgotrade.optimizer.local.``run(strategyClass, barFeed, strategyParameters, workerCount=None, logLevel=40, batchSize=200)

并行执行多个策略实例，并找到产生最佳结果的参数。

参数：

strategyClass – 策略类。
barFeed（pyalgotrade.barfeed.BarFeed）– 用于回测策略的 K 线数据源。
strategyParameters – 用于回测的参数集。一个可迭代对象，其中每个元素都是一个保存参数值的元组。
workerCount（int.）– 并行运行的策略数量。如果为 None，则使用与 CPU 数量相同的工作者。
logLevel – 日志级别。默认为logging.ERROR。
batchSize（int.）– 交付给每个工作者的策略执行数量。

返回类型：	一个Results实例，其中包含找到的最佳结果。

注意

服务器组件将策略执行分成不同的块，并分配给不同的工作器。您可以通过将batchSize传递给pyalgotrade.optimizer.xmlrpcserver.Server的构造函数来选择块大小。
pyalgotrade.strategy.BaseStrategy.getResult()方法用于选择最佳的策略执行。您可以重写该方法以使用不同的标准对执行进行排名。

marketsession – 市场交易时段

原文：gbeced.github.io/pyalgotrade/docs/v0.20/html/marketsession.html

class pyalgotrade.marketsession.``MarketSession

基类：object

市场交易时段的基类。

注意

这是一个基类，不应直接使用。

classmethod getTimezone()

返回市场交易时段的 pytz 时区。

class pyalgotrade.marketsession.``NASDAQ