def initialize(context):

    g.security = "600570.SS"

    set_universe(g.security)



def before_trading_start(context, data):

    g.count = 0



def handle_data(context, data):

    if g.count == 0:

        # 对持仓内的贝斯进行转股操作

        debt_to_stock_order("123075.SZ", -1000)

        g.count += 1

    # 查看委托状态

    log.info(get_orders())

    g.count += 1

#coding:gbk

c = True

account = '11111111' # 个人账户

def init(ContextInfo):

    pass

    

def handlebar(ContextInfo):

	if not ContextInfo.is_last_bar():

		#历史k线不应该发出实盘信号 跳过

		return



    if c:

        passorder(80,1101,account,s,5,0,-100,'1',2,'tzbz',ContextInfo) 

        c=False

		

import requests



def initialize(context):

    # 初始化策略

    g.security = "600570.SS"

    set_universe(g.security)



    

def handle_data(context, data):

    

    url='http://www.baidu.com'

    headers={'User-Agent':'Google'}

    try:

        r=requests.get(url,headers=headers)

        r.encoding='utf8'

        print(r.text)

    except Exception as e:

        print('error')

        print(e)

APScheduler (3.3.1)

arch (3.2)

bcolz (1.2.1)

beautifulsoup4 (4.6.0)

bleach (1.5.0)

boto (2.43.0)

Bottleneck (1.0.0)

bz2file (0.98)

cachetools (3.1.0)

click (4.0)

contextlib2 (0.4.0)

crypto (1.4.1)

cvxopt (1.1.8)

cx-Oracle (8.0.1)

cycler (0.10.0)

cyordereddict (0.2.2)

Cython (0.22.1)

decorator (4.0.10)

entrypoints (0.2.2)

fastcache (1.0.2)

gensim (0.13.3)

h5py (2.6.0)

hmmlearn (0.2.0)

hs-udata (0.3.6)

html5lib (0.9999999)

ipykernel (4.5.0)

ipython (5.1.0)

ipython-genutils (0.1.0)

ipywidgets (5.2.2)

jieba (0.38)

Jinja2 (2.8)

jsonpickle (1.0)

jsonschema (2.5.1)

jupyter (1.0.0)

jupyter-client (4.4.0)

jupyter-console (5.0.0)

jupyter-core (4.2.0)

jupyter-kernel-gateway (1.1.1)

Keras (2.3.1)

Keras-Applications (1.0.8)

Keras-Preprocessing (1.1.0)

line-profiler (2.1.2)

Logbook (1.4.3)

lxml (4.5.0)

Markdown (2.2.0)

MarkupSafe (0.23)

matplotlib (1.5.3)

mistune (0.7.3)

Naked (0.1.31)

nbconvert (4.2.0)

nbformat (4.1.0)

networkx (1.9.1)

nose (1.3.6)

notebook (4.2.3)

numexpr (2.6.1)

numpy (1.11.2)

pandas (0.23.4)

patsy (0.4.0)

pexpect (4.2.1)

pickleshare (0.7.4)

pip (9.0.1)

pkgconfig (1.0.0)

prompt-toolkit (1.0.8)

protobuf (3.3.0)

ptvsd (2.2.0)

ptyprocess (0.5.1)

PyBrain (0.3)

pycrypto (2.6.1)

Pygments (2.1.3)

PyMySQL (0.9.3)

pyparsing (2.1.10)

python-dateutil (2.7.5)

pytz (2015.4)

PyWavelets (0.4.0)

PyYAML (5.3.1)

pyzmq (16.1.0.dev0)

qtconsole (4.2.1)

requests (2.7.0)

retrying (1.3.3)

scikit-learn (0.18)

scipy (0.18.0)

seaborn (0.7.1)

setuptools (28.7.1)

setuptools-scm (3.1.0)

shellescape (3.4.1)

simplegeneric (0.8.1)

simplejson (3.17.0)

six (1.10.0)

sklearn (0.0)

smart-open (1.3.5)

SQLAlchemy (1.0.8)

statsmodels (0.10.2)

TA-Lib (0.4.10)

tables (3.3.0)

tabulate (0.7.5)

tensorflow (1.3.0rc1)

tensorflow-tensorboard (0.1.2)

terminado (0.6)

Theano (0.8.2)

toolz (0.7.4)

tornado (4.4.2)

traitlets (4.3.1)

tushare (1.2.48)

tzlocal (1.3)

wcwidth (0.1.7)

Werkzeug (0.12.2)

wheel (0.29.0)

widgetsnbextension (1.2.6)

xcsc-tushare (1.0.0)

xgboost (0.6a2)

xlrd (1.1.0)

xlwt (1.3.0)

zipline (0.8.3)

You are using pip version 9.0.1, however version 22.1.2 is available.

You should consider upgrading via the 'pip install --upgrade pip' command.

量化新人用QMT+chat GPT快速上手量化策略（一）QMT基础介绍



量化新人用QMT+chat GPT快速上手量化策略（二）QMT均线盘后选股



量化新人用QMT+chat GPT快速上手量化策略（三）一个基本的回测策略代码



量化新人用QMT+chat GPT快速上手量化策略（四） QMT运行一个策略的整体流程



量化新人用QMT+chat GPT快速上手量化策略（五）  获取股票数据



量化新人用QMT+chat GPT快速上手量化策略（六） tablib计算指标



量化新人用QMT+chat GPT快速上手量化策略（七） 下单代码编写

def init(ContextInfo):

    ContextInfo.run_time('execution', '3nSecond', '2019-10-14 13:20:00',)



def execution(ContextInfo):

    if not ContextInfo.is_last_bar():

        return

    data = ContextInfo.get_market_data_ex(

        [], ['123136.SZ'], period='tick'

        , start_time='', end_time='', count=1

        , dividend_type='follow', fill_data=True

        , subscribe=True)

    print(data)

    

    

def handlebar(ContextInfo):

    #计算当前主图的cci

    pass

m_strAccountID: 资金账号，账号，账号，资金账号



