3.46K views
5

###################################
#  1、 
#  本示例主要包含两个py文件
#   TqTrade.py为交易逻辑所在文件,在主线程完成交易逻辑
#  主要是建立 参数字典,行情字典,以及交易的处理逻辑
#  这样每次遍历字典就可以在主线程中完成多合约单策略的交易
#  里面的策略请勿用于实盘,亏钱,亏钱,亏钱自负。
#  本程序所用写法会影响交易速度,有速度需求,请谨慎参考
#  2、
#  TradeInterval.py 文件主要定义了各个品种的交易时间
#  以在策略中,当日进行平仓
#  更新记录 2019 年 12月 10 日
#  更新 TradeInterval.py 文件中郑商所品种的夜盘收盘时间
#  如果使用TradeInterval.py,有新品种上市请自行添加
###################################
 ###################################
##     TradeInterval.py
###################################
#!/usr/bin/python3
# Filename: TradeInterval.py
 # 本文件定义了各个品种的交易区间,以及查询给定合约给定时间的交易状态
 import re
  # 可以使用函数的方法某种特定的字典,类似C++ 中的结构体
# 定义交易需要的参数
def CreatPara(code):
    # 建立一个字典数据
    # 交易参数定义
    # "code" :交易合约
    # "orderId":订单编号
    #  "posvol":持仓量
    #  "posSide":持仓方向
    #  'posPrice':持仓价格
    para = {'code':code,
            'orderId': '',
            'posvol': 0,
            'posside': 'BUY',
            'posprice': 0}
    return para
  # 郑商所品种夜盘收盘时间表,-1 表示没有夜盘
# 白天各开盘时间和收盘时间都一样,不再定义
CZCE_NIGHT_END = {'TA':82800,
                  'MA':82800,
                  'SR':82800,
                  'CF':82800,
                  'CY':82800,
                  'ZC':82800,
                  'FG':82800,
                  'OI': 82800,
                  'RM': 82800,
                  'UR':-1,
                  'SM': -1,
                  'SF': -1,
                  'CJ':-1,
                  'AP': -1,
                  'WH': -1,
                  'RI': -1,
                  'LR': -1,
                  'JR': -1,
                  'RS': -1,
                  }
# 大商所品种交易时间定义
# 主要区别在于夜盘,白天交易时间不再单独定义
DCE_NIGHT_END = {'M':82800,
                 'Y':82800,
                 'A':82800,
                 'B':82800,
                 'P':82800,
                 'C':82800,
                 'CS':82800,
                 'RR':82800,
                 'L':82800,
                 'V':82800,
                 'PP':82800,
                 'EG':82800,
                 'EB':82800,
                 'J':82800,
                 'JM':82800,
                 'I':82800,
                 'JD':-1,
                 'BB':-1,
                 'FB':-1,
                  }
# 上期所品种交易时间定义
SHFE_NIGHT_END = {'CU':3600,
                  'AL':3600,
                  'ZN':3600,
                  'PB':3600,
                  'NI':3600,
                  'SN':3600,
                  'AU':9000,
                  'AG':9000,
                  'RB':82800,
                  'HC':82800,
                  'SS':82800,
                  'FU':82800,
                  'BU':82800,
                  'RU':82800,
                  'SP':82800,
                  'WR': -1,
                  }
# 能源交易所时间定义
INE_NIGHT_END = {'SC':9000,
                 'NR':82800
                 }
# 中金所品种交易时间定义
CFFEX_OPEN_TIME = {'IF':34200,
                   'IH':34200,
                   'IC':34200,
                   'TS':34200,
                   'TF':34200,
                   'T':34200}
