def checkWeekStrayForAll():
win_qq_name = '影子'
df_total = ts.get_stock_basics()
for stk in df_total.index:
if int(str(df_total.loc[stk, 'timeToMarket'])[:4]) >= int(get_current_date_str()[:4]) - 4:
print('函数 checkWeekStrayForAll：'+stk+'年龄不够4岁！')
continue
try:
stray_flag = week_macd_stray_judge(stk, win_qq_name)
except:
print('函数 checkWeekStrayForAll：' + stk + '判断翻转出错！')
stray_flag = False
if stray_flag:
df = get_k_data_JQ(stk, count=400, end_date=get_current_date_str())
fig, _ = genStkPicForQQ(df)
plt.title(str(stk))
send_pic_qq(win_qq_name, fig)
plt.close()
fig, _ = genStkIdxPicForQQ(df)
plt.title(str(stk))
send_pic_qq(win_qq_name, fig)
plt.close()
else:
print('No weed-stray in '+stk)
def updateSingleMacdHistory(stk_code, history_dict):
"""
更新单只stk的小时和半小时macd历史数据
:return:
"""
if stk_code not in history_dict.keys():
# df_30 = my_pro_bar(stk_code, start=add_date_str(get_current_date_str(), -200), freq='30min')
df_30 = get_k_data_JQ(stk_code, start_date=add_date_str(get_current_date_str(), -200), freq='30m')
df_30['MACD'], _, _ = talib.MACD(df_30.close,
fastperiod=12, slowperiod=26,
signalperiod=9)
df_60 = get_k_data_JQ(stk_code, start_date=add_date_str(get_current_date_str(), -200), freq='60m')
df_60['MACD'], _, _ = talib.MACD(df_60.close,
fastperiod=12, slowperiod=26,
signalperiod=9)
df_30 = df_30.dropna()
df_60 = df_60.dropna()
history_dict[stk_code] = {
'min30': df_30['close'],
'min60': df_60['close']
}
def getSigleStkReseau(stk_code):
"""
计算单只stk的当前网格
:return:
"""
# df = my_pro_bar(stk_code=stk_code, start=add_date_str(get_current_date_str(), -10))
df = get_k_data_JQ(stk_code=stk_code,
start_date=add_date_str(get_current_date_str(), -10),
end_date=get_current_date_str())
if len(df) < 7:
# df = my_pro_bar(stk_code=stk_code, start=add_date_str(get_current_date_str(), -30))
df = get_k_data_JQ(stk_code=stk_code,
start_date=add_date_str(get_current_date_str(),
-30),
end_date=get_current_date_str())
df = df.reset_index()
df = df_win_std(df, 3)
df = df_win_std(df, 6)
df['std_m'] = df.apply(lambda x: np.mean([x['std_3'], x['std_6']]), axis=1)
return df.tail(1)['std_m'].values[0]
def filter_by_age(stk_basics, age_min=None, age_max=None):
"""
根据股票的上市时间进行筛选, 以年为单位
:param df_total: tushare ts.get_stock_basics() 返回值
:param age_min:
:param age_max:
:return:
"""
df_total = stk_basics.deepcopy()
if age_min is not None:
# 过滤掉年龄过小的
df_total = df_total[df_total.apply(
lambda x: int(str(x['timeToMarket'])[:4]) <= int(
get_current_date_str()[:4]) - age_min,
axis=1)]
if age_max is not None:
# 过滤掉年龄过大的
df_total = df_total[df_total.apply(lambda x: int(get_current_date_str(
)[:4]) - int(str(x['timeToMarket'])[:4]) <= age_max,
axis=1)]
return df_total
def checkWeekStrayForAll():
towho = '影子2'
send_qq(towho, '以下是今晚海选结果：')
df_total = ts.get_stock_basics()
# 过滤掉年龄小于四岁的
df_age_filter = df_total[df_total.apply(lambda x: int(
str(x['timeToMarket'])[:4]) <= int(get_current_date_str()[:4]) - 4,
axis=1)]
# 根据week反转情况进行过滤，保留有反转的单位
df_age_filter_stray = list(df_age_filter.reset_index().apply(
lambda x: (x['code'], week_MACD_stray_judge(x['code'], towho)),
axis=1))
# 过滤掉非反转的情况
df_age_f2 = list(filter(lambda x: x[1][0], df_age_filter_stray))
# 增加stk的水平信息
df_level = [(x[0], x[1][1], cal_stk_p_level(x[1][1]['close'].values))
for x in df_age_f2]
# 按总体水平排序，筛选优异者
df_level.sort(key=lambda x: x[2]['total_last'])
df_level = df_level[:math.floor(len(df_level) / 3 * 2)]
# 按照近30的波动率进行排序,筛选优异者
df_level.sort(key=lambda x: x[2]['std'], reverse=True)
df_level = df_level[:math.floor(len(df_level) / 3 * 2)]
# 按照近30的水平排序，留下最后8只
df_level.sort(key=lambda x: x[2]['t30_last'], reverse=False)
df_level = df_level[:np.min([math.floor(len(df_level) / 3 * 2), 15])]
# 打印信息
stk_list = [k[0] for k in df_level]
for stk in stk_list:
# 打印周与月信息
send_W_M_MACD(stk_code=stk, towho=towho)
# 打印日线信息
df = get_k_data_JQ(stk, count=400, end_date=get_current_date_str())
fig, _, _ = genStkPicForQQ(df)
plt.title(str(stk))
send_pic_qq(towho, fig)
plt.close()
fig, _, _ = genStkIdxPicForQQ(df)
plt.title(str(stk))
send_pic_qq(towho, fig)
plt.close()
def get_k_data_JQ(stk,
count=None,
start_date=None,
end_date=None,
freq='daily'):
"""
使用JQData来下载stk的历史数据
:param stk_code:
:param amount:
:return:
"""
if 'm' in freq:
end_date = add_date_str(get_current_date_str(), 1)
if pd.isnull(end_date):
end_date = get_current_date_str()
try:
# 增加以兼容list的情况
if isinstance(stk, list):
stk_code = [jqdatasdk.normalize_code(x) for x in stk]
df = jqdatasdk.get_price(stk_code,
frequency=freq,
count=count,
end_date=end_date,
start_date=start_date)
elif stk in ['sh', 'sz', 'cyb', 'hs300', 'sz50', 'zz500']:
stk_code_normal = JQMethod.get_index_jq_code(stk)
df = jqdatasdk.get_price(stk_code_normal,
frequency=freq,
count=count,
start_date=start_date,
end_date=end_date)
else:
df = jqdatasdk.get_price(jqdatasdk.normalize_code(stk),
frequency=freq,
count=count,
end_date=end_date,
start_date=start_date)
if df.empty:
return df
df['datetime'] = df.index
df['date'] = df.apply(lambda x: str(x['datetime'])[:10], axis=1)
return df
except Exception as e:
print('函数get_k_data_JQ：出错！错误详情：\n' + str(e))
return pd.DataFrame()
def calSingleStkRank(m_days, stk_code, days_length, p_now):
"""
:param m_days: ？天均线的离心度
:param stk_code:
:param days_length: 在？天内进行排名
:return:
"""
df = ts.get_k_data(stk_code,
start=add_date_str(get_current_date_str(),
-1 * days_length * 1.8))
if len(df) < days_length * 0.8:
print('函数 calSingleStkRank: 该stk历史数据不足！')
return -1
# 测试相对均值偏移度
df['m9'] = df['close'].rolling(window=m_days).mean()
df['diff_m9'] = df.apply(lambda x: x['close'] - x['m9'], axis=1)
"""
df.plot('date', ['close', 'diff_m9', 'rank'], subplots=True)
"""
# 给m9打分
return relativeRand(df['diff_m9'], p_now)
def sendM305Pic(win_qq_name, stk_code):
df = ts.get_k_data(stk_code, start=add_date_str(get_current_date_str(), -400))
# 测试相对均值偏移度
df['m5'] = df['close'].rolling(window=5).mean()
df['m30'] = df['close'].rolling(window=30).mean()
df['diff_m305'] = df.apply(lambda x: x['m5'] - x['m30'], axis=1)
df['rank'] = df.apply(lambda x: relativeRank(df['diff_m305'], x['diff_m305']), axis=1)
df = df.dropna(axis=0)
df.plot('date', ['close', 'diff_m305', 'rank'], subplots=True)
plt.title(stk_code+'M5-M30 分数')
output = BytesIO() # BytesIO实现了在内存中读写byte
buf_save = BytesIO()
plt.savefig(output)
output.seek(0)
img = Image.open(output) # Image.open可以打开网络图片与本地图片。
img.convert("RGB").save(buf_save, "BMP") # 以RGB模式保存图像
data = buf_save.getvalue()[14:]
buf_save.close()
output.close()
plt.close()
send_pic_qq(win_qq_name, data)
def calRSVRank(stk_code, Mdays, history_length=20):
df = get_k_data_JQ(stk_code,
count=history_length,
end_date=get_current_date_str())
# 移动平均线+RSV（未成熟随机值）
M = Mdays
near_days = 9
df['low_M' + str(M)] = df['low'].rolling(window=M).mean()
df['high_M' + str(M)] = df['high'].rolling(window=M).mean()
df['close_M' + str(M)] = df['close'].rolling(window=M).mean()
df['low_M' + str(M) + '_min'] = df['low_M' +
str(M)].rolling(window=M).min()
df['high_M' + str(M) + '_max'] = df['high_M' +
str(M)].rolling(window=M).max()
df['RSV'] = df.apply(
lambda x: (x['close_M' + str(M)] - x['low_M' + str(M) + '_min']) /
(x['high_M' + str(M) + '_max'] - x['low_M' + str(M) + '_min']),
axis=1)
df['RSV_abs'] = df.apply(
lambda x: (x['close_M' + str(M)] - x['low_M' + str(M) + '_min']),
axis=1)
df['RSV_Rank'] = df.apply(
lambda x: relativeRank(df['RSV_abs'], x['RSV_abs']), axis=1)
return df.tail(1)['RSV_Rand'].values[0]
def check_single_stk_middle_level(stk_code, dict):
"""
输入代码，返回level
:param stk_code:
:return:
"""
# 获取当前价格
current_price = get_RT_price(stk_code, source='jq')
if stk_code in dict.keys():
l = relativeRank(dict[stk_code], current_price)
else:
df_hour = get_k_data_JQ(stk_code,
count=None,
start_date=add_date_str(
get_current_date_str(), -60),
freq='60m')
dict[stk_code] = list(df_hour['close'].values)
l = relativeRank(list(df_hour['close'].values), current_price)
with open(data_dir + 'middlePeriodHourData.json', 'w') as f:
json.dump(dict, f)
return l
def calRSVRank(stk_code, Mdays, history_length=400):
df = get_k_data_JQ(stk_code,
count=history_length,
end_date=get_current_date_str())
# 移动平均线+RSV（未成熟随机值）
M = Mdays
df['low_M' + str(M)] = df['low'].rolling(window=M).mean()
df['high_M' + str(M)] = df['high'].rolling(window=M).mean()
df['close_M' + str(M)] = df['close'].rolling(window=M).mean()
for idx in df.index:
if (df.loc[idx, 'high_M' + str(M)] - df.loc[idx, 'low_M' + str(M)]
== 0) | (df.loc[idx, 'close_M' + str(M)] -
df.loc[idx, 'low_M' + str(M)] == 0):
df.loc[idx, 'RSV'] = 0.5
else:
df.loc[idx, 'RSV'] = (df.loc[idx, 'close_M' + str(M)] -
df.loc[idx, 'low_M' + str(M)]) / (
df.loc[idx, 'high_M' + str(M)] -
df.loc[idx, 'low_M' + str(M)])
# df['RSV'] = df.apply(lambda x: (x['close_M'+str(M)] - x['low_M'+str(M)])/(x['high_M'+str(M)] - x['low_M'+str(M)]), axis=1)
return df.tail(1)['RSV'].values[0]
def gen_stk_sea_select_pic_sub(stk_code):
try:
jq_login()
# 保存路径
save_dir = sea_select_pic_dir + get_current_date_str() + '/'
if not os.path.exists(save_dir):
os.makedirs(save_dir)
# 准备 小时 和 日线 数据
df_hour = gen_hour_macd_values(stk_code)
df_day = get_k_data_JQ(stk_code, 800)
# 定义图片名称
file_name = stk_code + '.png'
# 生成小时图片
gen_hour_macd_pic_local(df_hour, stk_code, 'jq', '',
save_dir + 'h_' + file_name)
gen_hour_index_pic_local(df_hour[0], stk_code,
save_dir + 'h_idx_' + file_name)
gen_day_pic_local(df_day, stk_code, save_dir + 'd_' + file_name)
gen_w_m_macd_pic_local(df_day, stk_code,
save_dir + 'wm_' + file_name)
gen_idx_pic_local(df_day, stk_code,
save_dir + 'd_idx_' + file_name)
except Exception as e:
print('生成股票走势图失败！原因：\n' + str(e))
finally:
logout()
def update_stk_basics():
current_date = get_current_date_str()
if not is_table_exist(conn=conn_stkBasics,
database_name=stk_stkBasics_data_db_name,
table_name='stk_basics' + current_date):
ts.get_stock_basics()
def printConcernedPredict2Self():
win_qq_name = u'影子2'
for stk in ['000001', '000333', '300183']:
close_today = ts.get_k_data(
stk, start=add_date_str(get_current_date_str(),
-5)).tail(1)['close'].values[0]
r = [(label, '%0.2f' % predict_tomorrow(stk,
label,
N_STEPS=N_STEPS,
feature_cols=feature_cols,
HIDDEN_SIZE=HIDDEN_SIZE,
NUM_LAYERS=NUM_LAYERS))
for label in ['high', 'low', 'close']]
# 增加与今天收盘价的对比
r_contrast = [
(x[0], x[1],
'%0.2f' % ((float(x[1]) - close_today) / close_today * 100) + '%')
for x in r
]
# stk2name = {
# 'sh': '上证',
# 'sz': '深证',
# 'cyb': '创业板'
# }
send_qq(win_qq_name, stk + ':\n' + str(r_contrast))
def get_RT_price(stk_code, source='jq'):
if source == 'jq':
# 使用聚宽数据接口替代
if stk_code in ['sh', 'sz', 'cyb']:
stk_code_normal = {
'sh': '000001.XSHG',
'sz': '399001.XSHE',
'cyb': '399006.XSHE'
}[stk_code]
else:
stk_code_normal = jq.normalize_code(stk_code)
current_price = float(
jq.get_price(stk_code_normal,
count=1,
end_date=get_current_date_str())['close'].values[0])
elif source == 'ts':
# 获取实时价格
current_price = float(
ts.get_realtime_quotes(stk_code)['price'].values[0])
return current_price
def check_single_stk_hour_idx_wx(stk_code, source='jq', debug=False):
"""
打印常用指标
"""
stk_df = get_k_data_JQ(stk_code,
count=120,
end_date=add_date_str(get_current_date_str(), 1),
freq='30m')
# 按升序排序
stk_df = stk_df.sort_values(by='datetime', ascending=True)
"""
增加指标
'RSI5', 'RSI12', 'RSI30'
'SAR'
'slowk', 'slowd'
'upper', 'middle', 'lower'
'MOM'
"""
# 删除volume为空值的情况！
stk_df = stk_df.loc[
stk_df.apply(lambda x: not (int(x['volume']) == 0), axis=1), :]
# 计算index
stk_df = add_stk_index_to_df(stk_df).tail(60)
result_analysis = []
# 检查SAR
sar_tail_origin = stk_df.tail(2)
sar_tail = sar_tail_origin.copy()
sar_tail['compare'] = sar_tail_origin.apply(
lambda x: x['SAR'] - x['close'], axis=1)
if sar_tail.head(1)['compare'].values[0] * sar_tail.tail(
1)['compare'].values[0] < 0:
if sar_tail.tail(1)['SAR'].values[0] < sar_tail.tail(
1)['close'].values[0]:
title_tmp = stk_code + ' ' + code2name(
stk_code) + ' 注意 SAR 指标翻转，后续数小时可能上涨！'
result_analysis.append(title_tmp)
GenPic.set_background_color(bc='b_r')
else:
title_tmp = stk_code + ' ' + code2name(
stk_code) + ' 注意 SAR 指标翻转，后续数小时可能下跌！'
result_analysis.append(title_tmp)
# 打印过程日志
if debug:
txt_name = 'hour_index'
# 打印原始数据
debug_print_txt(txt_name, stk_code, stk_df.to_string() + '\n\n')
# 打印结果
debug_print_txt(txt_name, stk_code,
'结果：\n' + str(result_analysis) + '\n\n')
return result_analysis
def dailyStkInfoEmail_input(stk_list):
"""
定时器每天要执行的函数,发送所关心的基本的stk信息
:return:
"""
""" -------------------------- 组织html --------------------------- """
# 构造html的单位
H_str = '' + H_Head # html字符串
date_str = get_current_date_str() # 获取当前日期
pic_dir_list = [] # 用以保存用到的图片的路径
""" 制定html """
for stk in stk_list:
stk_df = ts.get_k_data(stk)
# 生成图片
pic_dir_stk = genStkPic(stk_df,
stk,
date_str,
pic_save_dir_root,
pic_name='stk_A_C_M.png')
pic_dir_index = genStkIdxPic(stk_df,
stk,
date_str,
pic_save_dir_root,
pic_name='stk_idx.png')
pic_dir_list.append(pic_dir_stk)
pic_dir_list.append(pic_dir_index)
# 构造html
H_str = H_str + gen_H_Unit(stk_code=stk,
stk_name=get_name_by_stk_code(g_total_stk_info_mysql, stk),
pic_dir=pic_dir_stk.replace(pic_save_dir_root, ''))\
+ gen_H_Unit(stk_code=stk,
stk_name=get_name_by_stk_code(g_total_stk_info_mysql, stk),
pic_dir=pic_dir_index.replace(pic_save_dir_root, ''))
print('完成' + str(stk) + ' 的邮件内容！')
H_str = H_str + H_tail
""" ------------------- 生成需要的图片 ----------------------- """
msgImage_list = genMIMEImageList(pic_dir_list)
""" -------------------- 邮件发送 ----------------------- """
while True:
mail_return = sendmail(
subject='Darling, daily report for you!',
MIMEText_Input=MIMEText(H_str, 'html', 'utf-8'),
MIMEImageList=msgImage_list,
toaddrs=["your [email protected]", "*****@*****.**"],
fromaddr="*****@*****.**",
smtpaddr="smtp.163.com",
password="******")
if mail_return == 0:
break
else:
print('邮件发送失败！原因：' + str(mail_return) + '\n将延时后重发！')
time.sleep(20)
def my_pro_bar(stk_code,
start,
end=get_current_date_str(),
adj='qfq',
freq='D'):
if stk_code in ['sh', 'sz', 'cyb']:
df = ts.pro_bar(ts_code=ts_code_normalize(stk_code),
asset='I',
start_date=start,
end_date=end,
freq=freq)
else:
df = ts.pro_bar(ts_code=ts_code_normalize(stk_code),
start_date=start,
end_date=end,
adj=adj,
freq=freq)
if freq == 'D':
df = df.rename(columns={
'trade_date': 'date'
}).sort_values(by='date', ascending=True)
df['date'] = df.apply(lambda x: x['date'][:4] + '-' + x['date'][4:6] +
'-' + x['date'][6:],
axis=1)
elif 'min' in freq:
df = df.rename(columns={
'trade_time': 'time'
}).sort_values(by='time', ascending=True)
return df
def saveStkMRankHistoryData2Global(stk_code, history_days, m_days, save_dir):
"""
保存stk的历史数据，用来实时计算均线离心度分数，需要存历史数据，尽量不要用！
:param stk_code:
:param history_days:
:param save_dir: './M_data/'
:return:
"""
df = get_k_data_JQ(stk_code, 400, end_date=get_current_date_str())
if len(df) < history_days*0.8:
print('函数 calSingleStkRank: 该stk历史数据不足！')
return -1
# 测试相对均值偏移度
df['m9'] = df['close'].rolling(window=m_days).mean()
df['diff_m9'] = df.apply(lambda x: (x['close'] - x['m9'])/x['close'], axis=1)
df = df.dropna()
dict_restore = {
'stk_code': stk_code,
'history_M_diverge_data': list(df['diff_m9'].values),
'latest_data': list(df.tail(m_days-1)['close'].values),
'update_date': df.tail(1)['date'].values[0]
}
# global M_Data
M_Data[stk_code] = dict_restore
def gen_pdf(self, stk_list_ss, pdf_save_dir):
"""
生成相应pdf
:return:
"""
# 生成pdf
c = canvas.Canvas(pdf_save_dir + U"魔灯海选" + get_current_date_str() +
".pdf",
pagesize=letter)
c = add_front(c,
'魔灯每日股票海选结果' + get_current_date_str(),
'本文档由免费开源的量化投资软件“魔灯”自动生成 末尾公众号内有软件介绍',
pagesize=letter)
for stk in stk_list_ss:
c = print_k_to_pdf(c, stk.stk_code, get_current_date_str())
c = self.add_tail_page(c)
c.save()
def MACD_test_daily():
step = 5
datenow = get_current_date_str()
# 创建pdf
c = canvas.Canvas('./MACD_PDF/' + U"MACD日度检测" + datenow + ".pdf",
pagesize=letter)
# 是否存在相应合适的
exist_flag = False
stk_code = list(ts.get_stock_basics().index)
# 检测几个大盘指数
for bk in ['sh', 'sz', 'cyb'] + stk_code:
# 下载数据
df_bk = ts.get_k_data(bk)
if df_bk.empty:
print('函数 MACD_test_daily：stk ' + bk + '没有数据！')
continue
# 只取时间上最新的100条数据
df_bk = df_bk.loc[len(df_bk) - 150:, :]
# 为数据添加MACD指标
df_bk['MACD'], df_bk['MACDsignal'], df_bk['MACDhist'] = talib.MACD(
df_bk.close, fastperiod=12, slowperiod=26, signalperiod=9)
# 获取最后step个数据
df_last = df_bk.loc[(len(df_bk) - step):, ['MACD']].reset_index()
# 使用2次曲线拟合判断拐点
coe = np.polyfit(np.array(df_last.index), np.array(df_last['MACD']), 2)
a = coe[0]
b = coe[1]
bottom = -1 * (b / (2 * a))
if step - 1.5 < bottom < step + 1.5:
c = RPL_Bk_Page(c, bk)
exist_flag = True
print('完成stk' + bk + '的MACD检测！')
# 如果存在MACD指标符合的stk，生成pdf并发送邮件
if exist_flag:
c.save()
# 发送邮件
sendMail("MACD日度检测" + datenow, ['*****@*****.**'], '',
'./MACD_PDF/' + U"MACD日度检测" + datenow + ".pdf")
else:
# 发送邮件
sendMail("MACD日度检测" + datenow, ['*****@*****.**'],
'Nothing happened today!')
def __init__(self, stk_code, retest_span, start_date, end_date=get_current_date_str(), reseau_quick=3, reseau_slow=6, rsv_span=4, debug=False):
"""
:param stk_code:
:param retest_span:
:param start_date:
:param end_date:
:param reseau_quick:
:param reseau_slow:
:param rsv_span:
:param debug:
用法举例：
r = RetestReseau(stk_code='601398', retest_span=5, start_date='2019-01-01', end_date='2019-03-10', debug=True)
# 增加动态网格
r.add_reseau()
# 进行回测
r.retest()
# 保存结果（可选）
r.save_csv()
# 画图展示
r.plot()
"""
self.start_date = start_date
self.end_date = end_date
self.stk_code = stk_code
self.debug = debug
self.retest_span = retest_span # 回测精度，单位为分钟
self.days = minus_date_str(end_date, start_date) # 回测周期
# 计算网格用的相关参数
self.reseau_slow = reseau_slow
self.reseau_quick = reseau_quick
self.rsv_span = rsv_span
# 计算起始时因为计算指标而无法回测的数据长度
self.max_days = np.max([self.reseau_slow, self.rsv_span])
self.i_start = int((self.max_days + 2) * 60 * 4 / self.retest_span)
self.data_day = pd.DataFrame()
self.data_minute = pd.DataFrame()
if self.days < self.max_days:
exit('设置天数小于最小天数！')
if not self.prepare_data():
exit('数据初始化失败！')
self.opt_record = OptRecordRetest(
money=50000,
ratio=0.5,
start_price=self.data_minute.head(1)['close'].values[0], money_each=5000)
def gen_pdf(stk_list_):
for stk_ in stk_list_:
# 将选定的股票的走势图打印到本地
gen_stk_sea_select_pic(stk_)
print('开始生成pdf...')
# 生成pdf
c_ = canvas.Canvas(U"魔灯海选" + get_current_date_str() + ".pdf",
pagesize=letter)
c_ = add_front(c_,
'魔灯每日股票海选结果' + get_current_date_str(),
'本文档由免费开源的量化投资软件“魔灯”自动生成 末尾公众号内有软件介绍',
pagesize=letter)
for stk_ in stk_list_:
c_ = print_k_to_pdf(c_, stk_, get_current_date_str())
c_ = add_tail_page(c_)
c_.save()
def get_single_stk_reseau(self, stk_code):
"""
计算单只stk的当前网格
:return:
"""
# df = my_pro_bar(stk_code=stk_code, start=add_date_str(get_current_date_str(), -10))
df_ = get_k_data_JQ(stk=stk_code,
start_date=add_date_str(get_current_date_str(),
-10),
end_date=get_current_date_str())
if len(df_) < 7:
# df = my_pro_bar(stk_code=stk_code, start=add_date_str(get_current_date_str(), -30))
df_ = get_k_data_JQ(stk=stk_code,
start_date=add_date_str(
get_current_date_str(), -30),
end_date=get_current_date_str())
return self.get_single_stk_reseau_sub(df_)
def cal_stk_rsv_rank(self, stk_code, m_days, history_length=400):
df = get_k_data_JQ(stk_code, count=history_length, end_date=get_current_date_str())
debug_print_txt('rsv_cal', '', code2name(stk_code) + '开始计算rsv:', True)
rsv = self.cal_rsv_rank_sub(df, m_days)
debug_print_txt('rsv_cal', '', '最终rsv：' + '%0.3f' % rsv, True)
return rsv
def get_h_l_pot(stk_list):
"""
给定stklist，给出他们的“年度”、“半年度”、“月度”最高点和最低点！
:param stk_list:
:return:
half_year_high half_year_low month_high month_low stk year_high \
0 1700.50 1205.03 1700.50 1316.10 cyb 1900.480
1 3106.42 2464.36 3106.42 2653.90 sh 3326.700
2 9700.49 7089.44 9700.49 7919.05 sz 11326.270
3 16.77 10.26 16.77 12.45 300183 19.656
4 8.94 5.68 8.94 7.79 000625 11.653
5 4.42 2.56 4.42 2.74 000725 5.972
"""
current_date = get_current_date_str() # 获取当前日期
years_before = add_date_str(current_date, -365) # 一年前日期
half_year = add_date_str(current_date, -180) # 半年前日期
month_before = add_date_str(current_date, -30) # 一月前日期
# 存储结果的list
MaxMinInfoList = []
for stk in stk_list:
# 下载数据
df = ts.get_k_data(stk, start=years_before)
# 计算年度高低点
year_low = np.min(df['close'])
years_high = np.max(df['close'])
# 计算半年度高低点
half_year_low = np.min(df[df['date'] > half_year]['close'])
half_year_high = np.max(df[df['date'] > half_year]['close'])
# 计算月度高低点
month_low = np.min(df[df['date'] > month_before]['close'])
month_high = np.max(df[df['date'] > month_before]['close'])
MaxMinInfoList.append({
'stk': stk,
'year_low': year_low,
'year_high': years_high,
'half_year_low': half_year_low,
'half_year_high': half_year_high,
'month_low': month_low,
'month_high': month_high
})
# 高低点转为df，这一天不再更改
df_high_low_pot = pd.DataFrame(MaxMinInfoList)
return df_high_low_pot
def update_middle_period_hour_data():
stk_list = read_config()['buy_stk'] + read_config()['concerned_stk']
# stk_list = readConfig()['buy_stk']
# 获取stk的小时数据
result = {}
for stk in stk_list:
df_hour = get_k_data_JQ(stk, count=None, start_date=add_date_str(get_current_date_str(), -60), freq='60m')
result[stk] = list(df_hour['close'].values)
with open(data_dir+'middlePeriodHourData.json', 'w') as f:
json.dump(result, f)
def calRelaPLevel(stk_list, period, towho):
"""
计算相对价格，并发送到qq
:param stk_list:
:return:
"""
r = [
(x, calStkPlevel(np.array(get_k_data_JQ(stk_code=x, start_date=add_date_str(get_current_date_str(), period))['close']))['total_last'])
for x in stk_list]
r_df = pd.DataFrame(data=r, columns=['code', 'level'])
sendPLevel2QQ(r_df, towho)
def gen_hour_macd_values(stk_code, source='jq', title=''):
if source == 'jq':
# df_30 = get_k_data_JQ(stk_code, start_date=add_date_str(get_current_date_str(), -20),
# end_date=add_date_str(get_current_date_str(), 1), freq='30m')
# df_60 = get_k_data_JQ(stk_code, start_date=add_date_str(get_current_date_str(), -20),
# end_date=add_date_str(get_current_date_str(), 1), freq='60m')
df_30 = get_k_data_JQ(stk_code, count=120,
end_date=add_date_str(get_current_date_str(), 1), freq='30m')
df_60 = get_k_data_JQ(stk_code, count=120,
end_date=add_date_str(get_current_date_str(), 1), freq='60m')
elif source == 'ts':
df_30 = my_pro_bar(stk_code, start=add_date_str(get_current_date_str(), -20), freq='30min')
df_60 = my_pro_bar(stk_code, start=add_date_str(get_current_date_str(), -20), freq='60min')
# 去掉volume为空的行
df_30 = df_30.loc[df_30.apply(lambda x: not (x['volume'] == 0), axis=1), :]
df_60 = df_60.loc[df_60.apply(lambda x: not (x['volume'] == 0), axis=1), :]
df_30['MACD'], _, _ = talib.MACD(df_30.close,
fastperiod=12, slowperiod=26,
signalperiod=9)
df_60['MACD'], _, _ = talib.MACD(df_60.close,
fastperiod=12, slowperiod=26,
signalperiod=9)
# 生成图片
df_30 = df_30.dropna()
df_60 = df_60.dropna()
if str(df_60.index[-1]) > get_current_datetime_str():
df_30 = df_30[:-1]
df_60 = df_60[:-1]
return df_30, df_60
def get_current_price_JQ(stk_code):
# 使用聚宽数据接口替代
if stk_code in ['sh', 'sz', 'cyb']:
stk_code_normal = {
'sh': '000001.XSHG',
'sz': '399001.XSHE',
'cyb': '399006.XSHE'
}[stk_code]
else:
stk_code_normal = jq.normalize_code(stk_code)
current_price = float(jq.get_price(stk_code_normal, count=1, end_date=get_current_date_str())['close'].values[0])
return current_price
