Пример #1
0
class Strategy:

    def __init__(self, instrument_id, time_frame, fast_length, slow_length, long_stop, short_stop, start_asset):
        try:
            print("{} {} 双均线多空策略已启动!".format(get_localtime(), instrument_id))   # 程序启动时打印提示信息
            config.loads('config.json')  # 载入配置文件
            self.instrument_id = instrument_id  # 合约ID
            self.time_frame = time_frame  # k线周期
            self.exchange = OKEXFUTURES(config.access_key, config.secret_key, config.passphrase, self.instrument_id)  # 初始化交易所
            self.position = POSITION(self.exchange, self.instrument_id, self.time_frame)  # 初始化potion
            self.market = MARKET(self.exchange, self.instrument_id, self.time_frame)  # 初始化market
            self.indicators = INDICATORS(self.exchange, self.instrument_id, self.time_frame)    # 初始化indicators
            # 在第一次运行程序时,将初始资金数据保存至数据库中
            self.database = "回测"    # 回测时必须为"回测"
            self.datasheet = self.instrument_id.split("-")[0].lower() + "_" + time_frame
            if config.first_run == "true":
                storage.mysql_save_strategy_run_info(self.database, self.datasheet, get_localtime(),
                                                "none", 0, 0, 0, 0, "none", 0, 0, 0, start_asset)
            # 读取数据库中保存的总资金数据
            self.total_asset = storage.read_mysql_datas(0, self.database, self.datasheet, "总资金", ">")[-1][-1]
            self.total_profit = storage.read_mysql_datas(0, self.database, self.datasheet, "总资金", ">")[-1][-2]  # 策略总盈亏
            self.counter = 0  # 计数器
            self.fast_length = fast_length  # 短周期均线长度
            self.slow_length = slow_length  # 长周期均线长度
            self.long_stop = long_stop   # 多单止损幅度
            self.short_stop = short_stop    # 空单止损幅度
            self.contract_value = self.market.contract_value()  # 合约面值,每次获取需发起网络请求,故于此处声明变量,优化性能
        except:
            logger.warning()

    def begin_trade(self, kline=None):
        try:
            if self.indicators.CurrentBar(kline=kline) < self.slow_length:  # 如果k线数据不够长就返回
                return
            timestamp = ts_to_datetime_str(utctime_str_to_ts(kline[-1][0])) if kline else get_localtime()    # 非回测模式下时间戳就是当前本地时间
            # 计算策略信号
            ma = self.indicators.MA(self.fast_length, self.slow_length, kline=kline)
            fast_ma = ma[0]
            slow_ma = ma[1]
            cross_over = fast_ma[-2] >= slow_ma[-2] and fast_ma[-3] < slow_ma[-3]   # 不用当根k线上的ma来计算信号,防止信号闪烁
            cross_below = slow_ma[-2] >= fast_ma[-2] and slow_ma[-3] < fast_ma[-3]
            if self.indicators.BarUpdate(kline=kline):     # 如果k线更新,计数器归零
                self.counter = 0
            if self.counter < 1:
                # 按照策略信号开平仓
                if cross_over:     # 金叉时
                    if self.position.amount() == 0:     # 若当前无持仓,则买入开多并推送下单结果
                        price = self.market.open(-1, kline=kline)  # 下单价格=此根k线收盘价
                        amount = round(self.total_asset / self.contract_value)   # 数量=总资金/价格/合约面值
                        info = self.exchange.buy(price, amount)
                        push(info)
                        storage.mysql_save_strategy_run_info(self.database, self.datasheet, timestamp, "买入开多",
                                                        price, amount, amount * self.contract_value, price,
                                                        "long", amount, 0, self.total_profit, self.total_asset)     # 将信息保存至数据库
                    if self.position.direction() == 'short':    # 若当前持空头,先平空再开多
                        profit = self.position.covershort_profit(market_type="usd_contract", last=self.market.open(-1, kline=kline))  # 在平空前先计算逻辑盈亏,当前最新成交价为开盘价
                        self.total_profit += profit
                        self.total_asset += profit  # 计算此次盈亏后的总资金
                        cover_short_price = self.market.open(-1, kline=kline)
                        cover_short_amount = self.position.amount()
                        open_long_price = self.market.open(-1, kline=kline)
                        open_long_amount = round(self.total_asset / self.contract_value)
                        info = self.exchange.BUY(cover_short_price, cover_short_amount, open_long_price, open_long_amount)
                        push("此次盈亏:{} 当前总资金:{}".format(profit, self.total_asset) + str(info))   # 需将返回的下单结果info转换为字符串后进行拼接
                        storage.mysql_save_strategy_run_info(self.database, self.datasheet, timestamp, "平空开多",
                                                        open_long_price, open_long_amount, open_long_amount * self.contract_value,
                                                        open_long_price, "long", open_long_amount, profit, self.total_profit, self.total_asset)
                if cross_below:     # 死叉时
                    if self.position.amount() == 0:
                        price = self.market.open(-1, kline=kline)
                        amount = round(self.total_asset / self.contract_value)
                        info = self.exchange.sellshort(price, amount)
                        push(info)
                        storage.mysql_save_strategy_run_info(self.database, self.datasheet, timestamp, "卖出开空",
                                                    price, amount, amount * self.contract_value, price,
                                                    "short", amount, 0, self.total_profit, self.total_asset)
                    if self.position.direction() == 'long':
                        profit = self.position.coverlong_profit(market_type="usd_contract", last=self.market.open(-1, kline=kline))     # 在平多前先计算逻辑盈亏,当前最新成交价为开盘价
                        self.total_profit += profit
                        self.total_asset += profit
                        cover_long_price = self.market.open(-1, kline=kline)
                        cover_long_amount = self.position.amount()
                        open_short_price = self.market.open(-1, kline=kline)
                        open_short_amount = round(self.total_asset / self.contract_value)
                        info = self.exchange.SELL(cover_long_price,
                                                  cover_long_amount,
                                                  open_short_price,
                                                  open_short_amount)
                        push("此次盈亏:{} 当前总资金:{}".format(profit, self.total_asset) + str(info))
                        storage.mysql_save_strategy_run_info(self.database, self.datasheet, timestamp, "平多开空",
                                                        open_short_price, open_short_amount,
                                                        open_short_amount * self.contract_value,
                                                        open_short_price, "short", open_short_amount, profit, self.total_profit,
                                                        self.total_asset)
                # 止损
                if self.position.amount() > 0:
                    if self.position.direction() == 'long' and self.market.low(-1, kline=kline) <= self.position.price() * self.long_stop:    # 多单止损
                        profit = self.position.coverlong_profit(market_type="usd_contract", last=self.position.price() * self.long_stop)    # 在平多前先计算逻辑盈亏,当前最新成交价为止损价
                        self.total_profit += profit
                        self.total_asset += profit
                        price = self.position.price() * self.long_stop
                        amount = self.position.amount()
                        info = self.exchange.sell(price, amount)
                        push("此次盈亏:{} 当前总资金:{}".format(profit, self.total_asset) + str(info))
                        storage.mysql_save_strategy_run_info(self.database, self.datasheet, timestamp,
                                                        "卖出止损", price, amount,
                                                        amount * self.contract_value,
                                                        0, "none", 0, profit, self.total_profit,
                                                        self.total_asset)
                        self.counter += 1   # 计数器加1,控制此根k线上不再下单

                    if self.position.direction() == 'short' and self.market.high(-1, kline=kline) >= self.position.price() * self.short_stop:  # 空头止损
                        profit = self.position.covershort_profit(market_type="usd_contract", last=self.position.price() * self.short_stop)
                        self.total_profit += profit
                        self.total_asset += profit
                        price = self.position.price() * self.short_stop
                        amount = self.position.amount()
                        info = self.exchange.buytocover(price, amount)
                        push("此次盈亏:{} 当前总资金:{}".format(profit, self.total_asset) + str(info))
                        storage.mysql_save_strategy_run_info(self.database, self.datasheet, timestamp,
                                                        "买入止损", price, amount,
                                                        amount * self.contract_value,
                                                        0, "none", 0, profit, self.total_profit,
                                                        self.total_asset)
                        self.counter += 1
        except:
            logger.info()