m_strExchangeID: 证券市场



m_strExchangeName: 交易市场



m_strProductID: 品种代码



m_strProductName: 品种名称



m_strInstrumentID: 证券代码



m_strInstrumentName: 证券名称，合约名称



m_strOrderRef: 内部委托号，下单引用等于股票的内部委托号



m_nOrderPriceType: EBrokerPriceType 类型，例如市价单、限价单



m_nDirection: EEntrustBS 类型，操作，多空，期货多空，股票买卖永远是 48，其他的 dir 同理



m_nOffsetFlag: EOffset_Flag_Type类型，买卖/开平，用此字段区分股票买卖，期货开、平仓，期权买卖等



m_nHedgeFlag: EHedge_Flag_Type 类型，投保



m_dLimitPrice: 委托价格,限价单的限价，就是报价



m_nVolumeTotalOriginal: 委托量，最初委托量



m_nOrderSubmitStatus: EEntrustSubmitStatus 类型，报单状态，提交状态，股票中不需要报单状态



m_strOrderSysID: 合同编号，委托号



m_nOrderStatus: EEntrustStatus，委托状态



m_nVolumeTraded: 成交数量，已成交量



m_nVolumeTotal: 委托剩余量，当前总委托量，股票的含义是总委托量减去成交量



m_nErrorID: 状态信息



m_strErrorMsg: 状态信息



m_nTaskId：任务号



m_dFrozenMargin: 冻结金额，冻结保证金



m_dFrozenCommission: 冻结手续费



m_strInsertDate: 委托日期，报单日期



m_strInsertTime: 委托时间



m_dTradedPrice: 成交均价（股票）



m_dCancelAmount: 已撤数量



m_strOptName: 买卖标记，展示委托属性的中文



m_dTradeAmount: 成交金额，成交额，期货 = 均价 * 量 * 合约乘数



m_eEntrustType: EEntrustTypes，委托类别



m_strCancelInfo: 废单原因



m_strUnderCode: 标的证券代码



m_eCoveredFlag: ECoveredFlag，备兑标记 '0' - 非备兑，'1' - 备兑



m_dOrderPriceRMB: 委托价格（人民币），目前用于港股通



m_dTradeAmountRMB: 成交金额（人民币），目前用于港股通



m_dReferenceRate: 汇率，目前用于港股通



m_strCompactNo: 合约编号



m_eCashgroupProp: EXTCompactBrushSource类型，头寸来源



m_dShortOccupedMargin: 预估在途占用保证金，用于期权



m_strXTTrade: 是否是迅投交易



m_strAccountKey: 账号key，唯一区别不同账号的key



m_strRemark：投资备注

attr EBrokerPriceType value  <class 'EBrokerPriceType'>

attr ECoveredFlag value  <class 'ECoveredFlag'>

attr EEntrustBS value  <class 'EEntrustBS'>

attr EEntrustStatus value  <class 'EEntrustStatus'>

attr EEntrustSubmitStatus value  <class 'EEntrustSubmitStatus'>

attr EEntrustTypes value  <class 'EEntrustTypes'>

attr EFutureTradeType value  <class 'EFutureTradeType'>

attr EHedge_Flag_Type value  <class 'EHedge_Flag_Type'>

attr EOffset_Flag_Type value  <class 'EOffset_Flag_Type'>

attr ESideFlag value  <class 'ESideFlag'>

attr EXTCompactBrushSource value  <class 'EXTCompactBrushSource'>

attr EXTCompactStatus value  <class 'EXTCompactStatus'>

attr EXTCompactType value  <class 'EXTCompactType'>

attr EXTSloTypeQueryMode value  <class 'EXTSloTypeQueryMode'>

attr EXTSubjectsStatus value  <class 'EXTSubjectsStatus'>

attr __class__ value  <class 'COrderDetail'>

attr __delattr__ value  <method-wrapper '__delattr__' of COrderDetail object at 0x000000004AD59A60>

attr __dict__ value  {}

attr __dir__ value  <built-in method __dir__ of COrderDetail object at 0x000000004AD59A60>

attr __doc__ value  None

attr __eq__ value  <method-wrapper '__eq__' of COrderDetail object at 0x000000004AD59A60>

attr __format__ value  <built-in method __format__ of COrderDetail object at 0x000000004AD59A60>

attr __ge__ value  <method-wrapper '__ge__' of COrderDetail object at 0x000000004AD59A60>

attr __getattribute__ value  <method-wrapper '__getattribute__' of COrderDetail object at 0x000000004AD59A60>

attr __gt__ value  <method-wrapper '__gt__' of COrderDetail object at 0x000000004AD59A60>

attr __hash__ value  <method-wrapper '__hash__' of COrderDetail object at 0x000000004AD59A60>

attr __init__ value  <bound method __init__ of <COrderDetail object at 0x000000004AD59A60>>

attr __init_subclass__ value  <built-in method __init_subclass__ of Boost.Python.class object at 0x0000000044C55368>

attr __instance_size__ value  1088

attr __le__ value  <method-wrapper '__le__' of COrderDetail object at 0x000000004AD59A60>

attr __lt__ value  <method-wrapper '__lt__' of COrderDetail object at 0x000000004AD59A60>

attr __ne__ value  <method-wrapper '__ne__' of COrderDetail object at 0x000000004AD59A60>

attr __new__ value  <built-in method __new__ of Boost.Python.class object at 0x000007FEDCF525C0>

attr __reduce__ value  <bound method <unnamed Boost.Python function> of <COrderDetail object at 0x000000004AD59A60>>

attr __reduce_ex__ value  <built-in method __reduce_ex__ of COrderDetail object at 0x000000004AD59A60>

attr __repr__ value  <method-wrapper '__repr__' of COrderDetail object at 0x000000004AD59A60>

attr __setattr__ value  <method-wrapper '__setattr__' of COrderDetail object at 0x000000004AD59A60>

attr __sizeof__ value  <built-in method __sizeof__ of COrderDetail object at 0x000000004AD59A60>

