绝不原创的飞龙

Python 算法交易秘籍（五）

原文：zh.annas-archive.org/md5/010eca9c9f84c67fe4f8eb1d9bd1d316

译者：飞龙

协议：CC BY-NC-SA 4.0

第十一章：算法交易 - 实际交易

现在我们已经建立了各种算法交易策略，并成功地进行了令人满意的回测，并在实时市场中进行了纸上交易，现在终于到了进行实际交易的时候了。

实际交易是指我们在真实市场小时内用真钱执行交易策略。如果您的策略在回测和纸上交易中表现良好，您可以期待在真实市场中获得类似的结果。请注意，尽管您的策略在回测和纸上交易中表现良好，但在真实市场中可能表现不如预期。盈利的回测和纸上交易结果是盈利的实际交易经验的前提，但不足以保证每个交易会盈利。

对于实际交易，需要策略配置。它包含多个参数，其中一些如下：

开始和结束时间：在当前一天内进行纸上交易的时间段。
金融工具：进行纸上交易的一个或多个金融工具。
蜡烛间隔：各种可能的蜡烛间隔之一；例如，1 分钟，15 分钟，小时或天。
策略特定参数：在策略中定义的自定义参数的值。
策略模式：其中之一是日内或交割。日内策略 punch 日内订单，这些订单在当天结束时平仓。交割策略 punch 交割订单，这些订单不会在当天结束时平仓，而会被延续到下一个交易日。

实际交易引擎需要根据给定的策略执行实际交易。在本章中，您将使用由 AlgoBulls 提供的实际交易引擎（algobulls.com），这是一个通过其开发者选项提供其服务的算法交易平台。它提供了一个名为 pyalgotrading 的 Python 包（github.com/algobulls/pyalgotrading）来提供这些服务。

您在第八章中编写了两个算法交易策略，逐步编码算法交易策略。请回忆一下策略描述如下：

EMA-Regular-Order 策略：基于技术指标 EMA 和常规订单的策略。（第七章的前六个配方，在交易所上放置挂单和止损单）
MACD-Bracket-Order 策略：基于技术指标 MACD 和挂单的策略。（第七章的其余六个配方，在交易所上放置挂单和止损单）

这些策略也作为 Python 包的一部分提供，即 pyalgostrategypool。你可以使用 $ pip install pyalgostrategypool 命令安装它。你也可以在 GitHub 上查看它们 (github.com/algobulls/pyalgostrategypool)。

当你在第八章中跟随 算法交易策略 – 逐步编码，你将这两个策略上传到你的 AlgoBulls 账户。在本章中，你将从你的 AlgoBulls 账户获取这些策略，并对它们进行真实交易。真实交易完全自动化，不需要你的任何干预，而交易会话正在进行时。进行真实交易后，你将收集策略执行日志和各种报告 – 即盈亏报告和统计报告。通过使用 pyalgotrading，你确保专注于开发和执行真实交易策略，而不必担心策略执行所需的生态系统。

本章包括了先前提及的策略的逐步示例，从建立到 AlgoBulls 平台的连接，获取策略，运行真实交易作业到获取执行日志和各种类型报告。

在本章中，你将学习以下内容：

EMA-Regular-Order 策略 – 获取该策略
EMA-Regular-Order 策略 – 实际交易该策略
EMA-Regular-Order 策略 – 实时获取实际交易日志
EMA-Regular-Order 策略 – 获取实际交易报告 – P&L 表
EMA-Regular-Order 策略 – 获取实际交易报告 – 统计表
MACD-Bracket-Order 策略 – 获取该策略
MACD-Bracket-Order 策略 – 实际交易该策略
MACD-Bracket-Order 策略 – 实时获取实际交易日志
MACD-Bracket-Order 策略 – 获取实际交易报告 – P&L 表
MACD-Bracket-Order 策略 – 获取实际交易报告 – 统计表

只有在实时市场小时运行的真实交易才有意义，而不像回测可以在任何时间运行。请确保你在实时市场小时尝试本章的示例。

技术要求

为了成功执行本章的示例，你将需要以下内容：

Python 3.7+
Python 包：
pyalgotrading（$ pip install pyalgotrading）

确保你已在 algobulls.com 上添加并绑定了你的经纪详情。有关更多细节，请参考 附录 II。你可以在此章节中使用任何 AlgoBulls 平台支持的经纪商。

本章的最新 Jupyter 笔记本可以在 GitHub 上找到 github.com/PacktPublishing/Python-Algorithmic-Trading-Cookbook/tree/master/Chapter11。

EMA-Regular-Order 策略 – 获取该策略

在这个配方中，你将从 AlgoBulls 平台上的你的账户中获取 StrategyEMARegularOrder 策略类。这个配方从建立到 AlgoBulls 平台的连接开始，查询你的账户中的所有可用策略，并获取所需策略类 StrategyEMARegularOrder 的详细信息。

确保你已经学习了第八章中的前六个配方，算法交易策略-逐步编码，以完全了解我们将使用的策略类；即 StrategyEMARegularOrder。

如何操作…

我们对此配方执行以下步骤：

导入所需模块：

>>> from pyalgotrading.algobulls import AlgoBullsConnection

创建一个新的 AlgoBulls 连接对象：

>>> algobulls_connection = AlgoBullsConnection()

获取授权 URL：

>>> algobulls_connection.get_authorization_url()

我们得到了以下输出：

Please login to this URL with your AlgoBulls credentials and get your developer access token: https://app.algobulls.com/user/login
'https://app.algobulls.com/user/login'

使用你的 AlgoBulls 凭证登录上述链接，获取你的令牌，并在此处设置它（有关更多详细信息，请参阅 附录 II）：

>>> algobulls_connection.set_access_token(
                    '80b7a69b168c5b3f15d56688841a8f2da5e2ab2c')

获取并显示到目前为止创建和上传的所有策略：

>>> all_strategies = algobulls_connection.get_all_strategies()
>>> all_strategies

我们得到了以下输出。你的输出可能会有所不同（确保你已经按照第八章中的配方操作，以获得类似的输出）：

https://github.com/OpenDocCN/freelearn-quant-zh/raw/master/docs/py-algo-trd-cb/img/4197d895-3742-4db6-aa0d-b5caac9f4a4e.png

获取并显示第一个策略的策略代码：

>>> strategy_code1 = all_strategies.iloc[0]['strategyCode']
>>> strategy_code1

我们得到了以下输出（你的输出可能会有所不同）：

'49287246f9704bbcbad76ade9e2091d9'

在实际交易策略之前，你可以检查你的策略，以确保你有正确的策略：

>>> strategy_details1 = \
         algobulls_connection.get_strategy_details(strategy_code1)
>>> print(strategy_details1)

我们得到了以下输出：

class StrategyEMARegularOrder(StrategyBase):

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)

        self.timeperiod1 = self.strategy_parameters['timeperiod1']
        self.timeperiod2 = self.strategy_parameters['timeperiod2']

        self.main_order = None

    def initialize(self):
        self.main_order = {}

    @staticmethod
    def name():
        return 'EMA Regular Order Strategy'
    ....
    def strategy_exit_position(self, candle, instrument, 
                               sideband_info):
        if sideband_info['action'] == 'EXIT':
            self.main_order[instrument].exit_position()
            self.main_order[instrument] = None
            return True

        return False

这里未显示完整的输出。请访问以下链接以阅读完整的输出，网址为github.com/algobulls/pyalgostrategypool/blob/master/pyalgostrategypool/strategy_ema_regular_order.py。

工作原理…

你在 第 1 步 中导入了所需的模块。在 第 2 步 中，创建了一个名为 algobulls_connection 的 AlgoBullsConnection 类的实例。在 第 3 步 中，使用 algobulls_connection 对象的 get_authorization_url() 方法获取授权 URL。这将打印授权 URL。你应该从 web 浏览器访问此 URL，以登录 AlgoBulls 平台并获取你的开发者访问令牌。（你可以在 附录 II 中找到有关从 AlgoBulls 平台获取开发者访问令牌的更多详细信息和截图。）在 第 4 步 中，使用 algobulls_connection 的 set_access_token() 方法设置访问令牌。如果令牌被接受，则与 AlgoBulls 平台建立成功的连接。

在第 5 步中，您获取到目前在 AlgoBulls 平台上创建并上传的所有策略。您使用 get_all_strategies() 方法进行此步骤，并将其赋值给一个新变量 all_strategies。这个变量是一个 pandas.DataFrame 对象，具有 strategyCode 和 strategyName 列。此表包含您先前上传的策略代码和策略名称的信息。如果您遵循了第八章的 EMA-Regular-Order strategy – uploading the strategy on the AlgoBulls trading platform 配方，Algorithmic Trading Strategies – Coding Step by Step，您将会找到一种名为 EMA regular order strategy 的策略。在第 6 步中，您将 EMA regular order strategy 策略的策略代码分配给一个新变量 strategy_code1。此步骤的输出中显示策略代码。这个策略代码对于 AlgoBulls 平台上的每个策略都是唯一的。

最后，在第 7 步中，您确保被 strategy_code1 引用的策略确实是您之前上传的那个（在 EMA-Regular-Order strategy – uploading the strategy on the AlgoBulls trading platform 配方中，在第八章，Algorithmic Trading Strategies – Coding Step by Step)。您使用 algobulls_connection 对象的 get_strategy_details() 方法来检查策略。此方法将策略代码作为参数。您在这里传递 strategy_code1。此方法将整个类代码作为字符串返回。您将其分配给一个新变量 strategy_details1 并显示它。