# 当天结束交易的时间
CFFEX_DAY_END = {'IF':54000,
                 'IH':54000,
                 'IC':54000,
                 'TS':54900,
                 'TF':54900,
                 'T':54900}
  def time2Secs(timestr):
    # 本函数摘抄自如下链接
    # https: // www.cnblogs.com / gayhub / p / 6154707.html
    # 转换:hh:mm:ss 格式的时间为秒时间
    h,m,s = timestr.strip().split(':')
    return int(h) * 3600 + int(m) * 60 + int(s)
  def secs_to_trade_end(symbol,timestr):
    # 计算给定时间距离收盘的时间
    # 先定义各个品种的交易时段信息
    # 返回值
    # interval  0 表示非交易时间,1-表示晚上,2-表示早上第一小节,3-表示早上第二小节,5-表示下午
    # secsEnd 距离收盘的时间值
     interval = 0
    secend = -1
    exch,sym = symbol.strip().split('.')
    commodity = (''.join(re.split(r'[^A-Za-z]', sym))).upper()
    secs = time2Secs(timestr)
    if secs < 0:
        return 0,0
    if exch == "CZCE":
        if 21 * 3600 - 1 < secs <= 23*3600 + 30 * 60:
            #夜盘
            if commodity in CZCE_NIGHT_END.keys():
                if CZCE_NIGHT_END[commodity] < 0:
                    interval = 0
                    secend = 0
                else:
                    interval = 1
                    secend = CZCE_NIGHT_END[commodity] - secs
            else:
                interval = 0
                secend = 0
        elif 9 * 3600 - 1 < secs <= 10 * 3600 + 15 * 60:
            #早盘第二小节
            if commodity in CZCE_NIGHT_END.keys():
                interval = 2
                secend = 10 * 3600 + 15 * 60 - secs
            else:
                interval = 0
                secend = -1
        elif 10 * 3600 + 30 * 60 <= secs <= 11 * 3600 + 30 * 60:
            #早盘第二小节
            if commodity in CZCE_NIGHT_END.keys():
                interval = 3
                secend = 11 * 3600 + 30 * 60 - secs
            else:
                interval = 0
                secend = -1
        elif 13 * 3600 + 30 * 60 <= secs <= 15 * 3600:
            #下午时段
            if commodity in CZCE_NIGHT_END.keys():
                interval = 5
                secend = 15 * 3600 - secs
            else:
                interval = 0
                secend = 0
        else:
            return 0,0
    elif exch == 'DCE':
        if  21 * 3600 - 1 < secs <= 23*3600:
            #夜盘
            if commodity in DCE_NIGHT_END.keys():
                if DCE_NIGHT_END[commodity] < 0:
                    interval = 0
                    secend = 0
                else:
                    interval = 1
                    secend = DCE_NIGHT_END[commodity] - secs
            else:
                interval = 0
                secend = 0
        elif 9 * 3600 - 1 < secs <= 10 * 3600 + 15 * 60:
            #早盘第二小节
            if commodity in DCE_NIGHT_END.keys():
                interval = 2
                secend = 10 * 3600 + 15 * 60 - secs
            else:
                interval = 0
                secend = -1
        elif 10 * 3600 + 30 * 60 < secs <= 11 * 3600 + 30 * 60:
            #早盘第二小节
            if commodity in DCE_NIGHT_END.keys():
                interval = 3
                secend = 11 * 3600 + 30 * 60 - secs
            else:
                interval = 0
                secend = -1
        elif 13 * 3600 + 30 * 60 < secs <= 15 * 3600:
            #下午时段
            if commodity in DCE_NIGHT_END.keys():
                interval = 5
                secend = 15 * 3600 - secs
            else:
                interval = 0
                secend = 0
        else:
            return 0,0
        pass
    elif exch == 'SHFE':
        if secs > 21 * 3600 - 1:
            #夜盘
            if commodity in SHFE_NIGHT_END.keys():
                if SHFE_NIGHT_END[commodity] > secs:
                    interval = 1
                    secend = SHFE_NIGHT_END[commodity] - secs
                elif 0 < SHFE_NIGHT_END[commodity] < 3 * 3600:
                    interval = 1
                    secend = 86400 - secs + SHFE_NIGHT_END[commodity]
        elif secs <= 2 * 3600 + 30 * 60:
            if commodity in SHFE_NIGHT_END.keys():
                if secs <= SHFE_NIGHT_END[commodity] < 2 * 3600 + 30 * 60 + 1:
                    interval = 1
                    secend = SHFE_NIGHT_END[commodity] - secs
        elif 9 * 3600 - 1 < secs <= 10 * 3600 + 15 * 60:
            # 早盘第二小节
            if commodity in SHFE_NIGHT_END.keys():
                interval = 2
                secend = 10 * 3600 + 15 * 60 - secs
            else:
                interval = 0
                secend = -1
        elif 10 * 3600 + 30 * 60 < secs <= 11 * 3600 + 30 * 60:
            # 早盘第二小节
            if commodity in SHFE_NIGHT_END.keys():
                interval = 3
                secend = 11 * 3600 + 30 * 60 - secs
            else:
                interval = 0
                secend = -1
        elif 13 * 3600 + 30 * 60 < secs <= 15 * 3600:
            #下午时段
            if commodity in SHFE_NIGHT_END.keys():
                interval = 5
                secend = 15 * 3600 - secs
            else:
                interval = 0
                secend = 0
        else:
            return 0,0
        pass
    elif exch == 'INE':
        if secs > 21 * 3600 - 1:
            #夜盘
            if commodity in INE_NIGHT_END.keys():
                if INE_NIGHT_END[commodity] > secs:
                    interval = 1
                    secend = INE_NIGHT_END[commodity] - secs
                elif 0 < INE_NIGHT_END[commodity] < 3 * 3600:
                    interval = 1
                    secend = 86400 + INE_NIGHT_END[commodity] - secs 
        elif secs <= 2 * 3600 + 30 * 60:
            if commodity in INE_NIGHT_END.keys():
                if secs <= INE_NIGHT_END[commodity] < 2 * 3600 + 30 * 60 + 1:
                    interval = 1
                    secend = INE_NIGHT_END[commodity] - secs
        elif 9 * 3600 - 1 < secs <= 10 * 3600 + 15 * 60:
            #早盘第二小节
            if commodity in INE_NIGHT_END.keys():
                interval = 2
                secend = 10 * 3600 + 15 * 60 - secs
            else:
                interval = 0
                secend = -1
        elif 10 * 3600 + 30 * 60 < secs <= 11 * 3600 + 30 * 60:
            #早盘第二小节
            if commodity in INE_NIGHT_END.keys():
                interval = 3
                secend = 11 * 3600 + 30 * 60 - secs
            else:
                interval = 0
                secend = -1
        elif 13 * 3600 + 30 * 60 < secs <= 15 * 3600:
            #下午时段
            if commodity in INE_NIGHT_END.keys():
                interval = 5
                secend = 15 * 3600 - secs
            else:
                interval = 0
                secend = 0
        else:
            return 0,0
    elif exch == 'CFFEX':
        if 9 * 3600 < secs <= 11 * 3600 + 30 * 60:
            #早盘
            if commodity in CFFEX_OPEN_TIME.keys():
                if secs - CFFEX_OPEN_TIME[commodity] < 0:
                    interval = 0
                    secend = 0
                else:
                    interval = 3
                    secend = 11 * 3600 + 30 * 60 - secs
            else:
                interval = 0
                secend = -1
        elif 13 * 3600 <= secs <= 15 * 3600 + 15 * 60:
            #下午时段
            if commodity in CFFEX_OPEN_TIME.keys():
                interval = 5
                secend = CFFEX_OPEN_TIME[commodity] - secs
            else:
                interval = 0
                secend = 0
        else:
            return 0,0
    else:
        return 0,0
     # 如果 secend < 0 ,则说明不是交易时间
     if secend < 0:
        interval = 0
    return interval,secend
  def secs_to_open(symbol,timestr):
    #检查当前时间距离开盘时间的秒数
    interval = 0
    secbegin = -1
    exch, sym = symbol.strip().split('.')
    commodity = (''.join(re.split(r'[^A-Za-z]', sym))).upper()
    secs = time2Secs(timestr)
    if secs < 0:
        return 0,0
    if exch == 'CZCE':
        if 21 * 3600 - 1 < secs <= 23 * 3600 + 30 * 60:
            if commodity in CZCE_NIGHT_END.keys():
                if CZCE_NIGHT_END[commodity] > 0:
                    interval = 1
                    secbegin = secs - 21 * 3600
        elif 9 * 3600 - 1 < secs <= 10 * 3600 + 15 * 60:
            interval = 2
            secbegin = secs - 9 * 3600
        elif 10 * 3600 + 30 * 60 <= secs <= 11 * 3600 + 30 * 60:
            interval = 3
            secbegin = secs - 10 * 3600 - 30 * 60
        elif 13 * 3600 + 30 * 60 <= secs <= 15 * 3600:
            interval = 5
            secbegin = secs - 13 * 3600 - 30 * 60
    elif exch == 'DCE':
        if 21 * 3600 - 1 < secs <= 23 * 3600:
            if commodity in DCE_NIGHT_END.keys():
                if DCE_NIGHT_END[commodity] > 0:
                    interval = 1
                    secbegin = secs - 21 * 3600
        elif 9 * 3600 - 1 < secs <= 10 * 3600 + 15 * 60:
            interval = 2
            secbegin = secs - 9 * 3600
        elif 10 * 3600 + 30 * 60 <= secs <= 11 * 3600 + 30 * 60:
            interval = 3
            secbegin = secs - 10 * 3600 - 30 * 60
        elif 13 * 3600 + 30 * 60 <= secs <= 15 * 3600:
            interval = 5
            secbegin = secs - 13 * 3600 - 30 * 60
    elif exch == 'SHFE':
        if secs > 21 * 3600 - 1:
            if commodity in SHFE_NIGHT_END.keys():
                if SHFE_NIGHT_END[commodity] > 0:
                    if secs <= SHFE_NIGHT_END[commodity] or SHFE_NIGHT_END[commodty[ < 3 * 3600:
                        interval = 1
                        secbegin = secs - 21 * 3600
        elif secs <= 2 * 3600 + 30 * 60:
            if commodity in SHFE_NIGHT_END.keys():
                if secs < SHFE_NIGHT_END[commodity] < 2 * 3600 +30 * 60 + 1:
                    interval = 1
                    secbegin = 3600
        elif 9 * 3600 - 1 < secs <= 10 * 3600 + 15 * 60:
            interval = 2
            secbegin = secs - 9 * 3600
        elif 10 * 3600 + 30 * 60 <= secs <= 11 * 3600 + 30 * 60:
            interval = 3
            secbegin = secs - 10 * 3600 - 30 * 60
        elif 13 * 3600 + 30 * 60 <= secs <= 15 * 3600:
            interval = 5
            secbegin = secs - 13 * 3600 - 30 * 60
    elif exch == 'INE':
        if secs > 21 * 3600 - 1:
            if commodity in INE_NIGHT_END.keys():
                if INE_NIGHT_END[commodity] > 0:
                    if secs < INE_NIGHT_END[commodity] or INE_NIGHT_END[commodity] < 3 * 3600:
                        interval = 1
                        secbegin = secs - 21 * 3600
        elif secs <= 2 * 3600 + 30 * 60:
            if commodity in INE_NIGHT_END.keys():
                if secs < INE_NIGHT_END[commodity] <= 2 * 3600 + 30 * 60:
                    interval = 1
                    secbegin = 3600
        elif 9 * 3600 - 1 < secs <= 10 * 3600 + 15 * 60:
            interval = 2
            secbegin = secs - 9 * 3600
        elif 10 * 3600 + 30 * 60 <= secs <= 11 * 3600 + 30 * 60:
            interval = 3
            secbegin = secs - 10 * 3600 - 30 * 60
        elif 13 * 3600 + 30 * 60 <= secs <= 15 * 3600:
            interval = 5
            secbegin = secs - 13 * 3600 - 30 * 60
    elif exch == 'CFFEX':
        if 9 * 3600 <= secs <= 11 * 3600 + 30 * 60:
            # 早盘
            if commodity in CFFEX_OPEN_TIME.keys():
                if secs - CFFEX_OPEN_TIME[commodity] < 0:
                    interval = 0
                    secbegin = 0
                else:
                    interval = 3
                    secbegin = secs - CFFEX_OPEN_TIME[commodity]
            else:
                interval = 0
                secbegin = -1
        elif 13 * 3600 <= secs <= 15 * 3600 + 15 * 60:
            # 下午时段
            if commodity in CFFEX_OPEN_TIME.keys() and secs <= CFFEX_DAY_END[commodity]:
                interval = 5
                secbegin = secs - 13 * 3600
            else:
                interval = 0
                secbegin = 0
        else:
            return 0,0
     return interval,secbegin
  if __name__ == '__main__':
     a = 10
    a -= 1
    print(a)
     code = 'CZCE.TA001'
    time_str = '21:30:00'
    print('Thie is assistan file')
    # 提取code中大小写字母,并组成新
    res = (''.join(re.split(r'[^A-Za-z]', code))).upper()
    print(res.upper())
     print(secs_to_trade_end(code,time_str))
     print(secs_to_open(code,time_str))
     if 'TA' in CZCE_NIGHT_END.keys():
        print('TA in CZCE_NIGHT_END')
 ######################################
##        TqTrade.py
######################################
### 此程序开始尝试编写一个简单的 tqsdk交易策略。
### 为以后做完整的界面进行铺路
### 本文提供一种单线程多合约相同策略的编写方式
 #先做一个简单的均线策略
#交易循环逻辑
# 开仓和平仓的时候需要根据交易时间进行处理
#
# 循环:
    #【1】、等待行情更新,并计算均线
    #【2】、首先判断当前合约是否有订单需要处理:
    #   如果有,则先处理订单,然后转到步骤【1】
    #   如果没有待处理订单,转到步骤【3】
    #【3】、检查是否有持仓需要处理
    #  如果有持仓,则处理持仓,处理完成后,转到步骤【1】
    #  如果没有持仓,则转到步骤【4】
    #【4】、判断开仓条件是否满足,进行开仓。
    #   无论是否开仓,完成后,都转到【1】
 # author : Jieyou
 from contextlib import closing
from tqsdk import TqApi
from tqsdk import TqAccount
from tqsdk import TqApi,TqSim,tafunc
import time
import TradeInterval
import threading
 # 此处填写自己的模拟账号或交易账号
tq_company = "simnow"
 # 此处填写自己的模拟账号和密码
 tq_account = 'xxxxxx'
tq_pwd = 'pwd'
  # 设定需要交易合约
 list_code = ["CZCE.TA001","SHFE.ni2002"]
 para1 = TradeInterval.CreatPara('CZCE.TA001')
ParaDic = {}
paraChFlag = {}
ParaDic.update({para1['code']:para1})
# para2 = CreatPara('SHFE.ni1912')
#para2['code'] = 'SHFE.ni1912'
#ParaDic.update({para2['code']:para2})
 # 生成参数组以及标记合约行情变化的信息
for code in list_code:
    ParaDic.update({code:TradeInterval.CreatPara(code)})
    paraChFlag.update({code:{'qtime':'','chflag':True}})
 print(ParaDic)
print(paraChFlag)
 #exit(0)
 #para1 = ParaDic['SHFE.ni1912']
 #para1['posvol'] = 1
#para1['posPrice'] = 135000
 #print(ParaDic)
 #此种情况不会改变已经存入字典中的值
para1 = TradeInterval.CreatPara('CZCE.MA001')
print(para1)
print(ParaDic)
#时间戳转换为 HH:MM:SS 格式
print(type(time.strftime("%H:%M:%S", time.localtime())))
 #exit(0)
  def TradeFunc(para,qtick,aliveorder):
    # 先判断时间
    pass
  try:
    # 如果登陆失败则抛出异常
    tq_acc_info = TqAccount(tq_company,tq_account,tq_pwd)
    tq_api = TqApi(tq_acc_info)
    #tq_api = TqApi(TqSim())
    print("登陆成功")
     # 获取资金信息,没有用到
    fundInfo = tq_api.get_account()
     # 获取订单信息
    orderInfo = tq_api.get_order()
     # 获取持仓信息,没有用到
    posInfo = tq_api.get_position()
     # 定义合约
    # symbol = 'CZCE.TA001'
    # kline_length = 20
     # 定义 tick 字典
    qtickDic = {}
    for code in list_code:
        qtickDic.update({code:tq_api.get_quote(code)})
     # 定义 k 线字典
    kLineDic = {}
    for code in list_code:
        kLineDic.update({code:tq_api.get_kline_serial(code,60,data_length=20)})
     """
    # 此部分用于测试,建立的tick 字典以及 kline 字典是否正常工作
    while True:
        tq_api.wait_update()
        for sym in qtickDic.keys():
            if tq_api.is_changing(kLineDic[sym]):
                print(sym,"up date")
    """
     # 此部分代码大部分为测试某些代码的结果
    # 在单合约需要,多合约的情况就不再需要
    """
    qtick = tq_api.get_quote(symbol)
    print(qtick.datetime)
    secs = tafunc.time_to_s_timestamp(qtick.datetime)
    print(tafunc.time_to_s_timestamp(qtick.datetime))
    print(time.strftime("%H:%M:%S",time.localtime(secs)))
    qm60kline = tq_api.get_kline_serial(symbol,60,data_length=20)
    ser_ma = list(tafunc.ma(qm60kline.close,5))
    print(ser_ma)
    tims_hms = time.strftime("%H:%M:%S", time.localtime(tafunc.time_to_s_timestamp(qtick.datetime)))
    print(tims_hms)
    interval, secsToEnd = TradeInterval.secs_to_trade_end(symbol, tims_hms)
    print(interval,secsToEnd)
    is_close = 0
    """
     while True:
        # print('主循环启动')
        tq_api.wait_update()
        #tq_api.is_changing(qtick)
        #print('最新 :',qtick.last_price)
        #print('买一:',qtick.bid_price1)
        #print('卖一:',qtick.ask_price1)
        # 多合约运行的话,需要循环检测哪个合约的行情产生了变化,进行处理
         for symbol in list_code:
            if tq_api.is_changing(kLineDic[symbol]):
                # 计算均线信息
                # 测试证明 k线也是实时更新的
                 # 计算距离开盘以及收盘的时间
                tims_hms = time.strftime("%H:%M:%S", time.localtime(tafunc.time_to_s_timestamp(qtickDic[symbol].datetime)))
                 #  根据行情的时间戳计算交易所时间
                # 计算当前时间距离开盘的时间
                interval, secs2Open = TradeInterval.secs_to_open(symbol, tims_hms)
                if interval == 0:
                    # 非交易时间,不再继续
                    continue
                # 计算当前时间距离收盘的时间
                interval,secsToEnd = TradeInterval.secs_to_trade_end(symbol,tims_hms)
                if interval == 0:
                    # 非交易时间,不再继续
                    continue
                 tempPara = ParaDic[symbol]
                 ser_ma = list(tafunc.ma(kLineDic[symbol].close,8))
                secs = kLineDic[symbol].iloc[-1]['datetime']/1000000000
                #print(ser_ma[-1])
                #print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
                #print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(secs)))
                #print("k 线更新")
                 # 如果有委托单,则处理委托单
                if tempPara['orderId'] != '':
                    #说明有订单需要处理,检测订单状态
                    tempOrder = orderInfo[tempPara['orderId']]
                    if tempOrder.status == 'FINISHED' and tempOrder.volume_orign - tempOrder.volume_left > 0:
                        # 订单成交
                        print('报单数量', tempOrder.volume_orign)
                        print('未成交数量', tempOrder.volume_left)
                         if tempOrder.offset == 'OPEN':
                            tempPara['posvol'] += tempOrder.volume_orign - tempOrder.volume_left
                            tempPara['orderId'] = ''
                            if tempOrder.direction == 'BUY':
                                tempPara['posside'] = 'BUY'
                            elif tempOrder.direction == 'SELL':
                                tempPara['posside'] = 'SELL'
                        elif tempOrder.offset == 'CLOSE' or tempOrder.offset == 'CLOSETODAY':
                            tempPara['posvol'] -= tempOrder.volume_orign - tempOrder.volume_left
                            tempPara['orderId'] = ''
                            print('平仓,策略持仓量', tempPara['posvol'])
                    elif tempOrder.status == 'ALIVE':
                        #此处处理订单排队或部分成交的情况
                        #如果行情变动已经偏离报盘价格,则需要进行撤单
                        if tempOrder.direction == 'BUY':
                            if qtickDic[symbol].bid_price1 > tempOrder.limit_price + 0.0001:
                                #撤单
                                tq_api.cancel_order(tempOrder)
                        elif tempOrder.direction == 'SELL':
                            if qtickDic[symbol].ask_price1 < tempOrder.limit_price - 0.0001:
                                #撤单
                                tq_api.cancel_order(tempOrder)
                    elif tempOrder.status == 'FINISHED' and tempOrder.volume_orign - tempOrder.volume_left == 0:
                        #此种情况应该是错单或者撤销的情况
                        print(tempOrder)
                        tempPara['orderId'] = ''
                        print('订单撤单或订单错误')
                     continue
                 # 如果合约有持仓,则处理持仓
                if tempPara['posvol'] > 0:
                    #持仓数据大于 0 检测是否达到平仓线
                    if ser_ma[-1] < ser_ma[-2] and ser_ma[-2] < ser_ma[-3]:
                        price = qtickDic[symbol].bid_price1
                        order = tq_api.insert_order(symbol, 'SELL', 'CLOSETODAY', 1, price)
                        tempPara['orderId'] = order.order_id
                        print('平仓条件满足,进行平仓')
                        print('平仓 orderid', tempPara['orderId'])
                    elif (interval == 1 or interval == 5) and secsToEnd < 30:
                        # 距离夜盘或当天收盘小于 30 秒,则平仓
                        print('临近收盘,平仓')
                        price = qtickDic[symbol].bid_price1
                        order = tq_api.insert_order(symbol, 'SELL', 'CLOSETODAY', 1, price)
                        tempPara['orderId'] = order.order_id
                    continue
                else:
                    pass
                    # print('没有持仓')
                #在没有持仓以及没有委托单的情况下
                #判断行情进行委托
                if interval == 0:
                    # 非交易时间,或者距离开盘小于60 秒 或者距离收盘小于 30 秒,不进行交易
                    print('非交易时间')
                    continue
                elif secs2Open < 60 and (interval == 1 or interval == 5):
                    print('开盘不到 60 秒')
                    continue
                elif secsToEnd < 30 and (interval == 1 or interval == 5):
                    print('临近收盘,不开仓')
                    continue
                 if ser_ma[-1] > ser_ma[-2] > ser_ma[-3]:
                    print("满足条件,执行开仓")
                    price = qtickDic[symbol].ask_price1
                    order = tq_api.insert_order(symbol,'BUY','OPEN',1,price)
                    tempPara['orderId'] = order.order_id
                    print('开仓 orderid', tempPara['orderId'])
                else:
                    #print("不满足开仓条件")
                    pass
             #退出 tqsdk
            #if is_close > 300:
            #    tq_api.close()
 except Exception as e:
    print("登陆失败")
    print(e)
 if __name__ == '__main__':
    print('test')

Edited question
0

赞赞赞~~!

Answered question
0

谢谢贡献源码!

Answered question