Пример #2
0
class Strategy:
    def __init__(self, instrument_id, time_frame, fast_length, slow_length,
                 long_stop, short_stop, start_asset, precision):
        config.loads('config.json')  # 载入配置文件
        self.instrument_id = instrument_id  # 合约ID
        self.time_frame = time_frame  # k线周期
        self.precision = precision  # 精度,即币对的最小交易数量
        self.exchange = OKEXSPOT(config.access_key, config.secret_key,
                                 config.passphrase,
                                 self.instrument_id)  # 初始化交易所
        self.position = POSITION(self.exchange, self.instrument_id,
                                 self.time_frame)  # 初始化potion
        self.market = MARKET(self.exchange, self.instrument_id,
                             self.time_frame)  # 初始化market
        self.indicators = INDICATORS(self.exchange, self.instrument_id,
                                     self.time_frame)  # 初始化indicators
        # 在第一次运行程序时,将初始资金数据保存至数据库中
        self.database = "回测"  # 回测时必须为"回测"
        self.datasheet = self.instrument_id.split(
            "-")[0].lower() + "_" + time_frame
        if config.first_run:
            storage.mysql_save_strategy_run_info(self.database, self.datasheet,
                                                 get_localtime(), "none", 0, 0,
                                                 0, 0, "none", 0, 0, 0,
                                                 start_asset)
        # 读取数据库中保存的总资金数据
        self.total_asset = storage.read_mysql_datas(0, self.database,
                                                    self.datasheet, "总资金",
                                                    ">")[-1][-1]
        self.total_profit = storage.read_mysql_datas(0, self.database,
                                                     self.datasheet, "总资金",
                                                     ">")[-1][-2]  # 策略总盈亏
        self.counter = 0  # 计数器
        self.fast_length = fast_length  # 短周期均线长度
        self.slow_length = slow_length  # 长周期均线长度
        self.long_stop = long_stop  # 多单止损幅度
        self.short_stop = short_stop  # 空单止损幅度
        self.hold_price = 0  # 注意:okex的现货没有获取持仓均价的接口,故需实盘时需要手动记录入场价格。此种写法对于不同的交易所是通用的。
        # 此种写法,若策略重启,持仓价格会回归0
        print("{} {} 双均线多空策略已启动!".format(get_localtime(),
                                         instrument_id))  # 程序启动时打印提示信息

    def begin_trade(self, kline=None):
        try:
            if self.indicators.CurrentBar(
                    kline=kline) < self.slow_length:  # 如果k线数据不够长就返回
                return
            timestamp = ts_to_datetime_str(utctime_str_to_ts(
                kline[-1]
                [0])) if kline else get_localtime()  # 非回测模式下时间戳就是当前本地时间
            # 计算策略信号
            ma = self.indicators.MA(self.fast_length,
                                    self.slow_length,
                                    kline=kline)
            fast_ma = ma[0]
            slow_ma = ma[1]
            cross_over = fast_ma[-2] >= slow_ma[-2] and fast_ma[-3] < slow_ma[
                -3]  # 不用当根k线上的ma来计算信号,防止信号闪烁
            cross_below = slow_ma[-2] >= fast_ma[-2] and slow_ma[-3] < fast_ma[
                -3]
            if self.indicators.BarUpdate(kline=kline):  # 如果k线更新,计数器归零
                self.counter = 0
            if self.counter < 1:
                # 按照策略信号开平仓
                if cross_over and round(
                        self.position.amount()
                ) < self.precision:  # 金叉时,若当前无持仓,则买入开多并推送下单结果。0.1这个数值根据每个币对的最小交易数量决定
                    price = float(self.market.open(
                        -1, kline=kline))  # 下单价格=此根k线开盘价
                    self.hold_price = price  # 记录开仓价格
                    amount = float(self.total_asset / price)  # 数量=总资金/价格
                    info = self.exchange.buy(price, amount)
                    push(info)
                    storage.mysql_save_strategy_run_info(
                        self.database, self.datasheet, timestamp, "买入开多",
                        price, amount, amount * price, price, "long", amount,
                        0, self.total_profit, self.total_asset)  # 将信息保存至数据库
                if cross_below and round(
                        self.position.amount(), 1
                ) >= self.precision:  # 死叉时,如果当前持多就卖出平多。当前持仓数量根据币对的最小交易数量取小数
                    price = float(self.market.open(-1, kline=kline))
                    amount = float(self.position.amount())
                    profit = (price - self.hold_price) * amount  # 计算逻辑盈亏
                    self.total_profit += profit
                    self.total_asset += profit
                    info = self.exchange.sell(price, amount)
                    push(info)
                    self.hold_price = 0  # 平多后记录持仓价格为0
                    storage.mysql_save_strategy_run_info(
                        self.database, self.datasheet, timestamp, "卖出平多",
                        price, amount, amount * price, 0, "none", 0, profit,
                        self.total_profit, self.total_asset)
                # 如果当前持多且最低价小于等于持仓均价*止损幅度,触发止损,卖出平多止损
                if round(self.position.amount(),
                         1) >= self.precision and self.market.low(
                             -1,
                             kline=kline) <= self.hold_price * self.long_stop:
                    price = float(self.hold_price * self.long_stop)
                    amount = float(self.position.amount())
                    profit = (price - self.hold_price) * amount  # 计算逻辑盈亏
                    self.total_profit += profit
                    self.total_asset += profit
                    info = self.exchange.sell(price, amount)
                    push("此次盈亏:{} 当前总资金:{}".format(profit, self.total_asset) +
                         str(info))
                    self.hold_price = 0  # 平多后记录持仓价格为0
                    storage.mysql_save_strategy_run_info(
                        self.database, self.datasheet, timestamp, "卖出止损",
                        price, amount, amount * price, 0, "none", 0, profit,
                        self.total_profit, self.total_asset)
                    self.counter += 1  # 计数器加1,控制此根k线上不再下单
        except Exception as e:
            logger.info()