如果您想更改由 strategy_code1 引用的类代码，如第 7 步所示，请参考第八章的 EMA-Regular-Order strategy – uploading the strategy on the AlgoBulls trading platform 配方中的 There’s more… 部分，Algorithmic Trading Strategies – Coding Step by Step。

EMA–Regular–Order strategy – real trading the strategy

在这个配方中，您将在EMA-Regular-Order strategy上执行真实交易。您必须在本章的前一步骤中从 AlgoBulls 平台上的您的账户中提取此策略。您将在此配方中利用 pyalgotrading 提供的实际交易功能，这将在 AlgoBulls 平台上提交一个真实交易任务。

一旦提交，AlgoBulls 实际交易引擎将运行真实交易。您可以随时查询其状态以了解真实交易工作的状态。该任务按给定的顺序经历以下状态：

STARTING（中间状态）
STARTED（稳定状态）
STOPPING（中间状态）
STOPPED（稳定状态）

提交作业后，它会以中间状态 STARTING 开始。在此状态下，AlgoBulls 真实交易引擎获取策略并准备执行环境，这可能需要几分钟。一旦完成，作业就会转移到 STARTED 状态。真实交易策略是在此阶段实施的。在此阶段，它会停留，直到真实交易完成。完成后，作业会转移到中间状态 STOPPING。在此状态下，AlgoBulls 真实交易引擎会清理为此作业分配的资源，这通常需要不到一分钟。最后，作业转移到 STOPPED 状态。

如果您已经提交了策略真实交易作业，就不能再为同一策略提交另一个作业，直到第一个作业完成。这意味着您必须等待第一个作业转移到 STOPPED 状态。如果第一个作业运行时间很长，而您希望立即停止它，可以通过 pyalgotrading 提交停止作业请求。在提交请求之前，您需要确保作业处于 STARTED 状态。

下面的状态机图演示了 AlgoBulls 平台上一项真实交易工作在其生命周期内的各种状态和转换：

https://github.com/OpenDocCN/freelearn-quant-zh/raw/master/docs/py-algo-trd-cb/img/4c0360d4-c14b-4cb0-a789-666710dcd2a4.png

提交真实交易工作后，您可以实时获取策略执行的日志和报告。这些日志和报告有助于验证策略的性能并调试任何潜在问题。

确保您已经完成了第八章的前六个食谱，即第八章 算法交易策略 - 逐步编码，以全面了解我们将使用的策略类 StrategyEMARegularORder。

准备工作

确保 algobulls_connection 和 strategy_code1 对象在您的 Python 命名空间中可用。请参阅前面的食谱设置 algobulls_connection 和 strategy_code1 对象。

如何操作…

我们对此食谱执行以下步骤：

导入必要的模块：

>>> from datetime import time
>>> from pyalgotrading.constants import *

使用其交易符号作为关键字搜索工具。将返回的对象分配给 instruments：

>>> instruments = algobulls_connection.search_instrument('SBIN')
>>> instruments

我们得到了以下输出（您的输出可能会有所不同）：

[{'id': 7, 'value': 'NSE:SBIN'}]

从 instruments 获取所选工具的 value：

>>> instrument = instruments[0]['value']
>>> instrument

我们得到了以下输出：

'NSE:SBIN'

提交 strategy_code1 的真实交易工作：

>>> algobulls_connection.realtrade(
        strategy_code=strategy_code1, 
        start_time=time(hour=9, minute=15), 
        end_time=time(hour=15, minute=30),
        instrument=instrument, 
        lots=1,
        strategy_parameters={
            'timeperiod1': 5,
            'timeperiod2': 12
        }, 
        candle_interval=CandleInterval.MINUTES_15)

我们得到了以下输出：

Setting Strategy Config... Success.
Submitting REALTRADING job... Success.

检查已提交真实交易工作的状态：

>>> algobulls_connection.get_realtrading_job_status(strategy_code1)

我们得到了以下输出：

{'data': 'STARTING'}

一段时间后再次检查已提交作业的状态：

>>> algobulls_connection.get_realtrading_job_status(strategy_code1)

我们得到了以下输出：

{'data': 'STARTED'}

工作原理…

在第 1 步中，你从datetime模块中导入time类，并从pyalgotrading.constants模块导入所有常量。在第 2 步中，你使用algobulls_connection对象的search_instrument()方法获取你想要实时交易策略的工具，EMA-Regular-Order 策略。search_instrument()方法接受一个搜索字符串作为参数，该字符串应为您感兴趣的工具的交易符号的一部分或全部。你在这里传递了'SBIN'。该函数返回一个包含与搜索字符串匹配的工具详情的列表。可能有多个工具的交易符号中包含搜索字符串。在第 3 步中，你获取第一个匹配工具的值，并将其赋值给一个新变量instrument。

在第 4 步中，你使用algobulls_connection()对象的realtrade()方法提交一个实时交易作业。它接受以下参数：

strategy_code: 要执行实时交易的策略的策略代码。这应该是一个字符串。你在这里传递了strategy_code1。
start_time: 实时交易应该开始的今天时间。这应该是一个datetime.time对象。在这里，你传递了一个持有 9:15 小时值的对象 - time(hour=9, minute=15)。有关创建time对象的详细信息，请参阅本书的第一篇配方。
end_time: 实时交易应该执行的今天时间。这个对象应该包含一个比start_time持有的值提前的时间值。这应该是一个datetime.time实例。在这里，你传递了一个持有 15:30 小时值的对象 - time(hour=15, minute=30)。
instrument: 应该进行实时交易的金融工具。将为此工具获取历史数据。这应该是一个字符串。你在这里传递了instrument。
lots: 应该进行实时交易的手数。这应该是一个整数。数量由策略计算为手数×金融工具的手数。你在这里传递了1。
strategy_parameters: 策略期望的参数名称和值。这应该是一个字典，带有parameter-name和parameter-value作为键值对。你在这里传递了以下参数：
timeperiod1: 5
timeperiod2: 12

（回想一下，EMA-Regular-Order 策略的参数已经在其__init__()方法中定义，如第八章的第一篇配方所示，逐步编码的算法交易策略）。

candle_interval: 用于实时交易获取历史数据的蜡烛间隔。这应该是CandleInterval类型的枚举。你在这里传递了CandleInterval.MINUTES_15。（CandleInterval枚举提供各种蜡烛间隔的枚举，其中一些是MINUTE_1、MINUTES_3、MINUTES_5、MINUTES_10、MINUTES_15、MINUTES_30、HOUR和DAY。）

如果作业提交成功，您将看到由realtrade()函数打印的Success消息。

一旦作业被提交，启动需要一段时间。启动后，完成可能需要一些时间，这取决于实际交易的持续时间，该持续时间使用start_time和end_time参数指定。通常，实际交易运行整个交易日，这意味着作业将运行 6-8 小时。

在步骤 5中，您使用algobulls_connection对象的get_realtrading_job_status()方法获取作业的状态。在这里将strategy_code1作为参数传递。此方法返回一个具有单个键值对 - data 和 job 状态的字典。如果在放置作业后立即查询状态，则会得到'STARTING'作为状态。在步骤 6中，您再次查询状态，如果作业启动，您将获得'STARTED'的状态。

成功提交意味着已经以所需格式传递了实际交易策略所需的最小输入。但是，这并不保证策略在实际交易中不会出现错误。策略的执行仍可能在实际交易过程中遇到错误。要调试执行问题，您需要获取输出日志，这将在下一个示例中进行说明。错误可能的原因可能是策略类 Python 代码中的错误或未完整传递到 realtrade() 函数的 strategy_parameters 字典。

还有更多内容…

如果作业运行时间很长，您想在其完成之前停止它，您可以使用algobulls_connection对象的stop_realtrading_job()方法。此方法接受策略代码作为参数。在这里传递strategy_code1。此方法向 AlgoBulls 实时交易引擎提交停止请求。如果请求被接受，您将在此处看到一个Success消息：

>>> algobulls_connection.stop_realtrading_job(strategy_code1)
 Stopping REALTRADING job... Success.

如果在提交停止请求后查询状态，您将得到'STOPPING'作为状态：

>>> algobulls_connection.get_realtrading_job_status(strategy_code1)
{'data': 'STOPPING'}

如果一段时间后再次查询状态，并且作业已停止，您将得到'STOPPED'作为状态：

>>> algobulls_connection.get_realtrading_job_status(strategy_code1)
{'data': 'STOPPED'}

EMA–Regular–Order 策略 – 实时获取真实交易日志

在 AlgoBulls 平台上提交实际交易任务后，AlgoBulls 实时交易引擎开始执行策略。在执行过程中，AlgoBulls 实时交易引擎发生的每个事件和所做的决定都以精确的时间戳形式记录在文本日志中。

记录活动的示例包括给定的策略配置，定期生成的每个新蜡烛，您的策略执行的交易，由这些交易创建的仓位的进入和退出，等待新蜡烛等等。在验证策略并调试在开发策略时经常遇到的行为或性能问题时，这些日志是必不可少的。

在这个配方中，您将为您的策略获取真实的交易日志。日志会在您提交的真实交易作业达到 'STARTED' 状态后立即开始出现（有关真实交易作业状态的更多信息，请参阅上一篇配方）。AlgoBulls 平台允许您实时获取日志，即使真实交易作业仍在进行中。您可以在无需等待真实交易作业完成的情况下深入了解策略的执行情况。这对于真实交易作业通常是长时间运行的情况非常有帮助。pyalgotrading 包提供了一个简单的方法，我们可以用来获取给定策略的执行日志。

确保您已经熟悉了第八章的前六个配方，算法交易策略 - 逐步编码，以全面了解我们将使用的策略类；即，StrategyEMARegularOrder。