attr __str__ value  <method-wrapper '__str__' of COrderDetail object at 0x000000004AD59A60>

attr __subclasshook__ value  <built-in method __subclasshook__ of Boost.Python.class object at 0x0000000044C55368>

attr __weakref__ value  None

attr j value  j

attr m_bEnable value  True

attr m_dCancelAmount value  0.0

attr m_dFrozenCommission value  0.15

attr m_dFrozenMargin value  1000.0

attr m_dLimitPrice value  2.3

import pickle

from collections import defaultdict

NOTEBOOK_PATH = '/home/fly/notebook/'

'''

持仓N日后卖出，仓龄变量每日pickle进行保存，重启策略后可以保证逻辑连贯

'''

def initialize(context):

    #尝试启动pickle文件

    try:

        with open(NOTEBOOK_PATH+'hold_days.pkl','rb') as f:

            g.hold_days = pickle.load(f)

Error! not UTF-8 encoded



Saving disable



See console for more details

用法： ContextInfo.get_market_data(fields, stock_code = , start_time = '', 

end_time = '', skip_paused = True, period = 'follow', 

dividend_type = 'follow', count = -1)

open -- 开盘价(str:numpy.float64)；

high -- 最高价(str:numpy.float64)；

low --最低价(str:numpy.float64)；

close -- 收盘价(str:numpy.float64)；

volume -- 交易量(str:numpy.float64)；

money -- 交易金额(str:numpy.float64)；

price -- 最新价(str:numpy.float64)；

preclose -- 昨收盘价(str:numpy.float64)(仅日线返回)；

high_limit -- 涨停价(str:numpy.float64)(仅日线返回)；

low_limit -- 跌停价(str:numpy.float64)(仅日线返回)；

unlimited -- 判断查询日是否无涨跌停限制(1：该日无涨跌停限制；0：该日有涨跌停限制)(str:numpy.float64)(仅日线返回)；

1. 涨停板；依赖ptrade的高速行情自动配合手动；
2. 两融账户的股票日内做T，持有底仓；
3. 股票小市值轮动+多因子
4. 可转债多因子（有N个版本+不同的排除因子 组合）
5. 可转债日内高频
6. 股票趋势动量
7. ETF轮动套利
8. 脉冲卖出扫描

margin_trade - 担保品买卖



margincash_open - 融资买入



margincash_close - 卖券还款



margincash_direct_refund - 直接还款



marginsec_open - 融券卖出



marginsec_close - 买券还券

2023-03-31 14:41:02 - INFO - 生成订单，订单号：cd25d27f39854721aac99db13c9e9b73股票代码：601328.SS 数量：信用买入1000

2023-03-31 14:41:02 - INFO - {'error_info': '', 'stock_code': '601328.SS', 'order_id': 'cd25d27f39854721aac99db13c9e9b73', 'status': '2', 'price': 5.1, 'entrust_type': '9', 'amount': 1000, 'business_amount': 0.0, 'entrust_prop': '0', 'entrust_no': '1', 'order_time': '2023-03-31 14:35:53.776'}

2023-03-31 14:41:02 - INFO - {'business_amount': 1000, 'order_id': 'cd25d27f39854721aac99db13c9e9b73', 'stock_code': '601328.SS', 'entrust_bs': '1', 'entrust_no': '1', 'status': '8', 'business_balance': 5100.0, 'business_price': 5.1, 'business_id': '2', 'business_time': '2023-03-31 14:39:17'}

2023-03-31 14:52:00 - INFO - 生成订单，订单号：01b7851d37014709bde3ec6ebe9e89c3股票代码：601328.SS 数量：融资买入100

2023-03-31 14:52:00 - INFO - {'price': 5.1, 'entrust_prop': '0', 'status': '2', 'entrust_type': '6', 'stock_code': '601328.SS', 'business_amount': 0.0, 'entrust_no': '3', 'order_time': '2023-03-31 14:46:51.620', 'error_info': '', 'amount': 100, 'order_id': '01b7851d37014709bde3ec6ebe9e89c3'}

2023-03-31 14:52:00 - INFO - {'business_id': '4', 'business_balance': 509.99999999999994, 'business_price': 5.1, 'order_id': '01b7851d37014709bde3ec6ebe9e89c3', 'business_time': '2023-03-31 14:50:14', 'status': '8', 'entrust_bs': '1', 'business_amount': 100, 'entrust_no': '3', 'stock_code': '601328.SS'}

2023-03-31 14:58:20 - INFO - start

2023-03-31 14:59:00 - INFO - 生成订单，订单号：20cef28ec52c4d41b09c80fc49167497股票代码：600269.SS 数量：卖券还款-200

2023-03-31 14:59:00 - INFO - {'business_amount': 0.0, 'amount': -200, 'stock_code': '600269.SS', 'error_info': '', 'order_time': '2023-03-31 14:53:51.375', 'price': 3.38, 'entrust_type': '6', 'status': '2', 'order_id': '20cef28ec52c4d41b09c80fc49167497', 'entrust_prop': '0', 'entrust_no': '5'}

2023-03-31 14:59:00 - INFO - {'status': '8', 'business_time': '2023-03-31 14:57:14', 'stock_code': '600269.SS', 'entrust_bs': '2', 'business_id': '6', 'business_balance': -676.0, 'business_amount': -200, 'order_id': '20cef28ec52c4d41b09c80fc49167497', 'business_price': 3.38, 'entrust_no': '5'}

def initialize(context):

    # 初始化策略

    # 设置我们要操作的股票池, 这里我们只操作一支股票

    g.security = "600300.SS"

    set_universe(g.security)



def before_trading_start(context, data):

    # 买入标识

    g.order_buy_flag = False

    # 卖出标识

    g.order_sell_flag = False



#当五日均线高于十日均线时买入，当五日均线低于十日均线时卖出

