1. Python
  2. 快速开始
PDF下载 下载
“”关键字 0 个。
2/10

快速开始

阅读 518244

常见的策略结构主要包括3类，如下图所示。

用户可以根据策略需求选择相应的策略结构，具体可以参考经典策略。

定时任务示例

以下代码的内容是：在每个交易日的14：50：00 市价买入200股浦发银行股票：

  1. # coding=utf-8
  2. from __future__ import print_function, absolute_import
  3. from gm.api import *
  6. def init(context):
  7.     # 每天14:50 定时执行algo任务,
  8.     # algo执行定时任务函数，只能传context参数
  9.     # date_rule执行频率，目前暂时支持1d、1w、1m，其中1w、1m仅用于回测，实时模式1d以上的频率，需要在algo判断日期
  10.     # time_rule执行时间， 注意多个定时任务设置同一个时间点，前面的定时任务会被后面的覆盖
  11.     schedule(schedule_func=algo, date_rule='1d', time_rule='14:50:00')
  15. def algo(context):
  16.     # 以市价购买200股浦发银行股票， price在市价类型不生效
  17.     order_volume(symbol='SHSE.600000', volume=200, side=OrderSide_Buy,
  18.                  order_type=OrderType_Market, position_effect=PositionEffect_Open, price=0)
  21. # 查看最终的回测结果
  22. def on_backtest_finished(context, indicator):
  23.     print(indicator)
  26. if __name__ == '__main__':
  27.     '''
  28.         strategy_id策略ID, 由系统生成
  29.         filename文件名, 请与本文件名保持一致
  30.         mode运行模式, 实时模式:MODE_LIVE回测模式:MODE_BACKTEST
  31.         token绑定计算机的ID, 可在系统设置-密钥管理中生成
  32.         backtest_start_time回测开始时间
  33.         backtest_end_time回测结束时间
  34.         backtest_adjust股票复权方式, 不复权:ADJUST_NONE前复权:ADJUST_PREV后复权:ADJUST_POST
  35.         backtest_initial_cash回测初始资金
  36.         backtest_commission_ratio回测佣金比例
  37.         backtest_slippage_ratio回测滑点比例
  38.     '''
  39.     run(strategy_id='strategy_id',
  40.         filename='main.py',
  41.         mode=MODE_BACKTEST,
  42.         token='token_id',
  43.         backtest_start_time='2020-11-01 08:00:00',
  44.         backtest_end_time='2020-11-10 16:00:00',
  45.         backtest_adjust=ADJUST_PREV,
  46.         backtest_initial_cash=10000000,
  47.         backtest_commission_ratio=0.0001,
  48.         backtest_slippage_ratio=0.0001)

整个策略需要三步:

  1. 设置初始化函数: init , 使用 schedule 函数进行定时任务配置
  2. 配置任务, 到点会执行该任务
  3. 执行策略

数据事件驱动示例

在用subscribe()接口订阅标的后，后台会返回tick数据或bar数据。每产生一个或一组数据，就会自动触发on_tick()或on_bar()里面的内容执行。比如以下范例代码片段，订阅浦发银行频率为1天和60s的bar数据，每产生一次bar，就会自动触发on_bar()调用，打印获取的bar信息：

  1. # coding=utf-8
  2. from __future__ import print_function, absolute_import
  3. from gm.api import *
  6. def init(context):
  7.     # 订阅浦发银行, bar频率为一天和一分钟
  8.     # 订阅订阅多个频率的数据，可多次调用subscribe
  9.     subscribe(symbols='SHSE.600000', frequency='1d')
  10.     subscribe(symbols='SHSE.600000', frequency='60s')
  13. def on_bar(context, bars):
  15.     # 打印bar数据
  16.     print(bars)
  19. if __name__ == '__main__':
  20.     '''
  21.         strategy_id策略ID, 由系统生成
  22.         filename文件名, 请与本文件名保持一致
  23.         mode运行模式, 实时模式:MODE_LIVE回测模式:MODE_BACKTEST
  24.         token绑定计算机的ID, 可在系统设置-密钥管理中生成
  25.         backtest_start_time回测开始时间
  26.         backtest_end_time回测结束时间
  27.         backtest_adjust股票复权方式, 不复权:ADJUST_NONE前复权:ADJUST_PREV后复权:ADJUST_POST
  28.         backtest_initial_cash回测初始资金
  29.         backtest_commission_ratio回测佣金比例
  30.         backtest_slippage_ratio回测滑点比例
  31.     '''
  32.     run(strategy_id='strategy_id',
  33.         filename='main.py',
  34.         mode=MODE_BACKTEST,
  35.         token='token_id',
  36.         backtest_start_time='2020-11-01 08:00:00',
  37.         backtest_end_time='2020-11-10 16:00:00',
  38.         backtest_adjust=ADJUST_PREV,
  39.         backtest_initial_cash=10000000,
  40.         backtest_commission_ratio=0.0001,
  41.         backtest_slippage_ratio=0.0001)

