调仓示例(报撤直到达到指定仓位)

1. #encoding:gbk
   
2. 
   
3. '''
   
4. 调仓到指定篮子
   
5. '''
   
6. 
   
7. import pandas as pd
   
8. import numpy as np
   
9. import time
   
10. from datetime import timedelta,datetime
    
11. 
    
12. #自定义类 用来保存状态
    
13. class a():pass
    
14. A=a()
    
15. A.waiting_dict =  {}
    
16. A.all_order_ref_dict = {}
    
17. #撤单间隔 单位秒 超过间隔未成交的委托撤回重报
    
18. A.withdraw_secs = 30
    
19. #定义策略开始结束时间 在两者间时进行下单判断 其他时间跳过
    
20. A.start_time = '093000'
    
21. A.end_time = '150000'
    
22. 
    
23. def init(C):
    
24.         '''读取目标仓位 字典格式 品种代码:持仓股数, 可以读本地文件/数据库，当前在代码里写死'''
    
25.         A.final_dict = {"600000.SH" :10000, '000001.SZ' : 20000}
    
26.         '''设置交易账号 acount accountType是界面上选的账号 账号类型'''
    
27.         A.acct = account
    
28.         A.acct_type = accountType
    
29.         #定时器 定时触发指定函数
    
30.         C.run_time("f","1nSecond","2019-10-14 13:20:00","SH")
    
31. 
    
32. 
    
33. def f(C):
    
34.         '''定义定时触发的函数 入参是ContextInfo对象'''
    
35.         #记录本次调用时间戳
    
36.         t0 = time.time()
    
37.         final_dict=A.final_dict
    
38.         #本次运行时间字符串
    
39.         now = datetime.now()
    
40.         now_timestr = now.strftime("%H%M%S")
    
41.         #跳过非交易时间
    
42.         if now_timestr < A.start_time or now_timestr > A.end_time:
    
43.                 return
    
44.         #获取账号信息
    
45.         acct = get_trade_detail_data(A.acct, A.acct_type, 'account')
    
46.         if len(acct) == 0:
    
47.                 print(A.acct, '账号未登录 停止委托')
    
48.                 return
    
49.         acct = acct[0]
    
50.         #获取可用资金
    
51.         available_cash = acct.m_dAvailable
    
52.         print(now, '可用资金', available_cash)
    
53.         #获取持仓信息
    
54.         position_list = get_trade_detail_data(A.acct, A.acct_type, 'position')
    
55.         #持仓数据 组合为字典
    
56.         position_dict = {i.m_strInstrumentID + '.' + i.m_strExchangeID : int(i.m_nVolume) for i in position_list}
    
57.         position_dict_available = {i.m_strInstrumentID + '.' + i.m_strExchangeID : int(i.m_nCanUseVolume) for i in position_list}
    
58.         #未持有的品种填充持股数0
    
59.         not_in_position_stock_dict = {i : 0 for i in final_dict if i not in position_dict}
    
60.         position_dict.update(not_in_position_stock_dict)
    
61.         #print(position_dict)
    
62.         stock_list = list(position_dict.keys())
    
63.         # print(stock_list)
    
64.         #获取全推行情
    
65.         full_tick = C.get_full_tick(stock_list)
    
66.         #print('fulltick', full_tick)
    
67.         #更新持仓状态记录
    
68.         refresh_waiting_dict(C)
    
69.         #撤超时委托
    
70.         order_list = get_trade_detail_data(A.acct, 'stock', 'order')
    
71.         if '091500'<= now_timestr <= '093000':#指定的范围內不撤单
    
72.                 pass
    
73.         else:
    
74.                 for order in order_list:
    
75.                         #非本策略 本次运行记录的委托 不撤
    
76.                         if order.m_strRemark not in A.all_order_ref_dict:
    
77.                                 continue
    
78.                         #委托后 时间不到撤单等待时间的 不撤
    
79.                         if time.time() - A.all_order_ref_dict[order.m_strRemark] < A.withdraw_secs:
    
80.                                 continue
    
81.                         #对所有可撤状态的委托 撤单
    
82.                         if order.m_nOrderStatus in [48,49,50,51,52,55,86,255]:
    
83.                                 print(f"超时撤单 停止等待 {order.m_strRemark}")
    
84.                                 cancel(order.m_strOrderSysID,A.acct,'stock',C)
    
85.         #下单判断
    
86.         for stock in position_dict:
    
87.                 #有未查到的委托的品种 跳过下单 防止超单
    
88.                 if stock in A.waiting_dict:
    
89.                         print(f"{stock} 未查到或存在未撤回委托 {A.waiting_dict[stock]} 暂停后续报单")
    
90.                         continue
    
91.                 if stock in position_dict.keys():
    
92.                         #print(position_dict[stock],target_vol,'1111')
    
93.                         #到达目标数量的品种 停止委托
    
94.                         target_vol = final_dict[stock] if stock in final_dict else 0
    
95.                         if int(abs(position_dict[stock] - target_vol)) == 0:
    
96.                                 print(stock, C.get_stock_name(stock), '与目标一致')
    