def handle_data(context, data):

    # 得到十日历史价格

    df = get_history(10, "1d", "close", g.security, fq=None, include=False)

    # 得到五日均线价格

    ma5 = round(df["close"][-5:].mean(), 3)

    # 得到十日均线价格

    ma10 = round(df["close"][-10:].mean(), 3)

    # 取得昨天收盘价

    price = data[g.security]["close"]

    # 如果五日均线大于十日均线

    if ma5 > ma10:

        if not g.order_buy_flag:

            # 获取最大可融资数量

            amount = get_margincash_open_amount(g.security).get(g.security)

            # 进行融资买入操作

            margincash_open(g.security, amount)

            # 记录这次操作

            log.info("Buying %s Amount %s" % (g.security, amount))

            # 当日已融资买入

            g.order_buy_flag = True



    # 如果五日均线小于十日均线，并且目前有头寸

    elif ma5 < ma10 and get_position(g.security).amount > 0:

        if not g.order_sell_flag:

            # 获取标的卖券还款最大可卖数量

            amount = get_margincash_close_amount(g.security).get(g.security)

            # 进行卖券还款操作

            margincash_close(g.security, -amount)

            # 记录这次操作

            log.info("Selling %s Amount %s" % (g.security, amount))

            # 当日已卖券还款

            g.order_sell_flag = True

担保品卖出指的是融资融券交易当中，用自有资金进行买卖的行为

def initialize(context):

    g.security = '600570.SS'

    set_universe(g.security)



def handle_data(context, data):

    # 以系统最新价委托

    margin_trade(g.security, 100)

    # 以72块价格下一个限价单

    margin_trade(g.security, 100, limit_price=72)

    # 以最优五档即时成交剩余撤销委托

    margin_trade(g.security, 200, market_type=4)

security：股票代码(str)；



amount：交易数量，正数表示买入，负数表示卖出(int)；



limit_price：买卖限价(float)；



market_type：市价委托类型，上证非科创板股票支持参数1、4，上证科创板股票支持参数0、1、2、4，深证股票支持参数0、2、3、4、5(int)；



0：对手方最优价格；

1：最优五档即时成交剩余转限价；

2：本方最优价格；

3：即时成交剩余撤销；

4：最优五档即时成交剩余撤销；

5：全额成交或撤单；

import pandas as pd

import datetime





def get_tick(code, start_time, end_time, period='tick'):

    from xtquant import xtdata



    xtdata.download_history_data(code, period=period, start_time=start_time, end_time=end_time)

    data = xtdata.get_local_data(field_list=, stock_code=

, period=period, count=10)

    result_list = data

    df = pd.DataFrame(result_list)



    df['time_str'] = df['time'].apply(lambda x: datetime.datetime.fromtimestamp(x / 1000.0))

    return df





def process_timestamp(df, filename):

    df = df.set_index('time_str')

    result = df.resample('3S').first().ffill()

    # result = result[(result.index >= '2022-07-20 09:30') & (result.index <= '2022-07-20 15:00')]

    result = result.reset_index()

    result.to_csv(filename + '.csv')





def dump_single_code_tick():

    # 导出单个转债的tick数据

    code='128022'

    start_date = '20210113'

    end_date = '20210130'



    post_fix = 'SZ' if code.startswith('12') else 'SH'

    code = '{}.{}'.format(code,post_fix)

    filename = '{}'.format(code)

    df = get_tick(code, start_date, end_date)

    process_timestamp(df, filename)



dump_single_code_tick()

def initialize(context):

    # 初始化策略

    g.security = "600570.SS"

    set_universe(g.security)



def handle_data(context, data):

    stock=get_Ashares()

    log.info(stock)

    obj_list = get_trade_detail_data(ACCOUNT,'stock','position')

    for obj in obj_list:

        print(obj.m_strInstrumentID,obj.m_strInstrumentName,'----')

        # 查看有哪些属性字段

        print('='*10)

        for item in dir(obj):

            if not item.startswith('__'):

                print(item)

                

        print('='*10)

m_bIsToday

m_dAvgOpenPrice

m_dCloseAmount

m_dCloseProfit

m_dFloatProfit

m_dInstrumentValue

m_dLastPrice

m_dLastSettlementPrice

m_dMargin

m_dMarketValue

m_dOpenCost

m_dOpenPrice

m_dPositionCost

m_dPositionProfit

m_dProfitRate

m_dRealUsedMargin

m_dRedemptionVolume

m_dReferenceRate

m_dRoyalty

m_dSettlementPrice

m_dSingleCost

m_dStaticHoldMargin

m_dStockLastPrice

m_dStructFundVol

m_dTotalCost

m_eFutureTradeType

m_eSideFlag

m_nCanUseVolume

m_nCidIncrease

m_nCidIsDelist

m_nCidRateOfCurrentLine

m_nCidRateOfTotalValue

m_nCloseVolume

m_nCoveredVolume

m_nDirection

m_nEnableExerciseVolume

m_nFrozenVolume

m_nHedgeFlag

m_nLegId

m_nOnRoadVolume

m_nOptCombUsedVolume

m_nPREnableVolume

m_nVolume

m_nYesterdayVolume

m_strAccountID

m_strAccountKey

m_strComTradeID

m_strExchangeID

m_strExchangeName

m_strExpireDate

m_strInstrumentID

m_strInstrumentName

m_strOpenDate

m_strProductID

m_strProductName

m_strStockHolder

m_strTradeID

m_strTradingDay

m_xtTag

def init(ContextInfo):

    print("==============start==========")

    ContextInfo.start = '2023-02-20 10:00:00'

    ContextInfo.end = '2023-02-23 10:00:00'

    if not ContextInfo.is_last_bar():

        return

# encoding:gbk

import logging

import pandas as pd

from datetime import datetime, timedelta, time

from decimal import InvalidOperation

from decimal import Decimal as D

from READFILE import read_file



logging.basicConfig(level=logging.INFO)

# 挂单失败后的等待时长，以秒计

TIMEOUT_ON_FAIL_SEC = 30

# 规避 account_callback 的 Racing Condition

RUN_TIME_DELAY = 10