整个策略需要三步:

  1. 设置初始化函数: init, 使用subscribe函数进行数据订阅
  2. 实现一个函数: on_bar, 来根据数据推送进行逻辑处理
  3. 执行策略

时间序列数据事件驱动示例

策略订阅代码时指定数据窗口大小与周期, 平台创建数据滑动窗口, 加载初始数据, 并在新的bar到来时自动刷新数据。

on_bar事件触发时, 策略可以取到订阅代码的准备好的时间序列数据。

以下的范例代码片段是一个非常简单的例子， 订阅浦发银行的日线和分钟bar, bar数据的更新会自动触发on_bar的调用, 每次调用context.data来获取最新的50条分钟bar信息：

  1. # coding=utf-8
  2. from __future__ import print_function, absolute_import
  3. from gm.api import *
  6. def init(context):
  7.     # 订阅浦发银行, bar频率为一天和一分钟
  8.     # 指定数据窗口大小为50
  9.     # 订阅订阅多个频率的数据，可多次调用subscribe
  10.     subscribe(symbols='SHSE.600000', frequency='1d', count=50)
  11.     subscribe(symbols='SHSE.600000', frequency='60s', count=50)
  14. def on_bar(context, bars):
  15.     # context.data提取缓存的数据滑窗, 可用于计算指标
  16.     # 注意：context.data里的count要小于或者等于subscribe里的count
  17.     data = context.data(symbol=bars[0]['symbol'], frequency='60s', count=50, fields='close,bob')
  19.     # 打印最后5条bar数据（最后一条是最新的bar）
  20.     print(data.tail())
  23. if __name__ == '__main__':
  24.     '''
  25.         strategy_id策略ID, 由系统生成
  26.         filename文件名, 请与本文件名保持一致
  27.         mode运行模式, 实时模式:MODE_LIVE回测模式:MODE_BACKTEST
  28.         token绑定计算机的ID, 可在系统设置-密钥管理中生成
  29.         backtest_start_time回测开始时间
  30.         backtest_end_time回测结束时间
  31.         backtest_adjust股票复权方式, 不复权:ADJUST_NONE前复权:ADJUST_PREV后复权:ADJUST_POST
  32.         backtest_initial_cash回测初始资金
  33.         backtest_commission_ratio回测佣金比例
  34.         backtest_slippage_ratio回测滑点比例
  35.     '''
  36.     run(strategy_id='strategy_id',
  37.         filename='main.py',
  38.         mode=MODE_BACKTEST,
  39.         token='token_id',
  40.         backtest_start_time='2020-11-01 08:00:00',
  41.         backtest_end_time='2020-11-10 16:00:00',
  42.         backtest_adjust=ADJUST_PREV,
  43.         backtest_initial_cash=10000000,
  44.         backtest_commission_ratio=0.0001,
  45.         backtest_slippage_ratio=0.0001)

整个策略需要三步:

  1. 设置初始化函数: init , 使用 subscribe 函数进行数据订阅
  2. 实现一个函数: on_bar , 来根据数据推送进行逻辑处理, 通过 context.data 获取数据滑窗
  3. 执行策略

选择回测模式/实时模式运行示例