97.                                 continue
    
98.                         #与目标数量差值小于100股的品种 停止委托
    
99.                         if abs(position_dict[stock] - target_vol) < 100:
    
100.                                 print(f"{stock} {C.get_stock_name(stock)} 目标持仓{target_vol} 当前持仓{position_dict[stock]} 差额小于100 停止委托")
     
101.                                 continue
     
102.                         #持仓大于目标持仓 卖出
     
103.                         if position_dict[stock]>target_vol:
     
104.                                 vol = int((position_dict[stock] - target_vol)/100)*100
     
105.                                 if stock not in position_dict_available:
     
106.                                         continue
     
107.                                 vol = min(vol, position_dict_available[stock])
     
108.                                 #获取买一价
     
109.                                 print(stock,'应该卖出')
     
110.                                 buy_one_price = full_tick[stock]['bidPrice'][0]
     
111.                                 #买一价无效时 跳过委托
     
112.                                 if not buy_one_price > 0:
     
113.                                         print(f"{stock} {C.get_stock_name(stock)} 取到的价格{buy_one_price}无效，跳过此次推送")
     
114.                                         continue
     
115.                                 print(f"{stock} {C.get_stock_name(stock)} 目标股数{target_vol} 当前股数{position_dict[stock]}")
     
116.                                 msg = f"{now.strftime('%Y%m%d%H%M%S')}_{stock}_sell_{vol}股"
     
117.                                 print(msg)
     
118.                                 #对手价卖出
     
119.                                 passorder(24,1101,A.acct,stock,14,-1,vol,'调仓策略',2,msg,C)
     
120.                                 A.waiting_dict[stock] = msg
     
121.                                 A.all_order_ref_dict[msg] = time.time()
     
122.                         #持仓小于目标持仓 买入
     
123.                         if position_dict[stock]<target_vol:
     
124.                                 vol = int((target_vol-position_dict[stock])/100)*100
     
125.                                 #获取卖一价
     
126.                                 sell_one_price = full_tick[stock]['askPrice'][0]
     
127.                                 #卖一价无效时 跳过委托
     
128.                                 if not sell_one_price > 0:
     
129.                                         print(f"{stock} {C.get_stock_name(stock)} 取到的价格{sell_one_price}无效，跳过此次推送")
     
130.                                         continue
     
131.                                 target_value = sell_one_price * vol
     
132.                                 if target_value > available_cash:
     
133.                                         print(f"{stock} 目标市值{target_value} 大于 可用资金{available_cash} 跳过委托")
     
134.                                         continue
     
135.                                 print(f"{stock} {C.get_stock_name(stock)} 目标股数{target_vol} 当前股数{position_dict[stock]}")
     
136.                                 msg = f"{now.strftime('%Y%m%d%H%M%S')}_{stock}_buy_{vol}股"
     
137.                                 print(msg)
     
138.                                 #对手价买入
     
139.                                 passorder(23,1101,A.acct,stock,14,-1,vol,'调仓策略',2,msg,C)
     
140.                                 A.waiting_dict[stock] = msg
     
141.                                 A.all_order_ref_dict[msg] = time.time()
     
142.                                 available_cash -= target_value
     
143.         #打印函数运行耗时 定时器间隔应大于该值
     
144.         print(f"下单判断函数运行完成 耗时{time.time() - t0}秒")
     
145. 
     
146. 
     
147. def refresh_waiting_dict(C):
     
148.         """更新委托状态 入参为ContextInfo对象"""
     
149.         #获取委托信息
     
150.         order_list = get_trade_detail_data(A.acct,A.acct_type,'order')
     
151.         #取出委托对象的 投资备注 : 委托状态
     
152.         ref_dict = {i.m_strRemark : int(i.m_nOrderStatus) for i in order_list}
     
153.         del_list = []
     
154.         for stock in A.waiting_dict:
     
155.                 if A.waiting_dict[stock] in ref_dict and ref_dict[A.waiting_dict[stock]] in [56, 53, 54]:
     
156.                         #查到对应投资备注 且状态为成交 / 已撤 / 部撤， 从等待字典中删除
     
157.                         print(f'查到投资备注 {A.waiting_dict[stock]}，的委托 状态{ref_dict[A.waiting_dict[stock]]} (56已成 53部撤 54已撤)从等待等待字典中删除')
     
158.                         del_list.append(stock)
     
159.                 if A.waiting_dict[stock] in ref_dict and ref_dict[A.waiting_dict[stock]] == 57:
     
160.                         #委托状态是废单的 也停止等待 从等待字典中删除
     
161.                         print(f"投资备注为{A.waiting_dict[stock]}的委托状态为废单 停止等待")
     
162.                         del_list.append(stock)
     
163.         for stock in del_list:
     
164.                 del A.waiting_dict[stock]
     

复制代码

实盘策略要注意委托状态的确认, 委托后加入等待列表, 暂停该品种后续报单, 委托查到后再从等待列表删除.
可以参考 http://dict.thinktrader.net/inne ... 5%E7%9B%B8%E5%85%B3

赞！！