class Strategy:
    """布林强盗策略"""
    def __init__(self, instrument_id, time_frame, bollinger_lengths,
                 filter_length, start_asset):
        try:
            # 策略启动时控制台输出提示信息
            print("{} {} 布林强盗突破策略已启动!".format(get_localtime(),
                                              instrument_id))  # 程序启动时打印提示信息
            config.loads("config.json")  # 载入配置文件
            # 初始化
            self.instrument_id = instrument_id  # 合约ID
            self.time_frame = time_frame  # k线周期
            self.exchange = OKEXFUTURES(config.access_key, config.secret_key,
                                        config.passphrase,
                                        self.instrument_id)  # 交易所
            self.market = MARKET(self.exchange, self.instrument_id,
                                 self.time_frame)  # 行情
            self.position = POSITION(self.exchange, self.instrument_id,
                                     self.time_frame)  # 持仓
            self.indicators = INDICATORS(self.exchange, self.instrument_id,
                                         self.time_frame)  # 指标
            # 在第一次运行程序时,将初始资金、总盈亏等数据保存至数据库中
            self.database = "回测"  # 数据库,回测时必须为"回测"
            self.datasheet = self.instrument_id.split(
                "-")[0].lower() + "_" + time_frame  # 数据表
            if config.first_run == "true":
                storage.mysql_save_strategy_run_info(self.database,
                                                     self.datasheet,
                                                     get_localtime(), "none",
                                                     0, 0, 0, 0, "none", 0, 0,
                                                     0, start_asset)
            # 读取数据库中保存的总资金数据
            self.total_asset = storage.read_mysql_datas(
                0, self.database, self.datasheet, "总资金", ">")[-1][-1]
            self.total_profit = storage.read_mysql_datas(
                0, self.database, self.datasheet, "总资金", ">")[-1][-2]  # 策略总盈亏
            # 策略参数
            self.contract_value = self.market.contract_value()  # 合约面值
            self.counter = 0  # 计数器
            self.bollinger_lengths = bollinger_lengths  # 布林通道参数
            self.filter_length = filter_length  # 过滤器参数
            self.out_day = 50  # 自适应出场ma的初始值为50,开仓后赋值为布林通道参数的值
        except:
            logger.warning()

    def begin_trade(self, kline=None):
        try:  # 异常处理
            if self.indicators.CurrentBar(
                    kline=kline) < self.bollinger_lengths:  # 如果k线数据不够长就返回
                return

            timestamp = ts_to_datetime_str(utctime_str_to_ts(
                kline[-1]
                [0])) if kline else get_localtime()  # 非回测模式下时间戳就是当前本地时间

            if self.indicators.BarUpdate(kline=kline):
                self.counter = 0  # k线更新时还原计数器
                if self.out_day > 10:  # 计算MA的天数最小递减到10。如果达到10,则不再递减。
                    self.out_day -= 1  # 自适应出场ma的长度参数根据持仓周期递减,持有头寸的时间每多一天,计算MA的天数减1

            deviation = float(
                self.indicators.STDDEV(self.bollinger_lengths,
                                       nbdev=2,
                                       kline=kline)[-1])  # 标准差
            middleband = float(
                self.indicators.BOLL(self.bollinger_lengths,
                                     kline=kline)['middleband'][-1])  # 布林通道中轨
            upperband = float(middleband + deviation)  # 布林通道上轨
            lowerband = float(middleband - deviation)  # 布林通道下轨
            filter = float(
                self.market.close(-1, kline=kline) - self.market.close(
                    (self.filter_length * -1) - 1,
                    kline=kline))  # 过滤器:当日收盘价减去30日前的收盘价
            ma = float(self.indicators.MA(self.out_day,
                                          kline=kline)[-1])  # 自适应移动出场平均线

            # 策略主体
            # 若k线数据足够长,且满足过滤条件,且当根k线最高价大于等于布林通道上轨,买入开多。
            # 开仓处也设置计数器过滤,是为了防止没有启用交易助手的情况下挂单未成交,仓位为零时当根k线一直满足开仓条件,会重复挂单。
            if self.indicators.CurrentBar(
                    kline=kline
            ) >= self.bollinger_lengths and filter > 0 and self.market.high(
                    -1, kline=kline) > upperband and self.counter < 1:
                if self.position.amount() == 0:  # 若当前无持仓
                    price = upperband  # 开多价格为布林通道上轨的值
                    amount = round(self.total_asset / upperband /
                                   self.contract_value)  # 合约张数取整
                    info = self.exchange.buy(price,
                                             amount)  # 买入开多,并将返回的信息赋值给变量info
                    push(info)  # 推送信息
                    storage.mysql_save_strategy_run_info(
                        self.database, self.datasheet, timestamp, "买入开多",
                        price, amount, amount * price * self.contract_value,
                        price, "long", amount, 0, self.total_profit,
                        self.total_asset)  # 将信息保存至数据库
                    self.counter += 1  # 此策略是在盘中开仓,而在回测时,每根bar只会运行一次,每根bar上的价格不分时间先后,故此处开仓后计数器加1,也就是当根k线不平仓
                    # 因为实盘时每个ticker进来策略就会运行一次。注意回测和实盘策略运行机制的不同。
                    self.out_day = self.bollinger_lengths  # 开仓后赋值
            # 开空
            if self.indicators.CurrentBar(
                    kline=kline
            ) >= self.bollinger_lengths and filter < 0 and self.market.low(
                    -1, kline=kline) < lowerband and self.counter < 1:
                if self.position.amount() == 0:
                    price = lowerband
                    amount = round(self.total_asset / upperband /
                                   self.contract_value)
                    info = self.exchange.sellshort(price, amount)
                    push(info)
                    storage.mysql_save_strategy_run_info(
                        self.database, self.datasheet, timestamp, "卖出开空",
                        price, amount, amount * price * self.contract_value,
                        price, "short", amount, 0, self.total_profit,
                        self.total_asset)
                    self.counter += 1
                    self.out_day = self.bollinger_lengths  # 开仓后赋值
            # 如果当前持多,且当根k线最低价小于等于中轨值,触发保护性止损,就平多止损
            # 因为回测是一根k线上运行整个策略一次,所以要实现当根k线开仓后当根k线不平仓,需要将self.counter < 1的条件加在平仓的地方
            if self.position.direction() == "long" and self.market.low(
                    -1, kline=kline) < middleband and self.counter < 1:
                profit = self.position.coverlong_profit(
                    last=middleband)  # 此处计算平多利润时,传入最新价last为中轨值,也就是触发止损价格的那个值。
                self.total_profit += profit  # 计算经过本次盈亏后的总利润
                self.total_asset += profit  # 计算经过本次盈亏后的总资金
                price = middleband  # 平多价格为中轨值
                amount = self.position.amount()  # 平仓数量为当前持仓数量
                info = self.exchange.sell(price, amount)
                push(info)
                self.counter += 1
                storage.mysql_save_strategy_run_info(
                    self.database, self.datasheet, timestamp, "卖出止损", price,
                    amount, price * amount * self.contract_value, 0, "none", 0,
                    profit, self.total_profit, self.total_asset)
            if self.position.direction() == "short" and self.market.high(
                    -1, kline=kline) > middleband and self.counter < 1:
                profit = self.position.covershort_profit(last=middleband)
                self.total_profit += profit
                self.total_asset += profit
                price = middleband
                amount = self.position.amount()
                info = self.exchange.buytocover(price, amount)
                push(info)
                self.counter += 1
                storage.mysql_save_strategy_run_info(
                    self.database, self.datasheet, timestamp, "买入止损", price,
                    amount, amount * price * self.contract_value, 0, "none", 0,
                    profit, self.total_profit, self.total_asset)
            # 平多
            if self.position.direction(
            ) == "long" and upperband > ma > self.market.low(
                    -1, kline=kline) and self.counter < 1:
                profit = self.position.coverlong_profit(last=ma)
                self.total_profit += profit
                self.total_asset += profit
                price = ma  # 平仓价格为自适应出场均线的值
                amount = self.position.amount()
                info = self.exchange.sell(price, amount)
                push(info)
                self.counter += 1
                storage.mysql_save_strategy_run_info(
                    self.database, self.datasheet, timestamp, "卖出平多", price,
                    amount, price * amount * self.contract_value, 0, "none", 0,
                    profit, self.total_profit, self.total_asset)
            # 平空
            if self.position.direction(
            ) == "short" and lowerband < ma < self.market.high(
                    -1, kline=kline) and self.counter < 1:
                profit = self.position.covershort_profit(last=ma)
                self.total_profit += profit
                self.total_asset += profit
                price = ma
                amount = self.position.amount()
                info = self.exchange.buytocover(price, amount)
                push(info)
                self.counter += 1
                storage.mysql_save_strategy_run_info(
                    self.database, self.datasheet, timestamp, "买入平空", price,
                    amount, amount * price * self.contract_value, 0, "none", 0,
                    profit, self.total_profit, self.total_asset)
        except:
            logger.error()