掘金3策略只有两种模式, 回测模式(backtest)与实时模式(live)。在加载策略时指定mode参数。

  1. # coding=utf-8
  2. from __future__ import print_function, absolute_import
  3. from gm.api import *
  6. def init(context):
  7.     # 订阅浦发银行的tick
  8.     subscribe(symbols='SHSE.600000', frequency='60s')
  11. def on_bar(context, bars):
  12.     # 打印当前获取的bar信息
  13.     print(bars)
  16. if __name__ == '__main__':
  17.     # 在终端仿真交易和实盘交易的启动策略按钮默认是实时模式，运行回测默认是回测模式，在外部IDE里运行策略需要修改成对应的运行模式
  18.     # mode=MODE_LIVE 实时模式, 回测模式的相关参数不生效
  19.     # mode=MODE_BACKTEST  回测模式
  21.     '''
  22.         strategy_id策略ID, 由系统生成
  23.         filename文件名, 请与本文件名保持一致
  24.         mode运行模式, 实时模式:MODE_LIVE回测模式:MODE_BACKTEST
  25.         token绑定计算机的ID, 可在系统设置-密钥管理中生成
  26.         backtest_start_time回测开始时间
  27.         backtest_end_time回测结束时间
  28.         backtest_adjust股票复权方式, 不复权:ADJUST_NONE前复权:ADJUST_PREV后复权:ADJUST_POST
  29.         backtest_initial_cash回测初始资金
  30.         backtest_commission_ratio回测佣金比例
  31.         backtest_slippage_ratio回测滑点比例
  32.     '''
  33.     run(strategy_id='strategy_id',
  34.         filename='main.py',
  35.         mode=MODE_LIVE,
  36.         token='token_id',
  37.         backtest_start_time='2020-11-01 08:00:00',
  38.         backtest_end_time='2020-11-10 16:00:00',
  39.         backtest_adjust=ADJUST_PREV,
  40.         backtest_initial_cash=10000000,
  41.         backtest_commission_ratio=0.0001,
  42.         backtest_slippage_ratio=0.0001)

整个策略需要三步:

  1. 设置初始化函数: init , 使用 subscribe 函数进行数据订阅代码
  2. 实现一个函数: on_bar , 来根据数据推送进行逻辑处理
  3. 选择对应模式，执行策略

提取数据研究示例

如果只想提取数据，无需实时数据驱动策略, 无需交易下单可以直接通过数据查询函数来进行查询。

  1. # coding=utf-8
  2. from __future__ import print_function, absolute_import
  3. from gm.api import *
  6. # 可以直接提取数据，掘金终端需要打开，接口取数是通过网络请求的方式，效率一般，行情数据可通过subscribe订阅方式
  7. # 设置token， 查看已有token ID,在用户-密钥管理里获取
  8. set_token('your token_id')
  10. # 查询历史行情, 采用定点复权的方式， adjust指定前复权，adjust_end_time指定复权时间点
  11. data = history(symbol='SHSE.600000', frequency='1d', start_time='2020-01-01 09:00:00', end_time='2020-12-31 16:00:00',
  12.                fields='open,high,low,close', adjust=ADJUST_PREV, adjust_end_time='2020-12-31', df=True)
  13. print(data)

整个过程只需要两步:

  1. set_token 设置用户token， 如果token不正确, 函数调用会抛出异常
  2. 调用数据查询函数， 直接进行数据查询

回测模式下高速处理数据示例