# global FILEPATH, DIR, PRICE, VOL, START_TIME, account

SH_pattern = r'^[1-9]\d{5}\.(sh|SH)$'

SZ_pattern = r'^(?!39)\d{6}\.(sz|SZ)$'

SH_prefix = ['5', '6', '9', '11']

SZ_prefix = ['0', '2', '30', '12', '159']

COLNAMES = ['direction', 'vol', 'price', 'start_time']





def init(ContextInfo):

    ContextInfo.accID = account

    ContextInfo.set_account(ContextInfo.accID)



    ContextInfo.can_order = False

    ContextInfo.all_order_done = False



    if not load_file_order(ContextInfo):

        load_sys_order(ContextInfo)



    # load_file_order(ContextInfo)

    ContextInfo.run_time("place_order", "{0}nSecond".format(TIMEOUT_ON_FAIL_SEC),

                         (datetime.now() + timedelta(seconds=RUN_TIME_DELAY)).strftime('%Y-%m-%d %H:%M:%S'), 'SH')





def account_callback(ContextInfo, accountInfo):

    if not ContextInfo.can_order:

        ContextInfo.can_order = True





def handlebar(ContextInfo):

    return





def load_file_order(ContextInfo):

    def _price_vol_filtering(row):

        if not isinstance(row.start_time, time):

            logging.warning('读取{0}指令时间失败: {1}'.format(row.name, row.start_time))

            return None

        if row.direction not in ['买', '卖']:

            logging.warning('读取{0}买卖方向失败: {1}'.format(row.name, row.direction))

            return None

        try:

            # parse start_time

            curr_start_time = datetime.now().strftime('%Y-%m-%d ') + row.start_time.strftime('%H:%M:%S')

            curr_start_time = datetime.strptime(curr_start_time, '%Y-%m-%d %H:%M:%S')

            # parse direction

            curr_direction = 23 if row.direction == '买' else 24

            # parse price and vol

            price = D(row.price)

            vol = int(row.vol)

            return pd.Series([curr_direction, vol, price, curr_start_time])

        except InvalidOperation:

            logging.warning("读取 {0} 指令价格失败: {1}".format(row.name, row.price))

            return None

        except ValueError:

            logging.warning('读取 {0} 下单总量失败: {1}'.format(row.name, row.vol))

            return None



    def _name_parser(asset_name):

        # 目前默认用户输入.SH 或.SZ时标的名称正确

        if '.SH' in asset_name or '.SZ' in asset_name:

            # todo: SH/SZ_pattern regex check here?

            return asset_name

        else:

            raise ValueError('{0} 标的代码不合法'.format(asset_name))



    try:

        tmp_df = read_file(FILEPATH, names=COLNAMES, index_col=0)

    except:

        logging.warning('读取挂单配置文件失败或挂单配置文件为空，尝试交易读取配置面板参数')

        return None

    if tmp_df.empty:

        logging.warning('读取挂单配置文件失败或挂单配置文件为空，尝试交易读取配置面板参数')

        return None



    tmp_df.index = tmp_df.index.to_series().astype(str)

    tmp_df.index = tmp_df.index.str.strip()

    tmp_df.index = tmp_df.index.str.upper()

    tmp_df.index = tmp_df.index.to_series().apply(_name_parser).dropna()

    tmp_df = tmp_df.apply(_price_vol_filtering, axis=1, broadcast=True).dropna()

    if tmp_df.empty:

        logging.warning('读取挂单配置文件失败或挂单配置文件为空，尝试交易读取配置面板参数')

        return False



    tmp_df.set_axis(COLNAMES, axis='columns', inplace=True)

    # 挂单成功Flag

    tmp_df['finished'] = [False] * tmp_df.shape[0]

    ContextInfo.order_df = tmp_df

    ContextInfo.set_universe(ContextInfo.order_df.index.tolist())

    return True





def load_sys_order(ContextInfo):

    try:

        asset_name = ContextInfo.stockcode + '.' + ContextInfo.market

        ContextInfo.set_universe([asset_name])

        direction = 23 if DIR == '买入' else 24

        start_time = datetime.strptime(datetime.now().strftime('%Y%m%d') + str(START_TIME), '%Y%m%d%H%M%S')

        price = D(PRICE)

        vol = int(VOL)

    except BaseException:

        raise ValueError("读取策略面板交易配置失败。请尝试修正挂单配置文件或者策略面板参数。")



    price = float(price)

    ContextInfo.order_df = pd.DataFrame(data=[direction, vol, price, start_time], index=COLNAMES,

                                        columns=[asset_name]).T

    ContextInfo.order_df['finished'] = False

    return





def place_order(ContextInfo):

    if not ContextInfo.can_order or ContextInfo.all_order_done:

        return

    for curr_asset in ContextInfo.get_universe():

        if not ContextInfo.order_df.loc[curr_asset].finished \

                and datetime.now() > ContextInfo.order_df.loc[curr_asset].start_time:

            curr_order = ContextInfo.order_df.loc[curr_asset]

            direction = int(curr_order.direction)

            txt_direction = '买入' if direction == 23 else '卖出'

            price = float(D(curr_order.price))

            vol = int(curr_order.vol)

            order_remark = '隔日文件挂单: 以 {0} {1} {2}'.format(price, txt_direction, curr_asset)

            passorder(direction, 1101, ContextInfo.accID, curr_asset, 11, price, vol, order_remark, 1, order_remark,

                      ContextInfo)

            ContextInfo.order_df.loc[curr_asset, 'finished'] = True



    ContextInfo.all_order_done = all(ContextInfo.order_df['finished'].tolist())