Пример #4
0
class Strategy:

    def __init__(self, instrument_id, time_frame, start_asset):     # 策略初始化时需传入合约id、k线周期、初始资金参数
        print("{} {} 海龟交易策略已启动!".format(get_localtime(), instrument_id))    # 程序启动时打印提示信息
        config.loads("config.json")     # 载入配置文件
        self.instrument_id = instrument_id  # 合约id
        self.time_frame = time_frame    # k线周期
        self.exchange = OKEXFUTURES(config.access_key, config.secret_key, config.passphrase, self.instrument_id, leverage=20)   # 初始化交易所
        self.market = MARKET(self.exchange, self.instrument_id, self.time_frame)    # 初始化market
        self.position = POSITION(self.exchange, self.instrument_id, self.time_frame)    # 初始化position
        self.indicators = INDICATORS(self.exchange, self.instrument_id, self.time_frame)    # 初始化indicators
        self.database = "回测"  # 如从purequant服务器的数据库上获取历史k线数据进行回测,必须为"回测"
        self.datasheet = self.instrument_id.split("-")[0].lower() + "_" + time_frame    # 数据表
        if config.first_run == "true":  # 程序第一次启动时保存数据,实盘时如策略中止再重启时,可以将配置文件中的first_run改成"false",程序再次启动会直接读取数据库中保存的数据
            storage.mysql_save_strategy_run_info(self.database, self.datasheet, get_localtime(),
                                                 "none", 0, 0, 0, 0, "none", 0, 0, 0, start_asset)
        # 读取数据库中保存的总资金、总盈亏数据
        self.total_asset = storage.read_mysql_datas(0, self.database, self.datasheet, "总资金", ">")[-1][-1]
        self.total_profit = storage.read_mysql_datas(0, self.database, self.datasheet, "总资金", ">")[-1][-2]  # 策略总盈亏
        # 一些策略参数
        self.contract_value = self.market.contract_value()  # 合约面值
        self.ATRLength = 20    # 平均波动周期
        self.boLength = 20  # 短周期 BreakOut Length
        self.fsLength = 55  # 长周期 FailSafe Length
        self.teLength = 10   # 离市周期 Trailing Exit Length
        self.LastProfitableTradeFilter = 1   # 使用入市过滤条件
        self.PreBreakoutFailure = False  # 前一次是否突破失败
        self.CurrentEntries = 0  # 当前持仓的开仓次数
        self.counter = 0    # 计数器,用以控制单根bar最大交易次数

    def begin_trade(self, kline=None):  # 实盘时从交易所实时获取k线数据,回测时传入自定义的kline
        try:
            # 如果k线数据不够长就返回
            if self.indicators.CurrentBar(kline=kline) < self.fsLength:
                return
            # 非回测模式下时间戳就是当前本地时间
            timestamp = ts_to_datetime_str(utctime_str_to_ts(kline[-1][0])) if kline else get_localtime()
            # k线更新时计数器归零
            if self.indicators.BarUpdate(kline=kline):
                self.counter = 0
            AvgTR = self.indicators.ATR(self.ATRLength, kline=kline)     # 计算真实波幅
            N = float(AvgTR[-2])   # N值为前一根bar上的ATR值,需将numpy.float64数据类型转换为float类型,下面的转换同理
            Units = int(self.total_asset / self.contract_value / 5)    # 每一份头寸大小为总资金的20%
            """计算短周期唐奇安通道"""
            # 唐奇安通道上轨,延后1个Bar
            DonchianHi = float(self.indicators.HIGHEST(self.boLength, kline=kline)[-2])
            # 唐奇安通道下轨,延后1个Bar
            DonchianLo = float(self.indicators.LOWEST(self.boLength, kline=kline)[-2])
            """计算长周期唐奇安通道"""
            # 唐奇安通道上轨,延后1个Bar,长周期
            fsDonchianHi = float(self.indicators.HIGHEST(self.fsLength, kline=kline)[-2])
            # 唐奇安通道下轨,延后1个Bar,长周期
            fsDonchianLo = float(self.indicators.LOWEST(self.fsLength, kline=kline)[-2])
            """计算止盈唐奇安通道"""
            # 离市时判断需要的N周期最低价
            ExitLowestPrice = float(self.indicators.LOWEST(self.teLength, kline=kline)[-2])
            # 离市时判断需要的N周期最高价
            ExitHighestPrice = float(self.indicators.HIGHEST(self.teLength, kline=kline)[-2])
            # 当不使用过滤条件,或者使用过滤条件且条件PreBreakoutFailure为True时,短周期开仓
            if self.indicators.CurrentBar(kline=kline) >= self.boLength and self.position.amount() == 0 and (self.LastProfitableTradeFilter != 1 or self.PreBreakoutFailure == False) and self.counter < 1:
                if self.market.high(-1, kline=kline) >= DonchianHi:  # 突破了短周期唐奇安通道上轨
                    price = DonchianHi  # 开多价格为短周期唐奇安通道上轨
                    amount = Units  # 开多数量为Units
                    receipt = self.exchange.buy(price, amount)  # 开多
                    push(receipt)   # 推送下单结果
                    self.CurrentEntries += 1    # 记录一次开仓次数
                    self.PreBreakoutFailure = False  # 将标识重置为默认值,根据离场时的盈亏情况再修改
                    storage.mysql_save_strategy_run_info(self.database, self.datasheet, timestamp, "买入开多",
                                                         price, amount, amount * self.contract_value, price,
                                                         "long", amount, 0, self.total_profit,
                                                         self.total_asset)  # 将信息保存至数据库
                    self.counter += 1   # 计数器加1
                if self.market.low(-1, kline=kline) <= DonchianLo: # 突破了短周期唐奇安通道下轨
                    price = DonchianLo  # 开空价格为DonchianLo
                    amount = Units  # 开空数量为Units
                    receipt = self.exchange.sellshort(price, amount)    # 开空
                    push(receipt)   # 推送下单结果
                    self.CurrentEntries += 1    # 记录一次开仓次数
                    self.PreBreakoutFailure = False     # 将标识重置为默认值,根据离场时的盈亏情况再修改
                    storage.mysql_save_strategy_run_info(self.database, self.datasheet, timestamp, "卖出开空",
                                                         price, amount, amount * self.contract_value, price,
                                                         "short", amount, 0, self.total_profit, self.total_asset)   # 保存信息至数据库
                    self.counter += 1   # 计数器加1
            # 长周期突破开仓,其他逻辑和短周期突破开仓一样。
            if self.indicators.CurrentBar(kline=kline) >= self.fsLength and self.position.amount() == 0 and self.counter < 1:
                if self.market.high(-1, kline=kline) >= fsDonchianHi:   # 突破了长周期唐奇安通道上轨
                    price = fsDonchianHi    # 开多价格为长周期唐奇安通道上轨值
                    amount = Units  # 数量为Units
                    receipt = self.exchange.buy(price, amount)  # 下单并返回下单结果
                    push(receipt)   # 推送下单结果
                    self.CurrentEntries += 1    # 记录一次开仓次数
                    self.PreBreakoutFailure = False     # 将标识重置为默认值
                    storage.mysql_save_strategy_run_info(self.database, self.datasheet, timestamp, "买入开多",
                                                         price, amount, amount * self.contract_value, price,
                                                         "long", amount, 0, self.total_profit,
                                                         self.total_asset)  # 将信息保存至数据库
                    self.counter += 1   # 计数器加1
                if self.market.low(-1, kline=kline) <= fsDonchianLo:    # 突破长周期唐奇安通道下轨
                    price = fsDonchianLo    # 开空价格为长周期唐奇安通道下轨值
                    amount = Units  # 开空数量为Units
                    receipt = self.exchange.sellshort(price, amount)    # 下单并返回下单结果
                    push(receipt)  # 推送下单结果
                    self.CurrentEntries += 1  # 记录一次开仓次数
                    self.PreBreakoutFailure = False   # 将标识重置为默认值
                    storage.mysql_save_strategy_run_info(self.database, self.datasheet, timestamp, "卖出开空",
                                                         price, amount, amount * self.contract_value, price,
                                                         "short", amount, 0, self.total_profit, self.total_asset)
                    self.counter += 1   # 计数器加1
            # 止盈、加仓和止损
            if self.position.direction() == "long" and self.counter < 1:     # 持多仓的情况。回测时是一根k线上整个策略从上至下运行一次,所以在此处设置计数器过滤
                if self.market.low(-1, kline=kline) <= ExitLowestPrice:    # 跌破止盈价
                    profit = self.position.coverlong_profit(last=ExitLowestPrice, market_type="usd_contract")   # 平仓前计算利润,传入最新价以及计算盈利的合约类型
                    self.total_profit += profit  # 计算经过本次盈亏后的总利润
                    self.total_asset += profit  # 计算经过本次盈亏后的总资金
                    price = ExitLowestPrice     # 平多价格为ExitLowestPrice
                    amount = self.position.amount()     # 数量为当前持仓数量
                    receipt = self.exchange.sell(price, amount)    # 平所有多单仓位
                    push(receipt)   # 推送下单结果
                    storage.mysql_save_strategy_run_info(self.database, self.datasheet, timestamp, "卖出平多",
                                                         price, amount, amount * self.contract_value,
                                                         0, "none", 0, profit, self.total_profit, self.total_asset)
                    self.counter += 1   # 计数器加1
                    self.CurrentEntries = 0   # 平仓后将开仓次数还原为0
                else:
                    # 加仓指令
                    '''以最高价为标准,判断是否能加仓,并限制最大加仓次数
                       如果价格过前次开仓价格1/2N,则直接加仓
                    '''
                    while self.market.high(-1, kline=kline) >= (self.position.price() + 0.5 * N) and (self.CurrentEntries <= 4):
                        price = self.position.price() + 0.5 * N     # 加仓的开仓价格为持仓价格+0.5 * N
                        amount = Units  # 数量为Units
                        storage.mysql_save_strategy_run_info(self.database, self.datasheet, timestamp, "多头加仓",
                                                             price, amount, amount * self.contract_value,
                                                             (self.position.price() + price) / 2,
                                                             "long", self.position.amount() + amount,
                                                             0, self.total_profit, self.total_asset)
                        receipt = self.exchange.buy(price, amount)
                        push(receipt)
                        self.CurrentEntries += 1
                    # 止损指令
                    if self.market.low(-1, kline=kline) <= (self.position.price() - 2 * N):   # 如果回落大于最后下单价格-2n,就止损
                        profit = self.position.coverlong_profit(last=self.position.price() - 2 * N, market_type="usd_contract")
                        self.total_profit += profit  # 计算经过本次盈亏后的总利润
                        self.total_asset += profit  # 计算经过本次盈亏后的总资金
                        price = self.position.price() - 2 * N
                        amount = self.position.amount()
                        receipt = self.exchange.sell(price, amount)  # 全部止损平仓
                        push(receipt)
                        self.PreBreakoutFailure = True  # 记录为突破失败,下次交易将使用长周期开仓
                        storage.mysql_save_strategy_run_info(self.database, self.datasheet, timestamp, "卖出止损",
                                                             price, amount, amount * self.contract_value,
                                                             0, "none", 0, profit, self.total_profit, self.total_asset)
                        self.counter += 1
                        self.CurrentEntries = 0  # 平仓后将开仓次数还原为0
            elif self.position.direction() == "short" and self.counter < 1: # 持空头的情况,除方向以外,其他逻辑和上面持多仓的一致
                if self.market.high(-1, kline=kline) >= ExitHighestPrice:
                    profit = self.position.covershort_profit(last=ExitHighestPrice, market_type="usd_contract")
                    self.total_profit += profit
                    self.total_asset += profit
                    price = ExitHighestPrice
                    amount = self.position.amount()
                    receipt = self.exchange.buytocover(price, amount)
                    push(receipt)
                    storage.mysql_save_strategy_run_info(self.database, self.datasheet, timestamp,
                                                         "买入平空", price, amount, amount * self.contract_value,
                                                         0, "none", 0, profit, self.total_profit, self.total_asset)
                    self.counter += 1
                    self.CurrentEntries = 0  # 平仓后将开仓次数还原为0
                else:
                    while self.market.low(-1, kline=kline) <= (self.position.price() - 0.5 * N) and (self.CurrentEntries <= 4):
                        price = self.position.price() - 0.5 * N
                        amount = Units
                        storage.mysql_save_strategy_run_info(self.database, self.datasheet, timestamp, "空头加仓",
                                                             price, amount, amount * self.contract_value,
                                                             (self.position.price() + price) / 2,
                                                             "short", self.position.amount() + amount,
                                                             0, self.total_profit, self.total_asset)
                        receipt = self.exchange.sellshort(self.position.price() - 0.5 * N, Units)
                        push(receipt)
                        self.CurrentEntries += 1
                    if self.market.high(-1, kline=kline) >= (self.position.price() + 2 * N):
                        profit = self.position.covershort_profit(last=self.position.price() + 2 * N, market_type="usd_contract")
                        self.total_profit += profit
                        self.total_asset += profit
                        price = self.position.price() + 2 * N
                        amount = self.position.amount()
                        receipt = self.exchange.buytocover(price, amount)
                        push(receipt)
                        self.PreBreakoutFailure = True
                        storage.mysql_save_strategy_run_info(self.database, self.datasheet, timestamp,
                                                             "买入止损", price, amount, amount * self.contract_value,
                                                             0, "none", 0, profit, self.total_profit, self.total_asset)
                        self.counter += 1
                        self.CurrentEntries = 0  # 平仓后将开仓次数还原为0
        except:
            logger.error()