本示例提供一种在init中预先取全集数据，规整后索引调用的高效数据处理方式，能够避免反复调用服务器接口导致的低效率问题，可根据该示例思路，应用到其他数据接口以提高效率.

  1. # coding=utf-8
  2. from __future__ import print_function, absolute_import
  3. from gm.api import *
  6. def init(context):
  7.     # 在init中一次性拿到所有需要的instruments信息
  8.     instruments = get_history_instruments(symbols='SZSE.000001,SZSE.000002', start_date=context.backtest_start_time,end_date=context.backtest_end_time)
  9.     # 将信息按symbol,date作为key存入字典
  10.     context.ins_dict = {(i.symbol, i.trade_date.date()): i for i in instruments}
  11.     subscribe(symbols='SZSE.000001,SZSE.000002', frequency='1d')
  13. def on_bar(context, bars):
  14.     print(context.ins_dict[(bars[0].symbol, bars[0].eob.date())])
  17. if __name__ == '__main__':
  18.     '''
  19.         strategy_id策略ID, 由系统生成
  20.         filename文件名, 请与本文件名保持一致
  21.         mode运行模式, 实时模式:MODE_LIVE回测模式:MODE_BACKTEST
  22.         token绑定计算机的ID, 可在系统设置-密钥管理中生成
  23.         backtest_start_time回测开始时间
  24.         backtest_end_time回测结束时间
  25.         backtest_adjust股票复权方式, 不复权:ADJUST_NONE前复权:ADJUST_PREV后复权:ADJUST_POST
  26.         backtest_initial_cash回测初始资金
  27.         backtest_commission_ratio回测佣金比例
  28.         backtest_slippage_ratio回测滑点比例
  29.     '''
  30.     run(strategy_id='strategy_id',
  31.         filename='main.py',
  32.         mode=MODE_BACKTEST,
  33.         token='token_id',
  34.         backtest_start_time='2020-11-01 08:00:00',
  35.         backtest_end_time='2020-11-10 16:00:00',
  36.         backtest_adjust=ADJUST_PREV,
  37.         backtest_initial_cash=10000000,
  38.         backtest_commission_ratio=0.0001,
  39.         backtest_slippage_ratio=0.0001)

整个策略需要三步:

  1. 设置初始化函数: init , 一次性拿到所有需要的instruments信息， 将信息按symbol,date作为key存入字典， 使用 subscribe 函数进行数据订阅代码
  2. 实现一个函数: on_bar , 来根据数据推送进行逻辑处理
  3. 执行策略

实时模式下动态参数示例

本示例提供一种通过策略设置动态参数，可在终端界面显示和修改，在不停止策略的情况下手动修改参数传入策略方法.

  1. # coding=utf-8
  2. from __future__ import print_function, absolute_import, unicode_literals
  3. from gm.api import *
  4. import numpy as np
  5. import pandas as pd
  8. '''动态参数，是指在不终止策略的情况下，掘金终端UI界面和策略变量做交互，
  9.     通过add_parameter在策略代码里设置动态参数，终端UI界面会显示对应参数
  10. '''
  13. def init(context):
  14.     # log日志函数，只支持实时模式，在仿真交易和实盘交易界面查看，重启终端log日志会被清除，需要记录到本地可以使用logging库
  15.     log(level='info', msg='平安银行信号触发', source='strategy')
  16.     # 设置k值阀值作为动态参数
  17.     context.k_value = 23
  18.     # add_parameter设置动态参数函数，只支持实时模式，在仿真交易和实盘交易界面查看，重启终端动态参数会被清除，重新运行策略会重新设置
  19.     add_parameter(key='k_value', value=context.k_value, min=0, max=100, name='k值阀值', intro='设置k值阀值',
  20.                   group='1', readonly=False)
  22.     # 设置d值阀值作为动态参数
  23.     context.d_value = 20
  24.     add_parameter(key='d_value', value=context.d_value, min=0, max=100, name='d值阀值', intro='设置d值阀值',
  25.                   group='2', readonly=False)
  27.     print('当前的动态参数有', context.parameters)
  28.     # 订阅行情
  29.     subscribe(symbols='SZSE.002400', frequency='60s', count=120)
  32. def on_bar(context, bars):
  34.     data = context.data(symbol=bars[0]['symbol'], frequency='60s', count=100)
  36.     kdj = KDJ(data, 9, 3, 3)
  37.     k_value = kdj['kdj_k'].values
  38.     d_value = kdj['kdj_d'].values
  40.     if k_value[-1] > context.k_value and d_value[-1] < context.d_value:
  41.         order_percent(symbol=bars[0]['symbol'], percent=0.01, side=OrderSide_Buy, order_type=OrderType_Market, position_effect=PositionEffect_Open)
  42.         print('{}下单买入， k值为{}'.format(bars[0]['symbol'], context.k_value))
  45. # 计算KDJ
  46. def KDJ(data, N, M1, M2):
  47.     lowList= data['low'].rolling(N).min()
  48.     lowList.fillna(value=data['low'].expanding().min(), inplace=True)
  49.     highList = data['high'].rolling(N).max()
  50.     highList.fillna(value=data['high'].expanding().max(), inplace=True)
  51.     rsv = (data['close'] - lowList) / (highList - lowList) * 100
  52.     data['kdj_k'] = rsv.ewm(alpha=1/M1).mean()
  53.     data['kdj_d'] = data['kdj_k'].ewm(alpha=1/M2).mean()
  54.     data['kdj_j'] = 3.0 * data['kdj_k'] - 2.0 * data['kdj_d']
  55.     return data
  58. # 动态参数变更事件
  59. def on_parameter(context, parameter):
  60.     # print(parameter)
  61.     if parameter['name'] == 'k值阀值':
  62.         # 通过全局变量把动态参数值传入别的事件里
  63.         context.k_value = parameter['value']
  64.         print('{}已经修改为{}'.format(parameter['name'], context.k_value))
  66.     if parameter['name'] == 'd值阀值':
  67.         context.d_value = parameter['value']
  68.         print('{}已经修改为{}'.format(parameter['name'], context.d_value))
  71. def on_account_status(context, account):
  72.     print(account)
  75. if __name__ == '__main__':
  76.     '''
  77.     strategy_id策略ID,由系统生成
  78.     filename文件名,请与本文件名保持一致
  79.     mode实时模式:MODE_LIVE回测模式:MODE_BACKTEST
  80.     token绑定计算机的ID,可在系统设置-密钥管理中生成
  81.     backtest_start_time回测开始时间
  82.     backtest_end_time回测结束时间
  83.     backtest_adjust股票复权方式不复权:ADJUST_NONE前复权:ADJUST_PREV后复权:ADJUST_POST
  84.     backtest_initial_cash回测初始资金
  85.     backtest_commission_ratio回测佣金比例
  86.     backtest_slippage_ratio回测滑点比例
  87.     '''
  88.     run(strategy_id='07c08563-a4a8-11ea-a682-7085c223669d',
  89.         filename='main.py',
  90.         mode=MODE_LIVE,
  91.         token='2c4e3c59cde776ebc268bf6d7b4c457f204482b3',
  92.         backtest_start_time='2020-09-01 08:00:00',
  93.         backtest_end_time='2020-10-01 16:00:00',
  94.         backtest_adjust=ADJUST_PREV,
  95.         backtest_initial_cash=500000,
  96.         backtest_commission_ratio=0.0001,
  97.         backtest_slippage_ratio=0.0001)

