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 total(self, dfs, period=14):
# 计算参数
df0 = dfs[self.mCodes[0]]
close = df0["close"]
df0["datetime"] = df0.index
df0['mcode'] = rq.get_dominant_future(self.code,
start_date=self.startDate,
end_date=self.endDate)
df0['high_5'] = ta.MAX(df0['high'].shift(1), timeperiod=self.preDays)
df0['low_5'] = ta.MIN(df0['low'].shift(1), timeperiod=self.preDays)
df0['high_p'] = df0['high'].shift(1)
df0['low_p'] = df0['low'].shift(1)
df0['atr'] = ta.ATR(df0['high'], df0['low'], close, timeperiod=period)
df0['mcode_1'] = df0['mcode'].shift(1)
df0['isAlter'] = df0.apply(lambda r: 1
if r['mcode'] != r['mcode_1'] else 0,
axis=1)
df1 = df0.apply(lambda row: self.jump0(row), axis=1)
for key in self.pointColumns:
df0[key] = df1[key]
df0['jump_min'], df0['jump_max'] = ta.MINMAXINDEX(
df0['jump0'], timeperiod=self.keepDays + 1)
df2 = df0.apply(lambda row: self.jumps(row, df0), axis=1)
for key in self.pointColumns2:
df0[key] = df2[key]
# 循环 scale
docs = []
for conds in self.iterCond():
uid = self.uidKey % ('_'.join(self.codes), str(period),
self.klineType, str(self.bullwidth), conds)
if self.code in self.csvList:
file = self.Rice.basePath + '%s_pre.csv' % (uid)
print(uid, '---------------------------- to_cvs', file,
df0.columns)
df0.to_csv(file, index=0)
#tot = None
tot = self.detect(df0, period=period, uid=uid)
if tot is not None and tot['amount'] != 0:
tot.update({
"method": self.method,
"code": self.code,
"period": period,
"uid": uid,
"createdate": public.getDatetime()
})
docs.append(tot)
return docs
def MINMAXINDEX(close, timeperiod=30):
''' Indexes of lowest and highest values over a specified period 周期内最小值和最大值索引
分组: Math Operator 数学运算符
简介: (返回元组````元组（array【最小】，array【最大】）```)
minidx, maxidx = MINMAXINDEX(close, timeperiod=30)
'''
return talib.MINMAXINDEX(close, timeperiod)
def minmaxindex(client, symbol, timeframe="6m", col="close", period=30):
"""This will return a dataframe of
Indexes 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)
x, y = t.MINMAXINDEX(df[col].values, period)
return x, df[col].values[x], y, df[col].values[y]
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 autoCreateAtr(self, type=0):
Rice = interface_Rice()
Rice.setIndexList(self.indexCodeList)
Base = future_baseInfo()
Record = self.Record = future_orderForm()
Model = model_future_zhao_v1()
methods = ['mZhao', 'mZhao55']
self.iniAmount, self.stopLine = 15400000, 0.0025
if type == 1:
methods = ['zhao', 'zhao55']
self.iniAmount, self.stopLine = 20000000, 0.0025
codes = Base.getUsedMap(hasIndex=True)
BI = BaseInfo(codes)
mCodes = Rice.getMain(codes)
#print(codes)
end = None
dd = str(public.getTime(style='%H:%M:%S'))
valids = Rice.getValidDate(start=-15, end=0)
if ('18:15:00' < dd < '23:59:59'):
end = public.getDate(diff=0)
else:
end = str(valids[-2])
dfs = Rice.kline(mCodes,
period='1d',
start=public.getDate(diff=-150),
end=end,
pre=20)
docs = []
Tmap = Record.trendMap(methods)
Pos = []
j = 0
for m in methods:
Pos.append(Record.getOpenMap(method=m, batchNum=1))
for mcode in mCodes:
code = BI.parseCode(mcode)
if code in self.banCodeList: continue
df = dfs[mcode]
close = df['close']
df["datetime"] = df.index
df["ma10"] = ma10 = ta.MA(close, timeperiod=10)
df["ma20"] = ma20 = ta.MA(close, timeperiod=20)
df["ma55"] = ta.MA(close, timeperiod=55)
atr21 = ta.ATR(df['high'], df['low'], close, timeperiod=21)
df['3atr'] = atr21 * 3
# 计算ma10-ma20 穿越线间距
df['mac'] = mac = ma10 - ma20
df['mac2'] = mac.shift(2)
df['mac3'] = mac.shift(3)
# isPoint
df['mad'] = mac * mac.shift(1)
df['mam'] = mam = df.apply(lambda row: self.isMam(row), axis=1)
minidx, maxidx = ta.MINMAXINDEX(mam, timeperiod=75)
df['interval'] = abs(minidx - maxidx)
# 修正不正常K线
df['high'] = df.apply(lambda row: self.k_fix(row, 1), axis=1)
df['low'] = df.apply(lambda row: self.k_fix(row, -1), axis=1)
# 唐奇安线18日
df['tu_s'] = ta.MAX(df['high'], timeperiod=18 - 1)
df['td_s'] = ta.MIN(df['low'], timeperiod=18 - 1)
# 唐奇安线27日
df['tu_s1'] = ta.MAX(df['high'], timeperiod=27 - 1)
df['td_s1'] = ta.MIN(df['low'], timeperiod=27 - 1)
# 唐奇安线34日
df['tu_34'] = ta.MAX(df['high'], timeperiod=33)
df['td_34'] = ta.MIN(df['low'], timeperiod=33)
# 40日低点
ld = close[close.notnull()]
p = 40 if len(ld) > 40 else len(ld) - 1
df['tu_d'] = ta.MAX(df['high'], timeperiod=p - 1)
df['td_d'] = ta.MIN(df['low'], timeperiod=p - 1)
fp, fd = 27, 5
# 计算穿越值
out = df.apply(lambda row: self.isout0(row), axis=1)
df['out_s'] = ta.SUM(out, timeperiod=fp)
df['trend'] = df['out_s'].apply(lambda x: -1 if x > fd else 1
if x < -fd else 0)
#posTrend = 0 if code not in trendMap else trendMap[code]['trend']
df['isout'] = isout = df.apply(lambda row: self.isout(row, 0),
axis=1)
df['isout3'] = ta.SUM(isout, timeperiod=3)
df['isout5'] = ta.SUM(isout, timeperiod=5)
param = copy.deepcopy(df.iloc[-1]).to_dict()
isLong, type = 1, 0
if code in Tmap:
isLong = Tmap[code]['trend']
type = 1
elif param['trend'] != 0:
isLong = param['trend']
type = 2
else:
isLong = -1 if param['ma20'] > param['ma55'] else 1
type = 3
j += 1
isL = -1 if code in self.shortCodeList else 1 if code in self.longCodeList else 0
if code in []:
print(code, isLong, isL, param['trend'])
file = Rice.basePath + '%s_%s_%s.csv' % (
code, public.getDatetime(style='%Y%m%d_%H%M%S'),
methods[0])
df.to_csv(file, index=0)
# 计算交易手数
mul = BI.att(code, "contract_multiplier")
dp = param['td_d'] if isLong > 0 else param['tu_d']
p18 = param['tu_s'] if isLong > 0 else param['td_s']
p27 = param['tu_s1'] if isLong > 0 else param['td_s1']
if np.isnan(param['ma55']) or np.isnan(p18):
print('period no long:', code)
continue
ma20v_18 = (self.iniAmount * self.stopLine / abs(p18 - dp) / mul)
ma20v_18 = int(ma20v_18 + 0.2)
ma20v_27 = (self.iniAmount * self.stopLine / abs(p27 - dp) / mul)
ma20v_27 = int(ma20v_27 + 0.2)
#
ma55v = (self.iniAmount * self.stopLine / param['3atr'] / mul)
ma55v = int(ma55v + 0.2)
# 固定一手交易
if code in self.oneCodeList:
ma55v = ma20v_18 = ma20v_27 = 1
# 计算持仓和止损
p = np.zeros((2, 3))
i = 0
mp = 0
for pos in Pos:
if code in pos:
d = pos[code][0]
# 最近高点
sign = np.sign(int(d['mode']))
p[i][0] = sign * d['hands']
p[i][2] = mul * d['hands'] * (param['close'] -
d['price']) * sign
if i == 0:
p[i][1] = param['td_d'] if sign > 0 else param['tu_d']
else:
mp = self.getMax(df, d['createdate'],
public.getDate(diff=1), d['mode'])
if np.isnan(mp):
print('no max Price:', code, mp)
p[i][1] = round(mp, 1) - sign * round(param['3atr'], 1)
i += 1
param.update({
'code': mcode,
'方向': '多' if isLong == 1 else '空',
'price_18': p18,
'vol_18': ma20v_18,
'price_27': p27,
'vol_27': ma20v_27,
'vol_55': ma55v,
'乘数': mul,
'3ATR': round(param['3atr'], 1),
'系统1持仓': p[0][0],
'price_40': dp,
'40日止损价': p[0][1],
'浮盈1': p[0][2],
'系统2持仓': p[1][0],
'最高点': mp,
'3ATR止损价': p[1][1],
'浮盈2': p[1][2],
'状态': Model.getStatus(methods, code),
'指定方向': Model.getTrend(code),
})
docs.append(param)
res = pd.DataFrame(docs,
columns=[
'code', 'close', '方向', 'price_40', 'price_18',
'vol_18', 'price_27', 'vol_27', '3ATR',
'vol_55', '乘数', '系统1持仓', '40日止损价', '浮盈1',
'系统2持仓', '最高点', '3ATR止损价', '浮盈2', '状态', '指定方向'
])
res = res.sort_values('code', ascending=True)
file = Rice.basePath + 'future_%s_%s.csv' % (public.getDate(),
methods[0])
res.to_csv(file, index=0)
logger.info(('autoCreateAtr finished:', len(docs)))
return res
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 MINMAXINDEX(data, **kwargs):
_check_talib_presence()
prices = _extract_series(data)
return talib.MINMAXINDEX(prices, **kwargs)
def MINMAXINDEX(Close, timeperiod=30):
minidx, maxidx = pd.DataFrame(), pd.DataFrame()
for i in Close.columns:
minidx[i], maxidx[i] = ta.MINMAXINDEX(Close[i], timeperiod)
return minidx, maxidx
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
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,
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 MINMAXINDEX(self, name, **parameters):
data = self.__data[name]
return talib.MINMAXINDEX(data, **parameters)
def total(self, dfs, dfs2=None, period=60):
# 计算参数
df0 = dfs[self.mCodes[0]]
df0["rel_price"] = close = df0["close"]
df0["datetime"] = df0.index
cc = close.reset_index(drop=True)
df0["No"] = cc.index
# bull
df0["ma"] = ma = ta.SMA(close, timeperiod=period)
df0["ma5"] = ma5 = ta.SMA(close, timeperiod=5)
df0["s5"] = ta.LINEARREG_SLOPE(ma5, timeperiod=2)
df0["std"] = std = ta.STDDEV(close, timeperiod=period, nbdev=1)
df0["std5"] = std5 = ta.STDDEV(close, timeperiod=5, nbdev=1)
df0["top"], df0["lower"] = ma + 2 * std, ma - 2 * std
df0["wds"] = self.stand(4 * std * 100 / ma, period=period)
#df0['isout'] = isout = df0.apply(lambda row: self.isout(row), axis=1)
#df0['isout3'] = ta.SUM(isout, timeperiod=3)
# 趋势计算
df0['mas'] = mas = ma5 - ma
df0['mam5'] = mas * mas.shift(1)
df0['mam5'] = om = df0.apply(lambda row: self.mam(row), axis=1)
df0['mio'], df0['mao'] = ta.MINMAXINDEX(om, timeperiod=50)
df0['interval'] = df0.apply(lambda row: self.getInterval(row), axis=1)
# 计算止损
df0['maxp'] = df0.apply(
lambda row: self.getLastMax(row, df0['high'], df0['low']), axis=1)
# 上下柜
width = (4 * std / ma * 100).fillna(0)
df0["wds"] = self.stand(width)
# 短期价格波动参数值
df0["slope"] = self.stand(ta.LINEARREG_SLOPE(close, timeperiod=period))
# kdj顶点
kdjK, kdjD = ta.STOCH(df0["high"],
df0["low"],
close,
fastk_period=5,
slowk_period=3,
slowk_matype=1,
slowd_period=3,
slowd_matype=1)
df0["kdj_d2"] = kdj_d2 = kdjK - kdjD
df0["kdjm"] = kdj_d2 * kdj_d2.shift(1)
df0["kdjm"] = df0.apply(
lambda row: self.turn(row['kdjm'], row['kdj_d2'], 1), axis=1)
df0['atr'] = ta.ATR(df0['high'], df0['low'], close, timeperiod=period)
# 循环 scale
docs = []
for scale in self.scaleList:
for conds in self.iterCond():
ktype = self.klineType[:-1]
uid = self.uidKey % ('_'.join(
self.codes), str(period), str(scale), ktype,
str(self.widthTimesPeriod) + '_' + conds)
# 计算关键转折点
df1 = df0.apply(lambda row: self.point(row, ktype, period),
axis=1)
for key in self.pointColumns:
df0[key] = df1[key]
isCvs = False
for key in self.csvList:
if uid.find(key) > -1:
#if self.codes[0] in ['MA','SC']:
isCvs = True
break
if isCvs and self.isAll == 0:
cs = []
bans = 'p_l,p_h,rel_price,mio,mao,op,om'.split(',')
for c in df0.columns:
if c not in bans:
cs.append(c)
file = self.Rice.basePath + '%s_pre.csv' % (uid)
print(uid, '---------------------------- to_cvs', file)
df0.to_csv(file, index=0, columns=cs)
# df0.fillna(0, inplace=True)
df1 = None
tot = None
#tot = self.detect(df0, df1, period=period, uid=uid)
if tot is not None and tot['amount'] != 0:
tot.update({
"scale": scale,
"code": self.codes[0],
"period": period,
"uid": uid,
# "shift": (p_l - p_h).mean(),
"createdate": public.getDatetime()
})
docs.append(tot)
return docs
def total(self, dfs, dfs2=None, period=60):
# 计算参数
df0 = dfs[self.mCodes[0]]
df0["rel_price"] = close = df0["close"]
df0["datetime"] = df0.index
s0 = self.shift[0]
p_l = df0["p_l"] = (df0["close"] + s0)
p_h = df0["p_h"] = (df0["close"] - s0)
# MA指标
df0["ma10"] = ma10 = ta.MA(close, timeperiod=10)
df0["ma20"] = ma20 = ta.MA(close, timeperiod=20)
df0["ma55"] = ma55 = ta.MA(close, timeperiod=55)
df0['atrb'] = ta.ATR(df0['high'], df0['low'], close, timeperiod=21)
# 调整异常high、low指标
df0['high1'] = df0['high']
df0['low1'] = df0['low']
df0['high'] = df0.apply(lambda row: self.k_fix(row, 1), axis=1)
df0['low'] = df0.apply(lambda row: self.k_fix(row, -1), axis=1)
mac = ma10 - ma20
# isPoint
df0['mad'] = mac * mac.shift(1)
df0['mam'] = mam = df0.apply(lambda row: self.isMam(row), axis=1)
minidx, maxidx = ta.MINMAXINDEX(mam, timeperiod=80)
df0['interval'] = abs(minidx - maxidx)
# 唐奇安线
df0['tu_s'] = ta.MAX(df0['high'].shift(1),
timeperiod=self.tangStartPeriod0)
df0['td_s'] = ta.MIN(df0['low'].shift(1),
timeperiod=self.tangStartPeriod0)
df0['tu_s1'] = ta.MAX(df0['high'].shift(1),
timeperiod=self.tangStartPeriod1)
df0['td_s1'] = ta.MIN(df0['low'].shift(1),
timeperiod=self.tangStartPeriod1)
df0['tu_d'] = ta.MIN(df0['high'].shift(1),
timeperiod=self.tangDropPeriod)
df0['td_d'] = ta.MIN(df0['low'].shift(1),
timeperiod=self.tangDropPeriod)
df0['tu_e'] = ta.MAX(df0['high'].shift(1),
timeperiod=self.tangEndPeriod)
df0['td_e'] = ta.MIN(df0['low'].shift(1),
timeperiod=self.tangEndPeriod)
df0['isout'] = isout = df0.apply(lambda row: self.isout(row), axis=1)
df0['isout3'] = ta.SUM(isout, timeperiod=3)
df0['isout5'] = ta.SUM(isout, timeperiod=5)
df1 = None
# 循环 scale
docs = []
for scale in self.scaleList:
for conds in self.iterCond():
uid = self.uidKey % ('_'.join(self.codes), str(period),
str(scale), self.klineType[:-1], conds)
isCvs = False
for key in self.csvList:
if uid.find(key) > -1:
isCvs = True
break
if isCvs:
cs = []
bans = 'ma,p_l,p_h,top,lower,std,delta,volume,sard,rel_price,width,volm,'.split(
',')
for c in df0.columns:
if c not in bans:
cs.append(c)
file = self.Rice.basePath + '%s_pre.csv' % (uid)
print(uid, '---------------------------- to_cvs', file)
df0.to_csv(file, index=0, columns=cs)
tot = self.detect(df0, df1, period=period, uid=uid)
if tot is not None and tot['amount'] != 0:
tot.update({
"scale": scale,
"code": self.codes[0],
"period": period,
"uid": uid,
"shift": (p_l - p_h).mean(),
"createdate": public.getDatetime()
})
docs.append(tot)
return docs
def TALIB_MINMAXINDEX(close, timeperiod=30):
'''00365,2,2'''
return talib.MINMAXINDEX(close, timeperiod)
def paramCalc(self, dfs, cur):
# 分钟线
if len(dfs) == 0: return None
c0 = cur[self.mCodes[0]]
c0['close'] = c0['last']
# 去掉当前的即时k线
df0 = copy.deepcopy(dfs[self.mCodes[0]])
# 添加即时K线
df0.loc[public.getDatetime()] = pd.Series(
[c0[key] for key in self.klinecolumns], index=self.klinecolumns)
close = df0["close"]
df0["datetime"] = df0.index
# MA指标
df0["ma10"] = ma10 = ta.MA(close, timeperiod=10)
df0["ma20"] = ma20 = ta.MA(close, timeperiod=20)
df0["ma55"] = ta.MA(close, timeperiod=55)
# 21日平均 ATR
df0['atrb'] = ta.ATR(df0['high'], df0['low'], close, timeperiod=21)
# 修正不正常K线
df0['high'] = df0.apply(lambda row: self.k_fix(row, 1), axis=1)
df0['low'] = df0.apply(lambda row: self.k_fix(row, -1), axis=1)
# 计算ma10-ma20 穿越线间距
df0['mac'] = mac = ma10 - ma20
df0['mac2'] = mac.shift(2)
df0['mac3'] = mac.shift(3)
# isPoint0
df0['mad'] = mac * mac.shift(1)
df0['mam'] = mam = df0.apply(lambda row: self.isMam(row), axis=1)
minidx, maxidx = ta.MINMAXINDEX(mam, timeperiod=75)
df0['interval'] = abs(minidx - maxidx)
# 唐奇安线18日
df0['tu_s'] = ta.MAX(df0['high'].shift(1),
timeperiod=self.tangStartPeriod0)
df0['td_s'] = ta.MIN(df0['low'].shift(1),
timeperiod=self.tangStartPeriod0)
# 唐奇安线27日
df0['tu_s1'] = ta.MAX(df0['high'].shift(1),
timeperiod=self.tangStartPeriod1)
df0['td_s1'] = ta.MIN(df0['low'].shift(1),
timeperiod=self.tangStartPeriod1)
# 40日低点
ld = close[close.notnull()]
dp = self.tangDropPeriod if len(
ld) > self.tangDropPeriod else len(ld) - 1
df0['tu_d'] = ta.MAX(df0['high'].shift(1), timeperiod=dp)
df0['td_d'] = ta.MIN(df0['low'].shift(1), timeperiod=dp)
# 唐奇安线34日
df0['tu_34'] = ta.MAX(df0['high'].shift(1),
timeperiod=self.tangStartPeriod55)
df0['td_34'] = ta.MIN(df0['low'].shift(1),
timeperiod=self.tangStartPeriod55)
# df0['tu_e'] = ta.MAX(df0['high'].shift(1), timeperiod=self.tangEndPeriod)
# df0['td_e'] = ta.MIN(df0['low'].shift(1), timeperiod=self.tangEndPeriod)
# 计算穿越值
"""
fp, fd = 27, 5
code = self.procMap.codes[0]
posTrend = 0 if code not in self.trendMap else self.trendMap[code]['trend']
out = df0.apply(lambda row: self.isout0(row), axis=1)
df0['out_s'] = ta.SUM(out, timeperiod=fp)
df0['trend'] = df0['out_s'].apply(lambda x: -1 if x > fd else 1 if x < -fd else 0)
df0['isout'] = isout = df0.apply(lambda row: self.isout(row, posTrend), axis=1)
df0['isout3'] = ta.SUM(isout, timeperiod=3)
df0['isout5'] = ta.SUM(isout, timeperiod=5)
"""
df0['isout3'] = 0
df0['isout5'] = 0
# 计算关键转折点
# df0.fillna(0, inplace=True)
param = copy.deepcopy(df0.iloc[-1]).to_dict()
self.df0 = df0
param.update({"p_l": c0["asks"][0], "p_h": c0["bids"][0]})
return param