准备就绪

确保您的 Python 命名空间中有 algobulls_connection 和 strategy_code1 对象。参考本章的第一个配方设置 algobulls_connection 和 strategy_code1 对象。

如何操作…

执行以下步骤完成此配方：

获取 strategy_code1 的真实交易执行日志：

>>> logs = algobulls_connection.get_realtrading_logs(
                                                strategy_code1)
>>> print(logs)

我们得到了以下输出（您的输出可能有所不同）：

[2020-07-09 09:12:25] Logs not available yet. Please retry in sometime.

一段时间后再次获取 strategy_code1 的真实交易执行日志：

>>> logs = algobulls_connection.get_realtrading_logs(
                                                strategy_code1)
>>> print(logs)

我们得到了以下输出（您的输出可能有所不同）：

…
########################################
 INITIALIZING ALGOBULLS CORE (v3.2.0)... 
########################################
[2020-07-09 09:13:05] Welcome PUSHPAK MAHAVIR DAGADE!
[2020-07-09 09:13:05] Reading strategy...
[2020-07-09 09:13:05] STARTING ALGOBULLS CORE...
...
[2020-07-09 10:30:00] [CRITICAL] [order] [PLACING NEW ORDER] [2020-07-09 10:30:00] [2b079bc873f64f53a33f91b6ceec707b] [BUY] [NSE:SBIN] [QTY:1] [QTY PENDING: 1] [ENTRY PRICE: 194.7] [PRICE:None] [TRIGGER PRICE:None] [ORDER_TYPE_REGULAR] [ORDER_CODE_INTRADAY] [ORDER_VARIETY_MARKET] [ORDER_POSITION_ENTER]
...
[2020-07-09 15:30:00] [INFO] [clock] Candle generation has been stopped...
[2020-07-09 15:30:00] [INFO] [tls] Received event END OF MARKET. Stopping Trading Core Engine...
[2020-07-09 15:30:00] [INFO] [tls] Exiting all open positions with order code: ORDER_CODE_INTRADAY (if any)...
[2020-07-09 15:30:00] [CRITICAL] [tls] [User: PUSHPAK MAHAVIR DAGADE] Trading session completed
...

这里未显示完整输出。请访问以下链接以阅读完整输出：github.com/algobulls/pyalgostrategypool/blob/master/pyalgostrategypool/sample/realtrading/strategy_ema_regular_order/logs.txt。

工作原理…

在 第一步 中，您使用 algobulls_connection 对象的 get_realtrading_logs() 方法实时获取策略的真实交易日志。此方法接受策略代码作为参数。在这里传递了 strategy_code1。返回的数据是一个字符串。如果您在提交作业后立即尝试此步骤，您会得到一个字符串，其中说日志尚未准备好（[2020-07-09 09:12:25] Logs not available yet. Please retry in sometime.）。如果真实交易作业处于 'STARTING' 状态，就会发生这种情况。

在 第二步 中，您再次在一段时间后获取日志。如果作业不在 'STARTING' 状态，则开始获取您的策略执行日志。每次调用 get_realtrading_logs() 函数时，您都会获得所有真实交易日志。

还有更多…

一旦真实交易任务转移到 'STOPPED' 状态，就不会生成新的日志。在提交下一个相同策略的真实交易任务之前，你可以随时获取完整的日志。如果提交了新的真实交易任务（相同的策略），则无法通过 get_realtrading_logs() 方法再次访问这些日志。如果需要，你可以将获取的日志保存到文件中，以便日后参考。

EMA–Regular–Order 策略 – 获取真实交易报告 – 损益表

在 AlgoBulls 平台上提交真实交易任务后，AlgoBulls 实时交易引擎开始执行策略。在执行过程中，除了日志外，AlgoBulls 实时交易引擎还实时生成了一张损益表。该表包含了策略输入的每一笔交易的信息。它还包含了入场和出场订单之间的映射细节、交易损益以及累积损益，按时间顺序排序，最新的订单排在前面。通过这张表，我们可以通过单个和累积损益数字了解策略的整体表现。入场-出场订单映射也有助于验证策略的行为。

在本示例中，你将获取策略的损益表报告。在提交真实交易任务后，只要你的策略打入了第一笔交易，这份报告就可以获得。AlgoBulls 平台允许你实时获取损益表，即使真实交易任务仍在进行中。你可以在不必等待真实交易任务完成的情况下，了解策略的表现。这对于长时间运行的真实交易任务非常有帮助。pyalgotrading 包提供了一个简单的方法，我们可以用它来获取给定策略的损益表。

确保你已经完成了第八章的前六个示例，算法交易策略 – 逐步编码，以完整了解我们将使用的策略类；即 StrategyEMARegularOrder。

准备工作

确保 algobulls_connection 和 strategy_code1 对象在你的 Python 命名空间中可用。请参阅本章第一个示例来设置 algobulls_connection 和 strategy_code1 对象。

操作步骤…

获取 strategy_code1 的真实交易损益报告：

>>> algobulls_connection.get_realtrading_report_pnl_table(strategy_code1)

我们得到以下输出。你的输出可能有所不同（注意以下输出已分成多个表格以供表示目的。在 Jupyter Notebook 中，你会看到一个宽表）：

https://github.com/OpenDocCN/freelearn-quant-zh/raw/master/docs/py-algo-trd-cb/img/c036f082-09ea-4980-98cc-78befbfd7668.png

工作原理…

在本示例中，你可以使用 algobulls_connection 对象的 get_realtrading_report_pnl_table() 方法实时获取真实交易损益表。该方法接受策略代码作为参数。你在这里传递了 strategy_code1。返回的数据是一个 pandas.DataFrame 对象，具有多个列，描述如下：

instrument: 进行交易的金融工具。
entry_timestamp: 下单进入的时间戳。（注意，在进入 'COMPLETE' 状态之前，可能会保持 'OPEN' 状态一段时间。）
entry_transaction_type: 进入订单的交易类型（可以是 BUY 或 SELL）。
entry_quantity: 进入订单数量。
entry_price: 进入订单执行并进入 'COMPLETE' 状态的价格。
exit_timestamp: 下单退出的时间戳。（注意，在进入 'COMPLETE' 状态之前，可能会保持 'OPEN' 状态一段时间。）
exit_transaction_type: 退出订单的交易类型（可以是 BUY 或 SELL）。
exit_quantity: 退出订单数量。
exit_price: 退出订单执行并进入 'COMPLETE' 状态的价格。
pnl_absolute: 退出订单执行价格与进入订单执行价格之间的差异。在数学上，对于多头交易，这是 (exit_price - entry_price)*exit_quantity，而对于空头交易，这是 (entry_price - exit_price)*exit_quantity。正值意味着交易是盈利的，负值意味着交易是亏损的。
pnl_percentage: 相对于进入价格的利润或损失百分比。在数学上，这是 pnl_absolute / entry_price / exit_quantity × 100。
pnl_cumulative_absolute: 累积利润或损失。在数学上，这是之前交易的所有 pnl_absolute 值的总和。此数字直接反映了策略相对于模拟时间的表现。
pnl_cumulative_percentage: 相对于进入价格的累积利润或损失的百分比。在数学上，这是 pnl_cumulative / entry_price / exit_quantity × 100。

还有更多…

一旦真实交易作业进入 'STOPPED' 状态，损益表报告将不再更新。您可以在提交同一策略的下一个真实交易作业之前随时获取完整的损益报告。如果提交了新的真实交易作业（对于相同的策略），则无法通过 get_realtrading_report_pnl_table() 方法再访问此报告。如果您希望以后参考，可以将获取的报告保存为 .csv 文件。

EMA–Regular–Order 策略 – 获取真实交易报告 – 统计表

在 AlgoBulls 平台上提交了一个实际交易任务后，AlgoBulls 实际交易引擎开始执行该策略。在执行过程中，除了日志和 P&L 表之外，AlgoBulls 实际交易引擎还实时从 P&L 表中生成一个摘要。此摘要是一个包含各种统计数字的统计表，例如 净盈亏（绝对值和百分比）、最大回撤（绝对值和百分比）、总交易次数、盈利交易次数、亏损交易次数、多头交易和空头交易次数、最大利润和最小利润（或最大损失），以及每次盈利和亏损交易的平均利润。该表提供了策略整体表现的即时概述。

在这个示例中，你将获取你的策略的统计表报告。这份报告在你提交实际交易任务后，你的策略第一笔交易被打入后即可获得。AlgoBulls 平台允许你实时获取统计表，即使实际交易任务仍在进行中。你可以在不必等待实际交易任务完成的情况下，了解策略的表现。这对于实际交易任务通常是长时间运行的情况很有帮助。pyalgotrading 包提供了一个简单的方法，我们可以用来获取给定策略的统计表。

确保你已经阅读了《第八章》的前六个配方，即《算法交易策略 - 逐步编码》，以全面了解我们将要使用的策略类别，即 StrategyEMARegularOrder。

准备工作

确保 algobulls_connection 和 strategy_code1 对象在你的 Python 命名空间中可用。参考本章的第一个配方来设置 algobulls_connection 和 strategy_code1 对象。

如何实现…

获取 strategy_code1 的实际交易统计报告：

>>> algobulls_connection.get_realtrading_report_statistics(strategy_code1)

我们得到了以下输出（你的输出可能不同）：

https://github.com/OpenDocCN/freelearn-quant-zh/raw/master/docs/py-algo-trd-cb/img/d55b9486-05e7-49f2-b21c-25ce31ebd828.png

工作原理…