level2数据驱动事件示例

本示例提供level2行情的订阅， 包括逐笔成交、逐笔委托、委托队列
仅券商托管版本支持

  1. # coding=utf-8
  2. from __future__ import print_function, absolute_import
  3. from gm.api import *
  6. def init(context):
  7.     # 查询历史L2 Tick行情
  8.     history_l2tick=get_history_l2ticks('SHSE.600519', '2020-11-23 14:00:00', '2020-11-23 15:00:00', fields=None,
  9.                         skip_suspended=True, fill_missing=None,
  10.                         adjust=ADJUST_NONE, adjust_end_time='', df=False)
  11.     print(history_l2tick[0])
  13.     # 查询历史L2 Bar行情
  14.     history_l2bar=get_history_l2bars('SHSE.600000', '60s', '2020-11-23 14:00:00', '2020-11-23 15:00:00', fields=None,
  15.                        skip_suspended=True, fill_missing=None,
  16.                        adjust=ADJUST_NONE, adjust_end_time='', df=False)
  17.     print(history_l2bar[0])
  19.     # 查询历史L2 逐笔成交
  20.     history_transactions = get_history_l2transactions('SHSE.600000', '2020-11-23 14:00:00', '2020-11-23 15:00:00', fields=None, df=False)
  21.     print(history_transactions[0])
  23.     # 查询历史L2 逐笔委托
  24.     history_order=get_history_l2orders('SZSE.000001', '2020-11-23 14:00:00', '2020-11-23 15:00:00', fields=None, df=False)
  25.     print(history_order[0])
  27.     # 查询历史L2 委托队列
  28.     history_order_queue = get_history_l2orders_queue('SZSE.000001', '2020-11-23 14:00:00', '2020-11-23 15:00:00', fields=None, df=False)
  29.     print(history_order_queue[0])
  30.     # 订阅浦发银行的逐笔成交数据
  31.     subscribe(symbols='SHSE.600000', frequency='l2transaction')
  32.     # 订阅平安银行的逐笔委托数据（仅支持深市标的）
  33.     subscribe(symbols='SZSE.000001', frequency='l2order')
  36. def on_l2order(context, order):
  37.     # 打印逐笔成交数据
  38.     print(order)
  41. def on_l2transaction(context, transition):
  42.     # 打印逐笔委托数据
  43.     print(transition)
  47. if __name__ == '__main__':
  48.     '''
  49.         strategy_id策略ID, 由系统生成
  50.         filename文件名, 请与本文件名保持一致
  51.         mode运行模式, 实时模式:MODE_LIVE回测模式:MODE_BACKTEST
  52.         token绑定计算机的ID, 可在系统设置-密钥管理中生成
  53.         backtest_start_time回测开始时间
  54.         backtest_end_time回测结束时间
  55.         backtest_adjust股票复权方式, 不复权:ADJUST_NONE前复权:ADJUST_PREV后复权:ADJUST_POST
  56.         backtest_initial_cash回测初始资金
  57.         backtest_commission_ratio回测佣金比例
  58.         backtest_slippage_ratio回测滑点比例
  59.     '''
  60.     run(strategy_id='strategy_id',
  61.         filename='main.py',
  62.         mode=MODE_BACKTEST,
  63.         token='token_id',
  64.         backtest_start_time='2020-11-01 08:00:00',
  65.         backtest_end_time='2020-11-10 16:00:00',
  66.         backtest_adjust=ADJUST_PREV,
  67.         backtest_initial_cash=10000000,
  68.         backtest_commission_ratio=0.0001,
  69.         backtest_slippage_ratio=0.0001)

