Example #1
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()
Example #2
0
class SIGNALIZE:
    """实盘时根据从交易所获取的k线数据绘制k线图、成交量图及指标"""
    def __init__(self, platform, symbol, time_frame):

        self.__platform = platform
        self.__symbol = symbol
        self.__time_frame = time_frame
        self.__market = MARKET(self.__platform, self.__symbol,
                               self.__time_frame)

        # pull some data
        self.__indicators = INDICATORS(self.__platform, self.__symbol,
                                       self.__time_frame)
        self.__kline = platform.get_kline(self.__time_frame)
        self.__kline.reverse()

        # format it in pandas
        try:  # dataframe有7列的情况
            self.__df = pd.DataFrame(self.__kline,
                                     columns=[
                                         'time', 'open', 'high', 'low',
                                         'close', 'volume', 'currency_volume'
                                     ])
            self.__df = self.__df.astype({
                'time': 'datetime64[ns]',
                'open': 'float64',
                'close': 'float64',
                'high': 'float64',
                'low': 'float64',
                'volume': 'float64',
                'currency_volume': 'float64'
            })
        except:  # dataframe只有6列的情况,如okex的现货k线数据
            self.__df = pd.DataFrame(
                self.__kline,
                columns=['time', 'open', 'high', 'low', 'close', 'volume'])
            self.__df = self.__df.astype({
                'time': 'datetime64[ns]',
                'open': 'float64',
                'close': 'float64',
                'high': 'float64',
                'low': 'float64',
                'volume': 'float64'
            })

        # create three plot 创建三层图纸,第一层画k线,第二层画成交量,第三层画一些适宜于副图显示的指标
        fplt.foreground = '#FFFFFF'  # 前景色
        fplt.background = '#333333'  # 背景色
        fplt.odd_plot_background = '#333333'  # 第二层图纸的背景色
        fplt.cross_hair_color = "#FFFFFF"  # 准星的颜色
        self.__ax, self.__ax2, self.__ax3 = fplt.create_plot(symbol, rows=3)

        # plot candle sticks
        candles = self.__df[['time', 'open', 'close', 'high', 'low']]
        fplt.candlestick_ochl(candles, ax=self.__ax)

        # overlay volume on the plot
        volumes = self.__df[['time', 'open', 'close', 'volume']]
        fplt.volume_ocv(volumes, ax=self.__ax2)
        fplt.add_legend("VOLUME", self.__ax2)  # 增加"VOLUME"图例

    """
    plot indicators
    """

    def show(self):
        """最后必须调用此函数以显示图像"""
        fplt.show()

    def plot_last(self, color=None):
        """在图上画出最新成交价这根横线,便于观察"""
        last = self.__market.last()
        array = np.empty(len(self.__kline))
        array.fill(last)
        color = color if color is not None else "#CD7F32"  # 默认设置为红色
        fplt.plot(self.__df['time'],
                  array,
                  color=color,
                  ax=self.__ax,
                  legend="LAST {}".format(last))

    def plot_array(self, array, ax, legend, color=None):
        """
        绘制任意的数组成线性
        :param array: 传入一个数组
        :param ax: 加载在第几行的图上
        :param legend: 图例名称
        :param color: 颜色
        :return:
        """
        if ax == 1:
            ax = self.__ax
        elif ax == 2:
            ax = self.__ax2
        elif ax == 3:
            ax = self.__ax3
        color = color if color is not None else "#FF0000"  # 默认设置为红色
        fplt.plot(self.__df['time'], array, color=color, ax=ax, legend=legend)

    def plot_atr(self, length, color=None):
        """
        在图上画出ATR
        :param length: ATR指标参数
        :param color: 线的颜色
        :return:
        """
        color = color if color is not None else "#FF0000"  # 默认设置为红色
        fplt.plot(self.__df['time'],
                  self.__indicators.ATR(length),
                  color=color,
                  ax=self.__ax3,
                  legend='ATR({})'.format(length))

    def plot_boll(self, length, color1=None, color2=None, color3=None):
        """
        在图上画出布林通道的上轨、中轨、下轨
        :param length: BOLL指标参数
        :param upperband_color: 上轨颜色
        :param middleband_color: 中轨颜色
        :param lowerband_color: 下轨颜色
        :return:
        """
        color1 = color1 if color1 is not None else "#FF0000"  # 默认设置为红色
        color2 = color2 if color2 is not None else "#00FF00"  # 默认设置为绿色
        color3 = color3 if color3 is not None else "#0000FF"  # 默认设置为蓝色
        upperband_array = self.__indicators.BOLL(length)['upperband']
        middleband_array = self.__indicators.BOLL(length)["middleband"]
        lowerband_array = self.__indicators.BOLL(length)["lowerband"]
        fplt.plot(self.__df['time'],
                  upperband_array,
                  color=color1,
                  ax=self.__ax,
                  legend='BOLL({})-UPPERBAND'.format(length))
        fplt.plot(self.__df['time'],
                  middleband_array,
                  color=color2,
                  ax=self.__ax,
                  legend='BOLL({})-MIDDLEBAND'.format(length))
        fplt.plot(self.__df['time'],
                  lowerband_array,
                  color=color3,
                  ax=self.__ax,
                  legend='BOLL({})-LOWERBAND'.format(length))
        # 副图上也加载
        fplt.plot(self.__df['time'],
                  upperband_array,
                  color=color1,
                  ax=self.__ax3,
                  legend='BOLL({})-UPPERBAND'.format(length))
        fplt.plot(self.__df['time'],
                  middleband_array,
                  color=color2,
                  ax=self.__ax3,
                  legend='BOLL({})-MIDDLEBAND'.format(length))
        fplt.plot(self.__df['time'],
                  lowerband_array,
                  color=color3,
                  ax=self.__ax3,
                  legend='BOLL({})-LOWERBAND'.format(length))

    def plot_highest(self, length, color=None):
        """
        在图上画出最高价
        :param length: HIGHEST指标参数
        :param color: 线的颜色
        :return:
        """
        color = color if color is not None else "#FF0000"  # 默认设置红黑色
        fplt.plot(self.__df['time'],
                  self.__indicators.HIGHEST(length),
                  color=color,
                  ax=self.__ax,
                  legend='HIGHEST({})'.format(length))
        # 副图也加载
        fplt.plot(self.__df['time'],
                  self.__indicators.HIGHEST(length),
                  color=color,
                  ax=self.__ax3,
                  legend='HIGHEST({})'.format(length))

    def plot_ma(self, length, color=None):
        """
        在图上画出移动平均线
        :param length: 简单移动平均线参数
        :param color: 线的颜色
        :return:
        """
        color = color if color is not None else "#FF0000"  # 默认设置为红色
        # 主图与副图加载指标
        fplt.plot(self.__df['time'],
                  self.__indicators.MA(length),
                  color=color,
                  ax=self.__ax,
                  legend='MA({})'.format(length))
        fplt.plot(self.__df['time'],
                  self.__indicators.MA(length),
                  color=color,
                  ax=self.__ax3,
                  legend='MA({})'.format(length))

    def plot_macd(self,
                  fastperiod,
                  slowperiod,
                  signalperiod,
                  color1=None,
                  color2=None,
                  color3=None):
        """
        在图上画出MACD指标
        :param fastperiod:
        :param slowperiod:
        :param signalperiod:
        :param color1:
        :param color2:
        :param color3:
        :return:
        """
        color1 = color1 if color1 is not None else "#FF0000"  # 默认设置为红色
        color2 = color2 if color2 is not None else "#00FF00"  # 默认设置为绿色
        color3 = color3 if color3 is not None else "#0000FF"  # 默认设置为蓝色
        dif = self.__indicators.MACD(fastperiod, slowperiod,
                                     signalperiod)['DIF']
        dea = self.__indicators.MACD(fastperiod, slowperiod,
                                     signalperiod)["DEA"]
        macd = self.__indicators.MACD(fastperiod, slowperiod,
                                      signalperiod)["MACD"]
        fplt.plot(self.__df['time'],
                  dif,
                  color=color1,
                  ax=self.__ax3,
                  legend='MACD({}, {}, {})-DIF'.format(fastperiod, slowperiod,
                                                       signalperiod))
        fplt.plot(self.__df['time'],
                  dea,
                  color=color2,
                  ax=self.__ax3,
                  legend='MACD({}, {}, {})-DEA'.format(fastperiod, slowperiod,
                                                       signalperiod))
        fplt.plot(self.__df['time'],
                  macd,
                  color=color3,
                  ax=self.__ax3,
                  legend='MACD({}, {}, {})-MACD'.format(
                      fastperiod, slowperiod, signalperiod))

    def plot_ema(self, length, color=None):
        """
        在图上画出EMA指标
        :param length:
        :param color:
        :return:
        """
        color = color if color is not None else "#FF0000"  # 默认设置为红色
        fplt.plot(self.__df['time'],
                  self.__indicators.EMA(length),
                  color=color,
                  ax=self.__ax,
                  legend='EMA({})'.format(length))
        # 副图也加载
        fplt.plot(self.__df['time'],
                  self.__indicators.EMA(length),
                  color=color,
                  ax=self.__ax3,
                  legend='EMA({})'.format(length))

    def plot_kama(self, length, color=None):
        """在图上画出KAMA指标"""
        color = color if color is not None else "#FF0000"  # 默认设置为红色
        fplt.plot(self.__df['time'],
                  self.__indicators.KAMA(length),
                  color=color,
                  ax=self.__ax,
                  legend='KAMA({})'.format(length))
        # 副图也加载
        fplt.plot(self.__df['time'],
                  self.__indicators.KAMA(length),
                  color=color,
                  ax=self.__ax3,
                  legend='KAMA({})'.format(length))

    def plot_kdj(self,
                 fastk_period,
                 slowk_period,
                 slowd_period,
                 color1=None,
                 color2=None):
        """
        在图上画出KDJ指标
        :param fastk_period:
        :param slowk_period:
        :param slowd_period:
        :param color1:
        :param color2:
        :param color3:
        :return:
        """
        color1 = color1 if color1 is not None else "#FF0000"  # 默认设置为红色
        color2 = color2 if color2 is not None else "#00FF00"  # 默认设置为绿色
        k = self.__indicators.KDJ(fastk_period, slowk_period,
                                  slowd_period)['k']
        d = self.__indicators.KDJ(fastk_period, slowk_period,
                                  slowd_period)["d"]
        # 仅副图加载
        fplt.plot(self.__df['time'],
                  k,
                  color=color1,
                  ax=self.__ax3,
                  legend='KDJ({}, {}, {})-K'.format(fastk_period, slowk_period,
                                                    slowd_period))
        fplt.plot(self.__df['time'],
                  d,
                  color=color2,
                  ax=self.__ax3,
                  legend='KDJ({}, {}, {})-D'.format(fastk_period, slowk_period,
                                                    slowd_period))

    def plot_lowest(self, length, color=None):
        """LOWEST"""
        color = color if color is not None else "#FF0000"  # 默认设置红黑色
        fplt.plot(self.__df['time'],
                  self.__indicators.LOWEST(length),
                  color=color,
                  ax=self.__ax,
                  legend='LOWEST({})'.format(length))
        # 副图也加载
        fplt.plot(self.__df['time'],
                  self.__indicators.LOWEST(length),
                  color=color,
                  ax=self.__ax3,
                  legend='LOWEST({})'.format(length))

    def plot_obv(self, color=None):
        """OBV"""
        color = color if color is not None else "#FF0000"  # 默认设置红黑色
        # 仅副图加载
        fplt.plot(self.__df['time'],
                  self.__indicators.OBV(),
                  color=color,
                  ax=self.__ax3,
                  legend='OBV')

    def plot_rsi(self, length, color=None):
        """RSI"""
        color = color if color is not None else "#FF0000"  # 默认设置为红色
        # 仅副图加载
        fplt.plot(self.__df['time'],
                  self.__indicators.RSI(length),
                  color=color,
                  ax=self.__ax3,
                  legend='RSI({})'.format(length))

    def plot_roc(self, length, color=None):
        """ROC"""
        color = color if color is not None else "#FF0000"  # 默认设置为红色
        # 仅副图加载
        fplt.plot(self.__df['time'],
                  self.__indicators.ROC(length),
                  color=color,
                  ax=self.__ax3,
                  legend='ROC({})'.format(length))

    def plot_stochrsi(self,
                      timeperiod,
                      fastk_period,
                      fastd_period,
                      color1=None,
                      color2=None):
        """STOCHRSI"""
        color1 = color1 if color1 is not None else "#FF0000"  # 默认设置为红色
        color2 = color2 if color2 is not None else "#00FF00"  # 默认设置为绿色
        stochrsi = self.__indicators.STOCHRSI(timeperiod, fastk_period,
                                              fastd_period)['stochrsi']
        fastk = self.__indicators.STOCHRSI(timeperiod, fastk_period,
                                           fastd_period)["fastk"]
        # 仅副图加载
        fplt.plot(self.__df['time'],
                  stochrsi,
                  color=color1,
                  ax=self.__ax3,
                  legend='STOCHRSI({}, {}, {})-STOCHRSI'.format(
                      timeperiod, fastk_period, fastd_period))
        fplt.plot(self.__df['time'],
                  fastk,
                  color=color2,
                  ax=self.__ax3,
                  legend='STOCHRSI({}, {}, {})-FASTK'.format(
                      timeperiod, fastk_period, fastd_period))

    def plot_sar(self, color=None):
        """
        在图上画出SAR
        :param length: SAR指标参数
        :param color: 线的颜色
        :return:
        """
        color = color if color is not None else "#FF0000"  # 默认设置为红色
        # 主副图均加载
        fplt.plot(self.__df['time'],
                  self.__indicators.SAR(),
                  color=color,
                  ax=self.__ax,
                  legend='SAR')
        fplt.plot(self.__df['time'],
                  self.__indicators.SAR(),
                  color=color,
                  ax=self.__ax3,
                  legend='SAR')

    def plot_stddev(self, length, color=None):
        """STDDEV"""
        color = color if color is not None else "#FF0000"  # 默认设置为红色
        # 仅副图加载
        fplt.plot(self.__df['time'],
                  self.__indicators.STDDEV(length),
                  color=color,
                  ax=self.__ax3,
                  legend='STDDEV({})'.format(length))

    def plot_trix(self, length, color=None):
        """STDDEV"""
        color = color if color is not None else "#FF0000"  # 默认设置为红色
        # 仅副图加载
        fplt.plot(self.__df['time'],
                  self.__indicators.TRIX(length),
                  color=color,
                  ax=self.__ax3,
                  legend='TRIX({})'.format(length))

    def plot_volume(self, color=None):
        """VOLUME"""
        color = color if color is not None else "#FF0000"  # 默认设置为红色
        # 仅副图均加载
        fplt.plot(self.__df['time'],
                  self.__indicators.VOLUME(),
                  color=color,
                  ax=self.__ax3,
                  legend='VOLUME')