在这个示例中，你可以使用 algobulls_connection 对象的 get_realtrading_report_statistics() 方法实时获取实际交易统计表。此方法接受策略代码作为参数。在这里你传递了 strategy_code1。返回的数据是一个 pandas.DataFrame 对象，包含两列 - highlight_type 和 highlight_value - 以及多行。行描述如下：

Net PnL: 累积实际交易盈亏。这也是 P&L 表中第一条目的 pnl_cumulative_absolute 值。
Net PnL %: 累积实际交易盈亏百分比。这也是 P&L 表中第一条目的 pnl_cumulative_percentage 值。
最大回撤: P&L 表中 pnl_cumulative 列中的最低值。这表示你的策略在执行过程中遭遇的最大损失。
最大回撤 %: 数学上来说，这是 (最大回撤) / (相应的进入价格) / 退出数量 × 100。
交易数量：会话期间的总交易次数（入场和出场计为一次）。
盈利交易次数：交易收益为非负数的交易次数。
亏损交易次数：交易收益为负数的交易次数。
多头交易数量：入场交易类型为'BUY'的交易数量。
空头交易数量：入场交易类型为'SELL'的交易数量。
最大收益：所有交易中收益最大的交易的收益和损失。
最小收益：所有交易中收益最小的交易的收益和损失。
平均每次盈利交易的利润：从数学上讲，这是*(盈利交易的总收益)* / (盈利交易的数量)。
平均每次亏损交易的利润：从数学上讲，这是*(亏损交易的总收益)* / (亏损交易的数量)。

MACD-Bracket-Order 策略 - 提取策略

在本文中，您将从 AlgoBulls 平台上的帐户中提取StrategyMACDBracketOrder策略类，您必须在上一篇第八章的最后一篇配方中上传。该配方开始于建立与 AlgoBulls 平台的连接，查询您帐户中所有可用的策略，并获取所需策略类（即StrategyMACDBracketOrder）的详细信息。

确保您已经阅读了第八章中的最后六个配方，逐步了解我们将使用的策略类的完整情况，即StrategyMACDBracketOrder。

操作步骤如下：

执行以下步骤完成此配方：

导入必要的模块：

>>> from pyalgotrading.algobulls import AlgoBullsConnection

创建一个新的 AlgoBulls 连接对象：

>>> algobulls_connection = AlgoBullsConnection()

获取授权 URL：

>>> algobulls_connection.get_authorization_url()

我们获得了以下输出：

Please login to this URL with your AlgoBulls credentials and get your developer access token: https://app.algobulls.com/user/login
'https://app.algobulls.com/user/login'

使用您的 AlgoBulls 凭据登录上述链接，获取您的令牌，并将其设置在此处（有关更多详细信息，请参阅附录 II）：

>>> algobulls_connection.set_access_token('
                        80b7a69b168c5b3f15d56688841a8f2da5e2ab2c')

提取并显示您迄今为止创建和上传的所有策略。

>>> all_strategies = algobulls_connection.get_all_strategies()
>>> all_strategies

我们得到了以下输出。你的输出可能不同（确保你已经按照第八章中的配方，逐步编码算法交易策略，来获得类似的输出）：

https://github.com/OpenDocCN/freelearn-quant-zh/raw/master/docs/py-algo-trd-cb/img/b27e136e-3524-4f41-b887-664074f8d1da.png

获取并显示第二个策略的策略代码；也就是 MACD-Bracket-Order 策略：

>>> strategy_code2 = all_strategies.iloc[1]['strategyCode']
>>> strategy_code2

我们得到了以下输出（你的输出可能不同）：

'49287246f9704bbcbad76ade9e2091d9'

在实际交易你的策略之前，你可以检查你的策略以确保你拥有正确的策略：

>>> strategy_details2 = \
        algobulls_connection.get_strategy_details(strategy_code2)
>>> print(strategy_details2)

我们得到了以下输出：

class StrategyMACDBracketOrder(StrategyBase):

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)

        self.fastMA_period = \
            self.strategy_parameters['fastma_period']
        self.slowMA_period = \
            self.strategy_parameters['slowma_period']
        self.signal_period = \
            self.strategy_parameters['signal_period']
        self.stoploss = \
            self.strategy_parameters['stoploss_trigger']
        self.target = self.strategy_parameters['target_trigger']
        self.trailing_stoploss = \
            self.strategy_parameters['trailing_stoploss_trigger']

        self.main_order = None

    def initialize(self):
        self.main_order = {}

    @staticmethod
    def name():
        return 'MACD Bracket Order Strategy'
    ....
    def strategy_exit_position(self, candle, instrument, \
                               sideband_info):
        if sideband_info['action'] == 'EXIT':
            self.main_order[instrument].exit_position()
            self.main_order[instrument] = None
            return True

        return False

完整的输出在此处未显示。请访问以下链接以阅读完整的输出：github.com/algobulls/pyalgostrategypool/blob/master/pyalgostrategypool/strategy_macd_bracket_order.py。

工作原理是…

在 第 1 步 中，你导入了必要的模块。在 第 2 步 中，你创建了AlgoBullsConnection类的一个实例，命名为algobulls_connection。在 第 3 步 中，你使用algobulls_connection对象的get_authorization_url()方法获取了授权 URL。这会打印授权 URL。你应该从你的网络浏览器中访问这个 URL，以登录 AlgoBulls 平台并获取你的开发者访问令牌。（你可以在 附录 II 中找到更多详细信息和屏幕截图，关于如何从 AlgoBulls 平台获取开发者访问令牌。）你复制访问令牌并在 第 4 步 中使用algobulls_connection的set_access_token()方法设置它。如果令牌被接受，就会建立与 AlgoBulls 平台的成功连接。

在 第 5 步 中，你获取了到目前为止在 AlgoBulls 平台上创建并上传的所有策略。你使用get_all_strategies()方法来执行此步骤，并将其分配给一个新变量，all_strategies。这个变量是一个pandas.DataFrame对象，带有strategyCode和strategyName列。这张表保存了你之前上传的策略代码和策略名称的信息。

如果你遵循了第八章中的 MACD-Bracket-Order Strategy – 将策略上传到 AlgoBulls 交易平台 配方，逐步编码算法交易策略，你将找到一个名为 MACD-Regular-Order strategy 的策略。在 第 6 步 中，你将 MACD-Regular-Order 策略的策略代码分配给一个名为 strategy_code2 的新变量。这个策略代码显示在这一步的输出中。这个策略代码对于 AlgoBulls 平台上的每个策略都是唯一的。

最后，在 步骤 7 中，您确保被 strategy_code2 引用的策略确实是您之前上传的那个（在第八章的最后一个配方中，《算法交易策略-逐步编码》）。您使用 algobulls_connection 对象的 get_strategy_details() 方法来检查策略。该方法以策略代码作为参数。在这里传递 strategy_code2。该方法返回整个类代码作为字符串。您将其分配给一个新变量 strategy_details2 并显示它。

如果您想要更改被 strategy_code2 引用的类代码，如 步骤 7 所示，请参考第八章的最后一个配方中的*还有更多……*部分，《算法交易策略-逐步编码》。

MACD–Bracket–Order 策略-实际交易该策略

在本配方中，您将在 MACD-Bracket-Order 策略上执行实际交易。您必须在本章的前一个配方中从 AlgoBulls 平台上的您的帐户中获取此策略。您将利用由 pyalgotrading 提供的实际交易功能来执行此配方，该功能又会在 AlgoBulls 平台上提交一个实际交易作业。

提交后，实际交易将由 AlgoBulls 实时交易引擎运行。您可以随时查询状态以了解实际交易作业的状态。作业按给定顺序经历以下状态：

STARTING（中间状态）
STARTED（稳定状态）
STOPPING（中间状态）
STOPPED（稳定状态）

在提交作业时，它以一个中间状态 'STARTING' 开始。在这种状态下，AlgoBulls 实时交易引擎获取策略并准备执行环境，这可能需要几分钟时间。完成后，作业将移至 'STARTED' 状态。策略实时交易发生在此阶段。在此阶段，它会停留直到实际交易完成。完成后，作业将移至一个中间状态 'STOPPING'。在此状态下，AlgoBulls 实时交易引擎清理为此作业分配的资源，通常需要不到一分钟的时间。最后，作业移至 'STOPPED' 状态。

如果您已经为某个策略提交了实际交易作业，则在第一个作业完成之前，不能为相同的策略提交另一个作业。这意味着您必须等待第一个作业移至 'STOPPED' 状态。如果第一个作业运行时间很长，并且您想立即停止它，您可以通过 pyalgotrading 提交一个停止作业请求。在提交请求之前，您需要确保作业处于 'STARTED' 状态。

在提交实际交易作业后，您可以实时获取策略执行的日志和报告。这些日志和报告有助于验证策略的性能并调试任何潜在问题。

您可以参考本章的第二个示例，了解 AlgoBulls 平台上实际交易工作的状态机图。它展示了实际交易工作在其整个生命周期中的各种状态和转换。

确保您已经阅读了本书的第八章的最后六个示例，逐步了解我们将使用的策略类的完整情况;也就是StrategyMACDBracketOrder。

准备就绪

确保algobulls_connection和strategy_code2对象在您的 Python 命名空间中可用。参考本章的前一节设置algobulls_connection和strategy_code2对象。

如何做…

执行以下步骤以完成此示例：

导入必要的模块：

>>> from datetime import time
>>> from pyalgotrading.constants import *

搜索一个工具并使用其交易符号作为关键字。将返回的对象分配给instruments：