def order_callback(ContextInfo, orderInfo):

    curr_asset = orderInfo.m_strInstrumentID + '.' + orderInfo.m_strExchangeID

    curr_remark = orderInfo.m_strRemark

    curr_status = orderInfo.m_nOrderStatus

    if '隔日文件挂单' in curr_remark and curr_status == 57:

        ContextInfo.order_df.loc[curr_asset, 'finished'] = False

        ContextInfo.all_order_done = False

        logging.error('{0} 隔日文件挂单：报单废单 (柜台返回失败)，原因：{1} 尝试重报'.format(curr_asset, orderInfo.m_strCancelInfo))

    elif '隔日文件挂单' in curr_remark and curr_status == 50:

        logging.info('{0} 隔日文件挂单：报单成功'.format(curr_asset))

    return





def orderError_callback(ContextInfo, orderArgs, errMsg):

    curr_asset = orderArgs.orderCode

    if '隔日文件挂单' in orderArgs.strategyName:

        ContextInfo.order_df.loc[curr_asset, 'finished'] = False

        ContextInfo.all_order_done = False

        logging.error('{0} 隔日文件挂单：账号下单异常 (COS/iQuant校验失败), 错误消息：{1} 尝试重报'.format(curr_asset, errMsg))

        return

综合交易下单 passorder()

用法： passorder(opType, orderType, accountid, orderCode, prType, modelprice, volume[, strategyName, quickTrade, userOrderId], ContextInfo)

期货六键：



0：开多



1：平昨多



2：平今多



3：开空



4：平昨空



5：平今空



期货四键：



6：平多,优先平今



7：平多,优先平昨



8：平空,优先平今



9：平空,优先平昨



期货两键：



10：卖出,如有多仓,优先平仓,优先平今,如有余量,再开空



11：卖出,如有多仓,优先平仓,优先平昨,如有余量,再开空



12：买入,如有空仓,优先平仓,优先平今,如有余量,再开多



13：买入,如有空仓,优先平仓,优先平昨,如有余量,再开多



14：买入,不优先平仓



15：卖出,不优先平仓



股票买卖：



23：股票买入，或沪港通、深港通股票买入



24：股票卖出，或沪港通、深港通股票卖出



融资融券：



27：融资买入



28：融券卖出



29：买券还券



30：直接还券



31：卖券还款



32：直接还款



33：信用账号股票买入



34：信用账号股票卖出



组合交易：



25：组合买入，或沪港通、深港通的组合买入



26：组合卖出，或沪港通、深港通的组合卖出



27：融资买入



28：融券卖出



29：买券还券



31：卖券还款



33：信用账号股票买入



34：信用账号股票卖出



40：期货组合开多



43：期货组合开空



46：期货组合平多,优先平今



47：期货组合平多,优先平昨



48：期货组合平空,优先平今



49：期货组合平空,优先平昨



期权交易：



50：买入开仓



51：卖出平仓



52：卖出开仓



53：买入平仓



54：备兑开仓



55：备兑平仓



56：认购行权



57：认沽行权



58：证券锁定



59：证券解锁

passorder(23,1101,account,s,11,14.00,100,2,ContextInfo)

1101：单股、单账号、普通、股/手方式下单



1102：单股、单账号、普通、金额（元）方式下单（只支持股票）



1113：单股、单账号、总资产、比例 [0 ~ 1] 方式下单



1123：单股、单账号、可用、比例[0 ~ 1]方式下单



1201：单股、账号组（无权重）、普通、股/手方式下单



1202：单股、账号组（无权重）、普通、金额（元）方式下单（只支持股票）



1213：单股、账号组（无权重）、总资产、比例 [0 ~ 1] 方式下单



1223：单股、账号组（无权重）、可用、比例 [0 ~ 1] 方式下单



2101：组合、单账号、普通、按组合股票数量（篮子中股票设定的数量）方式下单 > 对应 volume 的单位为篮子的份



2102：组合、单账号、普通、按组合股票权重（篮子中股票设定的权重）方式下单 > 对应 volume 的单位为元



2103：组合、单账号、普通、按账号可用方式下单 > （底层篮子股票怎么分配？答：按可用资金比例后按篮子中股票权重分配，如用户没填权重则按相等权重分配）只对股票篮子支持



2201：组合、账号组（无权重）、普通、按组合股票数量方式下单



2202：组合、账号组（无权重）、普通、按组合股票权重方式下单

-1：无效（实际下单时,需要用交易面板交易函数那设定的选价类型）



0：卖5价



1：卖4价



2：卖3价



3：卖2价



4：卖1价



5：最新价



6：买1价



7：买2价（组合不支持）



8：买3价（组合不支持）



9：买4价（组合不支持）



10：买5价（组合不支持）



11：（指定价）模型价（只对单股情况支持,对组合交易不支持）



12：涨跌停价



13：挂单价



14：对手价



27：市价即成剩撤(仅对股票期权申报有效)



28：市价即全成否则撤(仅对股票期权申报有效)



29：市价剩转限价(仅对股票期权申报有效)



42：最优五档即时成交剩余撤销申报(仅对上交所申报有效)



43：最优五档即时成交剩转限价申报(仅对上交所申报有效)



44：对手方最优价格委托(仅对深交所申报有效)



45：本方最优价格委托(仅对深交所申报有效)



46：即时成交剩余撤销委托(仅对深交所申报有效)



47：最优五档即时成交剩余撤销委托(仅对深交所申报有效)



48：全额成交或撤销委托(仅对深交所申报有效)



49：科创板盘后定价

passorder(

ContextInfo.TYPE_STOCK,



ContextInfo.TYPE_BUY,

100,

ContextInfo.LIMIT_PRICE,

ContextInfo)

volume，下单数量（股 / 手 / 元 / %）



passorder(opType, orderType, accountID, orderCode, prType, price, volume, ContextInfo)



根据 orderType 值最后一位确定 volume 的单位：



单股下单时：



1：股 / 手



2：金额（元）



3：比例（%）

#encoding:gbk



def init(ContextInfo):

    print('hello world')

    

def handlebar(ContextInfo):

    #计算当前主图的cci

    print("handle bar")

（3）Handlebar



