def ESCGO(df, p_len=8):
d_len = len(df)
hl2 = np.array((df.high + df.low) / 2)
nm = [0] * d_len
dm = [0] * d_len
cg = [0] * d_len
v1 = [0] * d_len
v2 = [0] * d_len
v3 = [0] * d_len
t = [0] * d_len
for i in range(p_len-1, d_len):
for j in range(0, p_len):
nm[i] += (j + 1) * hl2[i - j]
dm[i] += hl2[i - j]
cg[i] = -nm[i] / dm[i] + (p_len + 1) / 2.0 if dm[i] != 0 else 0
cg = np.array(cg)
min_value, max_value = talib.MINMAX(cg, timeperiod=p_len)
for i in range(p_len-1, d_len):
v1[i] = (cg[i] - min_value[i]) / (max_value[i] - min_value[i]) if max_value[i] is not min_value[i] else 0
v2[i] = (4 * v1[i] + 3 * v1[i - 1] + 2 * v1[i - 2] + v1[i - 3]) / 10.0
v3[i] = 2 * (v2[i] - 0.5)
t[i] = (0.96 * ((v3[i - 1]) + 0.02))
return v3, t
def Math_Operators(dataframe):
#Math Operator Functions
#ADD - Vector Arithmetic Add
df[f'{ratio}_ADD'] = talib.ADD(High, Low)
#c - Vector Arithmetic Div
df[f'{ratio}_ADD'] = talib.DIV(High, Low)
#MAX - Highest value over a specified period
df[f'{ratio}_MAX'] = talib.MAX(Close, timeperiod=30)
#MAXINDEX - Index of Highest value over a specified period
#integer = MAXINDEX(Close, timeperiod=30)
#MIN - Lowest value over a specified period
df[f'{ratio}_MIN'] = talib.MIN(Close, timeperiod=30)
#MININDEX - Index of Lowest value over a specified period
integer = talib.MININDEX(Close, timeperiod=30)
#MINMAX - Lowest and Highest values over a specified period
min, max = talib.MINMAX(Close, timeperiod=30)
#MINMAXINDEX - Indexes of Lowest and Highest values over a specified period
minidx, maxidx = talib.MINMAXINDEX(Close, timeperiod=30)
#MULT - Vector Arithmetic Mult
df[f'{ratio}_MULT'] = talib.MULT(High, Low)
#SUB - Vector Arithmetic Substraction
df[f'{ratio}_SUB'] = talib.SUB(High, Low)
#SUM - Summation
df[f'{ratio}_SUM'] = talib.SUM(Close, timeperiod=30)
return
def MINMAX(close, timeperiod=30):
''' Lowest and highest values over a specified period 周期内最小值和最大值
分组: Math Operator 数学运算符
简介: (返回元组````元组（array【最小】，array【最大】）```)
min, max = MINMAX(close, timeperiod=30)
'''
return talib.MINMAX(close, timeperiod)
def NAD_Factor(self, df, normperiod=100):
"""
the custom function that compute normalized AD
the equation is (ind - recentlow) / (recenthigh - recentlow)
range 0-1
"""
real = talib.AD(df.loc[:, self.map_dict['high']].values,
df.loc[:, self.map_dict['low']].values,
df.loc[:, self.map_dict['close']].values,
df.loc[:, self.map_dict['volume']].values)
min_val, max_val = talib.MINMAX(real, timeperiod=normperiod)
final_fea = (real - min_val) / (max_val - min_val)
return final_fea
def NADOSC_Factor(self, df, fastperiod=12, slowperiod=24, normperiod=100):
"""
the custom function that compute normalized ADOSC
range 0-1
"""
real = talib.ADOSC(df.loc[:, self.map_dict['high']].values,
df.loc[:, self.map_dict['low']].values,
df.loc[:, self.map_dict['close']].values,
df.loc[:, self.map_dict['volume']].values,
fastperiod=fastperiod,
slowperiod=slowperiod)
min_val, max_val = talib.MINMAX(real, timeperiod=normperiod)
final_fea = (real - min_val) / (max_val - min_val)
return final_fea
def minmax(client, symbol, timeframe="6m", col="close", period=30):
"""This will return a dataframe of
Lowest and highest values over a specified period
for the given symbol across the given timeframe
Args:
client (pyEX.Client); Client
symbol (string); Ticker
timeframe (string); timeframe to use, for pyEX.chart
col (string); column to use to calculate
period (int); period
Returns:
DataFrame: result
"""
df = client.chartDF(symbol, timeframe)
return t.MINMAX(df[col].values, period)
def math_operator_process(event):
print(event.widget.get())
math_operator = event.widget.get()
upperband, middleband, lowerband = ta.BBANDS(close,
timeperiod=5,
nbdevup=2,
nbdevdn=2,
matype=0)
fig, axes = plt.subplots(2, 1, sharex=True)
ax1, ax2 = axes[0], axes[1]
axes[0].plot(close, 'rd-', markersize=3)
axes[0].plot(upperband, 'y-')
axes[0].plot(middleband, 'b-')
axes[0].plot(lowerband, 'y-')
axes[0].set_title(math_operator, fontproperties="SimHei")
if math_operator == '指定的期间的最大值':
real = ta.MAX(close, timeperiod=30)
axes[1].plot(real, 'r-')
elif math_operator == '指定的期间的最大值的索引':
integer = ta.MAXINDEX(close, timeperiod=30)
axes[1].plot(integer, 'r-')
elif math_operator == '指定的期间的最小值':
real = ta.MIN(close, timeperiod=30)
axes[1].plot(real, 'r-')
elif math_operator == '指定的期间的最小值的索引':
integer = ta.MININDEX(close, timeperiod=30)
axes[1].plot(integer, 'r-')
elif math_operator == '指定的期间的最小和最大值':
min, max = ta.MINMAX(close, timeperiod=30)
axes[1].plot(min, 'r-')
axes[1].plot(max, 'r-')
elif math_operator == '指定的期间的最小和最大值的索引':
minidx, maxidx = ta.MINMAXINDEX(close, timeperiod=30)
axes[1].plot(minidx, 'r-')
axes[1].plot(maxidx, 'r-')
elif math_operator == '合计':
real = ta.SUM(close, timeperiod=30)
axes[1].plot(real, 'r-')
plt.show()
def add_ta_features(df, ta_settings):
"""Add technial analysis features from typical financial dataset that
typically include columns such as "open", "high", "low", "price" and
"volume".
http://mrjbq7.github.io/ta-lib/
Args:
df(pandas.DataFrame): original DataFrame.
ta_settings(dict): configuration.
Returns:
pandas.DataFrame: DataFrame with new features included.
"""
open = df['open']
high = df['high']
low = df['low']
close = df['price']
volume = df['volume']
if ta_settings['overlap']:
df['ta_overlap_bbands_upper'], df['ta_overlap_bbands_middle'], df[
'ta_overlap_bbands_lower'] = ta.BBANDS(close,
timeperiod=5,
nbdevup=2,
nbdevdn=2,
matype=0)
df['ta_overlap_dema'] = ta.DEMA(
close, timeperiod=15) # NOTE: Changed to avoid a lot of Nan values
df['ta_overlap_ema'] = ta.EMA(close, timeperiod=30)
df['ta_overlap_kama'] = ta.KAMA(close, timeperiod=30)
df['ta_overlap_ma'] = ta.MA(close, timeperiod=30, matype=0)
df['ta_overlap_mama_mama'], df['ta_overlap_mama_fama'] = ta.MAMA(close)
period = np.random.randint(10, 20, size=len(close)).astype(float)
df['ta_overlap_mavp'] = ta.MAVP(close,
period,
minperiod=2,
maxperiod=30,
matype=0)
df['ta_overlap_midpoint'] = ta.MIDPOINT(close, timeperiod=14)
df['ta_overlap_midprice'] = ta.MIDPRICE(high, low, timeperiod=14)
df['ta_overlap_sar'] = ta.SAR(high, low, acceleration=0, maximum=0)
df['ta_overlap_sarext'] = ta.SAREXT(high,
low,
startvalue=0,
offsetonreverse=0,
accelerationinitlong=0,
accelerationlong=0,
accelerationmaxlong=0,
accelerationinitshort=0,
accelerationshort=0,
accelerationmaxshort=0)
df['ta_overlap_sma'] = ta.SMA(close, timeperiod=30)
df['ta_overlap_t3'] = ta.T3(close, timeperiod=5, vfactor=0)
df['ta_overlap_tema'] = ta.TEMA(
close, timeperiod=12) # NOTE: Changed to avoid a lot of Nan values
df['ta_overlap_trima'] = ta.TRIMA(close, timeperiod=30)
df['ta_overlap_wma'] = ta.WMA(close, timeperiod=30)
# NOTE: Commented to avoid a lot of Nan values
# df['ta_overlap_ht_trendline'] = ta.HT_TRENDLINE(close)
if ta_settings['momentum']:
df['ta_momentum_adx'] = ta.ADX(high, low, close, timeperiod=14)
df['ta_momentum_adxr'] = ta.ADXR(high, low, close, timeperiod=14)
df['ta_momentum_apo'] = ta.APO(close,
fastperiod=12,
slowperiod=26,
matype=0)
df['ta_momentum_aroondown'], df['ta_momentum_aroonup'] = ta.AROON(
high, low, timeperiod=14)
df['ta_momentum_aroonosc'] = ta.AROONOSC(high, low, timeperiod=14)
df['ta_momentum_bop'] = ta.BOP(open, high, low, close)
df['ta_momentum_cci'] = ta.CCI(high, low, close, timeperiod=14)
df['ta_momentum_cmo'] = ta.CMO(close, timeperiod=14)
df['ta_momentum_dx'] = ta.DX(high, low, close, timeperiod=14)
df['ta_momentum_macd_macd'], df['ta_momentum_macd_signal'], df[
'ta_momentum_macd_hist'] = ta.MACD(close,
fastperiod=12,
slowperiod=26,
signalperiod=9)
df['ta_momentum_macdext_macd'], df['ta_momentum_macdext_signal'], df[
'ta_momentum_macdext_hist'] = ta.MACDEXT(close,
fastperiod=12,
fastmatype=0,
slowperiod=26,
slowmatype=0,
signalperiod=9,
signalmatype=0)
df['ta_momentum_macdfix_macd'], df['ta_momentum_macdfix_signal'], df[
'ta_momentum_macdfix_hist'] = ta.MACDFIX(close, signalperiod=9)
df['ta_momentum_mfi'] = ta.MFI(high, low, close, volume, timeperiod=14)
df['ta_momentum_minus_di'] = ta.MINUS_DI(high,
low,
close,
timeperiod=14)
df['ta_momentum_minus_dm'] = ta.MINUS_DM(high, low, timeperiod=14)
df['ta_momentum_mom'] = ta.MOM(close, timeperiod=10)
df['ta_momentum_plus_di'] = ta.PLUS_DI(high, low, close, timeperiod=14)
df['ta_momentum_plus_dm'] = ta.PLUS_DM(high, low, timeperiod=14)
df['ta_momentum_ppo'] = ta.PPO(close,
fastperiod=12,
slowperiod=26,
matype=0)
df['ta_momentum_roc'] = ta.ROC(close, timeperiod=10)
df['ta_momentum_rocp'] = ta.ROCP(close, timeperiod=10)
df['ta_momentum_rocr'] = ta.ROCR(close, timeperiod=10)
df['ta_momentum_rocr100'] = ta.ROCR100(close, timeperiod=10)
df['ta_momentum_rsi'] = ta.RSI(close, timeperiod=14)
df['ta_momentum_slowk'], df['ta_momentum_slowd'] = ta.STOCH(
high,
low,
close,
fastk_period=5,
slowk_period=3,
slowk_matype=0,
slowd_period=3,
slowd_matype=0)
df['ta_momentum_fastk'], df['ta_momentum_fastd'] = ta.STOCHF(
high, low, close, fastk_period=5, fastd_period=3, fastd_matype=0)
df['ta_momentum_fastk'], df['ta_momentum_fastd'] = ta.STOCHRSI(
close,
timeperiod=14,
fastk_period=5,
fastd_period=3,
fastd_matype=0)
df['ta_momentum_trix'] = ta.TRIX(
close, timeperiod=12) # NOTE: Changed to avoid a lot of Nan values
df['ta_momentum_ultosc'] = ta.ULTOSC(high,
low,
close,
timeperiod1=7,
timeperiod2=14,
timeperiod3=28)
df['ta_momentum_willr'] = ta.WILLR(high, low, close, timeperiod=14)
if ta_settings['volume']:
df['ta_volume_ad'] = ta.AD(high, low, close, volume)
df['ta_volume_adosc'] = ta.ADOSC(high,
low,
close,
volume,
fastperiod=3,
slowperiod=10)
df['ta_volume_obv'] = ta.OBV(close, volume)
if ta_settings['volatility']:
df['ta_volatility_atr'] = ta.ATR(high, low, close, timeperiod=14)
df['ta_volatility_natr'] = ta.NATR(high, low, close, timeperiod=14)
df['ta_volatility_trange'] = ta.TRANGE(high, low, close)
if ta_settings['price']:
df['ta_price_avgprice'] = ta.AVGPRICE(open, high, low, close)
df['ta_price_medprice'] = ta.MEDPRICE(high, low)
df['ta_price_typprice'] = ta.TYPPRICE(high, low, close)
df['ta_price_wclprice'] = ta.WCLPRICE(high, low, close)
if ta_settings['cycle']:
df['ta_cycle_ht_dcperiod'] = ta.HT_DCPERIOD(close)
df['ta_cycle_ht_phasor_inphase'], df[
'ta_cycle_ht_phasor_quadrature'] = ta.HT_PHASOR(close)
df['ta_cycle_ht_trendmode'] = ta.HT_TRENDMODE(close)
# NOTE: Commented to avoid a lot of Nan values
# df['ta_cycle_ht_dcphase'] = ta.HT_DCPHASE(close)
# df['ta_cycle_ht_sine_sine'], df['ta_cycle_ht_sine_leadsine'] = ta.HT_SINE(close)
if ta_settings['pattern']:
df['ta_pattern_cdl2crows'] = ta.CDL2CROWS(open, high, low, close)
df['ta_pattern_cdl3blackrows'] = ta.CDL3BLACKCROWS(
open, high, low, close)
df['ta_pattern_cdl3inside'] = ta.CDL3INSIDE(open, high, low, close)
df['ta_pattern_cdl3linestrike'] = ta.CDL3LINESTRIKE(
open, high, low, close)
df['ta_pattern_cdl3outside'] = ta.CDL3OUTSIDE(open, high, low, close)
df['ta_pattern_cdl3starsinsouth'] = ta.CDL3STARSINSOUTH(
open, high, low, close)
df['ta_pattern_cdl3whitesoldiers'] = ta.CDL3WHITESOLDIERS(
open, high, low, close)
df['ta_pattern_cdlabandonedbaby'] = ta.CDLABANDONEDBABY(open,
high,
low,
close,
penetration=0)
df['ta_pattern_cdladvanceblock'] = ta.CDLADVANCEBLOCK(
open, high, low, close)
df['ta_pattern_cdlbelthold'] = ta.CDLBELTHOLD(open, high, low, close)
df['ta_pattern_cdlbreakaway'] = ta.CDLBREAKAWAY(open, high, low, close)
df['ta_pattern_cdlclosingmarubozu'] = ta.CDLCLOSINGMARUBOZU(
open, high, low, close)
df['ta_pattern_cdlconcealbabyswall'] = ta.CDLCONCEALBABYSWALL(
open, high, low, close)
df['ta_pattern_cdlcounterattack'] = ta.CDLCOUNTERATTACK(
open, high, low, close)
df['ta_pattern_cdldarkcloudcover'] = ta.CDLDARKCLOUDCOVER(
open, high, low, close, penetration=0)
df['ta_pattern_cdldoji'] = ta.CDLDOJI(open, high, low, close)
df['ta_pattern_cdldojistar'] = ta.CDLDOJISTAR(open, high, low, close)
df['ta_pattern_cdldragonflydoji'] = ta.CDLDRAGONFLYDOJI(
open, high, low, close)
df['ta_pattern_cdlengulfing'] = ta.CDLENGULFING(open, high, low, close)
df['ta_pattern_cdleveningdojistar'] = ta.CDLEVENINGDOJISTAR(
open, high, low, close, penetration=0)
df['ta_pattern_cdleveningstar'] = ta.CDLEVENINGSTAR(open,
high,
low,
close,
penetration=0)
df['ta_pattern_cdlgapsidesidewhite'] = ta.CDLGAPSIDESIDEWHITE(
open, high, low, close)
df['ta_pattern_cdlgravestonedoji'] = ta.CDLGRAVESTONEDOJI(
open, high, low, close)
df['ta_pattern_cdlhammer'] = ta.CDLHAMMER(open, high, low, close)
df['ta_pattern_cdlhangingman'] = ta.CDLHANGINGMAN(
open, high, low, close)
df['ta_pattern_cdlharami'] = ta.CDLHARAMI(open, high, low, close)
df['ta_pattern_cdlharamicross'] = ta.CDLHARAMICROSS(
open, high, low, close)
df['ta_pattern_cdlhighwave'] = ta.CDLHIGHWAVE(open, high, low, close)
df['ta_pattern_cdlhikkake'] = ta.CDLHIKKAKE(open, high, low, close)
df['ta_pattern_cdlhikkakemod'] = ta.CDLHIKKAKEMOD(
open, high, low, close)
df['ta_pattern_cdlhomingpigeon'] = ta.CDLHOMINGPIGEON(
open, high, low, close)
df['ta_pattern_cdlidentical3crows'] = ta.CDLIDENTICAL3CROWS(
open, high, low, close)
df['ta_pattern_cdlinneck'] = ta.CDLINNECK(open, high, low, close)
df['ta_pattern_cdlinvertedhammer'] = ta.CDLINVERTEDHAMMER(
open, high, low, close)
df['ta_pattern_cdlkicking'] = ta.CDLKICKING(open, high, low, close)
df['ta_pattern_cdlkickingbylength'] = ta.CDLKICKINGBYLENGTH(
open, high, low, close)
df['ta_pattern_cdlladderbottom'] = ta.CDLLADDERBOTTOM(
open, high, low, close)
df['ta_pattern_cdllongleggeddoji'] = ta.CDLLONGLEGGEDDOJI(
open, high, low, close)
df['ta_pattern_cdllongline'] = ta.CDLLONGLINE(open, high, low, close)
df['ta_pattern_cdlmarubozu'] = ta.CDLMARUBOZU(open, high, low, close)
df['ta_pattern_cdlmatchinglow'] = ta.CDLMATCHINGLOW(
open, high, low, close)
df['ta_pattern_cdlmathold'] = ta.CDLMATHOLD(open,
high,
low,
close,
penetration=0)
df['ta_pattern_cdlmorningdojistar'] = ta.CDLMORNINGDOJISTAR(
open, high, low, close, penetration=0)
df['ta_pattern_cdlmorningstar'] = ta.CDLMORNINGSTAR(open,
high,
low,
close,
penetration=0)
df['ta_pattern_cdllonneck'] = ta.CDLONNECK(open, high, low, close)
df['ta_pattern_cdlpiercing'] = ta.CDLPIERCING(open, high, low, close)
df['ta_pattern_cdlrickshawman'] = ta.CDLRICKSHAWMAN(
open, high, low, close)
df['ta_pattern_cdlrisefall3methods'] = ta.CDLRISEFALL3METHODS(
open, high, low, close)
df['ta_pattern_cdlseparatinglines'] = ta.CDLSEPARATINGLINES(
open, high, low, close)
df['ta_pattern_cdlshootingstar'] = ta.CDLSHOOTINGSTAR(
open, high, low, close)
df['ta_pattern_cdlshortline'] = ta.CDLSHORTLINE(open, high, low, close)
df['ta_pattern_cdlspinningtop'] = ta.CDLSPINNINGTOP(
open, high, low, close)
df['ta_pattern_cdlstalledpattern'] = ta.CDLSTALLEDPATTERN(
open, high, low, close)
df['ta_pattern_cdlsticksandwich'] = ta.CDLSTICKSANDWICH(
open, high, low, close)
df['ta_pattern_cdltakuri'] = ta.CDLTAKURI(open, high, low, close)
df['ta_pattern_cdltasukigap'] = ta.CDLTASUKIGAP(open, high, low, close)
df['ta_pattern_cdlthrusting'] = ta.CDLTHRUSTING(open, high, low, close)
df['ta_pattern_cdltristar'] = ta.CDLTRISTAR(open, high, low, close)
df['ta_pattern_cdlunique3river'] = ta.CDLUNIQUE3RIVER(
open, high, low, close)
df['ta_pattern_cdlupsidegap2crows'] = ta.CDLUPSIDEGAP2CROWS(
open, high, low, close)
df['ta_pattern_cdlxsidegap3methods'] = ta.CDLXSIDEGAP3METHODS(
open, high, low, close)
if ta_settings['statistic']:
df['ta_statistic_beta'] = ta.BETA(high, low, timeperiod=5)
df['ta_statistic_correl'] = ta.CORREL(high, low, timeperiod=30)
df['ta_statistic_linearreg'] = ta.LINEARREG(close, timeperiod=14)
df['ta_statistic_linearreg_angle'] = ta.LINEARREG_ANGLE(close,
timeperiod=14)
df['ta_statistic_linearreg_intercept'] = ta.LINEARREG_INTERCEPT(
close, timeperiod=14)
df['ta_statistic_linearreg_slope'] = ta.LINEARREG_SLOPE(close,
timeperiod=14)
df['ta_statistic_stddev'] = ta.STDDEV(close, timeperiod=5, nbdev=1)
df['ta_statistic_tsf'] = ta.TSF(close, timeperiod=14)
df['ta_statistic_var'] = ta.VAR(close, timeperiod=5, nbdev=1)
if ta_settings['math_transforms']:
df['ta_math_transforms_atan'] = ta.ATAN(close)
df['ta_math_transforms_ceil'] = ta.CEIL(close)
df['ta_math_transforms_cos'] = ta.COS(close)
df['ta_math_transforms_floor'] = ta.FLOOR(close)
df['ta_math_transforms_ln'] = ta.LN(close)
df['ta_math_transforms_log10'] = ta.LOG10(close)
df['ta_math_transforms_sin'] = ta.SIN(close)
df['ta_math_transforms_sqrt'] = ta.SQRT(close)
df['ta_math_transforms_tan'] = ta.TAN(close)
if ta_settings['math_operators']:
df['ta_math_operators_add'] = ta.ADD(high, low)
df['ta_math_operators_div'] = ta.DIV(high, low)
df['ta_math_operators_min'], df['ta_math_operators_max'] = ta.MINMAX(
close, timeperiod=30)
df['ta_math_operators_minidx'], df[
'ta_math_operators_maxidx'] = ta.MINMAXINDEX(close, timeperiod=30)
df['ta_math_operators_mult'] = ta.MULT(high, low)
df['ta_math_operators_sub'] = ta.SUB(high, low)
df['ta_math_operators_sum'] = ta.SUM(close, timeperiod=30)
return df
def total(self, df0, tk, period=14):
# 计算参数
close = df0["close"]
df0["datetime"] = df0.index
df0["curMa"] = df0.apply(lambda row: self.curMA(row, df0), axis=1)
df0["ma"] = ma = ta.MA(close, timeperiod=period)
df0["std"] = std = ta.STDDEV(close, timeperiod=period, nbdev=1)
df0['mv'] = ta.MA(df0['volume'], timeperiod=period)
df0['volc120'] = df0['volume']/ta.MA(df0['volume'], timeperiod=120)
df0['volc'] = df0['volume'] / df0['mv']
df0['bias'] = (close - ma)/ma
df0['min5'], df0['max5'] = ta.MINMAX(close, timeperiod=10)
# df1 = df0.apply(lambda row: self.point(row, df0, b0['tick_size']), axis=1)
# for key in self.pointColumns: df0[key] = df1[key]
# tick
tk['vol'] = tk['volume'] - tk['volume'].shift(1)
tk = tk[tk['vol']>0]
#print(tk)
tk['raise'] = tk['last'] - tk['last'].shift(1)
tk['rdiff'] = tk['a1'] - tk['b1']
for k in ['a', 'b']:
tk['r' + k] = tk[k + '1'] - tk[k + '1'].shift(1)
#tk['p%s1'% k] = tk[k + '1'].shift(1)
rrr = tk['r' + k].apply(lambda x: 1 if x > 0 else -1 if x < 0 else 0)
for n in [3]:
key = 'r%s%s' % (k, str(n))
tk[key+'_v'] = ta.SUM(tk['r'+k], timeperiod=n)
tk[key] = ta.SUM(rrr, timeperiod=n)
#print(tk.iloc[-1])
tk['mode'] = tk.apply(lambda row: self.tickMode(row), axis=1)
tk['datetime'] = tk['datetime'].apply(lambda x: str(x)[:str(x).find(".")] if str(x).find(".") > -1 else x)
#tk['dd5'] = tk['datetime'].shift(5).fillna('2019-01-01 00:00:00')
#tk['diff'] = tk.apply(lambda row: public.timeDiff(str(row['datetime']), str(row['dd5'])), axis=1)
tk['modem'] = ta.SUM(tk['mode'], timeperiod=5)
tk['vol_t'] = ta.SUM(tk['vol'] * tk['mode'], timeperiod=5)
tk['modem3'] = ta.SUM(tk['mode'], timeperiod=3)
tk['vol_t3'] = ta.SUM(tk['vol'] * tk['mode'], timeperiod=3)
print(self.code, self.csvList)
if self.code in self.csvList:
# and uid== (self.csvKey % ('_'.join(self.codes), str(period)) + self.method):
file = self.Rice.basePath + '%s1_kline.csv' % (self.uid)
file1 = self.Rice.basePath + '%s1_tick.csv' % (self.uid)
print(self.uid, '---------------------------- to_cvs', file)
df0.to_csv(file, index=0)
columns = ['datetime', 'last', 'high', 'low', 'volume',
'a1', 'b1', 'a1_v', 'b1_v', 'change_rate', 'vol', 'ra', 'rb', 'ra2', 'ra3', 'rb2', 'rb3',
'raise', 'mode', 'modem', 'vol_t', 'modem3', 'vol_t3', 'diff']
tk.to_csv(file1, index=0, columns=columns)
return df0[self.startDate:], tk
def MINMAX(data, **kwargs):
_check_talib_presence()
prices = _extract_series(data)
return talib.MINMAX(prices, **kwargs)
def appendAllTAData(df=pd.DataFrame([])):
resDF = pd.DataFrame([])
# 函数名：AD名称：ChaikinA/DLine累积/派发线（Accumulation/DistributionLine）
# 简介：MarcChaikin提出的一种平衡交易量指标，以当日的收盘价位来估算成交流量，用于估定一段时间内该证券累积的资金流量。
# 计算公式：A/D=昨日A/D+多空对比*今日成交量多空对比=[（收盘价-最低价）-（最高价-收盘价）]/（最高价-最低价）
# 若最高价等于最低价：多空对比=（收盘价/昨收盘）-1
# 研判：1、A/D测量资金流向，向上的A/D表明买方占优势，而向下的A/D表明卖方占优势
# 2、A/D与价格的背离可视为买卖信号，即底背离考虑买入，顶背离考虑卖出
# 3、应当注意A/D忽略了缺口的影响，事实上，跳空缺口的意义是不能轻易忽略的
# A/D指标无需设置参数，但在应用时，可结合指标的均线进行分析例子：real=AD(high,low,close,volume)
resDF['AD'] = ta.AD(df['max_price'].values, df['min_price'].values,
df['price'].values, df['vol'].values)
# 函数名：ADOSC名称：Chaikin A/D Oscillator Chaikin震荡指标
# 简介：将资金流动情况与价格行为相对比，检测市场中资金流入和流出的情况
# 计算公式：fastperiod A/D - slowperiod A/D
# 研判：1、交易信号是背离：看涨背离做多，看跌背离做空
# 2、股价与90天移动平均结合，与其他指标结合
# 3、由正变负卖出，由负变正买进
# 例子：real = ADOSC(high, low, close, volume, fastperiod=3, slowperiod=10)
resDF['ADOSC'] = ta.ADOSC(df['max_price'].values,
df['min_price'].values,
df['price'].values,
df['vol'].values,
fastperiod=3,
slowperiod=10)
resDF['ADX'] = ta.ADX(df['max_price'].values, df['min_price'].values,
df['price'].values)
resDF['ADXR'] = ta.ADXR(df['max_price'].values,
df['min_price'].values,
df['price'].values,
timeperiod=14)
resDF['APO'] = ta.APO(df['price'].values,
fastperiod=12,
slowperiod=26,
matype=0)
resDF['aroondown'], resDF['aroonup'] = ta.AROON(df['max_price'].values,
df['min_price'].values,
timeperiod=14)
resDF['AROONOSC'] = ta.AROONOSC(df['max_price'].values,
df['min_price'].values,
timeperiod=14)
resDF['ATR'] = ta.ATR(df['max_price'].values,
df['min_price'].values,
df['price'].values,
timeperiod=14)
resDF['AVGPRICE'] = ta.AVGPRICE(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values, df['price'].values)
resDF['upperband'], resDF['middleband'], resDF['lowerband'] = ta.BBANDS(
df['price'].values, timeperiod=5, nbdevup=2, nbdevdn=2, matype=0)
resDF['BETA'] = ta.BETA(df['max_price'].values,
df['min_price'].values,
timeperiod=5)
resDF['BOP'] = ta.BOP(df['price_today_open'].values,
df['max_price'].values, df['min_price'].values,
df['price'].values)
resDF['CCI'] = ta.CCI(df['max_price'].values,
df['min_price'].values,
df['price'].values,
timeperiod=10)[-1]
# 函数名：CDL2CROWS名称：Two Crows 两只乌鸦
# 简介：三日K线模式，第一天长阳，第二天高开收阴，第三天再次高开继续收阴，收盘比前一日收盘价低，预示股价下跌。
# 例子：integer = CDL2CROWS(open, high, low, close)
resDF['CDL2CROWS'] = ta.CDL2CROWS(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDL3BLACKCROWS名称：Three Black Crows 三只乌鸦
# 简介：三日K线模式，连续三根阴线，每日收盘价都下跌且接近最低价，每日开盘价都在上根K线实体内，预示股价下跌。
# 例子：integer = CD3BLACKCROWS(open, high, low, close)
resDF['CDL3BLACKCROWS'] = ta.CDL3BLACKCROWS(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDL3INSIDE名称： Three Inside Up/Down 三内部上涨和下跌
# 简介：三日K线模式，母子信号+长K线，以三内部上涨为例，K线为阴阳阳，第三天收盘价高于第一天开盘价，第二天K线在第一天K线内部，预示着股价上涨。
# 例子：integer = CDL3INSIDE(open, high, low, close)
resDF['CDL3INSIDE'] = ta.CDL3INSIDE(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDL3LINESTRIKE名称： Three-Line Strike 三线打击
# 简介：四日K线模式，前三根阳线，每日收盘价都比前一日高，开盘价在前一日实体内，第四日市场高开，收盘价低于第一日开盘价，预示股价下跌。
# 例子：integer = CDL3LINESTRIKE(open, high, low, close)
resDF['CDL3LINESTRIKE'] = ta.CDL3LINESTRIKE(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDL3OUTSIDE名称：Three Outside Up/Down 三外部上涨和下跌
# 简介：三日K线模式，与三内部上涨和下跌类似，K线为阴阳阳，但第一日与第二日的K线形态相反，以三外部上涨为例，第一日K线在第二日K线内部，预示着股价上涨。
# 例子：integer = CDL3OUTSIDE(open, high, low, close)
resDF['CDL3OUTSIDE'] = ta.CDL3OUTSIDE(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDL3STARSINSOUTH名称：Three Stars In The South 南方三星
# 简介：三日K线模式，与大敌当前相反，三日K线皆阴，第一日有长下影线，第二日与第一日类似，K线整体小于第一日，第三日无下影线实体信号，成交价格都在第一日振幅之内，预示下跌趋势反转，股价上升。
# 例子：integer = CDL3STARSINSOUTH(open, high, low, close)
resDF['CDL3STARSINSOUTH'] = ta.CDL3STARSINSOUTH(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDL3WHITESOLDIERS名称：Three Advancing White Soldiers 三个白兵
# 简介：三日K线模式，三日K线皆阳，每日收盘价变高且接近最高价，开盘价在前一日实体上半部，预示股价上升。
# 例子：integer = CDL3WHITESOLDIERS(open, high, low, close)
resDF['CDL3WHITESOLDIERS'] = ta.CDL3WHITESOLDIERS(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLABANDONEDBABY名称：Abandoned Baby 弃婴
# 简介：三日K线模式，第二日价格跳空且收十字星（开盘价与收盘价接近，最高价最低价相差不大），预示趋势反转，发生在顶部下跌，底部上涨。
# 例子：integer = CDLABANDONEDBABY(open, high, low, close, penetration=0)
resDF['CDLABANDONEDBABY'] = ta.CDLABANDONEDBABY(
df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values,
penetration=0)
# 函数名：CDLADVANCEBLOCK名称：Advance Block 大敌当前
# 简介：三日K线模式，三日都收阳，每日收盘价都比前一日高，开盘价都在前一日实体以内，实体变短，上影线变长。
# 例子：integer = CDLADVANCEBLOCK(open, high, low, close)
resDF['CDLADVANCEBLOCK'] = ta.CDLADVANCEBLOCK(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLBELTHOLD名称：Belt-hold 捉腰带线
# 简介：两日K线模式，下跌趋势中，第一日阴线，第二日开盘价为最低价，阳线，收盘价接近最高价，预示价格上涨。
# 例子：integer = CDLBELTHOLD(open, high, low, close)
resDF['CDLBELTHOLD'] = ta.CDLBELTHOLD(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLBREAKAWAY名称：Breakaway 脱离
# 简介：五日K线模式，以看涨脱离为例，下跌趋势中，第一日长阴线，第二日跳空阴线，延续趋势开始震荡，第五日长阳线，收盘价在第一天收盘价与第二天开盘价之间，预示价格上涨。
# 例子：integer = CDLBREAKAWAY(open, high, low, close)
resDF['CDLBREAKAWAY'] = ta.CDLBREAKAWAY(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名： CDLCLOSINGMARUBOZU 名称：Closing Marubozu 收盘缺影线
# 简介：一日K线模式，以阳线为例，最低价低于开盘价，收盘价等于最高价，预示着趋势持续。
# 例子：integer = CDLCLOSINGMARUBOZU(open, high, low, close)
resDF['CDLCLOSINGMARUBOZU'] = ta.CDLCLOSINGMARUBOZU(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLCONCEALBABYSWALL名称： Concealing Baby Swallow 藏婴吞没
# 简介：四日K线模式，下跌趋势中，前两日阴线无影线，第二日开盘、收盘价皆低于第二日，第三日倒锤头，第四日开盘价高于前一日最高价，收盘价低于前一日最低价，预示着底部反转。
# 例子：integer = CDLCONCEALBABYSWALL(open, high, low, close)
resDF['CDLCONCEALBABYSWALL'] = ta.CDLCONCEALBABYSWALL(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLCOUNTERATTACK
# 名称：Counterattack 反击线
# 简介：二日K线模式，与分离线类似。
# 例子：integer = CDLCOUNTERATTACK(open, high, low, close)
resDF['CDLCOUNTERATTACK'] = ta.CDLCOUNTERATTACK(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLDARKCLOUDCOVER名称：Dark Cloud Cover 乌云压顶
# 简介：二日K线模式，第一日长阳，第二日开盘价高于前一日最高价，收盘价处于前一日实体中部以下，预示着股价下跌。
# 例子：integer = CDLDARKCLOUDCOVER(open, high, low, close, penetration=0)
resDF['CDLDARKCLOUDCOVER'] = ta.CDLDARKCLOUDCOVER(
df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values,
penetration=0)
# 函数名： CDLDOJI
# 名称：Doji 十字
# 简介：一日K线模式，开盘价与收盘价基本相同。
# 例子：integer = CDLDOJI(open, high, low, close)
resDF['CDLDOJI'] = ta.CDLDOJI(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名： CDLDOJISTAR
# 名称：Doji Star 十字星
# 简介：一日K线模式，开盘价与收盘价基本相同，上下影线不会很长，预示着当前趋势反转。
# 例子：integer = CDLDOJISTAR(open, high, low, close)
resDF['CDLDOJISTAR'] = ta.CDLDOJISTAR(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLDRAGONFLYDOJI名称：Dragonfly Doji 蜻蜓十字/T形十字
# 简介：一日K线模式，开盘后价格一路走低，之后收复，收盘价与开盘价相同，预示趋势反转。
# 例子：integer = CDLDRAGONFLYDOJI(open, high, low, close)
resDF['CDLDRAGONFLYDOJI'] = ta.CDLDRAGONFLYDOJI(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLENGULFING名称：Engulfing Pattern 吞噬模式
# 简介：两日K线模式，分多头吞噬和空头吞噬，以多头吞噬为例，第一日为阴线，第二日阳线，第一日的开盘价和收盘价在第二日开盘价收盘价之内，但不能完全相同。
# 例子：integer = CDLENGULFING(open, high, low, close)
resDF['CDLENGULFING'] = ta.CDLENGULFING(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLEVENINGDOJISTAR名称：Evening Doji Star 十字暮星
# 简介：三日K线模式，基本模式为暮星，第二日收盘价和开盘价相同，预示顶部反转。
# 例子：integer = CDLEVENINGDOJISTAR(open, high, low, close, penetration=0)
resDF['CDLEVENINGDOJISTAR'] = ta.CDLEVENINGDOJISTAR(
df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values,
penetration=0)
# 函数名：CDLEVENINGSTAR名称：Evening Star 暮星
# 简介：三日K线模式，与晨星相反，上升趋势中，第一日阳线，第二日价格振幅较小，第三日阴线，预示顶部反转。
# 例子：integer = CDLEVENINGSTAR(open, high, low, close, penetration=0)
resDF['CDLEVENINGSTAR'] = ta.CDLEVENINGSTAR(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values,
penetration=0)
# 函数名：CDLGAPSIDESIDEWHITE名称：Up/Down-gap side-by-side white lines 向上/下跳空并列阳线
# 简介：二日K线模式，上升趋势向上跳空，下跌趋势向下跳空，第一日与第二日有相同开盘价，实体长度差不多，则趋势持续。
# 例子：integer = CDLGAPSIDESIDEWHITE(open, high, low, close)
resDF['CDLGAPSIDESIDEWHITE'] = ta.CDLGAPSIDESIDEWHITE(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLGRAVESTONEDOJI名称：Gravestone Doji 墓碑十字/倒T十字
# 简介：一日K线模式，开盘价与收盘价相同，上影线长，无下影线，预示底部反转。
# 例子：integer = CDLGRAVESTONEDOJI(open, high, low, close)
resDF['CDLGRAVESTONEDOJI'] = ta.CDLGRAVESTONEDOJI(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLHAMMER
# 名称：Hammer 锤头
# 简介：一日K线模式，实体较短，无上影线，下影线大于实体长度两倍，处于下跌趋势底部，预示反转。
# 例子：integer = CDLHAMMER(open, high, low, close)
resDF['CDLHAMMER'] = ta.CDLHAMMER(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLHANGINGMAN
# 名称：Hanging Man 上吊线
# 简介：一日K线模式，形状与锤子类似，处于上升趋势的顶部，预示着趋势反转。
# 例子：integer = CDLHANGINGMAN(open, high, low, close)
resDF['CDLHANGINGMAN'] = ta.CDLHANGINGMAN(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLHARAMI名称：Harami Pattern 母子线
# 简介：二日K线模式，分多头母子与空头母子，两者相反，以多头母子为例，在下跌趋势中，第一日K线长阴，第二日开盘价收盘价在第一日价格振幅之内，为阳线，预示趋势反转，股价上升。
# 例子：integer = CDLHARAMI(open, high, low, close)
resDF['CDLHARAMI'] = ta.CDLHARAMI(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLHARAMICROSS名称：Harami Cross Pattern 十字孕线
# 简介：二日K线模式，与母子县类似，若第二日K线是十字线，便称为十字孕线，预示着趋势反转。
# 例子：integer = CDLHARAMICROSS(open, high, low, close)
resDF['CDLHARAMICROSS'] = ta.CDLHARAMICROSS(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLHIGHWAVE
# 名称：High-Wave Candle 风高浪大线
# 简介：三日K线模式，具有极长的上/下影线与短的实体，预示着趋势反转。
# 例子：integer = CDLHIGHWAVE(open, high, low, close)
resDF['CDLHIGHWAVE'] = ta.CDLHIGHWAVE(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLHIKKAKE名称：Hikkake Pattern 陷阱
# 简介：三日K线模式，与母子类似，第二日价格在前一日实体范围内，第三日收盘价高于前两日，反转失败，趋势继续。
# 例子：integer = CDLHIKKAKE(open, high, low, close)
resDF['CDLHIKKAKE'] = ta.CDLHIKKAKE(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLHIKKAKEMOD名称：Modified Hikkake Pattern 修正陷阱
# 简介：三日K线模式，与陷阱类似，上升趋势中，第三日跳空高开；下跌趋势中，第三日跳空低开，反转失败，趋势继续。
# 例子：integer = CDLHIKKAKEMOD(open, high, low, close)
resDF['CDLHIKKAKEMOD'] = ta.CDLHIKKAKEMOD(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLHOMINGPIGEON名称：Homing Pigeon 家鸽
# 简介：二日K线模式，与母子线类似，不同的的是二日K线颜色相同，第二日最高价、最低价都在第一日实体之内，预示着趋势反转。
# 例子：integer = CDLHOMINGPIGEON(open, high, low, close)
resDF['CDLHOMINGPIGEON'] = ta.CDLHOMINGPIGEON(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLIDENTICAL3CROWS名称：Identical Three Crows 三胞胎乌鸦
# 简介：三日K线模式，上涨趋势中，三日都为阴线，长度大致相等，每日开盘价等于前一日收盘价，收盘价接近当日最低价，预示价格下跌。
# 例子：integer = CDLIDENTICAL3CROWS(open, high, low, close)
resDF['CDLIDENTICAL3CROWS'] = ta.CDLIDENTICAL3CROWS(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLINNECK名称：In-Neck Pattern 颈内线
# 简介：二日K线模式，下跌趋势中，第一日长阴线，第二日开盘价较低，收盘价略高于第一日收盘价，阳线，实体较短，预示着下跌继续。
# 例子：integer = CDLINNECK(open, high, low, close)
resDF['CDLINNECK'] = ta.CDLINNECK(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLINVERTEDHAMMER名称：Inverted Hammer 倒锤头
# 简介：一日K线模式，上影线较长，长度为实体2倍以上，无下影线，在下跌趋势底部，预示着趋势反转。
# 例子：integer = CDLINVERTEDHAMMER(open, high, low, close)
resDF['CDLINVERTEDHAMMER'] = ta.CDLINVERTEDHAMMER(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLKICKING
# 名称：Kicking 反冲形态
# 简介：二日K线模式，与分离线类似，两日K线为秃线，颜色相反，存在跳空缺口。
# 例子：integer = CDLKICKING(open, high, low, close)
resDF['CDLKICKING'] = ta.CDLKICKING(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLKICKINGBYLENGTH名称：Kicking - bull/bear determined by the longer marubozu 由较长缺影线决定的反冲形态
# 简介：二日K线模式，与反冲形态类似，较长缺影线决定价格的涨跌。
# 例子：integer = CDLKICKINGBYLENGTH(open, high, low, close)
resDF['CDLKICKINGBYLENGTH'] = ta.CDLKICKINGBYLENGTH(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLLADDERBOTTOM名称：Ladder Bottom 梯底
# 简介：五日K线模式，下跌趋势中，前三日阴线，开盘价与收盘价皆低于前一日开盘、收盘价，第四日倒锤头，第五日开盘价高于前一日开盘价，阳线，收盘价高于前几日价格振幅，预示着底部反转。
# 例子：integer = CDLLADDERBOTTOM(open, high, low, close)
resDF['CDLLADDERBOTTOM'] = ta.CDLLADDERBOTTOM(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLLONGLEGGEDDOJI名称：Long Legged Doji 长脚十字
# 简介：一日K线模式，开盘价与收盘价相同居当日价格中部，上下影线长，表达市场不确定性。
# 例子：integer = CDLLONGLEGGEDDOJI(open, high, low, close)
resDF['CDLLONGLEGGEDDOJI'] = ta.CDLLONGLEGGEDDOJI(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLLONGLINE
# 名称：Long Line Candle 长蜡烛
# 简介：一日K线模式，K线实体长，无上下影线。
# 例子：integer = CDLLONGLINE(open, high, low, close)
resDF['CDLLONGLINE'] = ta.CDLLONGLINE(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLMARUBOZU
# 名称：Marubozu 光头光脚/缺影线
# 简介：一日K线模式，上下两头都没有影线的实体，阴线预示着熊市持续或者牛市反转，阳线相反。
# 例子：integer = CDLMARUBOZU(open, high, low, close)
resDF['CDLMARUBOZU'] = ta.CDLMARUBOZU(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLMATCHINGLOW名称：Matching Low 相同低价
# 简介：二日K线模式，下跌趋势中，第一日长阴线，第二日阴线，收盘价与前一日相同，预示底部确认，该价格为支撑位。
# 例子：integer = CDLMATCHINGLOW(open, high, low, close)
resDF['CDLMATCHINGLOW'] = ta.CDLMATCHINGLOW(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLMATHOLD名称：Mat Hold 铺垫
# 简介：五日K线模式，上涨趋势中，第一日阳线，第二日跳空高开影线，第三、四日短实体影线，第五日阳线，收盘价高于前四日，预示趋势持续。
# 例子：integer = CDLMATHOLD(open, high, low, close, penetration=0)
resDF['CDLMATHOLD'] = ta.CDLMATHOLD(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values,
penetration=0)
# 函数名：CDLMORNINGDOJISTAR名称：Morning Doji Star 十字晨星
# 简介：三日K线模式，基本模式为晨星，第二日K线为十字星，预示底部反转。
# 例子：integer = CDLMORNINGDOJISTAR(open, high, low, close, penetration=0)
resDF['CDLMORNINGDOJISTAR'] = ta.CDLMORNINGDOJISTAR(
df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values,
penetration=0)
# 函数名：CDLMORNINGSTAR名称：Morning Star 晨星
# 简介：三日K线模式，下跌趋势，第一日阴线，第二日价格振幅较小，第三天阳线，预示底部反转。
# 例子：integer = CDLMORNINGSTAR(open, high, low, close, penetration=0)
resDF['CDLMORNINGSTAR'] = ta.CDLMORNINGSTAR(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values,
penetration=0)
# 函数名：CDLONNECK名称：On-Neck Pattern 颈上线
# 简介：二日K线模式，下跌趋势中，第一日长阴线，第二日开盘价较低，收盘价与前一日最低价相同，阳线，实体较短，预示着延续下跌趋势。
# 例子：integer = CDLONNECK(open, high, low, close)
resDF['CDLONNECK'] = ta.CDLONNECK(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLPIERCING名称：Piercing Pattern 刺透形态
# 简介：两日K线模式，下跌趋势中，第一日阴线，第二日收盘价低于前一日最低价，收盘价处在第一日实体上部，预示着底部反转。
# 例子：integer = CDLPIERCING(open, high, low, close)
resDF['CDLPIERCING'] = ta.CDLPIERCING(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLRICKSHAWMAN名称：Rickshaw Man 黄包车夫
# 简介：一日K线模式，与长腿十字线类似，若实体正好处于价格振幅中点，称为黄包车夫。
# 例子：integer = CDLRICKSHAWMAN(open, high, low, close)
resDF['CDLRICKSHAWMAN'] = ta.CDLRICKSHAWMAN(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLRISEFALL3METHODS名称：Rising/Falling Three Methods 上升/下降三法
# 简介： 五日K线模式，以上升三法为例，上涨趋势中，第一日长阳线，中间三日价格在第一日范围内小幅震荡，第五日长阳线，收盘价高于第一日收盘价，预示股价上升。
# 例子：integer = CDLRISEFALL3METHODS(open, high, low, close)
resDF['CDLRISEFALL3METHODS'] = ta.CDLRISEFALL3METHODS(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLSEPARATINGLINES名称：Separating Lines 分离线
# 简介：二日K线模式，上涨趋势中，第一日阴线，第二日阳线，第二日开盘价与第一日相同且为最低价，预示着趋势继续。
# 例子：integer = CDLSEPARATINGLINES(open, high, low, close)
resDF['CDLSEPARATINGLINES'] = ta.CDLSEPARATINGLINES(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLSHOOTINGSTAR名称：Shooting Star 射击之星
# 简介：一日K线模式，上影线至少为实体长度两倍，没有下影线，预示着股价下跌
# 例子：integer = CDLSHOOTINGSTAR(open, high, low, close)
resDF['CDLSHOOTINGSTAR'] = ta.CDLSHOOTINGSTAR(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLSHORTLINE
# 名称：Short Line Candle 短蜡烛
# 简介：一日K线模式，实体短，无上下影线。
# 例子：integer = CDLSHORTLINE(open, high, low, close)
resDF['CDLSHORTLINE'] = ta.CDLSHORTLINE(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLSPINNINGTOP
# 名称：Spinning Top 纺锤
# 简介：一日K线，实体小。
# 例子：integer = CDLSPINNINGTOP(open, high, low, close)
resDF['CDLSPINNINGTOP'] = ta.CDLSPINNINGTOP(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLSTALLEDPATTERN名称：Stalled Pattern 停顿形态
# 简介：三日K线模式，上涨趋势中，第二日长阳线，第三日开盘于前一日收盘价附近，短阳线，预示着上涨结束。
# 例子：integer = CDLSTALLEDPATTERN(open, high, low, close)
resDF['CDLSTALLEDPATTERN'] = ta.CDLSTALLEDPATTERN(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLSTICKSANDWICH名称：Stick Sandwich 条形三明治
# 简介：三日K线模式，第一日长阴线，第二日阳线，开盘价高于前一日收盘价，第三日开盘价高于前两日最高价，收盘价于第一日收盘价相同。
# 例子：integer = CDLSTICKSANDWICH(open, high, low, close)
resDF['CDLSTICKSANDWICH'] = ta.CDLSTICKSANDWICH(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLTAKURI名称：Takuri (Dragonfly Doji with very long lower shadow) 探水竿
# 简介：一日K线模式，大致与蜻蜓十字相同，下影线长度长。
# 例子：integer = CDLTAKURI(open, high, low, close)
resDF['CDLTAKURI'] = ta.CDLTAKURI(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLTASUKIGAP名称：Tasuki Gap 跳空并列阴阳线
# 简介：三日K线模式，分上涨和下跌，以上升为例，前两日阳线，第二日跳空，第三日阴线，收盘价于缺口中，上升趋势持续。
# 例子：integer = CDLTASUKIGAP(open, high, low, close)
resDF['CDLTASUKIGAP'] = ta.CDLTASUKIGAP(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLTHRUSTING名称：Thrusting Pattern 插入
# 简介：二日K线模式，与颈上线类似，下跌趋势中，第一日长阴线，第二日开盘价跳空，收盘价略低于前一日实体中部，与颈上线相比实体较长，预示着趋势持续。
# 例子：integer = CDLTHRUSTING(open, high, low, close)
resDF['CDLTHRUSTING'] = ta.CDLTHRUSTING(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLTRISTAR
# 名称：Tristar Pattern 三星
# 简介：三日K线模式，由三个十字组成，第二日十字必须高于或者低于第一日和第三日，预示着反转。
# 例子：integer = CDLTRISTAR(open, high, low, close)
resDF['CDLTRISTAR'] = ta.CDLTRISTAR(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values)
# 函数名：CDLUNIQUE3RIVER名称：Unique 3 River 奇特三河床
# 简介：三日K线模式，下跌趋势中，第一日长阴线，第二日为锤头，最低价创新低，第三日开盘价低于第二日收盘价，收阳线，收盘价不高于第二日收盘价，预示着反转，第二日下影线越长可能性越大。
# 例子：integer = CDLUNIQUE3RIVER(open, high, low, close)
resDF['CDLUNIQUE3RIVER'] = ta.CDLUNIQUE3RIVER(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLUPSIDEGAP2CROWS名称：Upside Gap Two Crows 向上跳空的两只乌鸦
# 简介：三日K线模式，第一日阳线，第二日跳空以高于第一日最高价开盘，收阴线，第三日开盘价高于第二日，收阴线，与第一日比仍有缺口。
# 例子：integer = CDLUPSIDEGAP2CROWS(open, high, low, close)
resDF['CDLUPSIDEGAP2CROWS'] = ta.CDLUPSIDEGAP2CROWS(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
# 函数名：CDLXSIDEGAP3METHODS名称：Upside/Downside Gap Three Methods 上升/下降跳空三法
# 简介：五日K线模式，以上升跳空三法为例，上涨趋势中，第一日长阳线，第二日短阳线，第三日跳空阳线，第四日阴线，开盘价与收盘价于前两日实体内，第五日长阳线，收盘价高于第一日收盘价，预示股价上升。
# 例子：integer = CDLXSIDEGAP3METHODS(open, high, low, close)
resDF['CDLXSIDEGAP3METHODS'] = ta.CDLXSIDEGAP3METHODS(
df['price_today_open'].values, df['max_price'].values,
df['min_price'].values, df['price'].values)
resDF['CMO'] = ta.CMO(df['price'].values, timeperiod=14)
resDF['CORREL'] = ta.CORREL(df['max_price'].values,
df['min_price'].values,
timeperiod=30)
resDF['DEMA'] = ta.DEMA(df['price'].values, timeperiod=30)
resDF['DX'] = ta.DX(df['max_price'].values,
df['min_price'].values,
df['price'].values,
timeperiod=14)
resDF['EMA'] = ta.EMA(df['price'].values, timeperiod=30)
resDF['HT_DCPERIOD'] = ta.HT_DCPERIOD(df['price'].values)
resDF['HT_DCPHASE'] = ta.HT_DCPHASE(df['price'].values)
resDF['inphase'], resDF['quadrature'] = ta.HT_PHASOR(df['price'].values)
resDF['sine'], resDF['leadsine'] = ta.HT_SINE(df['price'].values)
resDF['HT_TRENDLINE'] = ta.HT_TRENDLINE(df['price'].values)
resDF['HT_TRENDMODE'] = ta.HT_TRENDMODE(df['price'].values)
resDF['KAMA'] = ta.KAMA(df['price'].values, timeperiod=30)
resDF['LINEARREG'] = ta.LINEARREG(df['price'].values, timeperiod=14)
resDF['LINEARREG_ANGLE'] = ta.LINEARREG_ANGLE(df['price'].values,
timeperiod=14)
resDF['LINEARREG_INTERCEPT'] = ta.LINEARREG_INTERCEPT(df['price'].values,
timeperiod=14)
resDF['LINEARREG_SLOPE'] = ta.LINEARREG_SLOPE(df['price'].values,
timeperiod=14)
resDF['MA'] = ta.MA(df['price'].values, timeperiod=30, matype=0)
resDF['macd'], resDF['macdsignal'], resDF['macdhist'] = ta.MACD(
df['price'].values, fastperiod=12, slowperiod=26, signalperiod=9)
resDF['macd'], resDF['macdsignal'], resDF['macdhist'] = ta.MACDEXT(
df['price'].values,
fastperiod=12,
fastmatype=0,
slowperiod=26,
slowmatype=0,
signalperiod=9,
signalmatype=0)
resDF['macd'], resDF['macdsignal'], resDF['macdhist'] = ta.MACDFIX(
df['price'].values, signalperiod=9)
#resDF['mama'], resDF['fama'] = ta.MAMA (df['price'].values, fastlimit=0, slowlimit=0)
resDF['MAX'] = ta.MAX(df['price'].values, timeperiod=30)
resDF['MAXINDEX'] = ta.MAXINDEX(df['price'].values, timeperiod=30)
resDF['MEDPRICE'] = ta.MEDPRICE(df['max_price'].values,
df['min_price'].values)
resDF['MFI'] = ta.MFI(df['price_today_open'].values,
df['max_price'].values,
df['min_price'].values,
df['price'].values,
timeperiod=14)
resDF['MIDPOINT'] = ta.MIDPOINT(df['price'].values, timeperiod=14)
resDF['MIDPRICE'] = ta.MIDPRICE(df['max_price'].values,
df['min_price'].values,
timeperiod=14)
resDF['MIN'] = ta.MIN(df['price'].values, timeperiod=30)
resDF['MININDEX'] = ta.MININDEX(df['price'].values, timeperiod=30)
resDF['min'], resDF['max'] = ta.MINMAX(df['price'].values, timeperiod=30)
resDF['minidx'], resDF['maxidx'] = ta.MINMAXINDEX(df['price'].values,
timeperiod=30)
resDF['MINUS_DI'] = ta.MINUS_DI(df['max_price'].values,
df['min_price'].values,
df['price'].values,
timeperiod=14)
resDF['MINUS_DM'] = ta.MINUS_DM(df['max_price'].values,
df['min_price'].values,
timeperiod=14)
resDF['MOM'] = ta.MOM(df['max_price'].values, timeperiod=10)
resDF['NATR'] = ta.NATR(df['max_price'].values,
df['min_price'].values,
df['price'].values,
timeperiod=14)
# 函数名：OBV 名称：On Balance Volume 能量潮
# 简介：Joe Granville提出，通过统计成交量变动的趋势推测股价趋势计算公式：以某日为基期，逐日累计每日上市股票总成交量，若隔日指数或股票上涨，则基期OBV加上本日成交量为本日OBV。隔日指数或股票下跌，则基期OBV减去本日成交量为本日OBV
# 研判：1、以“N”字型为波动单位，一浪高于一浪称“上升潮”，下跌称“跌潮”；上升潮买进，跌潮卖出
# 2、须配合K线图走势
# 3、用多空比率净额法进行修正，但不知TA-Lib采用哪种方法
# 多空比率净额= [（收盘价－最低价）－（最高价-收盘价）] ÷（ 最高价－最低价）×成交量
# 例子：real = OBV(close, volume)
resDF['OBV'] = ta.OBV(df['price'].values, df['vol'].values)
# resDF['PLUS_DI'] = ta.PLUS_DI
# resDF['PLUS_DM'] = ta.PLUS_DM
resDF['PPO'] = ta.PPO(df['price'].values,
fastperiod=12,
slowperiod=26,
matype=0)
resDF['ROC'] = ta.ROC(df['price'].values, timeperiod=10)
resDF['ROCP'] = ta.ROCP(df['price'].values, timeperiod=10)
resDF['ROCR'] = ta.ROCR(df['price'].values, timeperiod=10)
resDF['ROCR100'] = ta.ROCR100(df['price'].values, timeperiod=10)
resDF['RSI'] = ta.RSI(df['price'].values, timeperiod=14)
resDF['SAR'] = ta.SAR(df['max_price'].values,
df['min_price'].values,
acceleration=0,
maximum=0)
resDF['SAREXT'] = ta.SAREXT(df['max_price'].values,
df['min_price'].values,
startvalue=0,
offsetonreverse=0,
accelerationinitlong=0,
accelerationlong=0,
accelerationmaxlong=0,
accelerationinitshort=0,
accelerationshort=0,
accelerationmaxshort=0)
resDF['SMA'] = ta.SMA(df['price'].values, timeperiod=30)
resDF['STDDEV'] = ta.STDDEV(df['price'].values, timeperiod=5, nbdev=1)
# resDF['STOCH'] = ta.STOCH
# resDF['STOCHF'] = ta.STOCHF
resDF['fastk'], resDF['fastd'] = ta.STOCHRSI(df['price'].values,
timeperiod=14,
fastk_period=5,
fastd_period=3,
fastd_matype=0)
resDF['SUM'] = ta.SUM(df['price'].values, timeperiod=30)
resDF['T3'] = ta.T3(df['price'].values, timeperiod=5, vfactor=0)
resDF['TEMA'] = ta.TEMA(df['price'].values, timeperiod=30)
resDF['TRANGE'] = ta.TRANGE(df['max_price'].values, df['min_price'].values,
df['price'].values)
resDF['TRIMA'] = ta.TRIMA(df['price'].values, timeperiod=30)
resDF['TRIX'] = ta.TRIX(df['price'].values, timeperiod=30)
resDF['TSF'] = ta.TSF(df['price'].values, timeperiod=14)
resDF['TYPPRICE'] = ta.TYPPRICE(df['max_price'].values,
df['min_price'].values, df['price'].values)
# resDF['ULTOSC'] = ta.ULTOSC
resDF['VAR'] = ta.VAR(df['price'].values, timeperiod=5, nbdev=1)
resDF['WCLPRICE'] = ta.WCLPRICE(df['max_price'].values,
df['min_price'].values, df['price'].values)
# resDF['WILLR'] = ta.WILLR
resDF['WMA'] = ta.WMA(df['price'].values, timeperiod=30)
return resDF
div = ta.DIV(high, low)
#MAX - Highest value over a specified period
maxv = ta.MAX(close, timeperiod=30)
#MAXINDEX - Index of highest value over a specified period
maxindex = ta.MAXINDEX(close, timeperiod=30)
#MIN - Lowest value over a specified period
minv = ta.MIN(close, timeperiod=30)
#MININDEX - Index of lowest value over a specified period
minindex = ta.MININDEX(close, timeperiod=30)
#MINMAX - Lowest and highest values over a specified period
minsp, maxsp = ta.MINMAX(close, timeperiod=30)
#MINMAXINDEX - Indexes of lowest and highest values over a specified period
minidx, maxidx = ta.MINMAXINDEX(close, timeperiod=30)
#MULT - Vector Arithmetic Mult
mult = ta.MULT(high, low)
#SUB - Vector Arithmetic Substraction
sub = ta.SUB(high, low)
#SUM - Summation
sum = ta.SUM(close, timeperiod=30)
df_save = pd.DataFrame(
data={
df.index=pd.to_datetime(df.date)
df=df.sort_index()
return df
#获取上证指数收盘价、最高、最低价格
df=get_data('sh')[['open','close','high','low']]
#最高价与最低价之和
df['add']=ta.ADD(df.high,df.low)
#最高价与最低价之差
df['sub']=ta.SUB(df.high,df.low)
#最高价与最低价之乘
df['mult']=ta.MULT(df.high,df.low)
#最高价与最低价之除
df['div']=ta.DIV(df.high,df.low)
#收盘价的每30日移动求和
df['sum']=ta.SUM(df.close, timeperiod=30)
#收盘价的每30日内的最大最小值
df['min'], df['max'] = ta.MINMAX(df.close, timeperiod=30)
#收盘价的每30日内的最大最小值对应的索引值（第N行）
df['minidx'], df['maxidx'] = ta.MINMAXINDEX(df.close, timeperiod=30)
df.tail()
#将上述函数计算得到的结果进行可视化
df[['close','add','sub','mult','div','sum','min','max']].plot(figsize=(12,10),
subplots = True,
layout=(4, 2))
plt.subplots_adjust(wspace=0,hspace=0.2)
plt.show()
def data_indicator(data,time,normal=False):
ml_datas = data.drop(data.columns, axis=1)
open = data.open.values
high = data.high.values
close = data.close.values
low = data.low.values
volume = data.volume.values
var = [open,high,close,low,volume]
var_name = ['open','high','close','low','volume']
# 单输入带时间单输出
#为了凑数，以下候补
#[talib.DEMA, talib.WMA, talib.MAXINDEX, talib.MININDEX, talib.TEMA ]
#["DEMA", "WMA", "MAXINDEX", "MININDEX", "TEMA"]
single = [talib.EMA, talib.KAMA, talib.MA, talib.MIDPOINT, talib.SMA, talib.T3, talib.TRIMA,
talib.CMO, talib.MOM, talib.ROC, talib.ROCP, talib.ROCR, talib.ROCR100, talib.RSI, talib.TRIX, talib.MAX,
talib.MIN, talib.SUM]
single_name = ["EMA", "KAMA", "MA", "MIDPOINT", "SMA", "T3", "TRIMA", "CMO", "MOM", "ROC", "ROCP",
"ROCR", "ROCR100", "RSI", "TRIX", "MAX", "MIN", "SUM"]
def single_output(f, x1, timeperiod):
z = f(x1, timeperiod)
return z
for i in time:
for v in range(len(var)):
for p in range(len(single)):
locals()[single_name[p] + str('_') + var_name[v] + str('_') + str(i)] = single_output(single[p], var[v],
timeperiod=i)
for i in time:
for v in range(len(var)):
for p in range(len(single)):
ml_datas[single_name[p] + str('_') + var_name[v] + str('_') + str(i)] = pd.Series(
locals()[single_name[p] + str('_') + var_name[v] + str('_') + str(i)], index=data.index)
#单输入带时间多输出
for i in time:
for v in range(len(var)):
locals()['BBANDS_upper'+ str('_') + var_name[v] + str('_') + str(i)], \
locals()['BBANDS_middle' + str('_') + var_name[v] + str('_') + str(i)],\
locals()['BBANDS_lower'+ str('_') + var_name[v] + str('_') + str(i)] = talib.BBANDS(var[v], timeperiod=i)
locals()['STOCHRSI_fastk' + str('_') + var_name[v] + str('_') + str(i)], \
locals()['STOCHRSI_fastd' + str('_') + var_name[v] + str('_') + str(i)] = talib.STOCHRSI(var[v], timeperiod=i)
locals()['MINMAX_min' + str('_') + var_name[v] + str('_') + str(i)], \
locals()['MINMAX_max' + str('_') + var_name[v] + str('_') + str(i)] = talib.MINMAX(var[v], timeperiod=i)
locals()['MINMAX_minidx' + str('_') + var_name[v] + str('_') + str(i)], \
locals()['MINMAX_maxidx' + str('_') + var_name[v] + str('_') + str(i)] = talib.MINMAXINDEX(var[v], timeperiod=i)
for i in time:
for v in range(len(var)):
ml_datas['BBANDS_upper'+ str('_') + var_name[v] + str('_') + str(i)] = pd.Series(
locals()['BBANDS_upper'+ str('_') + var_name[v] + str('_') + str(i)], index=data.index)
ml_datas['BBANDS_middle' + str('_') + var_name[v] + str('_') + str(i)] = pd.Series(
locals()['BBANDS_middle' + str('_') + var_name[v] + str('_') + str(i)], index=data.index)
ml_datas['BBANDS_lower' + str('_') + var_name[v] + str('_') + str(i)] = pd.Series(
locals()['BBANDS_lower' + str('_') + var_name[v] + str('_') + str(i)], index=data.index)
ml_datas['STOCHRSI_fastk' + str('_') + var_name[v] + str('_') + str(i)] = pd.Series(
locals()['STOCHRSI_fastk' + str('_') + var_name[v] + str('_') + str(i)], index=data.index)
ml_datas['STOCHRSI_fastd' + str('_') + var_name[v] + str('_') + str(i)] = pd.Series(
locals()['STOCHRSI_fastd' + str('_') + var_name[v] + str('_') + str(i)], index=data.index)
ml_datas['MINMAX_min' + str('_') + var_name[v] + str('_') + str(i)] = pd.Series(
locals()['MINMAX_min' + str('_') + var_name[v] + str('_') + str(i)], index=data.index)
ml_datas['MINMAX_max' + str('_') + var_name[v] + str('_') + str(i)] = pd.Series(
locals()['MINMAX_max' + str('_') + var_name[v] + str('_') + str(i)], index=data.index)
ml_datas['MINMAX_minidx' + str('_') + var_name[v] + str('_') + str(i)] = pd.Series(
locals()['MINMAX_minidx' + str('_') + var_name[v] + str('_') + str(i)], index=data.index)
ml_datas['MINMAX_maxidx' + str('_') + var_name[v] + str('_') + str(i)] = pd.Series(
locals()['MINMAX_maxidx' + str('_') + var_name[v] + str('_') + str(i)], index=data.index)
# 多输入带时间单输出
for i in time:
locals()['ATR' + str('_') + str(i)] = talib.ATR(high, low, close, timeperiod=i)
locals()['NATR' + str('_') + str(i)] = talib.NATR(high, low, close, timeperiod=i)
locals()['ADX' + str('_') + str(i)] = talib.ADX(high, low, close, timeperiod=i)
locals()['ADXR' + str('_') + str(i)] = talib.ADXR(high, low, close, timeperiod=i)
locals()['AROONOSC' + str('_') + str(i)] = talib.AROONOSC(high, low, timeperiod=i)
locals()['CCI' + str('_') + str(i)] = talib.CCI(high, low, close, timeperiod=i)
locals()['DX' + str('_') + str(i)] = talib.DX(high, low, close, timeperiod=i)
locals()['MFI' + str('_') + str(i)] = talib.MFI(high, low, close, volume, timeperiod=i)
locals()['MINUS_DI' + str('_') + str(i)] = talib.MINUS_DI(high, low, close, timeperiod=i)
locals()['MINUS_DM' + str('_') + str(i)] = talib.MINUS_DM(high, low, timeperiod=i)
locals()['PLUS_DI' + str('_') + str(i)] = talib.PLUS_DI(high, low, close, timeperiod=i)
locals()['PLUS_DM' + str('_') + str(i)] = talib.PLUS_DM(high, low, timeperiod=i)
locals()['WILLR' + str('_') + str(i)] = talib.WILLR(high, low, close, timeperiod=i)
locals()['MIDPRICE' + str('_') + str(i)] = talib.MIDPRICE(high, low, timeperiod=i)
locals()['AROON_aroondown' + str('_') + str(i)], locals()['AROON_aroonup' + str('_') + str(i)] = talib.AROON(high, low, timeperiod=i)
for i in time:
ml_datas['ATR'] = pd.Series(locals()['ATR' + str('_') + str(i)], index=data.index)
ml_datas['NATR'] = pd.Series(locals()['NATR' + str('_') + str(i)], index = data.index)
ml_datas['ADX'] = pd.Series(locals()['ADX' + str('_') + str(i)], index = data.index)
ml_datas['ADXR'] = pd.Series(locals()['ADXR' + str('_') + str(i)], index = data.index)
ml_datas['AROONOSC'] = pd.Series(locals()['AROONOSC' + str('_') + str(i)], index = data.index)
ml_datas['CCI'] = pd.Series(locals()['CCI' + str('_') + str(i)], index = data.index)
ml_datas['DX'] = pd.Series(locals()['DX' + str('_') + str(i)], index = data.index)
ml_datas['MFI'] = pd.Series(locals()['MFI' + str('_') + str(i)], index = data.index)
ml_datas['MINUS_DI'] = pd.Series(locals()['MINUS_DI' + str('_') + str(i)], index = data.index)
ml_datas['MINUS_DM'] = pd.Series(locals()['MINUS_DM' + str('_') + str(i)], index = data.index)
ml_datas['PLUS_DI'] = pd.Series(locals()['PLUS_DI' + str('_') + str(i)], index = data.index)
ml_datas['PLUS_DM'] = pd.Series(locals()['PLUS_DM' + str('_') + str(i)], index = data.index)
ml_datas['WILLR'] = pd.Series(locals()['WILLR' + str('_') + str(i)], index = data.index)
ml_datas['MIDPRICE'] = pd.Series(locals()['MIDPRICE' + str('_') + str(i)], index = data.index)
ml_datas['AROON_aroondown'] = pd.Series(locals()['AROON_aroondown' + str('_') + str(i)], index = data.index)
ml_datas['AROON_aroonup'] = pd.Series(locals()['AROON_aroonup' + str('_') + str(i)], index = data.index)
#单输入不带时间
# single2 = [talib.ACOS, talib.ASIN, talib.ATAN, talib.CEIL, talib.COS, talib.COSH, talib.EXP, talib.FLOOR, talib.LN,
# talib.LOG10, talib.SIN, talib.SINH, talib.SQRT, talib.TAN, talib.TANH, talib.HT_DCPERIOD,
# talib.HT_DCPHASE, talib.HT_TRENDMODE, talib.HT_TRENDLINE, talib.APO]
# single2_name = ["ACOS", "ASIN", "ATAN", "CEIL", "COS", "COSH", "EXP", "FLOOR", "LN", "LOG10", "SIN", "SINH", "SQRT",
# "TAN", "TANH", "HT_DCPERIOD", "HT_DCPHASE", "HT_TRENDMODE", "HT_TRENDLINE", "APO"]
#
# def single2_output(f, x1):
# z = f(x1)
# return z
#
# for v in range(len(var)):
# for p in range(len(single2)):
# locals()[single2_name[p] + str('_') + var_name[v]] = single2_output(single2[p], var[v])
#
# for v in range(len(var)):
# for p in range(len(single2)):
# ml_datas[single2_name[p] + str('_') + var_name[v]] = pd.Series(locals()[single2_name[p] + str('_') + var_name[v]])
#
#
# 模式识别类指标
pattern = [talib.CDL2CROWS, talib.CDL3BLACKCROWS, talib.CDL3INSIDE, talib.CDL3LINESTRIKE, talib.CDL3OUTSIDE,
talib.CDL3STARSINSOUTH, talib.CDL3WHITESOLDIERS, talib.CDLABANDONEDBABY, talib.CDLADVANCEBLOCK,
talib.CDLBELTHOLD, talib.CDLBREAKAWAY, talib.CDLCLOSINGMARUBOZU, talib.CDLCONCEALBABYSWALL,
talib.CDLCOUNTERATTACK, talib.CDLDARKCLOUDCOVER, talib.CDLDOJI, talib.CDLDOJISTAR,
talib.CDLDRAGONFLYDOJI,
talib.CDLENGULFING, talib.CDLEVENINGDOJISTAR, talib.CDLEVENINGSTAR, talib.CDLGAPSIDESIDEWHITE,
talib.CDLGRAVESTONEDOJI, talib.CDLHAMMER, talib.CDLHANGINGMAN, talib.CDLHARAMI, talib.CDLHARAMICROSS,
talib.CDLHIGHWAVE, talib.CDLHIKKAKE, talib.CDLHIKKAKEMOD, talib.CDLHOMINGPIGEON,
talib.CDLIDENTICAL3CROWS,
talib.CDLINNECK, talib.CDLINVERTEDHAMMER, talib.CDLKICKING, talib.CDLKICKINGBYLENGTH,
talib.CDLLADDERBOTTOM,
talib.CDLLONGLEGGEDDOJI, talib.CDLLONGLINE, talib.CDLMARUBOZU, talib.CDLMATCHINGLOW, talib.CDLMATHOLD,
talib.CDLMORNINGDOJISTAR, talib.CDLMORNINGSTAR, talib.CDLONNECK, talib.CDLPIERCING, talib.CDLRICKSHAWMAN,
talib.CDLRISEFALL3METHODS, talib.CDLSEPARATINGLINES, talib.CDLSHOOTINGSTAR, talib.CDLSHORTLINE,
talib.CDLSPINNINGTOP, talib.CDLSTALLEDPATTERN, talib.CDLXSIDEGAP3METHODS, talib.CDLSTICKSANDWICH,
talib.CDLTAKURI, talib.CDLTASUKIGAP, talib.CDLTHRUSTING, talib.CDLTRISTAR, talib.CDLUNIQUE3RIVER, talib.CDLUPSIDEGAP2CROWS]
pattern_name = ["CDL2CROWS", "CDL3BLACKCROWS", "CDL3INSIDE", "CDL3LINESTRIKE", "CDL3OUTSIDE", "CDL3STARSINSOUTH",
"CDL3WHITESOLDIERS", "CDLABANDONEDBABY", "CDLADVANCEBLOCK", "CDLBELTHOLD", "CDLBREAKAWAY",
"CDLCLOSINGMARUBOZU", "CDLCONCEALBABYSWALL", "CDLCOUNTERATTACK", "CDLDARKCLOUDCOVER", "CDLDOJI",
"CDLDOJISTAR", "CDLDRAGONFLYDOJI", "CDLENGULFING", "CDLEVENINGDOJISTAR", "CDLEVENINGSTAR",
"CDLGAPSIDESIDEWHITE", "CDLGRAVESTONEDOJI", "CDLHAMMER", "CDLHANGINGMAN", "CDLHARAMI", "CDLHARAMICROSS",
"CDLHIGHWAVE", "CDLHIKKAKE", "CDLHIKKAKEMOD", "CDLHOMINGPIGEON", "CDLIDENTICAL3CROWS", "CDLINNECK",
"CDLINVERTEDHAMMER", "CDLKICKING", "CDLKICKINGBYLENGTH", "CDLLADDERBOTTOM", "CDLLONGLEGGEDDOJI",
"CDLLONGLINE", "CDLMARUBOZU", "CDLMATCHINGLOW", "CDLMATHOLD", "CDLMORNINGDOJISTAR", "CDLMORNINGSTAR",
"CDLONNECK", "CDLPIERCING", "CDLRICKSHAWMAN", "CDLRISEFALL3METHODS", "CDLSEPARATINGLINES",
"CDLSHOOTINGSTAR", "CDLSHORTLINE", "CDLSPINNINGTOP", "CDLSTALLEDPATTERN","CDLXSIDEGAP3METHODS","CDLSTICKSANDWICH","CDLTAKURI", "CDLTASUKIGAP", "CDLTHRUSTING", "CDLTRISTAR", "CDLUNIQUE3RIVER", "CDLUPSIDEGAP2CROWS"]
def Pattern_Recognition(f, x1, x2, x3, x4):
z = f(x1, x2, x3, x4)
return z
for p in range(len(pattern)):
locals()[pattern_name[p]] = Pattern_Recognition(pattern[p], open, high, low, close)
for p in range(len(pattern)):
ml_datas[pattern_name[p]] = pd.Series(locals()[pattern_name[p]], index=data.index)
#杂乱指标
#为了凑数，ULTOSC多用了一遍
ADD = talib.ADD(high, low)
MULT = talib.MULT(high, low)
SUB = talib.SUB(high, low)
TRANGE = talib.TRANGE(high, low, close)
AD = talib.AD(high, low, close, volume)
ADOSC = talib.ADOSC(high, low, close, volume)
OBV = talib.OBV(close, volume)
BOP = talib.BOP(open, high, low, close)
ml_datas['ADD'] = pd.Series(ADD, index=data.index)
ml_datas['MULT'] = pd.Series(MULT, index=data.index)
ml_datas['SUB'] = pd.Series(SUB, index=data.index)
ml_datas['TRANGE'] = pd.Series(TRANGE, index=data.index)
ml_datas['AD'] = pd.Series(AD, index=data.index)
ml_datas['ADOSC'] = pd.Series(ADOSC, index=data.index)
ml_datas['OBV'] = pd.Series(OBV, index=data.index)
ml_datas['BOP'] = pd.Series(BOP, index=data.index)
HT_PHASOR_inphase, HT_PHASOR_quadrature = talib.HT_PHASOR(close)
HT_SINE_sine, HT_SINE_leadsine = talib.HT_SINE(close)
MACD_macd, MACD_macdsignal, MACD_macdhist = talib.MACD(close)
MACDEXT_macd, MACDEXT_macdsignal, MACDEXT_macdhist = talib.MACDEXT(close)
MACDFIX_macd, MACDFIX_macdsignal, MACDFIX_macdhist = talib.MACDFIX(close)
PPO = talib.PPO(close)
MAMA_mama, MAMA_fama = talib.MAMA(close)
STOCH_slowk, STOCH_slowd = talib.STOCH(high, low, close)
STOCHF_fastk, STOCHF_fastd = talib.STOCHF(high, low, close)
SAR = talib.SAR(high, low)
SAREXT = talib.SAREXT(high, low)
ULTOSC = talib.ULTOSC(high, low, close, timeperiod1=7, timeperiod2=14, timeperiod3=28)
ml_datas['HT_PHASOR_inphase'] = pd.Series(HT_PHASOR_inphase, index=data.index)
ml_datas['HT_PHASOR_quadrature'] = pd.Series(HT_PHASOR_quadrature, index=data.index)
ml_datas['HT_SINE_sine'] = pd.Series(HT_SINE_sine, index=data.index)
ml_datas['HT_SINE_leadsine'] = pd.Series(HT_SINE_leadsine, index=data.index)
ml_datas['MACD_macd'] = pd.Series(MACD_macd, index=data.index)
ml_datas['MACD_macdsignal'] = pd.Series(MACD_macdsignal, index=data.index)
ml_datas['MACD_macdhist'] = pd.Series(MACD_macdhist, index=data.index)
ml_datas['MACDEXT_macd'] = pd.Series(MACDEXT_macd, index=data.index)
ml_datas['MACDEXT_macdsignal'] = pd.Series(MACDEXT_macdsignal, index=data.index)
ml_datas['MACDEXT_macdhist'] = pd.Series(MACDEXT_macdhist, index=data.index)
ml_datas['MACDFIX_macd'] = pd.Series(MACDFIX_macd, index=data.index)
ml_datas['MACDFIX_macdsignal'] = pd.Series(MACDFIX_macdsignal, index=data.index)
ml_datas['MACDFIX_macdhist'] = pd.Series(MACDFIX_macdhist, index=data.index)
ml_datas['PPO'] = pd.Series(PPO, index=data.index)
ml_datas['MAMA_mama'] = pd.Series(MAMA_mama, index=data.index)
ml_datas['MAMA_fama'] = pd.Series(MAMA_fama, index=data.index)
ml_datas['STOCH_slowk'] = pd.Series(STOCH_slowk, index=data.index)
ml_datas['STOCH_slowd'] = pd.Series(STOCH_slowd, index=data.index)
ml_datas['STOCHF_fastk'] = pd.Series(STOCHF_fastk, index=data.index)
ml_datas['STOCHF_fastd'] = pd.Series(STOCHF_fastd, index=data.index)
ml_datas['SAR'] = pd.Series(SAR, index=data.index)
ml_datas['SAREXT'] = pd.Series(SAREXT, index=data.index)
ml_datas['ULTOSC'] = pd.Series(ULTOSC, index=data.index)
ml_datas['ULTOSC_VAR'] = pd.Series(ULTOSC, index=data.index)
# 将原始数据集的数据移动一天，使每天收盘价数据的特征训练的时候用前一天的信息
ml_datas = ml_datas.shift(1)
ml_datas['target'] = close*100
#var_datas = ml_datas.drop(ml_datas.columns, axis=1)
#var_datas['target'] = var_datas.sum(axis=1) * 100
#ml_datas['target'] = var_datas['target']
#ml_datas = ml_datas.dropna(how='all', axis=1) #删掉都是NA的列
ml_datas = ml_datas.dropna(how='any', axis=0)
if normal:
X_ori = ml_datas.drop(['target'], axis=1)
scaler = preprocessing.StandardScaler().fit(X_ori)
X = scaler.transform(X_ori)
X_ori = pd.DataFrame(X,index=X_ori.index,columns=X_ori.columns)
format = lambda x: '%.1f' % x
X_ori['target'] = ml_datas['target'].map(format).map(float) #保留n位小数，然后转回float
#X_ori['target'] = pd.Series(ml_datas['target'],dtype=str)
ml_datas = X_ori.copy()
return ml_datas
def MINMAX(self, name, **parameters):
data = self.__data[name]
return talib.MINMAX(data, **parameters)
def main():
# read csv file and transform it to datafeed (df):
df = pd.read_csv(current_dir + "/" + base_dir + "/" + in_dir + "/" +
in_dir + '_' + stock_symbol + '.csv')
# set numpy datafeed from df:
df_numpy = {
'date': np.array(df['date']),
'open': np.array(df['open'], dtype='float'),
'high': np.array(df['high'], dtype='float'),
'low': np.array(df['low'], dtype='float'),
'close': np.array(df['close'], dtype='float'),
'volume': np.array(df['volume'], dtype='float')
}
date = df_numpy['date']
openp = df_numpy['open']
high = df_numpy['high']
low = df_numpy['low']
close = df_numpy['close']
volume = df_numpy['volume']
#########################################
##### Math Operator Functions ######
#########################################
#ADD - Vector Arithmetic Add
add = ta.ADD(high, low)
#DIV - Vector Arithmetic Div
div = ta.DIV(high, low)
#MAX - Highest value over a specified period
maxv = ta.MAX(close, timeperiod=30)
#MAXINDEX - Index of highest value over a specified period
maxindex = ta.MAXINDEX(close, timeperiod=30)
#MIN - Lowest value over a specified period
minv = ta.MIN(close, timeperiod=30)
#MININDEX - Index of lowest value over a specified period
minindex = ta.MININDEX(close, timeperiod=30)
#MINMAX - Lowest and highest values over a specified period
minsp, maxsp = ta.MINMAX(close, timeperiod=30)
#MINMAXINDEX - Indexes of lowest and highest values over a specified period
minidx, maxidx = ta.MINMAXINDEX(close, timeperiod=30)
#MULT - Vector Arithmetic Mult
mult = ta.MULT(high, low)
#SUB - Vector Arithmetic Substraction
sub = ta.SUB(high, low)
#SUM - Summation
sum = ta.SUM(close, timeperiod=30)
df_save = pd.DataFrame(
data={
'date': np.array(df['date']),
'add': add,
'div': div,
'max': maxv,
'maxindex': maxindex,
'min': minv,
'minindex': minindex,
'min_spec_period': minsp,
'max_spec_period': maxsp,
'minidx': minidx,
'maxidx': maxidx,
'mult': mult,
'sub': sub,
'sum': sum
})
df_save.to_csv(current_dir + "/" + base_dir + "/" + out_dir + '/' +
stock_symbol + "/" + out_dir + '_ta_math_operator_' +
stock_symbol + '.csv',
index=False)
def MINMAX(Close, timeperiod=30):
min, max = pd.DataFrame(), pd.DataFrame()
for i in Close.columns:
min[i], max[i] = ta.MINMAX(Close[i], timeperiod)
return min, max
def total(self, dfs, dfs2=None, scale=1, period=60):
uid = self.uidKey % ("_".join(self.codes), str(period), str(scale),
self.klineType[:-1], str(self.shiftScale))
df0, df1 = dfs[self.mCodes[0]], dfs[self.mCodes[1]]
df0["rel_price"] = close = df0["close"] / df1["close"]
df0["datetime"] = df0.index
# 模拟滑点
num = len(df0)
s0, s1 = self.shift[0], self.shift[1]
p_l = df0["p_l"] = (df0["close"] + s0) / (df1["close"] - s1)
p_h = df0["p_h"] = (df0["close"] - s0) / (df1["close"] + s1)
close2 = dfs2[self.mCodes[0]]["close"] / dfs2[self.mCodes[1]]["close"]
#ma = ta.MA(close, timeperiod=period)
#df0["rel_std"] = sd = ta.STDDEV(close, timeperiod=period, nbdev=1)
df0['ma'] = ma = df0.apply(lambda row: self.k_ma(
row['datetime'], row['rel_price'], close2, period, 0),
axis=1)
df0['rel_std'] = sd = df0.apply(lambda row: self.k_ma(
row['datetime'], row['rel_price'], close2, period, 1),
axis=1)
# 上下柜
top, lower = ma + scale * sd, ma - scale * sd
# bullWidth
df0["bullwidth"] = width = (4 * sd / ma * 100).fillna(0)
# 近三分钟width变动
df0["widthDelta"] = ta.MA(width - width.shift(1),
timeperiod=3).fillna(0)
df0["delta"] = (p_l - p_h) / sd
# 其他参数计算
min, max = ta.MINMAX(close, timeperiod=period)
df0["atr"] = ta.WMA((max.dropna() - min.dropna()),
timeperiod=period / 2)
# 协整
result = sm.tsa.stattools.coint(df0["close"], df1["close"])
df0.fillna(0, inplace=True)
isOpen, preDate, prePrice = 0, None, 0
doc, doc1, docs = {}, {}, []
for i in range(num):
isRun = False
if i < period and np.isnan(ma[i]): continue
# 开仓
if isOpen == 0:
# 大于上线轨迹
if p_h[i] >= top[i]:
isOpen = -1
isRun = True
elif p_l[i] <= lower[i]:
isOpen = 1
isRun = True
# 平仓
else:
# 回归ma则平仓 或 超过24分钟 或到收盘时间 强制平仓
if (isOpen *
((p_h[i] if isOpen == 1 else p_l[i]) - ma[i])) >= 0:
isOpen = 0
isRun = True
# 止损
if isRun:
doc, doc1 = self.order(df0.iloc[i], df1.iloc[i], isOpen, uid)
if doc1 is not None:
docs.append(doc)
docs.append(doc1)
res = pd.DataFrame(docs)
#res.fillna(0,inplace=True)
if len(res) > 0:
if self.saveDetail:
print(self.Train.tablename, len(res), 'save')
self.Train.insertAll(docs)
return {
"scale":
scale,
"code":
self.codes[0],
"code1":
self.codes[1],
"period":
period,
"count":
int(len(docs) / 4),
"amount":
(doc["price"] * doc["vol"] +
doc1["price"] * doc1["vol"]) if doc is not None else 0,
"price":
doc["price"] / doc1["price"],
"income":
res["income"].sum(),
"uid":
uid,
"relative":
per(df0["close"], df1["close"]),
"std":
res['rel_std'].mean(),
"shift": (p_l - p_h).mean(),
"delta":
res['delta'].mean(),
"coint":
0 if np.isnan(result[1]) else result[1],
"createdate":
public.getDatetime()
}
else:
return None
def TALIB_MINMAX(close, timeperiod=30):
'''00364,2,2'''
return talib.MINMAX(close, timeperiod)
def total(self, df0, df1=None, scale=1, period=60):
uid = self.uid
df0["rel_price"] = close = df0["close"] / df1["close"]
df0["datetime"] = df0.index
s0, s1 = self.shift[0], self.shift[1]
p_l = df0["p_l"] = (df0["close"] + s0) / (df1["close"] - s1)
p_h = df0["p_h"] = (df0["close"] - s0) / (df1["close"] + s1)
num = len(df0)
ma = ta.MA(close[0:num], timeperiod=period)
df0["std"] = std = ta.STDDEV(close, timeperiod=period, nbdev=1)
# 上下柜
top, lower = ma + scale * std, ma - scale * std
# bullWidth
df0["bullwidth"] = width = (4 * std / ma * 100).fillna(0)
# 近三分钟width变动
df0["widthDelta"] = wd1 = ta.MA(width - width.shift(1),
timeperiod=3).fillna(0)
df0["delta"] = (p_l - p_h) / std
wd2 = wd1 - wd1.shift(1)
wd2m = wd2 * wd2.shift(1)
# 其他参数计算
min, max = ta.MINMAX(close, timeperiod=period)
df0["atr"] = ta.WMA((max.dropna() - min.dropna()),
timeperiod=period / 2)
# 协整
result = sm.tsa.stattools.coint(df0["close"], df1["close"])
df0.fillna(0, inplace=True)
isOpen, preDate, prePrice = 0, None, 0
doc, doc1, docs = {}, {}, []
sline, wline = self.stopTimeDiff, self.widthDeltaLine
for i in range(period, num):
isRun, isstop = False, 0
# 开仓2
if isOpen == 0:
cond1, cond2 = True, False
if wline > 0:
# 布林宽带变化率
cond1 = not ((wd1[i] > wline) or (wd2[i] > (wline / 2)))
# 最大值
cond2 = wd2m[i] < 0
# 突变状态开始
# 大于上线轨迹
if p_h[i] >= top[i] and not cond1:
isOpen = -1
isRun = True
elif p_l[i] <= lower[i] and not cond1:
isOpen = 1
isRun = True
elif p_h[i] >= top[i] and cond1 and cond2:
isOpen = -2
isRun = True
elif p_l[i] <= lower[i] and cond1 and cond2:
isOpen = 2
isRun = True
# 平仓
else:
# 回归ma则平仓 或 超过24分钟 或到收盘时间 强制平仓
if (isOpen *
((p_h[i] if isOpen == 1 else p_l[i]) - ma[i])) >= 0:
isOpen = 0
isRun = True
# 止损
elif sline > 0 and self.preNode and len(self.preNode) == 2:
timediff = public.timeDiff(
df0['datetime'].values,
self.preNode[0]['createdate']) / 60
if timediff > sline:
isOpen, isstop = 0, 1
isRun = True
if isRun:
doc, doc1 = self.order(df0.iloc[i],
df1.iloc[i],
isOpen,
uid,
isstop=isstop)
if doc1 is not None:
docs.append(doc)
docs.append(doc1)
res = pd.DataFrame(docs).fillna(0).replace(np.inf,
0).replace(-np.inf, 0)
if self.saveDetail:
self.Train.insertAll(res.to_dict(orient='records'))
if len(res) > 0:
return {
"scale":
scale,
"code":
self.codes[0],
"code1":
self.codes[1],
"period":
period,
"count":
int(len(docs) / 4),
"amount":
(doc["price"] * doc["vol"] +
doc1["price"] * doc1["vol"]) if doc is not None else 0,
"price":
doc["price"] / doc1["price"],
"income":
res["income"].sum(),
"uid":
uid,
"relative":
per(df0["close"], df1["close"]),
"std":
std.mean(),
"shift": (p_l - p_h).mean(),
"delta": (p_l - p_h).mean() / std.mean(),
"coint":
0 if np.isnan(result[1]) else result[1],
"createdate":
public.getDatetime()
}
else:
return None
