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()
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')