本策略为波动率与价格想结合的策略，策略想法较为复杂，交易次数较少。

代码如下：

import pandas as pd
import pyodbc
from sqlalchemy import create_engine
import numpy as np
from statistics import median
import crash_on_ipy
import pdb
import matplotlib.pyplot as plt
# import matplotlib_finance as mpf
# from matplotlib.finance import candlestick
from numpy import nan
#SERVER服务器地址，DATABASE数据库名，UID用户名，PWD登录密码
con = pyodbc.connect(‘DRIVER={SQL Server};SERVER=192.168.60.5;DATABASE=data_history;UID=gx;PWD=01‘)
# querystring="select * from [data_history].[dbo].[ag1612]"
querystring="select top (20000000) [time],[price] from [data_history].[dbo].[ag1612]"
engine = create_engine(‘mssql+pyodbc://scott:tiger@mydsn‘)
data=http://www.mamicode.com/pd.read_sql(querystring, con, index_col=‘time‘)
# data=http://www.mamicode.com/pd.read_csv(‘data.csv‘,index_col=‘ID‘)
print(data.head())
print(data.tail())


# data=http://www.mamicode.com/data.iloc[:,0:3]
# data[‘date_time‘]=data[‘date‘]+data[‘time‘]
# del data[‘date‘],data[‘time‘]
data=http://www.mamicode.com/data.sort_index()
# data=http://www.mamicode.com/data.set_index(‘date_time‘)
data.rename(index=lambda x:str(x)[:16],inplace=True)
# #得到每小时K线数据的开盘价、最高价、最低价、收盘价

new_data=http://www.mamicode.com/data.groupby(data.index).last()
new_data[‘open_price‘]=data.groupby(data.index).first()
new_data[‘high_price‘]=data.groupby(data.index).max()
new_data[‘low_price‘]=data.groupby(data.index).min()
new_data.columns=[‘close_price‘,‘open_price‘, ‘high_price‘, ‘low_price‘]
print(‘new_date.head():{}‘.format(new_data.head()))
new_data.drop(new_data.index[152:181],inplace=True)
# new_data.to_csv(‘new_data1.csv‘)


# 得到周期为10的标准差
# 得到所有数据的行数
# 策略判断标准前面需要至少(3*24+10)h,即82h，当天需要6根k线，即6h，总共88h，取前88h，i从87开始。
T=len(new_data.index)
print(‘T:{}‘.format(T))
std=[]
std_mean=[]
#记录开平仓位置
position_locat=[0]*T
profit=[]
#定义前三日第二大方差差值、区间最大值、区间最小值、开仓价
second_diff=0
x=0;y=0;z=0;z1=0;z2=0;m=0;m1=0;m2=0
interval_data_max=0
interval_data_min=0
open_price=0


#std数据为T-10个
for i in range(10,T):
    data_close=new_data[‘close_price‘].iloc[i-10:i].values
    std.append(data_close.std())
# print(std)
#得到std的均值，为T-10-24个，即T-34个
for i in range(24,len(std)):
    std_mean.append(np.mean(std[i-24:i]))
# print(std_mean)
print(len(new_data),len(std),len(std_mean))
#new_data比std数据多10个，std数据比mean多24个，把所有数据量统一，去掉前面多于的数据
new_data=http://www.mamicode.com/new_data.iloc[34:,:]
std=std[24:]
print(len(new_data),len(std),len(std_mean))

T=len(new_data)
mark_enter=[0]*(T)
mark_leave=[0]*(T)

def vol(i):
    vol_open_condition = False
    second_diff = median([np.max(std[i - 77:i - 53]) - np.mean(std[i - 77:i - 53]),
                          np.max(std[i - 53:i - 29]) - np.mean(std[i - 53:i - 29]),
                          np.max(std[i - 29:i - 5]) - np.mean(std[i - 77:i - 53])])
    interval_data=http://www.mamicode.com/0;std_high=0;std_low=0;interval_data_max=0;interval_data_min=0;interval_begin_time=0;interval_close_time=0
    if std[i - 4] > 0.8 * second_diff and std[i - 4] >= std[i - 5] and std[i - 4] > std[i - 3] > std[i - 2] > std[
                i - 1]:
        # 记录区间的开始位置，(i-4)为高点，(i-5）是高点前一根K线
        x = i - 5
        b = True
        while b:
            if std[i - 1] >= std[i]:
                i += 1
            else:
                b = False
                break
        # 记录区间的结束位置，i-1为低点位置
        y = i - 1
        interval_data = http://www.mamicode.com/new_data.iloc[x:y+1, :]
        std_high = std[x - 4]
        std_low = std[y]
        second_diff_satisfy_std = second_diff
        interval_data_max = interval_data[‘high_price‘].max()
        interval_data_min = interval_data[‘low_price‘].min()
        interval_begin_time=interval_data.index[0]
        interval_close_time=interval_data.index[-1]
        # interval_std_high=std[i-4]
        print(x, y, std_high,std_low,interval_data_max, interval_data_min,interval_begin_time,interval_close_time)
        vol_open_condition = True
        return second_diff,interval_data,std_high,std_low,interval_data_max,interval_data_min,vol_open_condition
    return second_diff,interval_data,std_high,std_low,interval_data_max,interval_data_min,vol_open_condition
# interval_data,std_high,std_low,interval_data_max,interval_data_min=vol(22)

#得到所有最高点和最低点，即对应价格区间（x:y)
open_long=False
open_long_number=False
open_short_number=False
open_condition=False
second_diff_satisfy_std=0
interval_data_satisfy_std=0
std_high_satisfy_std=0
std_low_satisfy_std=0
interval_data_max_satisfy_std=0
interval_data_min_satisfy_std=0
# pdb.set_trace()
#79开始
for i in range(91, T - 10):
    if not open_condition and vol(i)[6]:
        # vol_condition = vol(i)
        # vol_condition[6]
        open_condition = True
        second_diff_satisfy_std=vol(i)[0]
        interval_data_satisfy_std=vol(i)[1]
        std_high_satisfy_std=vol(i)[2]
        std_low_satisfy_std=vol(i)[3]
        interval_data_max_satisfy_std=vol(i)[4]
        interval_data_min_satisfy_std=vol(i)[5]

    #向上突破后回调情况
    if open_condition and not open_long_number and not open_short_number and \
                            interval_data_min_satisfy_std<new_data.iloc[i,0]<interval_data_max_satisfy_std and new_data.iloc[i-1,3]>interval_data_max_satisfy_std:
        open_price=new_data.iloc[i,0]
        # 开多，记录开仓价格,i+2期收盘价
        print(‘买入开仓，开仓价为：{},开仓位为：{}‘.format(open_price,i))
        mark_enter[i]=1
        open_condition=False
        open_long_number=True

    # 得到向下突破后回调情况
    if open_condition and not open_long_number and not open_short_number and \
        interval_data_min_satisfy_std<new_data.iloc[i, 0]<interval_data_max_satisfy_std and new_data.iloc[i-1,2]<interval_data_min_satisfy_std:
        #开空，记录开仓价格,i+2期收盘价
        open_price=new_data.iloc[i,0]
        print(‘卖出开仓，开仓价为：{},开仓位为：{}‘.format(open_price,i))
        print(‘i:{}‘.format(i))
        # position_locat[i+3]=2
        open_condition=False
        open_short_number =True
        mark_enter[i] = 1

    #得到波动率大于前高的位置z3
    if open_condition and std[i-1] > std_high_satisfy_std:
        open_condition=False
        std_high_satisfy_std=std[i-1]
        print(‘波动率大于前高位置，重置区间,重置点为：{}‘.format(i))


    #出场
    #出场分四种情况，分别是多头（正常出场和止损出场）和空头（正常出场和止损出场）
    #多头正常出场
    if open_long_number and std[i-3]>0.3*second_diff_satisfy_std and std[i-1]>std[i-2] and std[i-1]>std[i]:
        # 平多，记录平仓位置
        # m1=i+4
        profit_yield = (new_data.iloc[i, 0] - open_price) / open_price
        print(‘正常卖出平仓，平仓价为：{},平仓位为：{}‘.format(new_data.iloc[i, 0],i))
        profit.append(profit_yield)
        open_long_number=False
        mark_leave[i] = 1

    #多头止损出场
    if open_long_number and (new_data.iloc[i,3]>interval_data_max_satisfy_std or new_data.iloc[i,2]<interval_data_min_satisfy_std):
        #平多，记录平仓位置
        # m2=i
        profit_yield = (new_data.iloc[i, 0] - open_price) / open_price
        print(‘止损卖出平仓，平仓价为：{},平仓位为：{}‘.format(new_data.iloc[i, 0],i))
        profit.append(profit_yield)
        open_long_number=False
        mark_leave[i] = 1

    #空头正常出场
    if open_short_number and std[i]>0.3*second_diff_satisfy_std and std[i-1]>std[i-2] and std[i-1]>std[i]:
        #平空，记录平仓位置
        # m1=i+4
        profit_yield = (open_price - new_data.iloc[i, 0]) / open_price
        print(‘正常买入平仓，平仓价为：{},平仓位为：{}‘.format(new_data.iloc[i, 0],i))
        profit.append(profit_yield)
        open_short_number=False
        mark_leave[i] = 1

    #空头止损出场
    if open_short_number and (new_data.iloc[i,3]>interval_data_max_satisfy_std or new_data.iloc[i,2]<interval_data_min_satisfy_std):
        #平空，记录平仓位置
        # m2=i
        profit_yield = (open_price - new_data.iloc[i, 0]) / open_price
        print(‘止损买入平仓，平仓价为：{},平仓位为：{}‘.format(new_data.iloc[i, 0],i))
        profit.append(profit_yield)
        open_short_number=False
        mark_leave[i] = 1

#计算sharpe
#计算总回报
total_return=np.expm1(np.log1p(profit).sum())
#计算年化回报
annual_return=(1+total_return)**(365/30)-1
risk_free_rate=0.015
profit_std=np.array(profit).std()
volatility=profit_std*(len(profit)**0.5)
annual_factor=12
annual_volatility=volatility*((annual_factor)**0.5)
sharpe=(annual_return-risk_free_rate)/annual_volatility
# print(total_return,annual_return,std,volatility,annual_volatility,sharpe)
print(‘夏普比率：{}‘.format(sharpe))

#计算最大回撤
#计算
df_cum=np.exp(np.log1p(profit).cumsum())
max_return=np.maximum.accumulate(df_cum)
max_drawdown=((max_return-df_cum)/max_return).max()
print(‘-----------------‘)
print(‘最大回撤: {}‘.format(max_drawdown))

#计算盈亏比plr
from collections import Counter
# win_times=Counter(x>0 for x in minute_return)
# loss_times=Counter(x<0 for x in minute_return)
win_times=sum(x>0 for x in profit)
loss_times=sum(x<0 for x in profit)
plr=win_times/loss_times
print(‘----------------------------‘)
print(‘盈利次数:{}‘.format(win_times))
print(‘亏损次数:{}‘.format(loss_times))
print(‘盈亏比:{}‘.format(plr))

# #画出净值走势图
fig=plt.figure()
ax1=fig.add_subplot(3,1,1)
ag_close_price,=plt.plot(new_data[‘close_price‘].values,label=‘close_price‘)
ag_open_price,=plt.plot(new_data[‘open_price‘].values,label=‘open_price‘)
ag_high_price,=plt.plot(new_data[‘high_price‘].values,label=‘high_price‘)
ag_low_price,=plt.plot(new_data[‘low_price‘].values,label=‘low_price‘)
plt.legend([ag_close_price,ag_open_price,ag_high_price,ag_low_price],[‘close_price‘,‘open_price‘,‘high_price‘,‘low_price‘])
ag_close_price_mark_enter=new_data.iloc[:,0].values.tolist()
ag_close_price_mark_leave=new_data.iloc[:,0].values.tolist()
# print(type(spread),type(spread_mark))
for i in range(0,T):
    if mark_enter[i]==0:
        ag_close_price_mark_enter[i]=nan
plt.plot(ag_close_price_mark_enter,‘*‘)
for i in range(0,T):
    if mark_leave[i]==0:
        ag_close_price_mark_leave[i]=nan
plt.plot(ag_close_price_mark_leave,‘+‘)

ax2=fig.add_subplot(3,1,2)
ag_std,=plt.plot(std,label=‘std‘)
ag_std_mean,=plt.plot(std_mean,label=‘std_mean‘)
plt.legend([ag_std,ag_std_mean],[‘std‘,‘std_mean‘])
ax3=fig.add_subplot(3,1,3)
cum_net_worth,=plt.plot(df_cum,label=‘cum_net_worth‘)
plt.legend([cum_net_worth],[‘cum_net_worth‘])


plt.show()
pdb.set_trace()

下面为运行结果图：

波动率与价格价格配合策略