可转债数据获取、交易示例

本示例提供可转债数据获取、可转债交易

  1. # coding=utf-8
  2. from __future__ import print_function, absolute_import
  3. from gm.api import *
  6. def init(context):
  7.     # 订阅可转债行情。与股票无异
  8.     subscribe(symbols='SHSE.113038', frequency='tick', count=2)
  10.     # 获取可转债基本信息，输入可转债代码即可
  11.     infos = get_instrumentinfos(symbols='SHSE.113038', df=True)
  13.     # 输入可转债标的代码，可以获取到历史行情，但是只能是分钟线，不能获取日线。
  14.     history_data = history(symbol='SHSE.113038', frequency='60s', start_time='2021-02-24 14:50:00',
  15.                                 end_time='2021-02-24 15:30:30', adjust=ADJUST_PREV, df=True)
  18.     # 可转债回售、转股、转股撤销，需要券商实盘环境，仿真回测不可用。
  19.     bond_convertible_call('SHSE.110051', 100, 0)  
  20.     bond_convertible_put('SHSE.183350', 100, 0)  
  21.     bond_convertible_put_cancel('SHSE.183350', 100)
  23.     # 可转债下单，仅将symbol替换为可转债标的代码即可
  24.     order_volume(symbol='SZSE.128041', volume=100, side=OrderSide_Buy, order_type=OrderType_Limit, position_effect=PositionEffect_Open, price=340)
  26.     # 直接获取委托，可以看到相应的可转债委托，普通买卖通过标的体现可转债交易，转股、回售、回售撤销通过order_business字段的枚举值不同来体现。
  27.     A = get_orders()
  30. def on_tick(context, tick):
  31.     # 打印频率为tick的浦发银行的50条最新tick
  32.     print(tick)
  35. if __name__ == '__main__':
  36.     run(strategy_id='strategy_id',
  37.         filename='main.py',
  38.         mode=MODE_LIVE,
  39.         token='token_id',
  40.         backtest_start_time='2020-12-16 09:00:00',
  41.         backtest_end_time='2020-12-16 09:15:00',
  42.         backtest_adjust=ADJUST_PREV,
  43.         backtest_initial_cash=10000000,
  44.         backtest_commission_ratio=0.0001,
  45.         backtest_slippage_ratio=0.0001
  46.         )
0 篇笔记
分享笔记
联系我们
掘金交流群
掘金交流群
更多群组
微信公众号
微信公众号