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 __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 kline_storage(self, database, data_sheet, platform, instrument_id,
time_frame):
"""
实时获取上一根k线存储至数据库中。
:param database: 数据库名称
:param data_sheet: 数据表名称
:param instrument_id: 交易对或合约id
:param time_frame: k线周期，如'1m', '1d'，字符串格式
:return:
"""
indicators = INDICATORS(platform, instrument_id, time_frame)
if indicators.BarUpdate():
last_kline = platform.get_kline(time_frame)[1]
if last_kline != self.__old_kline: # 若获取得k线不同于已保存的上一个k线
timestamp = last_kline[0]
open = last_kline[1]
high = last_kline[2]
low = last_kline[3]
close = last_kline[4]
volume = last_kline[5]
self.__six_save_kline_func(database, data_sheet, timestamp,
open, high, low, close, volume)
print("时间：{} 实时k线数据已保存至MySQL数据库中！".format(get_localtime()))
self.__old_kline = last_kline # 将刚保存的k线设为旧k线
else:
return
def __init__(self, instrument_id, time_frame, fast_length, slow_length, long_stop, short_stop, start_asset):
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 = "回测" # 无论实盘或回测，此处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, "策略参数为" + str(fast_length) + "&" + str(slow_length),
"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.counter = 0 # 计数器
self.fast_length = fast_length # 短周期均线长度
self.slow_length = slow_length # 长周期均线长度
self.long_stop = long_stop # 多单止损幅度
self.short_stop = short_stop # 空单止损幅度
self.total_profit = 0
self.contract_value = self.market.contract_value() # 合约面值，每次获取需发起网络请求，故于此处声明变量，优化性能
# 声明持仓方向、数量与价格变量，每次开平仓后手动重新赋值
self.hold_direction = "none"
self.hold_amount = 0
self.hold_price = 0
print("{} {} 双均线多空策略已启动！".format(get_localtime(), instrument_id)) # 程序启动时打印提示信息
def __init__(self):
config.loads('config.json')
self.symbol = "BTC-USDT-SWAP"
self.timeframe = "1m"
self.exchange = BINANCESWAP("", "", self.symbol)
self.indicators = INDICATORS(self.exchange, self.symbol,
self.timeframe)
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"图例
def binance_kline_storage(self, database, data_sheet, platform, instrument_id, time_frame):
"""存储实时的币安交易所k线数据"""
indicators = INDICATORS(platform, instrument_id, time_frame)
if indicators.BarUpdate() == True:
last_kline = platform.get_kline(time_frame)[1]
if last_kline != self.__old_kline: # 若获取得k线不同于已保存的上一个k线
timestamp = last_kline[0]
open = last_kline[1]
high = last_kline[2]
low = last_kline[3]
close = last_kline[4]
volume = last_kline[5]
self.__binance_save_kline_func(database, data_sheet, timestamp, open, high, low, close, volume)
print("{} {} {} 币安交易所实时k线数据已保存至MySQL数据库中！".format(time.get_localtime(), instrument_id, time_frame))
self.__old_kline = last_kline # 将刚保存的k线设为旧k线
else:
return
class Kline:
def __init__(self):
config.loads('config.json')
self.symbol = "BTC-USDT-SWAP"
self.timeframe = "1m"
self.exchange = BINANCESWAP("", "", self.symbol)
self.indicators = INDICATORS(self.exchange, self.symbol,
self.timeframe)
def update(self):
table = self.exchange.get_kline(self.timeframe)
table.reverse()
try:
df = pd.DataFrame(
table,
columns='time open high low close volume currency_volume'.
split())
df = df.astype({
'time': 'datetime64[ns]',
'open': 'float64',
'high': 'float64',
'low': 'float64',
'close': 'float64',
'volume': 'float64',
'currency_volume': 'float64'
})
except:
df = pd.DataFrame(
table, columns='time open high low close volume'.split())
df = df.astype({
'time': 'datetime64[ns]',
'open': 'float64',
'high': 'float64',
'low': 'float64',
'close': 'float64',
'volume': 'float64'
})
candlesticks = df['time open close high low'.split()]
volumes = df['time open close volume'.split()]
boll = self.indicators.BOLL(20)
upperband = boll['upperband']
middleband = boll['middleband']
lowerband = boll['lowerband']
if not plots:
# first time we create the plots
global ax, ax2
plots.append(fplt.candlestick_ochl(candlesticks))
plots.append(fplt.volume_ocv(volumes, ax=ax2))
plots.append(fplt.plot(upperband, legend="UPPERBAND"))
plots.append(fplt.plot(middleband, legend="MIDDLEBAND"))
plots.append(fplt.plot(lowerband, legend="LOWERBAND"))
else:
# every time after we just update the data sources on each plot
plots[0].update_data(candlesticks)
plots[1].update_data(volumes)
plots[2].update_data(upperband)
plots[3].update_data(middleband)
plots[4].update_data(lowerband)
class Kline:
def __init__(self):
config.loads('config.json')
self.symbol = "BTC-USD-SWAP"
self.timeframe = "1m"
self.exchange = HUOBISWAP("", "", self.symbol)
self.indicators = INDICATORS(self.exchange, self.symbol,
self.timeframe)
def update(self):
table = self.exchange.get_kline(self.timeframe)
table.reverse()
try:
df = pd.DataFrame(
table,
columns='time open high low close volume currency_volume'.
split())
df = df.astype({
'time': 'datetime64[ns]',
'open': 'float64',
'high': 'float64',
'low': 'float64',
'close': 'float64',
'volume': 'float64',
'currency_volume': 'float64'
})
except:
df = pd.DataFrame(
table, columns='time open high low close volume'.split())
df = df.astype({
'time': 'datetime64[ns]',
'open': 'float64',
'high': 'float64',
'low': 'float64',
'close': 'float64',
'volume': 'float64'
})
candlesticks = df['time open close high low'.split()]
volumes = df['time open close volume'.split()]
result = self.indicators.MACD(12, 26, 9)
dif = result['DIF']
dea = result['DEA']
macd = result['MACD']
if not plots:
# first time we create the plots
global ax, ax2, ax3
plots.append(fplt.candlestick_ochl(candlesticks))
plots.append(fplt.volume_ocv(volumes, ax=ax2))
plots.append(fplt.plot(dif, ax=ax3, legend="DIF"))
plots.append(fplt.plot(dea, ax=ax3, legend="DEA"))
plots.append(fplt.plot(macd, ax=ax3, legend="MACD"))
else:
# every time after we just update the data sources on each plot
plots[0].update_data(candlesticks)
plots[1].update_data(volumes)
plots[2].update_data(dif)
plots[3].update_data(dea)
plots[4].update_data(macd)
class Kline:
def __init__(self):
config.loads('config.json')
self.symbol = "BTC-USDT-SWAP"
self.timeframe = "1m"
self.exchange = OKEXSWAP("", "", "", self.symbol)
self.indicators = INDICATORS(self.exchange, self.symbol,
self.timeframe)
def update(self):
table = self.exchange.get_kline(self.timeframe)
table.reverse()
try:
df = pd.DataFrame(
table,
columns='time open high low close volume currency_volume'.
split())
df = df.astype({
'time': 'datetime64[ns]',
'open': 'float64',
'high': 'float64',
'low': 'float64',
'close': 'float64',
'volume': 'float64',
'currency_volume': 'float64'
})
except:
df = pd.DataFrame(
table, columns='time open high low close volume'.split())
df = df.astype({
'time': 'datetime64[ns]',
'open': 'float64',
'high': 'float64',
'low': 'float64',
'close': 'float64',
'volume': 'float64'
})
candlesticks = df['time open close high low'.split()]
volumes = df['time open close volume'.split()]
ma = self.indicators.MA(20, 30)
ma1 = ma[0]
ma2 = ma[1]
if not plots:
# first time we create the plots
global ax, ax2
plots.append(fplt.candlestick_ochl(candlesticks))
plots.append(fplt.volume_ocv(volumes, ax=ax2))
plots.append(fplt.plot(ma1, legend="MA20"))
plots.append(fplt.plot(ma2, legend="MA30"))
else:
# every time after we just update the data sources on each plot
plots[0].update_data(candlesticks)
plots[1].update_data(volumes)
plots[2].update_data(ma1)
plots[3].update_data(ma2)
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 __init__(self, instrument_id, time_frame, fast_length, slow_length,
long_stop, short_stop, start_asset, precision):
try:
print("{} {} 双均线多空策略已启动！".format(get_localtime(),
instrument_id)) # 程序启动时打印提示信息
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 == "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.hold_price = 0 # 注意：okex的现货没有获取持仓均价的接口，故需实盘时需要手动记录入场价格。此种写法对于不同的交易所是通用的。
# 此种写法，若策略重启，持仓价格会回归0
except:
logger.warning()
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()
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()
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')
from purequant.trade import HUOBISPOT from purequant.market import MARKET from purequant.indicators import INDICATORS from purequant.position import POSITION # 账户和策略参数等信息 accessy_key = 'your access_key' secret_key = 'your secret_key' instrument_id = 'ETC-USDT' time_frame = '1d' # 初始化交易所、行情模块与指标等模块 exchange = HUOBISPOT(accessy_key, secret_key, instrument_id) market = MARKET(exchange, instrument_id, time_frame) indicators = INDICATORS(exchange, instrument_id, time_frame) position = POSITION(exchange, instrument_id, time_frame) # 下单交易，买入和卖出 # info = exchange.buy(7.35, 0.02) # 以7.35的价格买入0.02个ETC # info = exchange.sell(7.35, 0.01) # 卖出0.02个ETC # 获取行情信息 # info = exchange.get_kline(time_frame) # 获取k线数据 # info = market.last() # 获取ETC-USDT的最新成交价 # info = market.open(-1) # 获取ETC-USDT的当日开盘价 # info = market.high(-1) # 获取ETC-USDT的当日最高价 # info = market.low(-1) # 获取ETC-USDT的当日最低价 # info = market.close(-1) # 获取ETC-USDT的当日收盘价 # 持仓信息 # info = position.amount() # 获取ETC-USDT交易对的ETC可用余额
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()
