def get_duration_filter(code, df=None, dtype='d', start=None, end=None, dl=None, filter=True, ptype='low', power=True):
if start is not None and end is None and filter:
index_d = cct.day8_to_day10(start)
start = tdd.get_duration_price_date(code, ptype=ptype, dt=start, df=df, dl=dl, power=power)
log.debug("start is not None start: %s index_d:%s" % (start, index_d))
elif end is not None and filter:
df = tdd.get_tdx_append_now_df_api(code, start=start, end=end, df=df, dl=dl, power=power).sort_index(ascending=True)
index_d = cct.day8_to_day10(start)
start = tdd.get_duration_price_date(code, ptype=ptype, dt=start, df=df, dl=dl, power=power)
df = df[df.index >= start]
if len(df) > 2 and dl is None:
if df.index.values[0] < index_d:
df = df[df.index >= index_d]
if dl is not None:
if power:
start, index_d, df = tdd.get_duration_price_date(
code, ptype=ptype, dl=dl, filter=False, df=df, power=True)
else:
start, index_d = tdd.get_duration_price_date(
code, ptype=ptype, dl=dl, filter=False, df=df, power=False)
log.debug("dl not None code:%s start: %s index_d:%s" % (code, start, index_d))
if len(df) > 0 and df is not None:
df = df.sort_index(ascending=True)
df = df[df.index >= start]
if len(df) == 0 or df is None:
if start is not None and len(start) > 8 and int(start[:4]) > 2500:
log.warn("code:%s ERROR:%s" % (code, start))
start = '2016-01-01'
df = tdd.get_tdx_append_now_df_api(
code, start, end).sort_index(ascending=True)
if start is None:
start = df.index.values[0]
if len(df) > 2 and dl is None and start is not None and filter:
if df.index.values[0] < index_d:
df = df[df.index >= index_d]
if not dtype == 'd':
df = tdd.get_tdx_stock_period_to_type(
df, dtype).sort_index(ascending=True)
return df
# log.setLevel(LoggerFactory.INFO)
# log.setLevel(LoggerFactory.DEBUG)
code = raw_input("code:")
args = parser.parse_args(code.split())
# if not code.lower() == 'q' and not code.lower() == 'quit' and not code.lower() == 'exit' and not code == 'q' and not code == 'e' and not str(args.code) == 'None' and (args.wencai == 'y' or re.match('[a-zA-Z]+',code) is not None or re.match('[ \u4e00 -\u9fa5]+',code) == None ):
# if not cct.get_os_system() == 'mac':
# import ipdb;ipdb.set_trace()
if not code.lower() == 'q' and not code.lower() == 'quit' and not code.lower() == 'exit' and not code == 'q' and not code == 'e' \
and not str(args.code) == 'None' and (args.wencai == 'y' and (re.match('[a-zA-Z]+',code) is None and re.match(ur"[\u4e00-\u9fa5]+",code) is not None ) ):
df = wcd.get_wencai_Market_url(code,200,pct=False)
print df.shape,df[:8]
if len(df) == 1:
if re.match('[ \u4e00 -\u9fa5]+',code) == None:
args.code = df.code.values[0]
start = cct.day8_to_day10(args.start)
end = cct.day8_to_day10(args.end)
args.filter = 'y'
for ptype in ['low', 'high']:
op, ra, st, days = pct.get_linear_model_status(args.code,df=None, dtype=args.dtype, start=start, end=end,
days=args.days, ptype=ptype, filter=args.filter,
dl=args.dl)
# print "%s op:%s ra:%s days:%s start:%s" % (args.code, op, str(ra), str(days[0]), st)
print "op:%s ra:%s days:%s start:%s" % (op, str(ra), str(days[0]), st)
elif len(str(args.code)) == 6:
if args.start is not None and len(args.start) <= 4:
args.dl = int(args.start)
args.start = None
start = cct.day8_to_day10(args.start)
def get_linear_model_status(code, df=None, dtype='d', type='m', start=None, end=None, days=1, filter='n',
dl=None, countall=True, ptype='low', power=True):
"""[pct test get_linear_model_status]
[description]
Arguments:
code {[type]} -- [description]
Keyword Arguments:
df {[type]} -- [description] (default: {None})
dtype {str} -- [description] (default: {'d'})
type {str} -- [description] (default: {'m'})
start {[type]} -- [description] (default: {None})
end {[type]} -- [description] (default: {None})
days {number} -- [description] (default: {1})
filter {str} -- [description] (default: {'n'})
dl {[type]} -- [description] (default: {None})
countall {bool} -- [description] (default: {True})
ptype {str} -- [description] (default: {'low'})
power {bool} -- [description] (default: {True})
Returns:
[type] -- [description]
"""
if start is not None and end is None and filter == 'y':
index_d = cct.day8_to_day10(start)
start = tdd.get_duration_price_date(code, ptype=ptype, dt=start, df=df, dl=dl, power=power)
log.debug("start is not None start: %s index_d:%s" % (start, index_d))
elif end is not None and filter == 'y':
df = tdd.get_tdx_append_now_df_api(code, start=start, end=end, df=df, dl=dl, power=power).sort_index(ascending=True)
index_d = cct.day8_to_day10(start)
start = tdd.get_duration_price_date(code, ptype=ptype, dt=start, df=df, dl=dl, power=power)
df = df[df.index >= start]
if len(df) > 2 and dl is None:
if df.index.values[0] < index_d:
df = df[df.index >= index_d]
if dl is not None:
if power:
start, index_d, df = tdd.get_duration_price_date(
code, ptype=ptype, dl=dl, filter=False, df=df, power=power)
else:
start, index_d = tdd.get_duration_price_date(
code, ptype=ptype, dl=dl, filter=False, df=df, power=power)
log.debug("dl not None code:%s start: %s index_d:%s" % (code, start, index_d))
if len(df) > 0 and df is not None:
df = df.sort_index(ascending=True)
df = df[df.index >= start]
if len(df) == 0 or df is None:
if start is not None and len(start) > 8 and int(start[:4]) > 2500:
log.warn("code:%s ERROR:%s" % (code, start))
start = '2016-01-01'
df = tdd.get_tdx_append_now_df_api(
code, start, end).sort_index(ascending=True)
if start is None:
start = df.index.values[0]
if len(df) > 2 and dl is None and start is not None and filter == 'y':
if df.index.values[0] < index_d:
df = df[df.index >= index_d]
if not dtype == 'd':
df = tdd.get_tdx_stock_period_to_type(
df, dtype).sort_index(ascending=True)
df = df.fillna(0)
if len(df) > 1 + days:
if days != 0:
asset = df[:-days]
else:
asset = df
else:
asset = df
if len(asset) > 1:
operationcount = 0
# ratio_l = []
if countall:
assetratio = asset
nowpratio = df['close'][-days] if len(df) > 1 + days else None
# print assetratio
op, ratio_l, status, sdl = get_linear_model_rule(code, df=assetratio, nowP=nowpratio, ptype=ptype)
# print op,ratio,status,sdl
# ratio_l.append(round(ratio, 2))
operationcount += op
else:
assetratio = asset
nowpratio = df['close'][-days] if len(df) > 1 + days else None
op, ratio_l, status, sdl = get_linear_model_rule(code, df=assetratio, nowP=nowpratio, ptype=ptype)
# ratio_l.append(round(ratio, 2))
operationcount += op
return operationcount, (ratio_l), df[:1].index.values[0], [len(df), df[:1]]
elif len(asset) == 1:
## log.error("powerCompute code:%s"%(code))
if ptype == 'high':
if df.close[-1] >= df.high[-1] * 0.99 and df.close[-1] >= df.open[-1]:
return 12, 0, df.index.values[0], [len(df), df[:1]]
elif df.close[-1] > df.open[-1]:
if df.close[-1] > df.high[-1] * 0.97:
if len(df) > 2 and df.close[-1] > df.close[-2]:
return 10, 0, df.index.values[0], [len(df), df[:1]]
else:
return 11, 0, df.index.values[0], [len(df), df[:1]]
else:
return 9, 0, df.index.values[0], [len(df), df[:1]]
else:
if len(df) >= 2:
if df.close[-1] > df.close[-2] * 1.01:
return 9, 0, df.index.values[0], [len(df), df[:1]]
elif df.close[-1] > df.close[-2]:
return 8, 0, df.index.values[0], [len(df), df[:1]]
elif df.low[-1] > df.low[-2]:
return 6, 0, df.index.values[0], [len(df), df[:1]]
else:
return 3, 0, df.index.values[0], [len(df), df[:1]]
else:
return 1, 0, df.index.values[0], [len(df), df[:1]]
else:
return -10, 0, df.index.values[0], [len(df), df[:1]]
else:
if ptype == 'high':
return 13, 1, cct.get_today(), [len(df), df[:1]]
else:
return -10, -10, cct.get_today(), [len(df), df[:1]]
def get_linear_model_histogram(code,
ptype='low',
dtype='d',
start=None,
end=None,
vtype='f',
filter='n',
df=None):
# 399001','cyb':'zs399006','zxb':'zs399005
# code = '999999'
# code = '601608'
# code = '000002'
# asset = get_kdate_data(code)['close'].sort_index(ascending=True)
# df = tdd.get_tdx_Exp_day_to_df(code, 'f').sort_index(ascending=True)
# ptype='close'
# if ptype == 'close' or ptype==''
# ptype=
if start is not None and filter == 'y':
if code not in ['999999', '399006', '399001']:
index_d, dl = tdd.get_duration_Index_date(dt=start)
log.debug("index_d:%s dl:%s" % (str(index_d), dl))
else:
index_d = cct.day8_to_day10(start)
log.debug("index_d:%s" % (index_d))
start = tdd.get_duration_price_date(code, ptype='low', dt=index_d)
log.debug("start:%s" % (start))
if df is None:
# df = tdd.get_tdx_append_now_df(code, ptype, start, end).sort_index(ascending=True)
df = tdd.get_tdx_append_now_df_api(code, start,
end).sort_index(ascending=True)
if not dtype == 'd':
df = tdd.get_tdx_stock_period_to_type(df,
dtype).sort_index(ascending=True)
asset = df[ptype]
log.info("df:%s" % asset[:1])
asset = asset.dropna()
dates = asset.index
if not code.startswith('999') and not code.startswith('399'):
# print "code:",code
if code[:1] in ['5', '6', '9']:
code2 = '999999'
elif code[:2] in ['30']:
# print "cyb"
code2 = '399006'
else:
code2 = '399001'
df1 = tdd.get_tdx_append_now_df_api(code2, start,
end).sort_index(ascending=True)
# df1 = tdd.get_tdx_append_now_df(code2, ptype, start, end).sort_index(ascending=True)
if not dtype == 'd':
df1 = tdd.get_tdx_stock_period_to_type(
df1, dtype).sort_index(ascending=True)
# if len(asset) < len(df1):
# asset1 = df1.loc[asset.index, ptype]
# else:
# asset1 = df1.loc[asset.index, ptype]
# startv = asset1[:1]
# asset1 = asset1.apply(lambda x: round(x / asset1[:1], 2))
# print asset[:1].index[0] , df1[:1].index[0]
if asset[:1].index[0] > df1[:1].index[0]:
asset1 = df1.loc[asset.index, ptype]
startv = asset1[:1]
asset1 = asset1.apply(lambda x: round(x / asset1[:1], 2))
else:
df = df[df.index >= df1.index[0]]
asset = df[ptype]
asset = asset.dropna()
dates = asset.index
asset1 = df1.loc[df.index, ptype]
asset1 = asset1.apply(lambda x: round(x / asset1[:1], 2))
else:
if code.startswith('399001'):
code2 = '999999'
elif code.startswith('399006'):
code2 = '399005'
else:
code2 = '399001'
df1 = tdd.get_tdx_append_now_df_api(code2, start,
end).sort_index(ascending=True)
# print df1[:1]
# df1 = tdd.get_tdx_append_now_df(code2, ptype, start, end).sort_index(ascending=True)
if not dtype == 'd':
df1 = tdd.get_tdx_stock_period_to_type(
df1, dtype).sort_index(ascending=True)
if len(asset) < len(df1):
asset1 = df1.loc[asset.index, ptype]
asset1 = asset1.apply(lambda x: round(x / asset1[:1], 2))
else:
df = df[df.index >= df1.index[0]]
asset = df[ptype]
asset = asset.dropna()
dates = asset.index
asset1 = df1.loc[df.index, ptype]
asset1 = asset1.apply(lambda x: round(x / asset1[:1], 2))
# print len(df),len(asset),len(df1),len(asset1)
if end is not None:
# print asset[-1:]
asset = asset[:-1]
dates = asset.index
asset1 = asset1[:-1]
asset1 = asset1.apply(lambda x: round(x / asset1[:1], 2))
# 画出价格随时间变化的图像
# _, ax = plt.subplots()
# fig = plt.figure()
fig = plt.figure(figsize=(16, 5))
# fig = plt.figure(figsize=(16, 10), dpi=72)
# fig.autofmt_xdate() #(no fact)
# plt.subplots_adjust(bottom=0.1, right=0.8, top=0.9)
plt.subplots_adjust(left=0.05,
bottom=0.08,
right=0.95,
top=0.95,
wspace=0.15,
hspace=0.25)
# set (gca,'Position',[0,0,512,512])
# fig.set_size_inches(18.5, 10.5)
# fig=plt.fig(figsize=(14,8))
ax1 = fig.add_subplot(121)
# asset=asset.apply(lambda x:round( x/asset[:1],2))
ax1.plot(asset)
# ax1.plot(asset1,'-r', linewidth=2)
ticks = ax1.get_xticks()
# start, end = ax1.get_xlim()
# print start, end, len(asset)
# print ticks, ticks[:-1]
# (ticks[:-1] if len(asset) > end else np.append(ticks[:-1], len(asset) - 1))
ax1.set_xticklabels(
[dates[int(i)] for i in (np.append(ticks[:-1],
len(asset) - 1))],
rotation=15) # Label x-axis with dates
# 拟合
X = np.arange(len(asset))
x = sm.add_constant(X)
model = regression.linear_model.OLS(asset, x).fit()
a = model.params[0]
b = model.params[1]
# log.info("a:%s b:%s" % (a, b))
log.info("X:%s a:%s b:%s" % (len(asset), a, b))
Y_hat = X * b + a
# 真实值-拟合值，差值最大最小作为价值波动区间
# 向下平移
i = (asset.values.T - Y_hat).argmin()
c_low = X[i] * b + a - asset.values[i]
Y_hatlow = X * b + a - c_low
# 向上平移
i = (asset.values.T - Y_hat).argmax()
c_high = X[i] * b + a - asset.values[i]
Y_hathigh = X * b + a - c_high
plt.plot(X, Y_hat, 'k', alpha=0.9)
plt.plot(X, Y_hatlow, 'r', alpha=0.9)
plt.plot(X, Y_hathigh, 'r', alpha=0.9)
# plt.xlabel('Date', fontsize=12)
plt.ylabel('Price', fontsize=12)
plt.title(code + " | " + str(dates[-1])[:11], fontsize=14)
plt.legend([asset.iat[-1]], fontsize=12, loc=4)
plt.grid(True)
# plt.legend([code]);
# plt.legend([code, 'Value center line', 'Value interval line']);
# fig=plt.fig()
# fig.figsize = [14,8]
scale = 1.1
zp = zoompan.ZoomPan()
figZoom = zp.zoom_factory(ax1, base_scale=scale)
figPan = zp.pan_factory(ax1)
# 将Y-Y_hat股价偏离中枢线的距离单画出一张图显示，对其边界线之间的区域进行均分，大于0的区间为高估，小于0的区间为低估，0为价值中枢线。
ax3 = fig.add_subplot(122)
# distance = (asset.values.T - Y_hat)
distance = (asset.values.T - Y_hat)[0]
# if code.startswith('999') or code.startswith('399'):
if len(asset) > len(df1):
ax3.plot(asset)
plt.plot(distance)
ticks = ax3.get_xticks()
ax3.set_xticklabels(
[dates[int(i)] for i in (np.append(ticks[:-1],
len(asset) - 1))],
rotation=15)
n = 5
d = (-c_high + c_low) / n
c = c_high
while c <= c_low:
Y = X * b + a - c
plt.plot(X, Y - Y_hat, 'r', alpha=0.9)
c = c + d
ax3.plot(asset)
## plt.xlabel('Date', fontsize=12)
plt.ylabel('Price-center price', fontsize=14)
plt.grid(True)
else:
as3 = asset.apply(lambda x: round(x / asset[:1], 2))
ax3.plot(as3)
ax3.plot(asset1, '-r', linewidth=2)
# assvol = df.loc[asset.index]['vol']
# assvol = assvol.apply(lambda x: round(x / assvol[:1], 2))
# ax3.plot(assvol, '-g', linewidth=2)
plt.grid(True)
zp3 = zoompan.ZoomPan()
figZoom = zp3.zoom_factory(ax3, base_scale=scale)
figPan = zp3.pan_factory(ax3)
# plt.title(code, fontsize=14)
if 'name' in df.columns:
plt.legend([df.name[-1], df1.name[-1]], loc=0)
else:
dm = tdd.get_sina_data_df(code)
if 'name' in dm.columns:
cname = dm.name[0]
else:
cname = '-'
# plt.legend([code, code2], loc=0)
plt.legend([cname, code2], loc=0)
plt.show(block=False)
def get_linear_model_histogramDouble(code,
ptype='low',
dtype='d',
start=None,
end=None,
vtype='f',
filter='n',
df=None,
dl=None):
# 399001','cyb':'zs399006','zxb':'zs399005
# code = '999999'
# code = '601608'
# code = '000002'
# asset = get_kdate_data(code)['close'].sort_index(ascending=True)
# df = tdd.get_tdx_Exp_day_to_df(code, 'f').sort_index(ascending=True)
# ptype='close'
# if ptype == 'close' or ptype==''
# ptype=
if start is not None and filter == 'y':
if code not in ['999999', '399006', '399001']:
index_d, dl = tdd.get_duration_Index_date(dt=start)
log.debug("index_d:%s dl:%s" % (str(index_d), dl))
else:
index_d = cct.day8_to_day10(start)
log.debug("index_d:%s" % (index_d))
start = tdd.get_duration_price_date(code, ptype='low', dt=index_d)
log.debug("start:%s" % (start))
if start is None and df is None and dl is not None:
start = cct.last_tddate(dl)
# print start
df = tdd.get_tdx_append_now_df_api(code, start=start,
end=end).sort_index(ascending=True)
if df is None:
# df = tdd.get_tdx_append_now_df(code, ptype, start, end).sort_index(ascending=True)
df = tdd.get_tdx_append_now_df_api(code, start,
end).sort_index(ascending=True)
if not dtype == 'd':
df = tdd.get_tdx_stock_period_to_type(df,
dtype).sort_index(ascending=True)
if len(df) == 0:
raise Exception("Code:%s error, df is None" % (code))
asset = df[ptype].round(2)
log.info("df:%s" % asset[:1])
asset = asset.dropna()
dates = asset.index
if not code.startswith('999') and not code.startswith('399'):
# print "code:",code
if code[:1] in ['5', '6', '9']:
code2 = '999999'
elif code[:2] in ['30']:
# print "cyb"
code2 = '399006'
else:
code2 = '399001'
df1 = tdd.get_tdx_append_now_df_api(code2, start,
end).sort_index(ascending=True)
# df1 = tdd.get_tdx_append_now_df(code2, ptype, start, end).sort_index(ascending=True)
if not dtype == 'd':
df1 = tdd.get_tdx_stock_period_to_type(
df1, dtype).sort_index(ascending=True)
# if len(asset) < len(df1):
# asset1 = df1.loc[asset.index, ptype]
# else:
# asset1 = df1.loc[asset.index, ptype]
# startv = asset1[:1]
# asset1 = asset1.apply(lambda x: round(x / asset1[:1], 2))
# print asset[:1].index[0] , df1[:1].index[0]
if asset[:1].index[0] > df1[:1].index[0]:
asset1 = df1.loc[asset.index, ptype]
startv = asset1[:1]
asset1 = asset1.apply(lambda x: round(x / asset1[:1], 2))
else:
df = df[df.index >= df1.index[0]]
asset = df[ptype]
asset = asset.dropna()
dates = asset.index
asset1 = df1.loc[df.index, ptype]
asset1 = asset1.apply(lambda x: round(x / asset1[:1], 2))
else:
if code.startswith('399001'):
code2 = '399006'
elif code.startswith('399006'):
code2 = '399005'
else:
code2 = '399006'
if code2.startswith('3990'):
df1 = tdd.get_tdx_append_now_df_api(code2, start,
end).sort_index(ascending=True)
if len(df1) < int(len(df) / 4):
code2 = '399001'
df1 = tdd.get_tdx_append_now_df_api(
code2, start, end).sort_index(ascending=True)
# df1 = tdd.get_tdx_append_now_df(code2, ptype, start, end).sort_index(ascending=True)
if not dtype == 'd':
df1 = tdd.get_tdx_stock_period_to_type(
df1, dtype).sort_index(ascending=True)
if len(asset) < len(df1):
asset1 = df1.loc[asset.index, ptype]
asset1 = asset1.apply(lambda x: round(x / asset1[:1], 2))
else:
df = df[df.index >= df1.index[0]]
asset = df[ptype]
asset = asset.dropna()
dates = asset.index
asset1 = df1.loc[df.index, ptype]
asset1 = asset1.apply(lambda x: round(x / asset1[:1], 2))
# print len(df),len(asset),len(df1),len(asset1)
if end is not None:
# print asset[-1:]
asset = asset[:-1]
dates = asset.index
asset1 = asset1[:-1]
asset1 = asset1.apply(lambda x: round(x / asset1[:1], 2))
# 画出价格随时间变化的图像
# _, ax = plt.subplots()
# fig = plt.figure()
# plt.ion()
fig = plt.figure(figsize=(16, 10))
# fig = plt.figure(figsize=(16, 10), dpi=72)
# fig.autofmt_xdate() #(no fact)
# plt.subplots_adjust(bottom=0.1, right=0.8, top=0.9)
plt.subplots_adjust(left=0.05,
bottom=0.08,
right=0.95,
top=0.95,
wspace=0.15,
hspace=0.25)
# set (gca,'Position',[0,0,512,512])
# fig.set_size_inches(18.5, 10.5)
# fig=plt.fig(figsize=(14,8))
ax1 = fig.add_subplot(321)
# asset=asset.apply(lambda x:round( x/asset[:1],2))
ax1.plot(asset)
# ax1.plot(asset1,'-r', linewidth=2)
ticks = ax1.get_xticks()
# start, end = ax1.get_xlim()
# print start, end, len(asset)
# print ticks, ticks[:-1]
# (ticks[:-1] if len(asset) > end else np.append(ticks[:-1], len(asset) - 1))
ax1.set_xticklabels(
[dates[int(i)] for i in (np.append(ticks[:-1],
len(asset) - 1))],
rotation=15) # Label x-axis with dates
# 拟合
X = np.arange(len(asset))
x = sm.add_constant(X)
model = regression.linear_model.OLS(asset, x).fit()
a = model.params[0]
b = model.params[1]
# log.info("a:%s b:%s" % (a, b))
log.info("X:%s a:%s b:%s" % (len(asset), a, b))
Y_hat = X * b + a
# 真实值-拟合值，差值最大最小作为价值波动区间
# 向下平移
i = (asset.values.T - Y_hat).argmin()
c_low = X[i] * b + a - asset.values[i]
Y_hatlow = X * b + a - c_low
# 向上平移
i = (asset.values.T - Y_hat).argmax()
c_high = X[i] * b + a - asset.values[i]
Y_hathigh = X * b + a - c_high
plt.plot(X, Y_hat, 'k', alpha=0.9)
plt.plot(X, Y_hatlow, 'r', alpha=0.9)
plt.plot(X, Y_hathigh, 'r', alpha=0.9)
# plt.xlabel('Date', fontsize=12)
plt.ylabel('Price', fontsize=12)
plt.title(code + " | " + str(dates[-1])[:11], fontsize=14)
plt.legend([asset.iat[-1]], fontsize=12, loc=4)
plt.grid(True)
# #plot volume
# pad = 0.25
# yl = ax1.get_ylim()
# ax1.set_ylim(yl[0]-(yl[1]-yl[0])*pad,yl[1])
# axx = ax1.twinx()
# axx.set_position(transforms.Bbox([[0.125,0.1],[0.9,0.32]]))
# volume = np.asarray(df.vol)
# pos = df['open']-df['close']<0
# neg = df['open']-df['close']>=0
# idx = np.asarray([x for x in range(len(df))])
# axx.bar(idx[pos],volume[pos],color='red',width=1,align='center')
# axx.bar(idx[neg],volume[neg],color='green',width=1,align='center')
# plt.legend([code]);
# plt.legend([code, 'Value center line', 'Value interval line']);
# fig=plt.fig()
# fig.figsize = [14,8]
scale = 1.1
zp = zoompan.ZoomPan()
figZoom = zp.zoom_factory(ax1, base_scale=scale)
figPan = zp.pan_factory(ax1)
# 将Y-Y_hat股价偏离中枢线的距离单画出一张图显示，对其边界线之间的区域进行均分，大于0的区间为高估，小于0的区间为低估，0为价值中枢线。
ax3 = fig.add_subplot(322)
# distance = (asset.values.T - Y_hat)
distance = (asset.values.T - Y_hat)[0]
# if code.startswith('999') or code.startswith('399'):
if len(asset) > len(df1):
ax3.plot(asset)
plt.plot(distance)
ticks = ax3.get_xticks()
ax3.set_xticklabels(
[dates[int(i)] for i in (np.append(ticks[:-1],
len(asset) - 1))],
rotation=15)
n = 5
d = (-c_high + c_low) / n
c = c_high
while c <= c_low:
Y = X * b + a - c
plt.plot(X, Y - Y_hat, 'r', alpha=0.9)
c = c + d
ax3.plot(asset)
## plt.xlabel('Date', fontsize=12)
plt.ylabel('Price-center price', fontsize=14)
plt.grid(True)
else:
as3 = asset.apply(lambda x: round(x / asset[:1], 2))
ax3.plot(as3)
ticks = ax3.get_xticks()
ax3.plot(asset1, '-r', linewidth=2)
# show volume bar !!!
# assvol = df.loc[asset.index]['vol']
# assvol = assvol.apply(lambda x: round(x / assvol[:1], 2))
# ax3.plot(assvol, '-g', linewidth=0.5)
ax3.set_xticklabels(
[dates[int(i)] for i in (np.append(ticks[:-1],
len(asset) - 1))],
rotation=15)
plt.grid(True)
zp3 = zoompan.ZoomPan()
figZoom = zp3.zoom_factory(ax3, base_scale=scale)
figPan = zp3.pan_factory(ax3)
# plt.title(code, fontsize=14)
if 'name' in df.columns:
plt.legend([df.name.values[-1:][0], df1.name.values[-1:][0]], loc=0)
else:
if code not in ['999999', '399006', '399001']:
indexIdx = False
else:
indexIdx = True
dm = tdd.get_sina_data_df(code, index=indexIdx)
if 'name' in dm.columns:
cname = dm.name[0]
else:
cname = '-'
# plt.legend([code, code2], loc=0)
plt.legend([cname, code2], loc=0)
ax2 = fig.add_subplot(323)
# ax2.plot(asset)
# ticks = ax2.get_xticks()
ax2.set_xticklabels(
[dates[int(i)] for i in (np.append(ticks[:-1],
len(asset) - 1))],
rotation=15)
# plt.plot(X, Y_hat, 'k', alpha=0.9)
n = 5
d = (-c_high + c_low) / n
c = c_high
while c <= c_low:
Y = X * b + a - c
plt.plot(X, Y, 'r', alpha=0.9)
c = c + d
# asset=asset.apply(lambda x:round(x/asset[:1],2))
ax2.plot(asset)
# ax2.plot(asset1,'-r', linewidth=2)
# plt.xlabel('Date', fontsize=12)
plt.ylabel('Price', fontsize=12)
plt.grid(True)
# plt.title(code, fontsize=14)
# plt.legend([code])
if len(df) > 10:
ax6 = fig.add_subplot(324)
h = df.loc[:, ['open', 'close', 'high', 'low']]
highp = h['high'].values
lowp = h['low'].values
openp = h['open'].values
closep = h['close'].values
# print len(closep)
lr = LinearRegression()
x = np.atleast_2d(np.linspace(0, len(closep), len(closep))).T
lr.fit(x, closep)
LinearRegression(copy_X=True,
fit_intercept=True,
n_jobs=1,
normalize=False)
xt = np.atleast_2d(np.linspace(0,
len(closep) + 200,
len(closep) + 200)).T
yt = lr.predict(xt)
bV = []
bP = []
for i in range(1, len(highp) - 1):
if highp[i] <= highp[i - 1] and highp[i] < highp[
i + 1] and lowp[i] <= lowp[i - 1] and lowp[i] < lowp[i +
1]:
bV.append(lowp[i])
bP.append(i)
else:
bV.append(lowp[i - 1])
bP.append(i - 1)
if len(bV) > 0:
d, p = LIS(bV)
idx = []
for i in range(len(p)):
idx.append(bP[p[i]])
lr = LinearRegression()
X = np.atleast_2d(np.array(idx)).T
Y = np.array(d)
lr.fit(X, Y)
estV = lr.predict(xt)
ax6.plot(closep, linewidth=2)
ax6.plot(idx, d, 'ko')
ax6.plot(xt, estV, '-r', linewidth=3)
ax6.plot(xt, yt, '-g', linewidth=3)
plt.grid(True)
# plt.tight_layout()
zp2 = zoompan.ZoomPan()
figZoom = zp2.zoom_factory(ax6, base_scale=scale)
figPan = zp2.pan_factory(ax6)
# 统计出每个区域内各股价的频数，得到直方图，为了更精细的显示各个区域的频数，这里将整个边界区间分成100份。
ax4 = fig.add_subplot(325)
log.info("assert:len:%s %s" % (len(asset.values.T - Y_hat),
(asset.values.T - Y_hat)[0]))
# distance = map(lambda x:int(x),(asset.values.T - Y_hat)/Y_hat*100)
# now_distanse=int((asset.iat[-1]-Y_hat[-1])/Y_hat[-1]*100)
# log.debug("dis:%s now:%s"%(distance[:2],now_distanse))
# log.debug("now_distanse:%s"%now_distanse)
distance = (asset.values.T - Y_hat)
now_distanse = asset.iat[-1] - Y_hat[-1]
# distance = (asset.values.T-Y_hat)[0]
pd.Series(distance).plot(kind='hist', stacked=True, bins=100)
# plt.plot((asset.iat[-1].T-Y_hat),'b',alpha=0.9)
plt.axvline(now_distanse, hold=None, label="1", color='red')
# plt.axhline(now_distanse,hold=None,label="1",color='red')
# plt.axvline(asset.iat[0],hold=None,label="1",color='red',linestyle="--")
plt.xlabel(
'Undervalue ------------------------------------------> Overvalue',
fontsize=12)
plt.ylabel('Frequency', fontsize=14)
# plt.title('Undervalue & Overvalue Statistical Chart', fontsize=14)
plt.legend([code, asset.iat[-1], str(dates[-1])[5:11]], fontsize=12)
plt.grid(True)
# plt.show()
# import os
# print(os.path.abspath(os.path.curdir))
ax5 = fig.add_subplot(326)
# fig.figsize=(5, 10)
log.info("assert:len:%s %s" % (len(asset.values.T - Y_hat),
(asset.values.T - Y_hat)[0]))
# distance = map(lambda x:int(x),(asset.values.T - Y_hat)/Y_hat*100)
distance = (asset.values.T - Y_hat) / Y_hat * 100
now_distanse = ((asset.iat[-1] - Y_hat[-1]) / Y_hat[-1] * 100)
log.debug("dis:%s now:%s" % (distance[:2], now_distanse))
log.debug("now_distanse:%s" % now_distanse)
# n, bins = np.histogram(distance, 50)
# print n, bins[:2]
pd.Series(distance).plot(kind='hist', stacked=True, bins=100)
# plt.plot((asset.iat[-1].T-Y_hat),'b',alpha=0.9)
plt.axvline(now_distanse, hold=None, label="1", color='red')
# plt.axhline(now_distanse,hold=None,label="1",color='red')
# plt.axvline(asset.iat[0],hold=None,label="1",color='red',linestyle="--")
plt.xlabel(
'Undervalue ------------------------------------------> Overvalue',
fontsize=14)
plt.ylabel('Frequency', fontsize=12)
# plt.title('Undervalue & Overvalue Statistical Chart', fontsize=14)
plt.legend([code, asset.iat[-1]], fontsize=12)
plt.grid(True)
# plt.ion()
plt.draw()
plt.pause(0.001)
# plt.show(block=False)
# plt.draw()
# plt.pause(0.001)
# plt.close()
# print plt.get_backend()
# plt.show(block=True)
return df