handlebar 是整个 Python 模型中的核心执行函数。当模型从数据层获取到运行所需要的数据之后，会对数据集上的每一根 bar，调用一次 handlebar 函数，处理当前这根 bar 上的数据。也就是说，用户模型的核心逻辑都是写在该函数中的，如获取数据，设置下单条件等。在 handlebar 中处理完数据后，用户可以通过 paint 方法将需要绘图输出的结果返回给界面。界面会将输出结果如实的展示出来。

（4）ContextInfo



ContextInfo 是整个 Python 框架中的一个核心对象。它包含了各种与 Python 底层框架交互的 API 方法，也是一个全局的上下文环境，可以在 init 以及 handlebar 这两个函数中自由地传递用户创建的各种自定义数据。

def init(ContextInfo):

    pass

    

def handlebar(ContextInfo):

    pass

# encoding:gbk

import logging

from datetime import datetime, timedelta

from decimal import Decimal as D

from decimal import InvalidOperation



logging.basicConfig(level=logging.INFO)



# 挂单失败后的等待时长，以秒计

TIMEOUT_ON_FAIL_SEC = 30

# 等待account_callback的时长

# RUN_TIME_DELAY = 30



# how is this not defined in package??

MORNING_START = datetime.strptime(datetime.now().strftime('%Y%m%d') + '093000', '%Y%m%d%H%M%S')

MORNING_END = datetime.strptime(datetime.now().strftime('%Y%m%d') + '113000', '%Y%m%d%H%M%S')

NOON_START = datetime.strptime(datetime.now().strftime('%Y%m%d') + '130000', '%Y%m%d%H%M%S')

NOON_END = datetime.strptime(datetime.now().strftime('%Y%m%d') + '153000', '%Y%m%d%H%M%S')



# for SH only

TRANS_COST_1D = D('5e-6')

TRANS_COST_LONG = D('1.5e-7')

TRANS_COST_MAX = 100



# ORDER LIMITS

SH_UPPER = 1e7

SH_LOWER = 1e5

SZ_UPPER = 1e8

SZ_LOWER = 1e3



# ASSET NAME DICT

SH_REV_REPO = {'上交所1天': '204001.SH', '上交所2天': '204002.SH', '上交所3天': '204003.SH',

               '上交所4天': '204004.SH', '上交所7天': '204007.SH', '上交所14天': '204014.SH',

               '上交所28天': '204028.SH', '上交所91天': '204091.SH', '上交所182天': '204182.SH',

               }



SZ_REV_REPO = {'深交所3天': '131800.SZ', '深交所7天': '131801.SZ', '深交所14天': '131802.SZ',

               '深交所28天': '131803.SZ', '深交所91天': '131805.SZ', '深交所182天': '131806.SZ',

               '深交所4天': '131809.SZ', '深交所1天': '131810.SZ', '深交所2天': '131811.SZ',

               }





def init(ContextInfo):

    ContextInfo.accID = account

    ContextInfo.set_account(ContextInfo.accID)

    ContextInfo.use_all_cap = False if ALL_CAP == '否' else True



    # global trading control, set to False if detected error on user's side

    # stop() does not halt strat

    ContextInfo.order_control = False



    if not ContextInfo.use_all_cap:

        try:

            ContextInfo.dollar_vol = float(D(DOLLAR_VOL))

        except InvalidOperation:

            ContextInfo.order_control = True

            raise ValueError('读取资金量失败')

    else:

        if DOLLAR_VOL != '':

            logging.warning('已设定使用全部账户资金，忽略所设置资金量')



    try:

        ContextInfo.start_time = datetime.strptime(datetime.now().strftime('%Y%m%d') + str(START_TIME), '%Y%m%d%H%M%S')

        ContextInfo.asset_name = SH_REV_REPO[ASSET_NAME]

    except KeyError:

        ContextInfo.asset_name = SZ_REV_REPO[ASSET_NAME]

    except ValueError as error:

        if 'unconverted data remains' in str(error):

            ContextInfo.order_control = True

            raise ValueError('读取挂单时间失败')



    if not (MORNING_END > ContextInfo.start_time >= MORNING_START) \

            and not (NOON_END > ContextInfo.start_time >= NOON_START):

        ContextInfo.order_control = True

        raise ValueError('挂单时间不在可交易时间内')



    ContextInfo.can_order = False

    ContextInfo.order_done = False



    if not ContextInfo.order_control:

        ContextInfo.run_time("place_order", "{0}nSecond".format(TIMEOUT_ON_FAIL_SEC),

                             ContextInfo.start_time.strftime('%Y-%m-%d %H:%M:%S'), 'SH')