>>> instrument = algobulls_connection.search_instrument('
                                                    TATASTEEL')
>>> instrument

我们得到了以下输出（您的输出可能有所不同）：

[{'id': 1, 'value': 'NSE:TATASTEEL'}]

从instruments中获取选择的工具的value：

>>> instrument = instrument[0]['value']
>>> instrument

我们得到了以下输出：

'NSE:TATASTEEL'

提交一个用于strategy_code2的实际交易工作：

>>> algobulls_connection.realtrade(
        strategy_code=strategy_code2,     
        start_time=time(hour=9, minute=15),
        end_time=time(hour=15, minute=30),
        instrument=instrument,
        lots=1,
        strategy_parameters={
            'fastma_period': 26, 
            'slowma_period': 6, 
            'signal_period': 9,
            'target_trigger': 0.01, 
            'stoploss_trigger': 0.01, 
            'trailing_stoploss_trigger': 1
        },
        candle_interval=CandleInterval.MINUTES_15)

我们得到了以下输出：

Setting Strategy Config... Success.
Submitting REALTRADING job... Success.

检查已提交的实际交易工作的状态：

>>> algobulls_connection.get_realtrading_job_status(strategy_code2)
{'data': 'STARTING'}

过一段时间后再次检查已提交的实际交易工作的状态：

>>> algobulls_connection.get_realtrading_job_status(strategy_code2)
{'data': 'STARTED'}

它是如何工作的…

在步骤 1中，您从datetime模块中导入了time类和pyalgotrading.constants模块中的所有常量。在步骤 2中，您使用algobulls_connection对象的search_instrument()方法获取您想要为其进行实际交易的工具，MACD-Bracket-Order 策略。search_instrument()方法接受一个搜索字符串作为参数，该参数应该是您感兴趣的工具的交易符号的一部分或完整内容。您在这里传递了'TATASTEEL'。此函数返回一个包含与搜索字符串匹配的工具详情的列表。可能有多个工具的交易符号中包含搜索字符串。在步骤 3中，您获取第一个匹配工具的值，并将其分配给一个新变量，instrument。

在步骤 4中，您使用algobulls_connection()对象的realtrade()方法提交了一个实际交易工作。它接受以下参数：

strategy_code：要执行实际交易的策略的策略代码。这应该是一个字符串。您在这里传递strategy_code2。
start_time：应该开始实际交易的今天的时间。这应该是一个datetime.time对象。在这里，您传递了一个保存了 9:15 小时值的对象 - time(hour=9, minute=15)。有关创建datetime对象的详细信息，请参阅本书的第一节。
end_time：应该在今天进行实际交易的时间。此对象应该保存一个在start_time保存的值之前的时间值。这应该是一个datetime.time实例。在这里，您传递了一个保存了 15:30 小时的值的对象 - time(hour=15, minute=30)。
instrument: 应该运行实际交易的金融工具。将为此工具获取历史数据。这应该是一个字符串。在这里传递instrument。
lots: 应该进行实际交易的手数。这应该是一个整数。数量由策略计算为手数×金融工具的手数。在这里传递1。
strategy_parameters: 策略期望的参数名称和值。这应该是一个字典，其中parameter-name和parameter-value是键值对。在这里传递以下参数：
fastma_period: 26
slowma_period: 6
signal_period: 9
target_trigger: 0.01
stoploss_trigger: 0.01
trailing_stoploss_trigger: 1

（回想一下，MACD-Bracket-Order 策略的参数已经在其__init__()方法中定义，如第八章的第一个示例中所示，算法交易策略 - 逐步编码）。

candle_interval: 用于实际交易获取的历史数据的蜡烛间隔。这应该是CandleInterval类型的枚举。在这里传递CandleInterval.MINUTES_15。（CandleInterval枚举提供各种蜡烛间隔的枚举，其中一些是MINUTE_1、MINUTES_3、MINUTES_5、MINUTES_10、MINUTES_15、MINUTES_30、HOUR和DAY。）

如果作业提交成功，您将看到由realtrade()函数打印的Success消息。

一旦任务提交，启动需要一段时间。启动后，根据使用start_time和end_time参数指定的实际交易持续时间，可能需要一段时间才能完成。通常，实际交易会持续整个交易日，这意味着任务将运行 6-8 小时。

在步骤 5中，使用algobulls_connection对象的get_realtrading_job_status()方法获取作业的状态。在这里传递strategy_code2作为参数。此方法返回一个具有单个键值对 - 数据和作业状态的字典。如果在放置作业后立即查询状态，则会将'STARTING'作为状态返回。在步骤 6中，经过一段时间后再次查询状态，如果作业已启动，则会返回状态'STARTED'。

成功提交意味着已按所需格式传递了实际交易策略的最小输入。但是，这并不保证策略在实际交易中运行时不会出现错误。在实际交易期间，策略的执行仍可能遇到错误。要调试执行问题，您需要获取输出日志，下一个示例将对此进行说明。出错的可能原因可能是策略类 Python 代码中的错误或已将不完整的strategy_parameters字典传递给realtrade()函数。

还有更多…

如果一个任务运行了很长时间，并且你想在完成之前停止它，你可以使用 algobulls_connection 对象的 stop_realtrading_job() 方法。这个方法接受策略代码作为参数。在这里你传递 strategy_code2。这个方法提交一个停止请求给 AlgoBulls 真实交易引擎。如果请求被接受，你将会看到一个 Success 消息：

>>> algobulls_connection.stop_realtrading_job(strategy_code2)
 Stopping REALTRADING job... Success.

如果你在提交停止请求后查询状态，你会得到 'STOPPING' 作为状态：

>>> algobulls_connection.get_realtrading_job_status(strategy_code2)
{'data': 'STOPPING'}

如果你一段时间后再次查询状态，且任务已经停止，你将会得到 'STOPPED' 作为状态：

>>> algobulls_connection.get_realtrading_job_status(strategy_code2)
{'data': 'STOPPED'}

MACD–Bracket–Order 策略 – 实时获取真实交易日志

在 AlgoBulls 平台提交真实交易任务后，AlgoBulls 真实交易引擎开始执行策略。在执行过程中，AlgoBulls 真实交易引擎记录下每个事件和每个决策，并以文本日志的形式精确记录时间戳。

记录的活动示例包括给定策略配置、定期生成的每个新蜡烛、策略输入的交易、这些交易创建的头寸的进入和退出、等待新蜡烛等。这些日志对于验证策略和调试经常在开发策略时遇到的行为或性能问题至关重要。

在这个配方中，你将获取你的策略的真实交易日志。一旦你提交的真实交易任务达到 'STARTED' 状态，日志就会开始出现（有关真实交易任务状态的更多信息，请参考上一个配方）。AlgoBulls 平台允许你实时获取日志，即使真实交易任务仍在进行中。你可以在不等待真实交易任务完成的情况下了解策略的执行情况。这对于真实交易任务通常是长时间运行的情况很有帮助。pyalgotrading 包提供了一个简单的方法来获取给定策略的执行日志。

确保你已经学习了第八章的最后六个配方，算法交易策略 – 逐步编码，以获得我们将使用的策略类 StrategyMACDBracketOrder 的完整图片。

准备就绪

确保 algobulls_connection 和 strategy_code2 对象在你的 Python 命名空间中可用。参考本章的MACD-Bracket-Order 策略 – 获取策略配方来设置 algobulls_connection 和 strategy_code2 对象。

如何实现…

执行以下步骤来完成这个配方：

获取 strategy_code2 的真实交易执行日志：

>>> logs = algobulls_connection.get_realtrading_logs(
                                                strategy_code2)
>>> print(logs)

我们得到了以下输出（你的输出可能不同）：

[2020-07-09 09:13:45] Logs not available yet. Please retry in sometime.

一段时间后，再次获取 strategy_code2 的真实交易执行日志：

>>> logs = algobulls_connection.get_realtrading_logs(
                                                strategy_code2)
>>> print(logs)

我们得到了以下输出（你的输出可能不同）：

...
########################################
 INITIALIZING ALGOBULLS CORE (v3.2.0)... 
########################################
[2020-07-09 09:14:09] Welcome PUSHPAK MAHAVIR DAGADE!
[2020-07-09 09:14:09] Reading strategy...
[2020-07-09 09:14:09] STARTING ALGOBULLS CORE...
...
[2020-07-09 09:45:00] [CRITICAL] [order] [PLACING NEW ORDER] [2020-07-09 09:45:00][577e6b4cb646463282ae98ec1c0e6c25] [BUY] [NSE:TATASTEEL] [QTY:1] [QTY PENDING: 1] [ENTRY PRICE: 345.0] [PRICE:345.0] [TRIGGER PRICE:None] [ORDER_TYPE_BRACKET] [ORDER_CODE_INTRADAY] [ORDER_VARIETY_LIMIT] [ORDER_POSITION_ENTER] [STOPLOSS TRIGGER:341.55] [TARGET TRIGGER:348.45] [TRAILING STOPLOSS TRIGGER:345.0]
...
[2020-07-09 15:30:00] [INFO] [clock] Candle generation has been stopped...
[2020-07-09 15:30:00] [INFO] [tls] Received event END OF MARKET. Stopping Trading Core Engine...
[2020-07-09 15:30:00] [INFO] [tls] Exiting all open positions with order code: ORDER_CODE_INTRADAY (if any)...
[2020-07-09 15:30:00] [CRITICAL] [tls] [User: PUSHPAK MAHAVIR DAGADE] Trading session completed
...

此处未显示完整输出。请访问以下链接以阅读完整输出：github.com/algobulls/pyalgostrategypool/blob/master/pyalgostrategypool/sample/realtrading/strategy_macd_bracket_order/logs.txt。

工作原理如下…

在步骤 1中，您使用algobulls_connection对象的get_realtrading_logs()方法实时获取策略的真实交易日志。此方法接受策略代码作为参数。在此处传递strategy_code2。返回的数据是一个字符串。如果在提交任务后立即尝试此步骤，您会得到一个字符串，其中说日志尚未准备好（[2020-07-09 09:13:45] Logs not available yet. Please retry in sometime.）。如果真实交易任务处于'STARTING'状态，则会出现此情况。

在步骤 2中，您会在一段时间后再次获取日志。如果任务不再处于'STARTING'状态，则开始获取您的策略执行日志。每次调用get_realtrading_logs()函数时，都会获取所有真实交易日志。

还有更多…

当真实交易任务进入'STOPPED'状态后，将不再生成新的日志。您可以在提交下一个相同策略的真实交易任务之前的任何时间获取完整的日志。如果提交了新的真实交易任务（针对相同的策略），则无法再通过get_realtrading_logs()方法访问这些日志。如果您希望以后参考这些日志，可以将获取的日志保存到文件中。

MACD–Bracket–Order 策略 – 获取真实交易报告 – 利润和损失表

在 AlgoBulls 平台上提交真实交易任务后，AlgoBulls 真实交易引擎开始执行该策略。在执行过程中，除了日志外，AlgoBulls 真实交易引擎还实时生成 P&L 表。此表包含策略打入的每笔交易的信息。它还包含有关入场和出场订单之间的映射、交易 P&L 和累积 P&L 的详细信息，按时间顺序排序，最新的订单排在最前面。这张表通过个人和累积 P&L 数字为我们提供了有关策略整体表现的见解。入场-出场订单映射还有助于验证策略的行为。

在本示例中，您将获取您策略的 P&L 表报告。在提交真实交易任务后，您的策略第一笔交易打入后，此报告即可获得。AlgoBulls 平台允许您实时获取 P&L 表，即使真实交易任务仍在进行中。这样做有助于了解策略的表现，而无需等待真实交易任务完成。这对于长时间运行的真实交易任务非常有帮助。pyalgotrading包提供了一个简单的方法，我们可以用来获取给定策略的 P&L 表。

确保你已经熟悉了第八章的最后六个示例，逐步编码算法交易策略，以完整了解我们将使用的策略类；即 StrategyMACDBracketOrder。

准备工作

确保 algobulls_connection 和 strategy_code2 对象在你的 Python 命名空间中可用。参考本章的 MACD-Bracket-Order 策略 – 获取策略 示例设置 algobulls_connection 和 strategy_code2 对象。

如何做…

获取 strategy_code2 的真实交易盈亏报告：

>>> algobulls_connection.get_realtrading_report_pnl_table(strategy_code2)

我们得到了以下输出。你的输出可能会有所不同（注意以下输出已分成多个表格以表示目的。在你的 Jupyter Notebook 中，你将看到一个宽表格）：

https://github.com/OpenDocCN/freelearn-quant-zh/raw/master/docs/py-algo-trd-cb/img/025cf486-ac12-4e3d-8f06-3a7dbc4cf80f.png

工作原理…

在这个示例中，你将使用 algobulls_connection 对象的 get_realtrading_report_pnl_table() 方法实时获取真实交易的盈亏表。该方法接受策略代码作为参数。你在这里传递了 strategy_code2。返回的数据是一个 pandas.DataFrame 对象，具有多列，描述如下：

instrument: 进行交易的金融工具。
entry_timestamp: 放置进入订单的时间戳。（注意，它可能在进入 'OPEN' 状态一段时间后才转入 'COMPLETE' 状态。）
entry_transaction_type: 进入订单交易类型（BUY 或 SELL）。
entry_quantity: 进入订单数量。
entry_price: 进入订单执行并进入 'COMPLETE' 状态的价格。
exit_timestamp: 放置退出订单的时间戳。（注意，它可能在进入 'OPEN' 状态一段时间后才转入 'COMPLETE' 状态。）
exit_transaction_type: 退出订单交易类型（BUY 或 SELL）。
exit_quantity: 退出订单数量。
exit_price: 退出订单执行并进入 'COMPLETE' 状态的价格。
pnl_absolute: 退出订单执行价格与进入订单执行价格的差额。从数学上讲，这是长期交易的 (退出价格 - 进入价格)*退出数量，短期交易的 (进入价格 - 退出价格)*退出数量。正值意味着该交易是盈利交易。负值意味着该交易是亏损交易。
pnl_percentage: 相对于进入价格的利润或损失百分比。从数学上讲，这是 pnl_absolute / entry_price / exit_quantity x 100。
pnl_cumulative_absolute: 累积盈亏。从数学上讲，这是之前所有交易的 pnl_absolute 值的总和。这个数字直接反映了策略在模拟时间内的表现。
pnl_cumulative_percentage: 相对于入场价格的累计利润或损失的百分比。从数学上讲，这是 pnl_cumulative / entry_price / exit_quantity x 100。

MACD-Bracket-Order 策略 - 获取真实交易报告 - 统计表

在 AlgoBulls 平台上提交了一个真实交易任务后，AlgoBulls 真实交易引擎开始执行策略。在其执行过程中，除了日志和 P&L 表之外，AlgoBulls 真实交易引擎还实时生成来自 P&L 表的摘要。此摘要是包含各种统计数字的统计表，如 净利润（绝对值和百分比）、最大回撤（绝对值和百分比）、总交易次数、盈利交易次数、亏损交易次数、多头交易和空头交易次数、最大盈利和最小盈利（或最大亏损），以及每个盈利和亏损交易的平均利润。此表提供了策略整体表现的即时概览。

在这个示例中，您将获取您的策略的统计表报告。此报告在您提交了一个真实的交易任务后，只要您的策略首次进行了交易，就可以获得。AlgoBulls 平台允许您在真实交易任务仍在进行时实时获取统计表。您可以在等待真实交易任务完成之前了解策略的表现。这对于真实交易任务通常是长时间运行的情况很有帮助。pyalgotrading 包提供了一个简单的方法，我们可以用来获取给定策略的统计表。

确保您已经阅读了第八章的最后六个示例，算法交易策略 - 逐步编码，以完整了解我们将要使用的策略类别; 即 StrategyMACDBracketOrder。

准备工作

确保您的 Python 命名空间中有 algobulls_connection 和 strategy_code2 对象可用。参考本章的 MACD-Bracket-Order 策略 - 获取策略 示例来设置 algobulls_connection 和 strategy_code2 对象。

如何做…

获取strategy_code2的真实交易统计报告：

>>> algobulls_connection.get_realtrading_report_statistics(strategy_code2)

我们得到了以下输出（您的输出可能会有所不同）:

https://github.com/OpenDocCN/freelearn-quant-zh/raw/master/docs/py-algo-trd-cb/img/ad70d4f2-8b7a-47fe-b213-16b345702865.png

工作原理…

在本示例中，您使用algobulls_connection对象的get_realtrading_report_statistics()方法实时获取真实交易统计表。此方法接受策略代码作为参数。您在此处传递了strategy_code2。返回数据是一个pandas.DataFrame对象，具有两列 - highlight_type和highlight_value - 和多行。行的描述如下：

Net PnL: 累计真实交易盈亏。这也是盈亏表中第一项的pnl_cumulative_absolute值。
Net PnL %: 累计真实交易盈亏百分比。这也是盈亏表中第一项的pnl_cumulative_percentage值。
Max Drawdown: 盈亏表中pnl_cumulative列的最低值。这表示您的策略在执行过程中遇到的最大损失。
Max Drawdown %: 在数学上，这是 (最大回撤) / (对应的入场价格) / 退出数量 x 100。
Number of Trades: 会话期间的总交易数（入场和出场计为一次）。
Number of Wins: 交易盈亏为非负数的交易数量。
Number of Losses: 交易盈亏为负数的交易数量。
Number of Long Trades: 入场交易类型为'BUY'的交易数量。
Number of Short Trades: 入场交易类型为'SELL'的交易数量。
Max Gain: 所有交易中盈利最高的交易的盈亏。
Min Gain: 所有交易中盈利最低的交易的盈亏。
Avg. Profit per winning trade: 在数学上，这是 (盈利交易的总盈亏) / (盈利交易的数量)。
Avg. Profit per losing trade: 在数学上，这是 (亏损交易的总盈亏) / (亏损交易的数量)。

还有更多…

如果在真实交易作业仍在运行时获取统计表，则上述数字将是中间数字，基于截至该时间的已完成交易。随着更多交易的录入，这些数字可能会发生变化，直到真实交易作业完成。

一旦真实交易作业转移到'STOPPED'状态，统计表将不再更改。您可以在提交下一个相同策略的真实交易作业之前随时获取完整的统计表。如果提交了新的真实交易作业（相同的策略），则无法再通过get_realtrading_report_statistics()方法访问此表。如果您希望以后参考，可以将获取的报告保存为.csv文件。

附录 I：设置您的 Zerodha 账户

本附录将帮助您设置与 Zerodha 的证券账户（zerodha.com）。

本附录将解释以下部分：

在线开设 Zerodha 账户
登录到 Zerodha 交易平台网站
设置您的 Zerodha 开发者选项账户
登录到 Zerodha 开发者选项网站
购买并启用 Zerodha 开发者选项 API
测试 API 密钥并通过发出您的第一个 API 调用授权应用程序

在线开设 Zerodha 账户

您可以按照此 YouTube 视频中解释的步骤在线开设 Zerodha 账户：www.youtube.com/watch?v=dcOIc8YZ9pc。

如果您有视频中提到的必要文件，账户设置可以在不到 30 分钟内完成。完成后，您的账户开户流程已启动，您必须等待 Zerodha 的账户开户团队的响应。 Zerodha 通常会在一周内回复您的账户凭证。

如果您在开设账户方面需要任何帮助，也可以访问 Zerodha 支持链接（support.zerodha.com/category/account-opening/online-account-opening/articles/how-do-i-open-an-account-online）。

登录到 Zerodha 交易平台网站

成功开设 Zerodha 账户后，您可以使用您收到的凭证登录到他们的交易平台，称为 Kite。访问 kite.zerodha.com。

访问网站后，您可以通过以下五个步骤登录到网站：

输入您的用户 ID。
输入您的密码。
单击登录按钮：

https://github.com/OpenDocCN/freelearn-quant-zh/raw/master/docs/py-algo-trd-cb/img/ce2f99d8-47a8-4bdf-af0d-644236310d29.png

输入您的 PIN：

https://github.com/OpenDocCN/freelearn-quant-zh/raw/master/docs/py-algo-trd-cb/img/d4ea7384-102d-410c-bb03-0956e853f043.png

点击继续按钮。

成功登录后，您应该会看到以下截图中显示的仪表板：

https://github.com/OpenDocCN/freelearn-quant-zh/raw/master/docs/py-algo-trd-cb/img/80ecb160-27ec-4757-bc28-93e0ee86a05a.png

设置您的 Zerodha 开发者选项账户

一旦您获得了 Zerodha 证券账户凭据，我们现在可以继续设置 Zerodha 的开发者选项账户。

请前往 kite.trade 并点击注册：

https://github.com/OpenDocCN/freelearn-quant-zh/raw/master/docs/py-algo-trd-cb/img/accd89b4-623b-4baa-b3ac-5083fa61cbed.png

您可以通过以下八个步骤注册新账户：

输入您的电子邮件地址。
输入您的名字**。**
输入您的密码。
验证您的密码。
输入您的电话号码。
选择您的居住州。
阅读并检查我同意上述条款复选框。
单击注册按钮：

https://github.com/OpenDocCN/freelearn-quant-zh/raw/master/docs/py-algo-trd-cb/img/bf15567c-f8f7-40f8-bafe-2d5cdc06e146.png

登录到 Zerodha 开发者选项网站

成功注册 Kite Connect 后，您可以使用您设置的凭据登录。访问 kite.trade。

你可以通过三个步骤登录到网站：

输入你注册的电子邮箱 ID。
输入你的密码（用于注册的密码）。
点击登录按钮：

https://github.com/OpenDocCN/freelearn-quant-zh/raw/master/docs/py-algo-trd-cb/img/27506670-1abc-4d5c-89f4-d7dbcc49c50a.png

第一次登录后，你应该会登陆到这样的页面：

https://github.com/OpenDocCN/freelearn-quant-zh/raw/master/docs/py-algo-trd-cb/img/c7bccf39-e38e-40f5-8591-2a812fe14a18.png

购买并启用 Zerodha 开发者选项 API

有两种类型的 API 可用：

Connect API：此 API 允许通过 API 下订单，获取持仓/持仓/订单，获取配置文件等。这个 API 对于实际交易是必需的，但对于回测或模拟交易是不必要的。
历史数据 API：此 API 允许获取历史数据。如果您正在实施自己的算法交易系统，则可能需要此 API。您还可以从其他供应商获取历史数据。

这两个 API 的文档可以在此处找到：kite.trade/docs/connect。

如果你打算在实际交易中使用 AlgoBulls 交易平台（algobulls.com），那么你只需要为你的经纪账户购买和启用 Connect API。你不需要为回测或模拟交易购买任何 API。AlgoBulls 平台提供所有服务的历史数据。

登录到kite.trade后，你可以通过以下两个步骤购买所需的 API 积分：

点击顶部菜单中的计费。这将加载一个新页面：

https://github.com/OpenDocCN/freelearn-quant-zh/raw/master/docs/py-algo-trd-cb/img/1b9caabd-9964-4db7-b7ff-f5283b0dad5d.png

输入所需金额，然后点击添加积分按钮。通过弹出的支付网关窗口完成支付：

https://github.com/OpenDocCN/freelearn-quant-zh/raw/master/docs/py-algo-trd-cb/img/90e43b31-2767-4ac8-ae51-0aa6e6150c3f.png

如果你想要启用这两个 API，所需金额应为4000。如果你只想启用 Connect API，则所需金额应为2000。登录到developers.kite.trade/create了解购买 API 所需确切金额的更多信息。

接下来，为了启用所需的 API，应该从首页执行以下步骤：

点击创建新应用程序。这将加载一个新页面：

https://github.com/OpenDocCN/freelearn-quant-zh/raw/master/docs/py-algo-trd-cb/img/75c62e85-623b-4b2d-b14c-f9e1287b7e9f.png

确保选择了类型：Connect。
输入你的应用程序名称。
输入你的 Zerodha 客户 ID。
将http://127.0.0.1作为你的重定向 URL。（如果你在本地端口80上托管服务器，你可以输入一个不同端口的 URL，该端口未被使用，比如http://127.0.0.1:8000）。
为你的应用程序输入一个描述。
点击创建按钮：

https://github.com/OpenDocCN/freelearn-quant-zh/raw/master/docs/py-algo-trd-cb/img/4b355d53-b75c-417d-9878-312f8ee666ab.png

阅读确认消息并输入I UNDERSTAND。
点击OK按钮：

https://github.com/OpenDocCN/freelearn-quant-zh/raw/master/docs/py-algo-trd-cb/img/6ef2bee2-6398-405f-8208-3e65bc656340.png

这完成了你的第一个应用程序的创建。现在你应该在首页看到你的应用程序：

https://github.com/OpenDocCN/freelearn-quant-zh/raw/master/docs/py-algo-trd-cb/img/9eeed032-de99-4c35-a27e-a7a9fc4353de.png

单击该应用程序以检查您的详细信息并获取 API 密钥和 API 密钥。可选地，如果您想激活历史数据 API，请在附加组件部分单击订阅，并确认订阅。这将花费 2,000 积分：

https://github.com/OpenDocCN/freelearn-quant-zh/raw/master/docs/py-algo-trd-cb/img/a5a3b73f-4927-4a4c-9f2a-0c940ca70d54.png

如下屏幕截图所示，可以获取密钥（API 密钥和API 密钥）。单击显示 API 密钥按钮以显示它：

https://github.com/OpenDocCN/freelearn-quant-zh/raw/master/docs/py-algo-trd-cb/img/c48b002e-fff5-4f79-8049-b80ee2e1ccdf.png

通过发出您的第一个 API 调用来测试 API 密钥并授权该应用程序。

您可以使用一个简单的 Python 程序测试您的 API 密钥。执行以下步骤：

从pyalgotrading中导入 Zerodha 经纪人连接类：

>>> from pyalgotrading.broker.broker_connection_zerodha import BrokerConnectionZerodha

使用您的 API 密钥和 API 密钥创建经纪人连接：

>>> api_key = ""
>>> api_secret = ""
>>> broker_connection = BrokerConnectionZerodha(api_key, api_secret)

您将获得以下结果：

https://kite.trade/connect/login?api_key=

您需要通过单击生成的链接并按照以下步骤进行 Zerodha 登录：

输入您的用户 ID。
输入您的密码（用于交易平台）。
单击登录按钮：

https://github.com/OpenDocCN/freelearn-quant-zh/raw/master/docs/py-algo-trd-cb/img/a65bf736-ba88-4646-b375-27bc3812d776.png

输入您的 PIN。
单击继续按钮：

https://github.com/OpenDocCN/freelearn-quant-zh/raw/master/docs/py-algo-trd-cb/img/f489b788-3f22-48ae-8c8c-d2c7703ee72d.png

单击授权按钮：

https://github.com/OpenDocCN/freelearn-quant-zh/raw/master/docs/py-algo-trd-cb/img/aed96346-2653-45af-868a-463bbb493c90.png

此步骤仅在新的 Zerodha Developer Options 应用程序中发生一次。

如果您的凭据正确，您将被重定向到127.0.0.1。忽略可能显示的任何错误消息。只需从您的标签页的地址栏中复制令牌。令牌是在request_token=和&字符之间的字符串，两者都不包括。每次按照这些步骤操作时都会生成一个新的随机令牌。例如，如果重定向 URL 为https://127.0.0.1/?request_token=iHCKrv8oAM9X2oPRURMNRdZdG4uxhfJq&action=login&status=success，则令牌为iHCKrv8oAM9X2oPRURMNRdZdG4uxhfJq：

https://github.com/OpenDocCN/freelearn-quant-zh/raw/master/docs/py-algo-trd-cb/img/f209eb1b-9f82-4de1-8b54-1ac2fcee0c2f.png

设置通过上一输出中给出的 URL 接收的令牌：

>>> request_token = ""
>>> broker_connection.set_access_token(request_token)

您可以通过获取您的个人资料详细信息来检查连接是否成功：

>>> broker_connection.get_profile()

这将产生以下输出：

{'user_id': <your-user-id>,
 'user_type': 'individual',
 'email': '',
 'user_name': <your-user-name>',
 'user_shortname': <your-user-shortname>',
 'broker': 'ZERODHA',
 'exchanges': ['CDS', 'MF', 'NFO', 'NSE', 'BSE'],
 'products': ['CNC', 'NRML', 'MIS', 'BO', 'CO'],
 'order_types': ['MARKET', 'LIMIT', 'SL', 'SL-M'],
 'avatar_url': '',
 'meta': {'demat_consent': 'physical'}}

这成功验证了 API 密钥是否有效。

附录 II：设置您的 AlgoBulls 账户

本附录将帮助您在 AlgoBulls（algobulls.com）上设置您的账户。

本附录解释了以下部分：

在 AlgoBulls 平台上注册
登录到 AlgoBulls 网站
获取您的 AlgoBulls 开发者选项令牌
为实际交易设置您的经纪账户

在 AlgoBulls 平台上注册

您可以通过转到官方网站algobulls.com，并点击 SIGNUP 注册 AlgoBulls 平台，如下面的截图所示：

https://github.com/OpenDocCN/freelearn-quant-zh/raw/master/docs/py-algo-trd-cb/img/94c1bd2d-9b32-4230-ae3e-8a327a81fa7e.png

您可以在九个步骤中注册该网站，如下所示：

输入您的名字。
输入您的电子邮件 ID。
输入您的电话号码。确保此电话号码可用于接收一次性密码（OTP）。
点击“I’m not a robot”复选框。
点击获取 OTP 按钮，如下面的截图所示：

https://github.com/OpenDocCN/freelearn-quant-zh/raw/master/docs/py-algo-trd-cb/img/ddd9c45e-500c-4f7e-90e6-628191320af6.png

等待直到您收到手机上的 OTP。收到后输入 OTP。
输入您的密码。
确认您的密码。
点击注册按钮，如下面的截图所示：

https://github.com/OpenDocCN/freelearn-quant-zh/raw/master/docs/py-algo-trd-cb/img/84462639-d355-4aed-ab88-3eb2f738c390.png

您现在已在该网站上注册。点击 Go to Login 按钮登录到该网站，如下面的截图所示：

https://github.com/OpenDocCN/freelearn-quant-zh/raw/master/docs/py-algo-trd-cb/img/557162c9-27c5-4030-ae48-09a22cafce07.png

登录到 AlgoBulls 网站

您可以通过转到官方网站algobulls.com并点击 LOGIN 登录到 AlgoBulls 平台，如下面的截图所示：

https://github.com/OpenDocCN/freelearn-quant-zh/raw/master/docs/py-algo-trd-cb/img/ecbea7b8-153d-4b9d-b51d-010420cce66f.png

您可以在三个步骤中登录到网站，如下：

输入您注册的电话号码。
输入您的密码。
点击登录按钮，如下面的截图所示：

https://github.com/OpenDocCN/freelearn-quant-zh/raw/master/docs/py-algo-trd-cb/img/5b674d69-8796-49b3-8963-c4d7226c5e08.png

获取您的 AlgoBulls 开发者选项令牌

登录后，您可以通过从侧边栏导航到开发者选项页面—Settings | General | Developer Options | API Token 来获取您的开发者选项令牌。您可以点击查看按钮（右侧的眼睛图标）来查看和复制应用程序编程接口（API）令牌，如下面的截图所示：

https://github.com/OpenDocCN/freelearn-quant-zh/raw/master/docs/py-algo-trd-cb/img/e9843e4c-21b3-4019-896e-861212a180fb.png

例如，前面截图中显示的 API 令牌为b042fdd8b8cc996abe6773edb4c8ead28acc1c47。

设置您的 AlgoBulls 账户

您需要执行以下操作才能从 AlgoBulls 平台获得算法交易服务：

订阅计划：服务 - 回测、模拟交易和实盘交易 - 是收费的。您需要在使用这些服务之前订阅一个计划。有免费计划可供您在有限的时间内使用这些服务。您可以订阅这些计划来测试本章中的所有策略。稍后，您可以订阅付费计划，以月付的方式使用服务。
对于真实交易（第十一章，算法交易 - 真实交易），您需要额外设置以下内容：
风险管理设置：这些设置帮助您在处理真实资金时限制损失。
添加经纪人：您需要将您的经纪账户与 AlgoBulls 连接起来。您可以选择 AlgoBulls 支持的任何经纪人。

你可以在help.algobulls.com/developers/找到设置这些细节的逐步信息和截图。任何可能随时间而来的额外设置说明都将在该链接上提供。你也可以通过 [email protected] 联系我们以获取任何额外需求。

附录 III：开发和改进策略

在这个附录中，我们将涵盖一些关于执行算法交易策略时应考虑的关键要点。

策略的盈利性受季节影响

策略可能不会全年都有良好的回报。它们可能是季节性的，这意味着它们在一年中的某些时候表现良好，而在其他时候表现不佳。因此，识别策略的正确时间或正确季节，并仅在那些时间使用它是至关重要的。

策略的盈利性受其参数值影响

策略依赖于各种参数。相同的策略可能对不同的工具和技术指标的不同值表现不同。例如，具有参数（时间段）4 和 9 的指数移动平均线（EMA）策略可能对股票 X 表现良好，但具有不同参数值（例如 5 和 13）的相同策略可能不适用于股票 X，甚至相同参数值的相同策略可能不适用于股票 Y。因此，找到正确的工具和参数可以使您的策略成功。

您可以使用优化算法找到使您的策略盈利的正确参数组合。成本函数可以是您的回测收益和损失（要最大化）以及回撤（要最小化）。变量可以是工具和策略参数值。

仅仅通过回测不能保证策略的盈利性

一个盈利的回测报告是盈利交易的先决条件之一，但并非唯一的先决条件。这增加了策略在实际交易中表现良好的机会，但并不保证。除了历史结果外，还有许多其他因素可能影响实际策略的表现。风险管理条件应该在你的策略中得到很好的安置，以减少在任何这种不可预见情况下的不利影响。确保这一点的一种方法是通过使用括号或盖单，在任何时候都放置强制性的止损。

经纪人的限制

并非所有经纪人都提供用于算法交易的 API。此外，即使提供了 API，经纪人也可能不支持所有类型的订单，例如内置风险管理的括号或盖单。在利用某个特定经纪人的服务之前，请检查并验证其提供的所有支持和服务。选择正确的经纪人可能会最大程度地减少你的策略编码工作。

与社区保持联系

你可以通过在论坛上向社区提问来获得编写自己策略的支持。你也可以从技术分析和其他算法交易论坛的书籍中获取见解和指引。此外，你可以关注提供免费策略及其 Python 代码的 GitHub 仓库（例如，github.com/algobulls/pyalgostrategypool）。

准备好在实际交易中遇到技术故障

无论你的策略有多么强大，实际交易中的策略执行可能不会按计划进行。这可能出现各种原因：

经纪商 API 可能由于服务器过载而出现超时故障。这种情况经常发生在市场开盘时间，那时大量交易者几乎同时下单以抓住市场开盘机会。
经纪商技术栈可能依赖于多个供应商，除了其自有的专有技术之外，这意味着即使其中一个失败，你也可能成为受害者，因为你的订单可能无法通过。
如果你使用的是算法交易平台，由于上述第一点提到的相同原因，它可能会失败。
你的策略可能会失败，因为它可能遇到了测试中未涵盖的新条件。例如，如果在实际交易中下达涉及非常大数量的订单，订单可能会分成多个较小的订单分别执行。如果你的策略没有考虑到这一点，它可能会失败。此外，这样的情况在回测过程中无法发现，因为这是虚拟交易，订单从不分裂，因此提供解决方案可能会比较棘手。
历史数据源可能会消失。可能是过时数据，也可能是没有数据，这两种情况都可能导致根据你的策略做出错误决策。

Python 算法交易秘籍（五）

第十一章：算法交易 - 实际交易

技术要求

EMA-Regular-Order 策略 – 获取该策略

如何操作…

工作原理…

EMA–Regular–Order strategy – real trading the strategy

准备工作

如何操作…

工作原理…

还有更多内容…

EMA–Regular–Order 策略 – 实时获取真实交易日志

准备就绪

如何操作…

工作原理…

还有更多…

EMA–Regular–Order 策略 – 获取真实交易报告 – 损益表

准备工作

操作步骤…

工作原理…

还有更多…

EMA–Regular–Order 策略 – 获取真实交易报告 – 统计表

准备工作

如何实现…

工作原理…

更多内容…

MACD-Bracket-Order 策略 - 提取策略

操作步骤如下：

工作原理是…

MACD–Bracket–Order 策略-实际交易该策略

准备就绪

如何做…

它是如何工作的…

还有更多…

MACD–Bracket–Order 策略 – 实时获取真实交易日志

准备就绪

如何实现…

工作原理如下…

还有更多…

MACD–Bracket–Order 策略 – 获取真实交易报告 – 利润和损失表

准备工作

如何做…

工作原理…

更多内容…

MACD-Bracket-Order 策略 - 获取真实交易报告 - 统计表

准备工作

如何做…

工作原理…

还有更多…

附录 I：设置您的 Zerodha 账户

在线开设 Zerodha 账户

登录到 Zerodha 交易平台网站

设置您的 Zerodha 开发者选项账户

登录到 Zerodha 开发者选项网站

购买并启用 Zerodha 开发者选项 API

通过发出您的第一个 API 调用来测试 API 密钥并授权该应用程序。

附录 II：设置您的 AlgoBulls 账户

在 AlgoBulls 平台上注册

登录到 AlgoBulls 网站

获取您的 AlgoBulls 开发者选项令牌

设置您的 AlgoBulls 账户

附录 III：开发和改进策略

策略的盈利性受季节影响

策略的盈利性受其参数值影响

仅仅通过回测不能保证策略的盈利性

经纪人的限制

与社区保持联系

准备好在实际交易中遇到技术故障

你可能感兴趣的:(默认分类,默认分类)