def sample_231():
"""
2.3.1 类的封装
:return:
"""
price_array = '30.14,29.58,26.36,32.56,32.82'.split(',')
date_base = 20170118
# 从StockTradeDays类初始化一个实例对象trade_days，内部会调用__init__
trade_days = StockTradeDays(price_array, date_base)
# 打印对象信息
print('trade_days:', trade_days)
print('trade_days对象长度为: {}'.format(len(trade_days)))
from collections import Iterable
# 如果是trade_days是可迭代对象，依次打印出
if isinstance(trade_days, Iterable):
for day in trade_days:
print(day)
print(trade_days.filter_stock())
# 两年的TSLA收盘数据 to list
price_array = ABuSymbolPd.make_kl_df('TSLA', n_folds=2).close.tolist()
# 两年的TSLA收盘日期 to list，这里的写法不考虑效率，只做演示使用
date_array = ABuSymbolPd.make_kl_df('TSLA', n_folds=2).date.tolist()
print('price_array[:5], date_array[:5]:', price_array[:5], date_array[:5])
trade_days = StockTradeDays(price_array, date_base, date_array)
print('trade_days对象长度为: {}'.format(len(trade_days)))
print('最后一天交易数据为：{}'.format(trade_days[-1]))
def sample_54_2():
"""
5.4 使用seaborn可视化数据
:return:
"""
change_df = pd.DataFrame({'tsla': tsla_df.p_change})
# join usGOOG
change_df = change_df.join(pd.DataFrame({'goog': ABuSymbolPd.make_kl_df('usGOOG', n_folds=2).p_change}),
how='outer')
# join usAAPL
change_df = change_df.join(pd.DataFrame({'aapl': ABuSymbolPd.make_kl_df('usAAPL', n_folds=2).p_change}),
how='outer')
# join usFB
change_df = change_df.join(pd.DataFrame({'fb': ABuSymbolPd.make_kl_df('usFB', n_folds=2).p_change}),
how='outer')
# join usBIDU
change_df = change_df.join(pd.DataFrame({'bidu': ABuSymbolPd.make_kl_df('usBIDU', n_folds=2).p_change}),
how='outer')
change_df = change_df.dropna()
# 表5-2所示
print('change_df.head():\n', change_df.head())
# 使用corr计算数据的相关性
corr = change_df.corr()
_, ax = plt.subplots(figsize=(8, 5))
# sns.heatmap热力图展示每组股票涨跌幅的相关性
sns.heatmap(corr, ax=ax)
plt.show()
def sample_233_2():
"""
2.3.3_2 静态类方法@classmethod与@staticmethod
:return:
"""
# 两年的TSLA收盘数据 to list
price_array = ABuSymbolPd.make_kl_df('TSLA', n_folds=2).close.tolist()
# 两年的TSLA收盘日期 to list，这里的写法不考虑效率，只做演示使用
date_array = ABuSymbolPd.make_kl_df('TSLA', n_folds=2).date.tolist()
trade_days = StockTradeDays(price_array, 0, date_array)
trade_strategy2 = TradeStrategy2()
trade_loop_back = TradeLoopBack(trade_days, trade_strategy2)
trade_loop_back.execute_trade()
print('回测策略2 总盈亏为：{}%'.format(reduce(lambda a, b: a + b, trade_loop_back.profit_array) * 100))
plt.plot(np.array(trade_loop_back.profit_array).cumsum())
plt.show()
# 实例化一个新的TradeStrategy2类对象
trade_strategy2 = TradeStrategy2()
# 修改为买入后持有股票20天，默认为10天
TradeStrategy2.set_keep_stock_threshold(20)
# 修改股价下跌买入阀值为-0.08（下跌8%），默认为-0.10（下跌10%）
TradeStrategy2.set_buy_change_threshold(-0.08)
# 实例化新的回测对象trade_loop_back
trade_loop_back = TradeLoopBack(trade_days, trade_strategy2)
# 执行回测
trade_loop_back.execute_trade()
print('回测策略2 总盈亏为：{}%'.format(reduce(lambda a, b: a + b, trade_loop_back.profit_array) * 100))
# 可视化回测结果
plt.plot(np.array(trade_loop_back.profit_array).cumsum())
plt.show()
def sample_231():
"""
2.3.1 类的封装
:return:
"""
price_array = '30.14,29.58,26.36,32.56,32.82'.split(',')
date_base = 20170118
# 从StockTradeDays类初始化一个实例对象trade_days，内部会调用__init__
trade_days = StockTradeDays(price_array, date_base)
# 打印对象信息
print('trade_days:', trade_days)
print('trade_days对象长度为: {}'.format(len(trade_days)))
from collections import Iterable
# 如果是trade_days是可迭代对象，依次打印出
if isinstance(trade_days, Iterable):
for day in trade_days:
print(day)
print(trade_days.filter_stock())
# 两年的TSLA收盘数据 to list
price_array = ABuSymbolPd.make_kl_df('TSLA', n_folds=2).close.tolist()
# 两年的TSLA收盘日期 to list，这里的写法不考虑效率，只做演示使用
date_array = ABuSymbolPd.make_kl_df('TSLA', n_folds=2).date.tolist()
print('price_array[:5], date_array[:5]:', price_array[:5], date_array[:5])
trade_days = StockTradeDays(price_array, date_base, date_array)
print('trade_days对象长度为: {}'.format(len(trade_days)))
print('最后一天交易数据为：{}'.format(trade_days[-1]))
def sample_233_2():
"""
2.3.3_2 静态类方法@classmethod与@staticmethod
:return:
"""
# 两年的TSLA收盘数据 to list
price_array = ABuSymbolPd.make_kl_df('TSLA', n_folds=2).close.tolist()
# 两年的TSLA收盘日期 to list，这里的写法不考虑效率，只做演示使用
date_array = ABuSymbolPd.make_kl_df('TSLA', n_folds=2).date.tolist()
trade_days = StockTradeDays(price_array, 0, date_array)
trade_strategy2 = TradeStrategy2()
trade_loop_back = TradeLoopBack(trade_days, trade_strategy2)
trade_loop_back.execute_trade()
print('回测策略2 总盈亏为：{}%'.format(
reduce(lambda a, b: a + b, trade_loop_back.profit_array) * 100))
plt.plot(np.array(trade_loop_back.profit_array).cumsum())
plt.show()
# 实例化一个新的TradeStrategy2类对象
trade_strategy2 = TradeStrategy2()
# 修改为买入后持有股票20天，默认为10天
TradeStrategy2.set_keep_stock_threshold(20)
# 修改股价下跌买入阀值为-0.08（下跌8%），默认为-0.10（下跌10%）
TradeStrategy2.set_buy_change_threshold(-0.08)
# 实例化新的回测对象trade_loop_back
trade_loop_back = TradeLoopBack(trade_days, trade_strategy2)
# 执行回测
trade_loop_back.execute_trade()
print('回测策略2 总盈亏为：{}%'.format(
reduce(lambda a, b: a + b, trade_loop_back.profit_array) * 100))
# 可视化回测结果
plt.plot(np.array(trade_loop_back.profit_array).cumsum())
plt.show()
def sample_54_2():
"""
5.4 使用seaborn可视化数据
:return:
"""
change_df = pd.DataFrame({'tsla': tsla_df.p_change})
# join usGOOG
change_df = change_df.join(pd.DataFrame(
{'goog': ABuSymbolPd.make_kl_df('usGOOG', n_folds=2).p_change}),
how='outer')
# join usAAPL
change_df = change_df.join(pd.DataFrame(
{'aapl': ABuSymbolPd.make_kl_df('usAAPL', n_folds=2).p_change}),
how='outer')
# join usFB
change_df = change_df.join(pd.DataFrame(
{'fb': ABuSymbolPd.make_kl_df('usFB', n_folds=2).p_change}),
how='outer')
# join usBIDU
change_df = change_df.join(pd.DataFrame(
{'bidu': ABuSymbolPd.make_kl_df('usBIDU', n_folds=2).p_change}),
how='outer')
change_df = change_df.dropna()
# 表5-2所示
print('change_df.head():\n', change_df.head())
# 使用corr计算数据的相关性
corr = change_df.corr()
_, ax = plt.subplots(figsize=(8, 5))
# sns.heatmap热力图展示每组股票涨跌幅的相关性
sns.heatmap(corr, ax=ax)
plt.show()
def get():
#两年的TSLA收盘数据tolist()
price_array = ABuSymbolPd.make_kl_df('TSLA', n_folds=2).close.tolist()
#两年的TSLA收盘日期tolist()
date_array = ABuSymbolPd.make_kl_df('TSLA', n_folds=2).date.tolist()
# print(price_array[:5])
# print(date_array[:5])
# print(date_array)
return price_array, date_array
def sample_102(show=True):
"""
10.2 生成猪老三的世界中的映射股票数据
:return:
"""
choice_symbols = ['usNOAH', 'usSFUN', 'usBIDU', 'usAAPL', 'usGOOG',
'usTSLA', 'usWUBA', 'usVIPS']
another_word_dict = {}
real_dict = {}
for symbol in choice_symbols:
# 猪老三世界的股票走势字典
another_word_dict[symbol] = change_real_to_another_word(symbol)
# 真实世界的股票走势字典，这里不考虑运行效率问题
real_dict[symbol] = ABuSymbolPd.make_kl_df(symbol)
if show:
# 表10-1所示
print('another_word_dict[usNOAH].head():\n', another_word_dict['usNOAH'].head())
print('real_dict[usNOAH].head():\n', real_dict['usNOAH'].head().filter(['close', 'date_week', 'volume']))
import itertools
# 4 ＊ 2
_, axs = plt.subplots(nrows=4, ncols=2, figsize=(20, 15))
# 将画布序列拉平
axs_list = list(itertools.chain.from_iterable(axs))
for symbol, ax in zip(choice_symbols, axs_list):
# 绘制猪老三世界的股价走势
another_word_dict[symbol].close.plot(ax=ax)
# 同样的股票在真实世界的股价走势
real_dict[symbol].close.plot(ax=ax)
ax.set_title(symbol)
plt.show()
return another_word_dict
def sample_102(show=True):
"""
10.2 生成猪老三的世界中的映射股票数据
:return:
"""
choice_symbols = ['usNOAH', 'usSFUN', 'usBIDU', 'usAAPL', 'usGOOG',
'usTSLA', 'usWUBA', 'usVIPS']
another_word_dict = {}
real_dict = {}
for symbol in choice_symbols:
# 猪老三世界的股票走势字典
another_word_dict[symbol] = change_real_to_another_word(symbol)
# 真实世界的股票走势字典，这里不考虑运行效率问题
real_dict[symbol] = ABuSymbolPd.make_kl_df(symbol)
if show:
# 表10-1所示
print('another_word_dict[usNOAH].head():\n', another_word_dict['usNOAH'].head())
print('real_dict[usNOAH].head():\n', real_dict['usNOAH'].head().filter(['close', 'date_week', 'volume']))
import itertools
# 4 ＊ 2
_, axs = plt.subplots(nrows=4, ncols=2, figsize=(20, 15))
# 将画布序列拉平
axs_list = list(itertools.chain.from_iterable(axs))
for symbol, ax in zip(choice_symbols, axs_list):
# 绘制猪老三世界的股价走势
another_word_dict[symbol].close.plot(ax=ax)
# 同样的股票在真实世界的股价走势
real_dict[symbol].close.plot(ax=ax)
ax.set_title(symbol)
plt.show()
return another_word_dict
def plot_trend(symbol='usTSLA',
n_folds=1,
only_last=False,
how='both',
show_step=False):
n_folds = int(n_folds)
# 获取symbol的n_folds年数据
kl = ABuSymbolPd.make_kl_df(symbol, n_folds=n_folds)
# 构造技术线对象
kl_tl = tl.AbuTLine(kl.close, 'kl')
if how == 'support':
# 只绘制支持线
kl_tl.show_support_trend(only_last=only_last,
show=True,
show_step=show_step)
elif how == 'resistance':
# 只绘制阻力线
kl_tl.show_resistance_trend(only_last=only_last,
show=True,
show_step=show_step)
else:
# 支持线和阻力线都绘制
kl_tl.show_support_resistance_trend(only_last=only_last,
show=True,
show_step=show_step)
def get_close_line(self):
self.kl_df = ABuSymbolPd.make_kl_df(self.symbol, n_folds=2)
closeValueList = self.kl_df["close"].values.tolist()
closeDayList = self.kl_df["close"].index.tolist()
closeDayList = [str(i.strftime("%Y%m%d")) for i in closeDayList]
return closeDayList, closeValueList
def sample_232():
"""
2.3.2 继承和多态
:return:
"""
# 两年的TSLA收盘数据 to list
price_array = ABuSymbolPd.make_kl_df('TSLA', n_folds=2).close.tolist()
# 两年的TSLA收盘日期 to list，这里的写法不考虑效率，只做演示使用
date_array = ABuSymbolPd.make_kl_df('TSLA', n_folds=2).date.tolist()
trade_days = StockTradeDays(price_array, 0, date_array)
trade_loop_back = TradeLoopBack(trade_days, TradeStrategy1())
trade_loop_back.execute_trade()
print('回测策略1 总盈亏为：{}%'.format(reduce(lambda a, b: a + b, trade_loop_back.profit_array) * 100))
plt.plot(np.array(trade_loop_back.profit_array).cumsum())
plt.show()
def sample_232():
"""
2.3.2 继承和多态
:return:
"""
# 两年的TSLA收盘数据 to list
price_array = ABuSymbolPd.make_kl_df('TSLA', n_folds=2).close.tolist()
# 两年的TSLA收盘日期 to list，这里的写法不考虑效率，只做演示使用
date_array = ABuSymbolPd.make_kl_df('TSLA', n_folds=2).date.tolist()
trade_days = StockTradeDays(price_array, 0, date_array)
trade_loop_back = TradeLoopBack(trade_days, TradeStrategy1())
trade_loop_back.execute_trade()
print('回测策略1 总盈亏为：{}%'.format(reduce(lambda a, b: a + b, trade_loop_back.profit_array) * 100))
plt.plot(np.array(trade_loop_back.profit_array).cumsum())
plt.show()
def sample_233_1():
"""
2.3.3_1 property属性
:return:
"""
trade_strategy1 = TradeStrategy1()
# 买入阀值从0.07上升到0.1
trade_strategy1.buy_change_threshold = 0.1
# 两年的TSLA收盘数据 to list
price_array = ABuSymbolPd.make_kl_df('TSLA', n_folds=2).close.tolist()
# 两年的TSLA收盘日期 to list，这里的写法不考虑效率，只做演示使用
date_array = ABuSymbolPd.make_kl_df('TSLA', n_folds=2).date.tolist()
trade_days = StockTradeDays(price_array, 0, date_array)
trade_loop_back = TradeLoopBack(trade_days, trade_strategy1)
trade_loop_back.execute_trade()
print('回测策略1 总盈亏为：{}%'.format(reduce(lambda a, b: a + b, trade_loop_back.profit_array) * 100))
# 可视化profit_array
plt.plot(np.array(trade_loop_back.profit_array).cumsum())
plt.show()
def sample_a21():
"""
A.2.1 数据模式的切换
:return:
"""
# 表A-1所示
print(ABuSymbolPd.make_kl_df('601398').tail())
# 局部使用enable_example_env_ipython，示例
abupy.env.enable_example_env_ipython()
# 如果本地有相应股票的缓存，可以使用如下代码强制使用本地缓存数据
# abupy.env.g_data_fetch_mode = EMarketDataFetchMode.E_DATA_FETCH_FORCE_LOCAL
# 设置初始资金数
read_cash = 1000000
# 择时股票池
choice_symbols = [
'usNOAH', 'usSFUN', 'usBIDU', 'usAAPL', 'usGOOG', 'usTSLA', 'usWUBA',
'usVIPS'
]
# 使用run_loop_back运行策略
abu_result_tuple, _ = abu.run_loop_back(read_cash,
buy_factors,
sell_factors,
stock_pickers,
choice_symbols=choice_symbols,
n_folds=2)
metrics = AbuMetricsBase(*abu_result_tuple)
metrics.fit_metrics()
metrics.plot_returns_cmp()
# *****************************************************************************************************************
# 切换数据源
abupy.env.g_market_source = EMarketSourceType.E_MARKET_SOURCE_tx
# 强制走网络数据源
abupy.env.g_data_fetch_mode = EMarketDataFetchMode.E_DATA_FETCH_FORCE_NET
# 择时股票池
choice_symbols = [
'601398', '600028', '601857', '601318', '600036', '000002', '600050',
'600030'
]
# 使用run_loop_back运行策略
abu_result_tuple, _ = abu.run_loop_back(read_cash,
buy_factors,
sell_factors,
stock_pickers,
choice_symbols=choice_symbols,
n_folds=2)
metrics = AbuMetricsBase(*abu_result_tuple)
metrics.fit_metrics()
metrics.plot_returns_cmp()
def sample_233_1():
"""
2.3.3_1 property属性
:return:
"""
trade_strategy1 = TradeStrategy1()
# 买入阀值从0.07上升到0.1
trade_strategy1.buy_change_threshold = 0.1
# 两年的TSLA收盘数据 to list
price_array = ABuSymbolPd.make_kl_df('TSLA', n_folds=2).close.tolist()
# 两年的TSLA收盘日期 to list，这里的写法不考虑效率，只做演示使用
date_array = ABuSymbolPd.make_kl_df('TSLA', n_folds=2).date.tolist()
trade_days = StockTradeDays(price_array, 0, date_array)
trade_loop_back = TradeLoopBack(trade_days, trade_strategy1)
trade_loop_back.execute_trade()
print('回测策略1 总盈亏为：{}%'.format(reduce(lambda a, b: a + b, trade_loop_back.profit_array) * 100))
# 可视化profit_array
plt.plot(np.array(trade_loop_back.profit_array).cumsum())
plt.show()
def change_real_to_another_word(symbol):
"""
将原始真正的股票数据只保留价格的头两个，量，周几，将其它价格使用_gen_another_word_price变成另一个世界价格
:param symbol:
:return:
"""
kl_pd = ABuSymbolPd.make_kl_df(symbol)
if kl_pd is not None:
kl_dream = kl_pd.filter(['close', 'date_week', 'volume'])
# 只保留原始头两天的交易收盘价格
kl_dream['close'][2:] = np.nan
# 将其它价格变成另一个世界中价格
_gen_another_word_price(kl_dream)
return kl_dream
def change_real_to_another_word(symbol):
"""
将原始真正的股票数据只保留价格的头两个，量，周几，将其它价格使用_gen_another_word_price变成另一个世界价格
:param symbol:
:return:
"""
kl_pd = ABuSymbolPd.make_kl_df(symbol)
if kl_pd is not None:
kl_dream = kl_pd.filter(['close', 'date_week', 'volume'])
# 只保留原始头两天的交易收盘价格
kl_dream['close'][2:] = np.nan
# 将其它价格变成另一个世界中价格
_gen_another_word_price(kl_dream)
return kl_dream
def change_real_to_another_word(symbol):
"""
将原始真正的股票数据价格只保留前两天数据，成交量，周几列完全保留，价格列其他数据使用_gen_another_word_price,变成另一个世界价格
:param symbol:
:return:
"""
kl_pd = ABuSymbolPd.make_kl_df(symbol)
if kl_pd is not None:
#原始股票数据只保留价格、周几和成交量
kl_fairy_tale = kl_pd.filter(['close', 'date_week', 'volume'])
#只保留头两天的原始交易收盘价格，其他都赋予nan
kl_fairy_tale['close'][2:] = np.nan
#将其他nan价格变成童话世界的价格需使用_gen_another_word_price
_gen_another_word_price(kl_fairy_tale)
return kl_fairy_tale
def sample_c1():
"""
C.1 量化统计分析应用
:return:
"""
tsla_df = ABuSymbolPd.make_kl_df('usTSLA', n_folds=2)
jumps = tl.jump.calc_jump(tsla_df)
print('jumps:\n', jumps)
# sw[0]代表非时间因素的jump_power，sw[1]代表时间加权因素的jump_power，当sw[0]=1时与非加权方式相同，具体实现请参考源代码
filter_jumps = tl.jump.calc_jump_line_weight(tsla_df, sw=(0.5, 0.5))
print('filter_jumps:\n', filter_jumps)
# tl.wave.calc_wave_abs()函数可视化价格波动情况
tl.wave.calc_wave_abs(tsla_df, xd=21, show=True)
def change_real_to_another_word(symbol):
"""
将原始真正的股票数据价格列只保留前两天数据，成交量，周几列完全保留
价格列其他数据使用_gen_another_word_price变成另一个世界价格
:param symbol:
:return:
"""
kl_pd = ABuSymbolPd.make_kl_df(symbol)
if kl_pd is not None:
# 原始股票数据也只保留价格，周几，成交量
kl_pig_three = kl_pd.filter(['close', 'date_week', 'volume'])
# 只保留原始头两天的交易收盘价格，其他的的都赋予nan
kl_pig_three['close'][2:] = np.nan
# 将其他nan价格变成猪老三世界中价格使用_gen_another_word_price
_gen_another_word_price(kl_pig_three)
return kl_pig_three
def sample_c1():
"""
C.1 量化统计分析应用
:return:
"""
tsla_df = ABuSymbolPd.make_kl_df('usTSLA', n_folds=2)
jumps = tl.jump.calc_jump(tsla_df)
print('jumps:\n', jumps)
# sw[0]代表非时间因素的jump_power，sw[1]代表时间加权因素的jump_power，当sw[0]=1时与非加权方式相同，具体实现请参考源代码
filter_jumps = tl.jump.calc_jump_line_weight(tsla_df, sw=(0.5, 0.5))
print('filter_jumps:\n', filter_jumps)
# tl.wave.calc_wave_abs()函数可视化价格波动情况
tl.wave.calc_wave_abs(tsla_df, xd=21, show=True)
def sample_12():
from abupy import ABuRegUtil
# kl_pd = ABuSymbolPd.make_kl_df('601398', start='2015-03-01', end='2015-04-01', parallel=False, n_folds=1)
kl_pd = ABuSymbolPd.make_kl_df('601398',
start='2011-03-01',
parallel=False,
n_folds=1)
deg = ABuRegUtil.calc_regress_deg(kl_pd.close.values, show=False)
print('趋势角度:' + str(deg))
pd = calc_wave_std(kl_pd, show=False)
print(pd)
print(pd.high)
print(pd.low)
print(pd.close)
def change_real_to_another_word(symbol):
"""
将原始真正的股票数据价格列只保留前两天数据，成交量，周几列完全保留
价格列其他数据使用_gen_another_word_price变成另一个世界价格
:param symbol:
:return:
"""
kl_pd = ABuSymbolPd.make_kl_df(symbol)
if kl_pd is not None:
# 原始股票数据也只保留价格，周几，成交量
kl_pig_three = kl_pd.filter(['close', 'date_week', 'volume'])
# 只保留原始头两天的交易收盘价格，其他的的都赋予nan
kl_pig_three['close'][2:] = np.nan
# 将其他nan价格变成猪老三世界中价格使用_gen_another_word_price
_gen_another_word_price(kl_pig_three)
return kl_pig_three
def sample_13():
kl_pd = ABuSymbolPd.make_kl_df(
'601398',
data_mode=ABuEnv.EMarketDataSplitMode.E_DATA_SPLIT_UNDO,
start='2012-04-20',
end='2018-04-20',
parallel=False)
print(kl_pd)
# kl_pd.to_csv("/Users/juchen/abu/601398.csv")
upper, middle, lower = calc_boll(kl_pd.close, 20, 2)
print(middle)
print(lower)
rsi = calc_rsi(kl_pd.close)
print(rsi)
abupy.nd.boll.plot_boll_from_klpd(kl_pd)
abupy.nd.rsi.plot_rsi_from_klpd(kl_pd)
def sample_a21():
# 局部使用enable_example_env_ipython，示例
# abupy.env.enable_example_env_ipython()
# abupy.env.disable_example_env_ipython()
# 如果本地有相应股票的缓存，可以使用如下代码强制使用本地缓存数据
# 设置初始资金数
read_cash = 1000000
# *****************************************************************************************************************
# 切换数据源
# 强制走网络数据源
# abupy.env.g_data_cache_type = EMarketDataFetchMode.E_DATA_CACHE_HDF5
# 择时股票池
# choice_symbols = ['601398', '600028', '601857', '601318', '600036', '000002', '600050', '600030']
choice_symbols = ['600036']
print(ABuSymbolPd.make_kl_df('603993', parallel=False).tail())
def sample_macd():
# kl_pd = ABuSymbolPd.make_kl_df('601398', start='2017-12-01', end='2018-03-02', parallel=False, n_folds=4)
kl_pd = ABuSymbolPd.make_kl_df('601398', parallel=False, n_folds=4)
# print(calc_wave_abs(kl_pd, show=False))
dif, dea, bar = calc_macd(kl_pd.close)
print(dif)
print(dea)
print(bar)
for row in kl_pd.iterrows(): # 获取每行的index、row
# print(type(row[1]))
# print(row[1])
# print(len(row))
if int(row[1].key) == 0:
continue
pre_i = int(row[1].key) - 1
now_i = int(row[1].key)
if dif[pre_i] < dea[pre_i] and dif[now_i] >= dea[now_i]:
print(row[0])
None,
'stock',
day_sum=False,
html_bk=False,
save=False)
print('type(df_stock0_5.open.values):', type(df_stock0_5['open'].values))
print('df_stock0_5.open.index:\n', df_stock0_5['open'].index)
print('df_stock0_5.columns:\n', df_stock0_5.columns)
"""
4.2 基本数据分析示例
"""
# n_folds=2两年
tsla_df = ABuSymbolPd.make_kl_df('usTSLA', n_folds=2)
def sample_420():
# 表4-7所示
print('tsla_df.tail():\n', tsla_df.tail())
def sample_421():
"""
4.2.1 数据整体分析
:return:
"""
print('tsla_df.info():\n', tsla_df.info())
print('tsla_df.describe():\n', tsla_df.describe())
def sample_15():
# kl_pd = ABuSymbolPd.make_kl_df('601398', start='2017-12-01', end='2018-03-02', parallel=False, n_folds=4)
kl_pd = ABuSymbolPd.make_kl_df('601398', parallel=False, n_folds=4)
# print(calc_wave_abs(kl_pd, show=False))
print(calc_wave_std(kl_pd))
url = HBNApi.K_NET_BASE % (req_cnt, symbol_name)
data = ABuNetWork.get(url=url, timeout=K_TIME_OUT)
json_data = data.json()
kl_df = self.data_parser_cls(self._symbol, json_data['data']).df
if kl_df is None:
return None
return TCBaseMarket._fix_kline_pd(kl_df, n_folds, start, end)
def minute(self, *args, **kwargs):
"""分钟k线接口"""
raise NotImplementedError('HBNApi minute NotImplementedError!')
# abupy.env.g_market_source = EMarketSourceType.E_MARKET_SOURCE_tx
# symbol = code_to_symbol('usFB')
# us_jd = ABuSymbolPd.make_kl_df(symbol)
abupy.env.disable_example_env_ipython()
# 切换到币市
abupy.env.g_market_source = EMarketSourceType.E_MARKET_SOURCE_tx
us_jd = ABuSymbolPd.make_kl_df('usFB')
btc = ABuSymbolPd.make_kl_df('usFB', start='2015-09-01', end='2019-06-22')
# 再次开启沙盒环境，本节的示例都是在沙盒数据环境下运行
# abupy.env.enable_example_env_ipython()
tail = None
if us_jd is not None:
tail = us_jd.tail()
tail
print(tail)
print(btc)
import pandas as pd
import seaborn as sns
# noinspection PyUnresolvedReferences
import abu_local_env
import abupy
from abupy import ABuSymbolPd
from abupy import six, xrange
from abc import ABCMeta, abstractmethod
warnings.filterwarnings('ignore')
sns.set_context(rc={'figure.figsize': (14, 7)})
# 使用沙盒数据，目的是和书中一样的数据环境
abupy.env.enable_example_env_ipython()
tsla_close = ABuSymbolPd.make_kl_df('usTSLA').close
# x序列: 0，1，2, ...len(tsla_close)
x = np.arange(0, tsla_close.shape[0])
# 收盘价格序列
y = tsla_close.values
"""
第六章 量化工具——数学：你一生的追求到底能带来多少幸福
abu量化系统github地址：https://github.com/bbfamily/abu (您的star是我的动力！)
abu量化文档教程ipython notebook：https://github.com/bbfamily/abu/tree/master/abupy_lecture
"""
def sample_611_1(show=True):
"""
6.1.1 线性回归
import seaborn as sns
# noinspection PyUnresolvedReferences
import abu_local_env
import abupy
from abupy import ABuSymbolPd
from abupy import six, xrange
from abc import ABCMeta, abstractmethod
warnings.filterwarnings('ignore')
sns.set_context(rc={'figure.figsize': (14, 7)})
# 使用沙盒数据，目的是和书中一样的数据环境
abupy.env.enable_example_env_ipython()
tsla_close = ABuSymbolPd.make_kl_df('usTSLA').close
# x序列: 0，1，2, ...len(tsla_close)
x = np.arange(0, tsla_close.shape[0])
# 收盘价格序列
y = tsla_close.values
"""
第六章 量化工具——数学：你一生的追求到底能带来多少幸福
abu量化系统github地址：https://github.com/bbfamily/abu (您的star是我的动力！)
abu量化文档教程ipython notebook：https://github.com/bbfamily/abu/tree/master/abupy_lecture
"""
def sample_611_1(show=True):
# 可视化的内容
import pandas as pd
import numpy as np
from abupy import ABuSymbolPd
import matplotlib.pyplot as plt
tsla_df = ABuSymbolPd.make_kl_df('usTSLA', n_folds=2)
tsla_df.tail()
def plot_demo(axs=None, just_series=False):
drawer = plt if axs is None else axs
drawer.plot(tsla_df.close, c='r')
if not just_series:
drawer.plot(tsla_df.close.index, tsla_df.close.values + 10, c='g')
drawer.plot(tsla_df.close.index.tolist(),
(tsla_df.close.values + 20).tolist(),
c='b')
plt.xlabel('time')
plt.ylabel('close')
plt.title('TSLA CLOSE')
plt.grid(True)
plot_demo()
# 子画布以及 loc 的指定
_, axs = plt.subplots(nrows=2, ncols=2, figsize=(14, 10))
# 画布0, loc 0
"""
for ind, day in enumerate(self.trade_days):
"""
以时间驱动，完成交易回测
"""
if self.trade_strategy.keep_stock_day > 0:
# 如果有持有股票，加入交易盈亏结果序列
self.profit_array.append(day.change)
# hasattr: 用来查询对象有没有实现某个方法
if hasattr(self.trade_strategy, 'buy_strategy'):
# 买入策略执行
self.trade_strategy.buy_strategy(ind, day, self.trade_days)
if hasattr(self.trade_strategy, 'sell_strategy'):
# 卖出策略执行
self.trade_strategy.sell_strategy(ind, day, self.trade_days)
price_array = ABuSymbolPd.make_kl_df('TSLA', n_folds=2).close.tolist()
# 两年的TSLA收盘日期 to list，这里的写法不考虑效率，只做演示使用
date_array = ABuSymbolPd.make_kl_df('TSLA', n_folds=2).date.tolist()
date_base = 20170118
trade_days = StockTradeDays(price_array, date_base, date_array)
trade_loop_back = TradeLoopBack(trade_days, TradeStrategy1())
trade_loop_back.execute_trade()
print('TradeLoopBack Strategy 1 {}%'.format(
reduce(lambda a, b: a + b, trade_loop_back.profit_array) * 100))
import numpy as np
import pandas as pd
import seaborn as sns
from scipy import stats
# noinspection PyUnresolvedReferences
import abu_local_env
import abupy
from abupy import ABuSymbolPd
from abupy import pd_rolling_std, pd_ewm_std, pd_rolling_mean
warnings.filterwarnings('ignore')
sns.set_context(rc={'figure.figsize': (14, 7)})
# 使用沙盒数据，目的是和书中一样的数据环境
abupy.env.enable_example_env_ipython()
tsla_df = ABuSymbolPd.make_kl_df('usTSLA', n_folds=2)
"""
第五章 量化工具——可视化
abu量化系统github地址：https://github.com/bbfamily/abu (您的star是我的动力！)
abu量化文档教程ipython notebook：https://github.com/bbfamily/abu/tree/master/abupy_lecture
"""
# noinspection PyUnresolvedReferences
def plot_demo(axs=None, just_series=False):
"""
绘制tsla的收盘价格曲线
:param axs: axs为子画布，稍后会详细讲解
:param just_series: 是否只绘制一条收盘曲线使用series，后面会用到
:return:
import numpy as np
import pandas as pd
import seaborn as sns
from scipy import stats
# noinspection PyUnresolvedReferences
import abu_local_env
import abupy
from abupy import ABuSymbolPd
from abupy import pd_rolling_std, pd_ewm_std, pd_rolling_mean
warnings.filterwarnings('ignore')
sns.set_context(rc={'figure.figsize': (14, 7)})
# 使用沙盒数据，目的是和书中一样的数据环境
abupy.env.enable_example_env_ipython()
tsla_df = ABuSymbolPd.make_kl_df('usTSLA', n_folds=2)
"""
第五章 量化工具——可视化
abu量化系统github地址：https://github.com/bbfamily/abu (您的star是我的动力！)
abu量化文档教程ipython notebook：https://github.com/bbfamily/abu/tree/master/abupy_lecture
"""
# noinspection PyUnresolvedReferences
def plot_demo(axs=None, just_series=False):
"""
绘制tsla的收盘价格曲线
:param axs: axs为子画布，稍后会详细讲解
:param just_series: 是否只绘制一条收盘曲线使用series，后面会用到
def sample_14():
kl_pd = ABuSymbolPd.make_kl_df('601398', parallel=False, n_folds=4)
print(kl_pd.head())
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import abupy
from abupy import abu, AbuFactorBuyTD, BuyCallMixin, ABuSymbolPd, ABuKLUtil, EMarketSourceType
from abupy import AbuFactorSellNDay, AbuMetricsBase, ABuProgress
us_choice_symbols = [
'usSYK', 'usVAR', 'usJNJ', 'usMDT', 'usBSX', 'usISRG', 'usCAH', 'usABT'
]
kl_dict = {
us_symbol[2:]: ABuSymbolPd.make_kl_df(us_symbol,
start='2017-01-01',
end='2018-01-01')
for us_symbol in us_choice_symbols
}
pd.options.display.precision = 2
pd.options.display.max_columns = 30
#var_dw =ABuKLUtil.date_week_win(kl_dict['TQQQ'])
#var_dw_vd = var_dw[var_dw.win>0.55]
class AbuFactorBuyWD(AbuFactorBuyTD, BuyCallMixin):
def _init_self(self, **kwargs):
"""
kwargs中可选参数：buy_dw: 代表周期胜率阀值，默认0.55即55%
kwargs中可选参数：buy_dwm: 代表涨幅比例阀值系数，默认0.618
df_stock0_5['low'].values,
df_stock0_5['close'].values,
np.random.random(len(df_stock0_5)),
None, 'stock', day_sum=False,
html_bk=False, save=False)
print('type(df_stock0_5.open.values):', type(df_stock0_5['open'].values))
print('df_stock0_5.open.index:\n', df_stock0_5['open'].index)
print('df_stock0_5.columns:\n', df_stock0_5.columns)
"""
4.2 基本数据分析示例
"""
# n_folds=2两年
tsla_df = ABuSymbolPd.make_kl_df('usTSLA', n_folds=2)
def sample_420():
# 表4-7所示
print('tsla_df.tail():\n', tsla_df.tail())
def sample_421():
"""
4.2.1 数据整体分析
:return:
"""
print('tsla_df.info():\n', tsla_df.info())
print('tsla_df.describe():\n', tsla_df.describe())
with open(r'D:\LSTM_PREDICTION\data\stock.txt') as f:
for stock in f:
stock = stock[1:7]
stock_list.append(stock)
return stock_list
stock_list = get_symbol()
# 对股票数据进行重构
# 定义函数，从df中取指定的列
# 预测第二天的平均价格，所以对DataFrame进行相应的处理
def reformat_df(df):
new_df = df[['open', 'high', 'low', 'close', 'volume']]
new_df['xopen'] = new_df['open'].shift(-1)
new_df['xclose'] = new_df['close'].shift(-1)
return new_df
# 将重构后的股票数据写入stock_data文件夹中
for stock in stock_list:
df = ABuSymbolPd.make_kl_df(stock, n_folds=4)
# df = ts.get_hist_data(stock)
if df is not None:
new_df = reformat_df(df)
new_df.to_csv(r'stock_data\%s.csv' % stock)
print('%s is written' % stock)
'---------------------------------------------------'
import pandas as pd
import seaborn as sns
# noinspection PyUnresolvedReferences
import abu_local_env
import abupy
from abupy import ABuSymbolPd
from abupy import six, xrange
from abc import ABCMeta, abstractmethod
warnings.filterwarnings('ignore')
sns.set_context(rc={'figure.figsize': (14, 7)})
# 使用沙盒数据，目的是和书中一样的数据环境
abupy.env.enable_example_env_ipython()
tsla_close = ABuSymbolPd.make_kl_df('usTSLA').close
# x序列: 0，1，2, ...len(tsla_close)
x = np.arange(0, tsla_close.shape[0])
# 收盘价格序列
y = tsla_close.values
"""
第六章 量化工具——数学：你一生的追求到底能带来多少幸福
abu量化系统github地址：https://github.com/bbfamily/abu (您的star是我的动力！)
abu量化文档教程ipython notebook：https://github.com/bbfamily/abu/tree/master/abupy_lecture
"""
def sample_611_1(show=True):
"""
6.1.1 线性回归
import os
import sys
import numpy as np
import pandas as pd
sys.path.insert(0, os.path.abspath('../'))
import abupy
abupy.env.enable_example_env_ipython()
from abupy import abu, AbuFactorBuyTD, BuyCallMixin, ABuSymbolPd, ABuKLUtil
from abupy import AbuFactorSellNDay, AbuMetricsBase, ABuProgress
if __name__ == '__main__':
us_choice_symbols = [
'usTSLA', 'usNOAH', 'usSFUN', 'usBIDU', 'usAAPL', 'usGOOG', 'usWUBA',
'usVIPS'
]
kl_dict = {
us_symbol[2:]: ABuSymbolPd.make_kl_df(us_symbol,
start='2014-07-26',
end='2015-07-26')
for us_symbol in us_choice_symbols
}
# ABuKLUtil.wave_change_rate(kl_dict)
pd.options.display.precision = 2
pd.options.display.max_columns = 30
dww = ABuKLUtil.date_week_win(kl_dict)
print(dww)
for item in itertools.combinations(items, 2):
print(item)
for item in itertools.combinations_with_replacement(items, 2):
print(item)
ab = ['a', 'b']
cd = ['c', 'd']
# 针对ab，cd两个集合进行排列组合
for item in itertools.product(ab, cd):
print(item)
# 两年的TSLA收盘数据 to list
g_price_array = ABuSymbolPd.make_kl_df('TSLA', n_folds=2).close.tolist()
# 两年的TSLA收盘日期 to list，这里的写法不考虑效率，只做演示使用
g_date_array = ABuSymbolPd.make_kl_df('TSLA', n_folds=2).date.tolist()
g_trade_days = StockTradeDays(g_price_array, 0, g_date_array)
def calc(keep_stock_threshold, buy_change_threshold):
"""
:param keep_stock_threshold: 持股天数
:param buy_change_threshold: 下跌买入阀值
:return: 盈亏情况，输入的持股天数, 输入的下跌买入阀值
"""
# 实例化TradeStrategy2
trade_strategy2 = TradeStrategy2()
# 通过类方法设置买入后持股天数
TradeStrategy2.set_keep_stock_threshold(keep_stock_threshold)
kl_pig_three = kl_pd.filter(['close', 'date_week', 'volume'])
# 只保留原始头两天的交易收盘价格，其他的的都赋予nan
kl_pig_three['close'][2:] = np.nan
# 将其他nan价格变成猪老三世界中价格使用_gen_another_word_price
_gen_another_word_price(kl_pig_three)
return kl_pig_three
choice_symbols = ['usNOAH', 'usSFUN', 'usBIDU', 'usAAPL', 'usGOOG',
'usTSLA', 'usWUBA', 'usVIPS']
another_word_dict = {}
real_dict = {}
for symbol in choice_symbols:
# 猪老三世界的股票走势字典
another_word_dict[symbol] = change_real_to_another_word(symbol)
# 真实世界的股票走势字典，这里不考虑运行效率问题
real_dict[symbol] = ABuSymbolPd.make_kl_df(symbol)
# 表10-1所示
show1 = another_word_dict['usNOAH'].head()
print(show1)
import itertools
# 4 ＊ 2
_, axs = plt.subplots(nrows=4, ncols=2, figsize=(20, 15))
# 将画布序列拉平
axs_list = list(itertools.chain.from_iterable(axs))
for symbol, ax in zip(choice_symbols, axs_list):
# 绘制猪老三世界的股价走势
another_word_dict[symbol].close.plot(ax=ax)
# 同样的股票在真实世界的股价走势
real_dict[symbol].close.plot(ax=ax)
