def handle_data(self):
'''
1st_touch: ma250*.97<=low<=ma250, close>=ma250, can repeat until trend turn;
if trend up:
if touch ma145(close>=ma145): buy in
elif trend up and close <= ma145: observe (til touch)
elif trend turn: sell
else trend turn down:
wait for 2nd_touch: ma250*.3<=low<=ma250, close>=ma250:
if trend keep up:
1st buy
if touch ma145:
2nd buy
trend keep: hold
trend turn: sell
else trend turn down:
sell
'''
df = k_data_dao.get_k_data(code='603799',
start='2016-07-01',
end='2018-07-27')
df['ma20'] = cal_ma20(df)
df['ma145'] = cal_ma145(df)
df['ma250'] = cal_ma250(df)
print(df)
def test_pattern_reconize(self):
col_list = []
df = k_data_dao.get_k_data(code='000826',
start='2018-06-01',
end='2018-06-25',
cal_next_direction=False)
pattern_list = [
r for r in getmembers(pattern_recognition) if isfunction(r[1])
]
for func in pattern_list:
if hasattr(pattern_recognition, func[0]):
func_feature = func[1](df)
if isinstance(func_feature, pd.core.series.Series):
df[func[0]] = func_feature
col_list.append(func[0])
else:
df = df.join(func_feature)
col_names_list = func_feature.columns.values
for col in col_names_list:
col_list.append(col)
df = df.dropna()
df.to_csv('t.csv')
def before_handle_data(self):
if len(self.context.portfolio.positions) == 0:
# 记录当日收益
self.context.profits.append(
Profit(self.context.current_date,
self.context.base_capital / self.context.init_capital))
return
p_total = 0.0
for position in self.context.portfolio.positions:
daily_stock_data = k_data_dao.get_k_data(
code=position.code,
start=self.context.current_date,
end=self.context.current_date,
futu_quote_ctx=self.futu_quote_ctx)
# 如果当日没有交易数据, 使用上一日的仓位数据填充
if len(daily_stock_data.index) > 0:
price = daily_stock_data['close'].tail(1).values[0]
position.price = price
total = position.price * position.shares
p_total += total - self.cal_sell_trade_fee(total)
# 计算净资产
net_asset = p_total + self.context.blance
# 记录当日收益
self.context.profits.append(
Profit(self.context.current_date,
net_asset / self.context.init_capital))
def test_get_k_data(self):
df = k_data_dao.get_k_data(code="600196",
start="2018-01-02",
end="2018-01-06")
print(df)
self.assertIsNotNone(df)
def test_get_last_macd_cross_point(self):
df = k_data_dao.get_k_data(code="601668",
start=get_next_date(-120),
end=get_current_date())
df = df.join(cal_macd(df))
item = k_data_dao.get_last_macd_cross_point(df, window_size=8)
print(item)
def cal_kdj():
df = k_data_dao.get_k_data(code='601881',
start='2017-12-01',
end='2018-07-09')
k_d_j = acc_kdj(df)
ccb_df_with_kdj = pd.concat([df, k_d_j], axis=1)
return ccb_df_with_kdj
def on_get(self, req, resp):
data = k_data_dao.get_k_data('600196',
start='2018-01-01',
end='2018-07-01')
df = data[[
'date', 'open', 'close', 'low', 'high', 'volume', 'pre_close'
]]
df_json = df.to_json(orient='records')
print(df_json)
resp.context['result'] = df_json
def collect_single(code, start, end, table_name='k_data_tech_feature'):
data = k_data_dao.get_k_data(code,
start=start,
end=end,
cal_next_direction=False)
data, features = collect_features(data)
features.append('code')
features.append('date')
data = data[features]
data.to_sql(table_name,
dataSource.mysql_quant_engine,
if_exists='append',
index=False)
def hs_300_base_profit(self):
hs_df = k_data_dao.get_k_data(
'SH.000300',
start=self.context.start,
end=self.context.end,
futu_quote_ctx=self.context.futu_quote_ctx)
self.context.hs_300_profit = pd.DataFrame(
columns=['date', 'base_profit'])
self.context.hs_300_profit['date'] = pd.to_datetime(hs_df['time_key'],
format='%Y-%m-%d')
for i in range(0, len(hs_df['change_rate'])):
if i == 0:
self.context.hs_300_profit['base_profit'].loc[i] = hs_df[
'change_rate'][i]
else:
self.context.hs_300_profit['base_profit'].loc[i] = hs_df[
'change_rate'].loc[:i].sum()
print(self.context.hs_300_profit)
def cal_bk_vol():
bk_vol_frame = pd.DataFrame(columns=['bkcode', 'bk_name', 'total_mavol_3'])
filter_list = [
'BK0743', 'BK0804', 'BK0568', 'BK0707', 'BK0701', 'BK0611', 'BK0705',
'BK0612', 'BK0500'
]
org_bk_code_list = list(stock_industry_dao.get_bkcode_list().values)
bk_code_list = [c for c in org_bk_code_list if c not in filter_list]
for bk in bk_code_list:
bk_stocks = stock_industry_dao.get_by_bkcode(bk[0])
bk_vol3 = 0
try:
bk_name = bk_stocks['bk_name'][0]
except:
bk_name = 'N/A'
for code in bk_stocks['code'].values:
stock_df = k_data_dao.get_k_data(code=code,
start=get_next_date(-30),
end=get_current_date())
if len(stock_df) == 0:
continue
stock_df['mavol3'] = cal_mavol3(stock_df)
try:
bk_vol3 += stock_df['mavol3'].values[-1:][0]
except Exception as e:
logger.debug("code:%s, error:%s" % (code, repr(e)))
bk_vol_frame.loc[bk_vol_frame.shape[0] + 1] = {
'bkcode': bk,
'bk_name': bk_name,
'total_mavol_3': bk_vol3
}
bk_vol_frame = bk_vol_frame.sort_values('total_mavol_3', ascending=False)
bk_vol_frame.to_csv('bk_csv.csv', encoding='utf_8_sig')
def cal_single_stock(code):
#data = k_data_tech_feature_dao.get_k_data(code, start=get_next_date(-10), end=get_current_date())
#df_k_data = k_data_dao.get_k_data(code, start=get_next_date(-10), end=get_current_date())
data = k_data_dao.get_k_data(code)
data = data.join(acc_kdj(data))
data['ma10'] = cal_ma10(data)
data['ma5'] = cal_ma5(data)
price = data['close'].tail(1).values[0]
ma10 = data['ma10'].values[-1]
ma5 = data['ma5'].values[-1]
if price < ma5:
return None, None, None
if price < 4:
return None, None, None
label, k, d = cal_signal(data)
return label, k, d
def collect_quarter(code, start, end, year, quarter):
data = k_data_dao.get_k_data(code, start, end, cal_next_direction=False)
data_report = stock_performance_dao.get_by_code(code, year, quarter)
for index, row in data.iterrows():
try:
dict = [{
'code': code,
'date': row['date'],
'eps': data_report['eps'].values[0],
'eps_yoy': data_report['eps_yoy'].values[0],
'bvps': data_report['bvps'].values[0],
'roe': data_report['roe'].values[0],
'epcf': data_report['epcf'].values[0],
'net_profits': data_report['net_profits'].values[0],
'profits_yoy': data_report['profits_yoy'].values[0]
}]
df = pd.DataFrame(dict)
df.to_sql('k_data_stock_performance', dataSource.mysql_quant_engine, if_exists='append',
index=False)
except Exception as e:
logger.error("code:%s, error:%s" % (code, repr(e)))
def handle_data(self):
temp_target_list = pd.DataFrame(columns=['code', 'pe', 'pb', 'eps', 'm_cap'])
sh_index = k_data_dao.get_k_data('SH.000001', start=get_next_date(-30), end=get_next_date(-1))
# if sh_index['change_rate'].rolling(window=3).sum().values[-1] >= -0.039:
# for position in context.portfolio.positions[:]:
# code = position.code
# shares = position.shares
# price = position.price
# self.sell_value(code=code, shares=shares, price=price)
for code in self.context.pool:
stock_basic_info = stock_basic_dao.get_by_code(code=code)
if len(stock_basic_info) == 0:
continue
try:
pe_value = stock_basic_info['pe'].values[0]
pb_value = stock_basic_info['pb'].values[0]
eps_value = stock_basic_info['eps'].values[0]
m_cap = stock_basic_info['total_market'].values[0]
except:
pass
if pe_value < 20 and pb_value < 1.8 and eps_value > 0:
target_stock = {'code': code, 'pe': pe_value, 'pb': pb_value, 'eps': eps_value, 'm_cap': m_cap}
temp_target_list.loc[temp_target_list.shape[0] + 1] = target_stock
temp_target_stock = temp_target_list.sort_values('m_cap', ascending=False)[:5]
target_code_list = temp_target_stock['code'].values
current_stock_code = []
for positions in self.context.portfolio.positions:
current_stock_code.append(positions.code)
print(current_stock_code)
stock_to_be_added = [i for i in target_code_list if i not in current_stock_code]
stock_to_be_removed = [j for j in current_stock_code if j not in target_code_list]
for code in stock_to_be_removed:
# self.sell_value(code=code, price=price, shares=-1)
logger.info('direction = sell:' + code)
for code in stock_to_be_added:
#k_data = k_data_dao.get_k_data(code=code, start=self.context.current_date, end=self.context.current_date)
#if len(k_data) == 0:
#continue
#price = k_data['close'].values[-1]
#if len(self.context.portfolio.positions) >= 5:
#break
# self.buy_in_percent(code=code, price=price, percent=0.2)
k_data = k_data_dao.get_k_data(code=code, start=get_next_date(-2), end=self.context.current_date)
price = k_data['close'].values[-1]
shares = int(4000 / price / 100) * 100
print('direction = buy:%s, shares:%s'%(code, shares))
def handle_data(self):
target_frame = pd.DataFrame(columns=[
'code', 'close', 'k_value', 'd_value', 'pre_k', 'pre_d', 'macd',
'pre_macd', 'diff', 'pre_diff', 'dea', 'pre_dea',
'current_vol_weekly', 'pre_vol_weekly'
])
for code in self.context.pool:
try:
daily_stock_data = k_data_dao.get_k_data(
code=code,
start=get_next_date(days=-100, args=context.current_date),
end=self.context.current_date,
futu_quote_ctx=self.futu_quote_ctx)
weekly_stock_data = k_data_weekly_dao.get_k_data(
code=code,
start='2013-01-01',
end=get_next_date(-5),
futu_quote_ctx=self.futu_quote_ctx)
pre_vol_weely = weekly_stock_data['volume'].iloc[-2:].values[0]
current_vol_weekly = weekly_stock_data['volume'].iloc[
-1:].values[0]
daily_stock_data = daily_stock_data.join(
acc_kdj(daily_stock_data))
daily_stock_data_withf = daily_stock_data.join(
cal_macd(daily_stock_data))
daily_stock_data_withf['ma5'] = cal_ma20(
daily_stock_data_withf)
k_value = daily_stock_data_withf['k_value'].iloc[-1:].values[0]
d_value = daily_stock_data_withf['d_value'].iloc[-1:].values[0]
pre_k = daily_stock_data_withf['k_value'].iloc[-2:].values[0]
pre_d = daily_stock_data_withf['d_value'].iloc[-2:].values[0]
pre_macd_value = daily_stock_data_withf['macd'].iloc[
-2:].values[0]
current_macd_value = daily_stock_data_withf['macd'].iloc[
-1:].values[0]
pre_macd_diff = daily_stock_data_withf['diff'].iloc[
-2:].values[0]
macd_diff = daily_stock_data_withf['diff'].iloc[-1:].values[0]
pre_macd_dea = daily_stock_data_withf['dea'].iloc[-2:].values[
0]
macd_dea = daily_stock_data_withf['dea'].iloc[-1:].values[0]
last_close = daily_stock_data_withf['close'].iloc[-1:].values[
0]
# 金叉
# and current_macd_value >= current_macd_signal and pre_macd_value < current_macd_value and current_vol_weekly / pre_vol_weely >= 1.3
# (k_value >= d_value or 10 >= abs(pre_k - pre_d) >= abs(k_value - d_value))
# k_value >= d_value and abs(k_value - d_value) <= 5
if (k_value >= d_value or abs(k_value - d_value) <= 10) and pre_k <= pre_d \
and ((macd_diff > macd_dea and pre_macd_diff < pre_macd_dea) or (macd_diff-macd_dea) < (pre_macd_diff-macd_dea) and 0.05 >= current_macd_value >= 0) \
and current_vol_weekly / pre_vol_weely >= 1.5:
target_stock = {
'code': self.fill_zero(code),
'close': last_close,
'k_value': k_value,
'd_value': d_value,
'pre_k': pre_k,
'pre_d': pre_d,
'macd': current_macd_value,
'pre_macd': pre_macd_value,
'diff': macd_diff,
'pre_diff': pre_macd_diff,
'dea': macd_dea,
'pre_dea': pre_macd_dea,
'current_vol_weekly': current_vol_weekly,
'pre_vol_weekly': pre_vol_weely,
}
target_frame.loc[target_frame.shape[0] + 1] = target_stock
print(target_stock)
# self.buy_in_percent(code=code, price=last_close, percent=0.1)
except:
continue
target_frame.to_csv('kdj_result.csv')
def test_fill_k_data(self):
code = '603799'
data = k_data_dao.get_k_data(code, start='2015-01-01', end='2018-06-01')
data = stock_structure_dao.fill_stock_structure(code, data)
data.to_csv('result.csv')
# ae_h - 2018/7/16
from config import default_config
from dao.k_data.k_data_dao import k_data_dao
import futuquant as ft
df = k_data_dao.get_k_data(code='000528',
start='2010-01-01',
end='2017-01-01',
futu_quote_ctx=ft.OpenQuoteContext(
host=default_config.FUTU_OPEND_HOST,
port=default_config.FUTU_OPEND_PORT))
print(df)