def account_callback(ContextInfo, accountInfo):

    if not ContextInfo.can_order:

        ContextInfo.can_order = True

        if ContextInfo.use_all_cap:

            ContextInfo.dollar_vol = accountInfo.m_dAvailable

        else:

            if ContextInfo.dollar_vol > accountInfo.m_dAvailable:

                ContextInfo.order_control = True

                raise ValueError('下单额度大于账户可用资金')



        # check if order satisfies lower limit for each exchange

        if ('SH' in ContextInfo.asset_name and ContextInfo.dollar_vol < SH_LOWER) \

                or ('SZ' in ContextInfo.asset_name and ContextInfo.dollar_vol < SZ_LOWER):

            ContextInfo.order_control = True

            raise ValueError('下单额度低于交易所最低限额')



        # checks dollar_vol and rounds the total amount

        if 'SH' in ContextInfo.asset_name and ContextInfo.dollar_vol % SH_LOWER != 0:

            ContextInfo.dollar_vol = (ContextInfo.dollar_vol // SH_LOWER) * SH_LOWER

            logging.warning('下单额度已规整为：{0}'.format(ContextInfo.dollar_vol))

        elif 'SZ' in ContextInfo.asset_name and ContextInfo.dollar_vol % SZ_LOWER != 0:

            ContextInfo.dollar_vol = (ContextInfo.dollar_vol // SZ_LOWER) * SZ_LOWER

            logging.warning('下单额度已规整为：{0}'.format(ContextInfo.dollar_vol))



        '''

        if 'SH' in ContextInfo.asset_name:

            num_batch_order = int(ContextInfo.dollar_vol // SH_UPPER)

            remain_order = ContextInfo.dollar_vol - num_batch_order * SH_UPPER

            if ContextInfo.asset_name == '204001.SH':

                transaction_cost = TRANS_COST_MAX * num_batch_order + remain_order * TRANS_COST_1D

            else:

                transaction_cost = TRANS_COST_MAX * num_batch_order + remain_order * TRANS_COST_LONG

            if transaction_cost + ContextInfo.dollar_vol > accountInfo.m_dAvailable:

                ContextInfo.order_control = True

                raise ValueError('可用资金不足以垫付交易金额与手续费')

       '''



        ContextInfo.remain_vol = ContextInfo.dollar_vol





def handlebar(ContextInfo):

    return





def place_order(ContextInfo):

    if not ContextInfo.can_order or ContextInfo.order_control:

        return



    if not ContextInfo.order_done:

        if 'SH' in ContextInfo.asset_name:

            num_batch_order = int(ContextInfo.remain_vol // SH_UPPER)

            remain_order = ContextInfo.remain_vol - num_batch_order * SH_UPPER

            for _ in range(num_batch_order):

                order_remark = '国债逆回购：尝试报单{0}元 {1}'.format(SH_UPPER, ContextInfo.asset_name)

                passorder(24, 1102, ContextInfo.accID, ContextInfo.asset_name, 5, -1, SH_UPPER, order_remark, 1,

                          order_remark, ContextInfo)

        else:

            num_batch_order = int(ContextInfo.remain_vol // SZ_UPPER)

            remain_order = ContextInfo.remain_vol - num_batch_order * SZ_UPPER

            for _ in range(num_batch_order):

                order_remark = '国债逆回购：尝试报单{0}元 {1}'.format(SZ_UPPER, ContextInfo.asset_name)

                passorder(24, 1102, ContextInfo.accID, ContextInfo.asset_name, 5, -1, SZ_UPPER, order_remark, 1,

                          order_remark, ContextInfo)



        order_remark = '国债逆回购：尝试报单{0}元 {1}'.format(remain_order, ContextInfo.asset_name)

        passorder(24, 1102, ContextInfo.accID, ContextInfo.asset_name, 5, -1, remain_order, order_remark, 1,

                  order_remark, ContextInfo)



        ContextInfo.remain_vol = 0

        ContextInfo.order_done = True





def order_callback(ContextInfo, orderInfo):

    curr_remark = orderInfo.m_strRemark

    curr_status = orderInfo.m_nOrderStatus



    if '国债逆回购' in curr_remark and ContextInfo.asset_name in curr_remark and curr_status == 57:

        ContextInfo.order_done = False

        # up the leftover dollar vol by failed amount

        # logging.info('reported trade amount:{0}, reported_trade_volume:{1}'.format(orderInfo.m_dTradeAmount, orderInfo.m_nVolumeTotal))

        # 单张100元

        ContextInfo.remain_vol += orderInfo.m_nVolumeTotal * 100

        if '交易时间不合法' in orderInfo.m_strCancelInfo:

            ContextInfo.order_control = True

            raise ValueError('国债逆回购：未能在交易时间内完成下单，停止报单。余量{0}元未报'.format(ContextInfo.remain_vol))

        logging.warning('国债逆回购：报单废单，原因：\"{0}\"，尝试重报'.format(orderInfo.m_strCancelInfo))

    elif '国债逆回购' in curr_remark and ContextInfo.asset_name in curr_remark and curr_status == 50:

        logging.info('国债逆回购：报单{0}元成功'.format(orderInfo.m_nVolumeTotal * 100))

    return









待续，不定期更新

在模型编辑器中，有“回测”和“运行”两个按钮，分别代表两种模式，它们之间的区别如下：

（1）回测模式指策略以历史行情为依据，以回测参数中的开始时间、结束时间为回测时间区间进行运

算，投资者可观察该策略在历史行情所获得的年化收益率、夏普比率、最大回撤、信息比率等指标表

现。



（2）运行模式指策略根据实时行情信号进行运算，以主图行情开始时间到当前时间为运行区间，进行策

略的模拟运行，但不进行真实的委托。



注：如果需要向模拟/实盘柜台发送真实的委托，请将策略加入到“模型交易”中。

盘后运行可能会有抽风现象。



回测的时候日期问题，只能选副图，不知道为何

def initialize(context):

    g.security = ['IF1712.CCFX', 'CU1806.XSGE']

    set_universe(g.security)



def handle_data(context, data):

    #买入开仓

    buy_open('IF1712.CCFX', 1)



    #买入开仓(限定点数为52220)

    buy_open('CU1806.XSGE', 1, limit_price=52220)

def initialize(context):

    g.security = ['IF1712.CCFX', 'CU1806.XSGE']

    set_universe(g.security)



def handle_data(context, data):

    #卖出平仓

    sell_close('IF1712.CCFX', 1)

    #卖出平今仓(限定点数为52220)

    sell_close ('CU1806.XSGE', 1, limit_price=52220, close_today=True)

    #卖出平仓(限定点数为52220)

    sell_close ('CU1806.XSGE', 1, limit_price=52220)

get_instruments(contract)

返回

FutureParams对象，主要返回的字段为:

contract_code -- 合约代码，str类型；
contract_name -- 合约名称，str类型；
exchange -- 交易所：大商所、郑商所、上期所、中金所，str类型；
trade_unit -- 交易单位，int类型；
contract_multiplier -- 合约乘数，float类型；
delivery_date -- 交割日期，str类型；
listing_date -- 上市日期，str类型；
trade_code -- 交易代码，str类型；
margin_rate -- 保证金比例，float类型；

def initialize(context):

    g.security = ["CU2112.XSGE", "IF2112.CCFX"]

    set_universe(g.security)



def before_trading_start(context, data):

    # 获取股票池代码合约信息

    for security in g.security:

        info = get_instruments(security)

    log.info(info)



def handle_data(context, data):

    pass