def create_df(ticker): delay = 2 max_period = 20 slope_period = 30 timeperiod = 14 bars_list = api.get_barset(symbols=ticker, timeframe='minute', limit=30) ticker_bars = bars_list[ticker] ohlc_df = pd.DataFrame(columns=['high', 'low', 'close', 'volume']) high_list = [] low_list = [] close_list = [] volume_list = [] for i in range(len(ticker_bars)): high_list.append(ticker_bars[i].h) low_list.append(ticker_bars[i].l) close_list.append(ticker_bars[i].c) volume_list.append(ticker_bars[i].v) ohlc_df['high'] = high_list ohlc_df['low'] = low_list ohlc_df['close'] = close_list ohlc_df['volume'] = volume_list ohlc_df['v_shift'] = ohlc_df['volume'].shift(delay) ohlc_df['av'] = ohlc_df['volume'].rolling(window=delay).max() ohlc_df['max'] = ohlc_df['v_shift'].rolling(window=(max_period - delay)).max() ohlc_df['adx'] = ta.ADX(ohlc_df['high'], ohlc_df['low'], ohlc_df['close']) ohlc_df['slope'] = slope(ohlc_df['close'], slope_period) return ohlc_df
def test_adx(): '''test TA.ADX''' adx = TA.ADX(ohlc, period=12) ta_adx = talib.ADX(ohlc["high"], ohlc["low"], ohlc["close"], timeperiod=12) assert int(ta_adx[-1]) == int(adx.values[-1])
def double_top_double_bottom(key, dataList, time_frame): price_action = pd.DataFrame( dataList, columns=[id.time, id.open, id.close, id.high, id.low, id.volume]) if price_action.empty: return window_size = constants.strategy_params[id.window_size] # To determine up/down trend and the strength upTrend = utils.__uptrend( price_action.iloc[-2 * window_size - 3:-3][id.close].values, window_size) downTrend = utils.__downtrend( price_action.iloc[-2 * window_size - 3:-3][id.close].values, window_size) # ADX to determine the strength of the trend and OBV to get volume of trades placed adx = ta.ADX(price_action[id.high], price_action[id.low], price_action[id.close], window_size) obv = ta.OBV(price_action[id.close], price_action[id.volume]) # Calculate the local maxima and minima in the window frame local_minima, local_maxima, indices_minima, indices_maxima = utils.__local_min_max( np.array(price_action[id.high])) notifier = {values.double_top: False, values.double_bottom: False} if upTrend and adx[len(adx) - 1] >= constants.strategy_params[id.trend_strength]: notifier[values.double_top] = check_double_top(price_action, indices_maxima, obv) if downTrend and adx[len(adx) - 1] >= constants.strategy_params[id.trend_strength]: notifier[values.double_bottom] = check_double_bottom( price_action, indices_minima, obv) if notifier[values.double_top]: try: #db.insert_strategy(key, time_frame, values.double_top, price_action.iloc[-1][id.time]) return { id.name: id.double_top, id.key: key, id.price_action: dataList } except: print('Unable to add to database') return {} if notifier[values.double_bottom]: try: #db.insert_strategy(key, time_frame, values.double_bottom, price_action.iloc[-1][id.time]) return { id.name: id.double_bottom, id.key: key, id.price_action: dataList } except: print('Unable to add to database') return {}
def talib_adx(stock_data, LENGTH=14): ''' Function to calculate ADX - Average Directional Movement Index Explain ======= calculate ADX Input ===== stock_data: DataFrame with OHLC, 'volume' and 'code' in each row Output ====== Return: DataFrame with 'ADX' in each row, use the same index from Input stock_data ''' # create a new empty output dataframe, sharing the same index newdf = pd.DataFrame(index=stock_data.index.copy()) # calculate ADX newdf['ADX'] = talib.ADX(stock_data['high'].values, stock_data['low'].values, stock_data['close'].values, timeperiod=LENGTH) return newdf
def signal_pair(self, symbol): short_ema = self.params.get('short_ema') long_ema = self.params.get('long_ema') adx_period = self.params.get('adx') rsi = self.params.get('rsi') candles = self.data_reader.get_candle(symbol, PERIOD_H1, count=50, fromTime=None, toTime=None, price_type='M', smooth=False) adx = ta.ADX(candles['askhigh'], candles['bidlow'], candles['bidclose'], timeperiod=adx_period) ema_short = ta.EMA(candles['bidclose'], timeperiod=short_ema) ema_long = ta.EMA(candles['bidclose'], timeperiod=long_ema) mean = (candles['askhigh'] + candles['bidlow']) / 2 rsi = ta.RSI(mean, timeperiod=rsi) # upper, middle, lower = ta.BBANDS(h1_candles['close'], matype=MA_Type.T3) if self.can_open(): self.open(symbol, ema_short, ema_long, adx, rsi) self.close(symbol, ema_short, ema_long, adx, rsi)
def adx(candles: np.ndarray, period: int = 14, sequential: bool = False) -> Union[float, np.ndarray]: """ ADX - Average Directional Movement Index :param candles: np.ndarray :param period: int - default=14 :param sequential: bool - default=False :return: float | np.ndarray """ warmup_candles_num = get_config('env.data.warmup_candles_num', 240) if not sequential and len(candles) > warmup_candles_num: candles = candles[-warmup_candles_num:] res = talib.ADX(candles[:, 3], candles[:, 4], candles[:, 2], timeperiod=period) if sequential: return res else: return None if np.isnan(res[-1]) else res[-1]
def getMomentumIndicators(df): high = df['High'] low = df['Low'] close = df['Close'] open = df['Open'] volume = df['Volume'] df['ADX'] = ta.ADX(high, low, close, timeperiod=14) df['SMA'] = ta.ADXR(high, low, close, timeperiod=14) df['APO'] = ta.APO(close, fastperiod=12, slowperiod=26, matype=0) df['AROONDOWN'], df['AROOONUP'] = ta.AROON(high, low, timeperiod=14) df['AROONOSC'] = ta.AROONOSC(high, low, timeperiod=14) df['BOP'] = ta.BOP(open, high, low, close) df['CCI'] = ta.CCI(high, low, close, timeperiod=14) df['CMO'] = ta.CMO(close, timeperiod=14) df['DX'] = ta.DX(high, low, close, timeperiod=14) df['MACD'], df['MACDSIGNAL'], df['MACDHIST'] = ta.MACD(close, fastperiod=12, slowperiod=26, signalperiod=9) df['MFI'] = ta.MFI(high, low, close, volume, timeperiod=14) df['MINUS_DI'] = ta.MINUS_DI(high, low, close, timeperiod=14) df['MINUS_DM']= ta.MINUS_DM(high, low, timeperiod=14) df['MOM'] = ta.MOM(close, timeperiod=10) df['PLUS_DM'] =ta.PLUS_DM(high, low, timeperiod=14) df['PPO'] = ta.PPO(close, fastperiod=12, slowperiod=26, matype=0) df['ROC'] = ta.ROC(close, timeperiod=10) df['ROCP'] = ta.ROCP(close, timeperiod=10) df['ROCR'] = ta.ROCR(close, timeperiod=10) df['ROCR100'] = ta.ROCR100(close, timeperiod=10) df['RSI'] = ta.RSI(close, timeperiod=14) df['SLOWK'], df['SLOWD'] = ta.STOCH(high, low, close, fastk_period=5, slowk_period=3, slowk_matype=0, slowd_period=3, slowd_matype=0) df['FASTK'], df['FASTD'] = ta.STOCHF(high, low, close, fastk_period=5, fastd_period=3, fastd_matype=0) df['FASTK2'], df['FASTD2'] = ta.STOCHRSI(close, timeperiod=14, fastk_period=5, fastd_period=3, fastd_matype=0) df['TRIX'] = ta.TRIX(close, timeperiod=30) df['ULTOSC'] = ta.ULTOSC(high, low, close, timeperiod1=7, timeperiod2=14, timeperiod3=28) df['WILLR'] = ta.WILLR(high, low, close, timeperiod=14)
def buildTAindicators(stock_df): stock_df['REDORGREEN'] = stock_df.loc[:, 'Open'].subtract( stock_df.loc[:, 'Close']).apply(lambda x: 1 if x > 0 else 0).values stock_df['CANDLE_HEIGHT'] = stock_df.loc[:, 'Open'].subtract( stock_df.loc[:, 'Close']).values stock_df['NATR'] = ta.NATR(stock_df.loc[:, 'High'].values, stock_df.loc[:, 'Low'].values, stock_df.loc[:, 'Close'].values, 5) close = stock_df.loc[:, 'Close'].values high = stock_df.loc[:, 'High'].values low = stock_df.loc[:, 'Low'].values volume = pd.Series.astype(stock_df.loc[:, 'Volume'], dtype='double').values adx = ta.ADX(high, low, close, timeperiod=14) macd, macdsignal, macdhist = ta.MACD(close, fastperiod=12, slowperiod=26, signalperiod=9) mfi = ta.MFI(high, low, close, volume, timeperiod=14) rsi = ta.RSI(close, timeperiod=14) beta = ta.BETA(high, low, timeperiod=5) stock_df['ADX'] = pd.Series(adx).values stock_df['MFI'] = pd.Series(mfi).values stock_df['RSI'] = pd.Series(rsi).values stock_df['MACD'] = pd.Series(macd).values stock_df['BETA'] = pd.Series(beta).values stock_df = stock_df.iloc[33:, :] return stock_df
def rebalance(context, data): # 获取过去7天的收盘价 history = data.history(assets=context.asset, fields=['close', 'high', 'low'], bar_count=context.adx_window * 2, frequency='1d') date = history.index.values[-1] high = history['high'].values low = history['low'].values close = history['close'].values adx = ta.ADX(high, low, close, timeperiod=context.adx_window) record(price=data.current(symbol('IBM'), 'close'), adx=adx[-1]) buy_signal_triggered = False sell_signal_triggered = False if adx[-1] > context.adx_buy_line: buy_signal_triggered = True elif adx[-1] < context.adx_sell_line: sell_signal_triggered = True current_position = context.portfolio.positions[context.asset].amount if buy_signal_triggered and current_position == 0: print(str(date) + '==>买入') order_target_percent(context.asset, 0.5) elif sell_signal_triggered and current_position > 0: print(str(date) + '==>卖出') order_target_percent(context.asset, 0.0) else: print(str(date) + '==>无交易')
def get_stock_data(ticker, start_date, end_date): print(end_date, type(ticker)) data = nse.get_history(symbol=ticker, start=start_date, end= end_date) #data = nse.get_history(symbol= ticker, start=start_date, end= end_date) data = data.drop(['Prev Close','Symbol', 'Series', 'Deliverable Volume', '%Deliverble', 'Trades', 'Last'], axis = 1) close = data['Close'].values high = data['High'].values low = data['Low'].values #Computing technical indicators data['upB'], data['midB'], data['lowB'] = talib.BBANDS(close, timeperiod=20, nbdevup=2, nbdevdn=2, matype=0) data['RSI'] = talib.RSI(close, timeperiod=10) data['K'], d = talib.STOCH(high, low, close, fastk_period=14, slowk_period=14, slowk_matype=0, slowd_period=3, slowd_matype=0) macd, macdsignal, data['MACD'] = talib.MACD(close, fastperiod=12, slowperiod=26, signalperiod=9) data['EMA'] = talib.EMA(close, timeperiod=30) data['ADX'] = talib.ADX(high, low, close, timeperiod=14) data['AroonUp'], data['AroonDown'] = talib.AROON(high, low, timeperiod=14) data['diff'] = data['High'] - data['Low'] data = data.dropna() #saving as a csv file data.to_csv('stock_prices' + str(ticker) + '.csv', index=False)
def get_features(data): tech_data = pd.DataFrame(index=data.index); for t in periods_list: tech_data[f'SMA_{t}'] = talib.SMA(data.close,timeperiod=t) tech_data[f'MOM_{t}'] = talib.MOM(data.close, timeperiod=t) tech_data[f'RSI_{t}'] = talib.RSI(data.close, timeperiod=t) tech_data[f'MA_{t}'] = talib.MA(data.close, timeperiod=t) tech_data[f'DX_{t}'] = talib.DX(data.high, data.low, data.close, timeperiod=t) tech_data[f'volume_change_{t}'] = data.volume.pct_change(periods=t) tech_data[f'volatility_{t}'] = data.close.pct_change(periods=t).std() tech_data[f'ADX_{t}'] = talib.ADX(data.high, data.low, data.close, timeperiod=t) tech_data[f'ADXR_{t}'] = talib.ADXR(data.high, data.low, data.close, timeperiod=t) tech_data[f'AROONOSC_{t}'] = talib.AROONOSC(data.high, data.low, timeperiod=t) tech_data[f'ROC_{t}'] = talib.ROC(data.close, timeperiod=t) tech_data[f'BIAS_{t}'] = (data['close'] - data['close'].rolling(t, min_periods=1).mean())/ data['close'].rolling(t, min_periods=1).mean()*100 tech_data[f'BOLL_upper_{t}'], tech_data[f'BOLL_middle_{t}'], tech_data[f'BOLL_lower_{t}'] = talib.BBANDS( data.close, timeperiod=t, nbdevup=2, nbdevdn=2, matype=0) tech_data['SAR'] = talib.SAR(data.high, data.low) tech_data['AD'] = talib.AD(data.high, data.low, data.close, data.volume) tech_data['OBV'] = talib.OBV(data.close, data.volume) tech_data['target'] = data.close.pct_change().shift(-1).apply(lambda x: 1 if x > 0 else -1).fillna(0) tech_data['time'] = data.time tech_data = tech_data.set_index('time') reduce(lambda x, y: cross_over(x, y, tech_data), periods_list) features = list(set(tech_data.columns) - set(data.columns) - set(['target'])) return tech_data.dropna(), features
def ADX5_AROON(self, df): adx5_exLevel = 95 adx5_brLevel = 10 df.drop(df.last_valid_index(), axis=0, inplace=True) df['PLUS_DI'] = talib.PLUS_DI(df['High'].values, df['Low'].values, df['Close'].values, timeperiod=5) df['MINUS_DI'] = talib.MINUS_DI(df['High'].values, df['Low'].values, df['Close'].values, timeperiod=5) df['ADX5'] = talib.ADX(df['High'].values, df['Low'].values, df['Close'].values, timeperiod=5) df['ARDN'], df['ARUP'] = talib.AROON(df['High'].values, df['Low'].values, timeperiod=10) df['ADX5SHIFTED'] = df['ADX5'].shift(1) df['ARDNSHIFTED'] = df['ARDN'].shift(1) df['ARUPSHIFTED'] = df['ARUP'].shift(1) columns = ['PLUS_DI', 'MINUS_DI', 'ADX5', 'AROONDN', 'AROONUP', 'ADX5SHIFTED', 'ARDNSHIFTED', 'ARUPSHIFTED'] def adx5_aroon_cond(row, columns): df1_adx5_cond = (row['ADX5'] > row['ADX5SHIFTED']) & (row['ADX5'] > adx5_brLevel) & ( row['ADX5'] < adx5_exLevel) arbuy = (row['ARUPSHIFTED'] < 5) & (row['ARUP'] > 85) & (row['ARUP'] > row['ARDN']) arsell = (row['ARDNSHIFTED'] < 5) & (row['ARDN'] > 85) & (row['ARUP'] < row['ARDN']) buy = (row['PLUS_DI'] > row['MINUS_DI']) & df1_adx5_cond & arbuy sell = (row['PLUS_DI'] < row['MINUS_DI']) & df1_adx5_cond & arsell return buy, sell df['BUY'], df['SELL'] = zip(*df.apply(lambda row: adx5_aroon_cond(row, columns), axis=1)) df2 = df.tail(self.withinBars) df2['BUY'].any() df2['SELL'].any() #return [df['SELL'].iloc[-1], df['BUY'].iloc[-1], df['normal_time']] return [df2['SELL'].any(), df2['BUY'].any(), df['normal_time']]
def technical_indicators_df(self): o = self.daily_data['Open'].values c = self.daily_data['Close'].values h = self.daily_data['High'].values l = self.daily_data['Low'].values v = self.daily_data['Volume'].astype(float).values # define the technical analysis matrix ta = pd.DataFrame() ta['MA5'] = tb.MA(c, timeperiod=5) ta['MA10'] = tb.MA(c, timeperiod=10) ta['MA20'] = tb.MA(c, timeperiod=20) ta['MA60'] = tb.MA(c, timeperiod=60) ta['MA120'] = tb.MA(c, timeperiod=120) ta['MA5'] = tb.MA(v, timeperiod=5) ta['MA10'] = tb.MA(v, timeperiod=10) ta['MA20'] = tb.MA(v, timeperiod=20) ta['ADX'] = tb.ADX(h, l, c, timeperiod=14) ta['ADXR'] = tb.ADXR(h, l, c, timeperiod=14) ta['MACD'] = tb.MACD(c, fastperiod=12, slowperiod=26, signalperiod=9)[0] ta['RSI'] = tb.RSI(c, timeperiod=14) ta['BBANDS_U'] = tb.BBANDS(c, timeperiod=5, nbdevup=2, nbdevdn=2, matype=0)[0] ta['BBANDS_M'] = tb.BBANDS(c, timeperiod=5, nbdevup=2, nbdevdn=2, matype=0)[1] ta['BBANDS_L'] = tb.BBANDS(c, timeperiod=5, nbdevup=2, nbdevdn=2, matype=0)[2] ta['AD'] = tb.AD(h, l, c, v) ta['ATR'] = tb.ATR(h, l, c, timeperiod=14) ta['HT_DC'] = tb.HT_DCPERIOD(c) self.ta = ta
def calculate_indicators(data): close = data['Close'].values high = data['High'].values low = data['Low'].values data['upB'], data['midB'], data['lowB'] = talib.BBANDS(close, timeperiod=20, nbdevup=2, nbdevdn=2, matype=0) data['RSI'] = talib.RSI(close, timeperiod=10) data['K'], d = talib.STOCH(high, low, close, fastk_period=14, slowk_period=14, slowk_matype=0, slowd_period=3, slowd_matype=0) macd, macdsignal, data['MACD'] = talib.MACD(close, fastperiod=12, slowperiod=26, signalperiod=9) data['EMA'] = talib.EMA(close, timeperiod=30) data['ADX'] = talib.ADX(high, low, close, timeperiod=14) data['AroonUp'], data['AroonDown'] = talib.AROON(high, low, timeperiod=14) data['diff'] = data['High'] - data['Low'] return data
def ADX(df, n): return pd.Series(talib.ADX(df['high'].values, df['low'].values, df['close'].values, timeperiod=n), index=df.index, name='ADX_%s' % str(n))
def ADX(data, n=14): """ data: original data with open,high,low,close,vol n: timeperiod """ data['adx'] = ta.ADX( np.array(data.high), np.array(data.low), np.array(data.close), n) #Average Directional Movement Index (Momentum Indicators) data['mdi'] = ta.MINUS_DI(np.array(data.high), np.array(data.low), np.array(data.close), n) data['pdi'] = ta.PLUS_DI(np.array(data.high), np.array(data.low), np.array(data.close), n) signal = pd.DataFrame(index=data.index) #strategy 1 """ 当+DI上穿-DI,买入,信号为1 当+DI下穿-DI,卖空,信号为-1 """ signal['1'] = ((data['pdi'] > data['mdi']) & (data['pdi'].shift(1) < data['mdi'].shift(1))) * 1 + ( (data['pdi'] <= data['mdi']) & (data['pdi'].shift(1) < data['mdi'].shift(1))) * (-1) signal['1'] = signal['1'][signal['1'].isin([1, -1])].reindex(data.index, method='ffill') signal = signal.fillna(0) return signal
def dmi(source, dmi_period, dmi_smooth): minus_name = "MINUS_DI_" + str(dmi_period) + "_" + str(dmi_smooth) plus_name = "PLUS_DI_" + str(dmi_period) + "_" + str(dmi_smooth) adx_name = "ADX_" + str(dmi_period) + "_" + str(dmi_smooth) source = source.join( pd.Series(talib.MINUS_DI(source['High'], source['Low'], source['Close'], timeperiod=dmi_period), name=minus_name)) source = source.join(pd.Series(talib.PLUS_DI(source['High'], source['Low'], source['Close'], timeperiod=dmi_period), name=plus_name)) source = source.join(pd.Series(talib.ADX(source['High'], source['Low'], source['Close'], timeperiod=dmi_smooth), name=adx_name)) # Trends source = do_uptrend(source, adx_name) source = do_uptrend(source, plus_name) source = do_uptrend(source, minus_name) # Overs source = do_over(source, adx_name, plus_name) source = do_over(source, adx_name, minus_name) source = do_over(source, plus_name, minus_name) # Aboves for level in range(5, 65, 5): source = do_above(source, adx_name, level) source = do_above(source, plus_name, level) source = do_above(source, minus_name, level) source = source.drop(columns=[adx_name, plus_name, minus_name]) return source
def get(self, df): h, l, c = df['h'], df['l'], df['c'] adx = talib.ADX(h, l, c, timeperiod=self.time_period) plus_di = talib.PLUS_DI(h, l, c, timeperiod=self.time_period) minus_di = talib.MINUS_DI(h, l, c, timeperiod=self.time_period) last_adx, last_plus_di, last_minus_di = adx.iloc[-1], plus_di.iloc[-1], minus_di.iloc[-1] material = dict(adx=adx, plus_di=plus_di, minus_di=minus_di) if last_adx > self.trend_threshold: if last_plus_di > last_minus_di: indicator_value = IndicatorValue(ADXIndicatorSign.TREND_PLUS.name, material=material) else: indicator_value = IndicatorValue(ADXIndicatorSign.TREND_MINUS.name, material=material) else: if last_plus_di > last_minus_di: indicator_value = IndicatorValue(ADXIndicatorSign.NO_TREND_PLUS.name, material=material) else: indicator_value = IndicatorValue(ADXIndicatorSign.NO_TREND_MINUS.name, material=material) if not self.is_test: logging.info('sign=>%s ADX=>%s +DI=>%s -DI=>%s', indicator_value.value, last_adx, last_plus_di, last_minus_di) return indicator_value
def run_indicators(symbol, file): try: if os.path.exists(file): # read file df = np.genfromtxt(file, delimiter=',') # run talib indicators using dataframe # create additional columns in the datafarame closePrice = df[:, 4] openPrice = df[:, 1] highPrice = df[:, 2] lowPrice = df[:, 3] volume = df[:, 5] sma = talib.SMA(closePrice) atr = talib.ATR(highPrice, lowPrice, closePrice) natr = talib.NATR(highPrice, lowPrice, closePrice) adx = talib.ADX(highPrice, lowPrice, closePrice) mfi = talib.MFI(highPrice, lowPrice, closePrice, volume) ppo = talib.PPO(closePrice, fastperiod=12, slowperiod=26, matype=0) rsi = talib.RSI(closePrice) slowk, slowd = talib.STOCH(highPrice, lowPrice, closePrice, fastk_period=14, slowk_period=3, slowd_period=3) macd, macdsignal, macdhist = talib.MACD(closePrice, fastperiod=12, slowperiod=26, signalperiod=9) # get ticker current price client = Client(os.environ.get('BINANCE_API_KEY'), os.environ.get('BINANCE_SECRET_KEY'), {"timeout": 100}) closing_price = client.get_symbol_ticker(symbol=symbol) # create crypto object crypto = {} crypto['ticker'] = symbol crypto['price'] = closing_price['price'] crypto['SMA14'] = sma[-1] crypto['ATR'] = atr[-1] crypto['NATR'] = natr[-1] crypto['ADX'] = adx[-1] crypto['MFI'] = mfi[-1] crypto['RSI'] = rsi[-1] crypto['STO'] = slowk[-1], slowd[-1] crypto['MACD'] = macd[-1] crypto['PPO'] = ppo[-1] else: crypto = {} crypto['ticker'] = symbol return crypto except Exception as e: print(str(e))
def add_feature_analysis(df): df['MA5'] = df['종가'].rolling(window=5).mean() df['MA20'] = df['종가'].rolling(window=20).mean() df['MADiff'] = df['MA5'] - df['MA20'] df['MA60'] = df['종가'].rolling(window=60).mean() # Stochastic_slow_k, Stochastic_slow_d (12,3,3) 모멘텀지표 (상하한) df['SlowK'], df['SlowD'] = ta.STOCH(np.array(df['고가'].astype(float)), np.array(df['저가'].astype(float)), np.array(df['종가'].astype(float)), fastk_period=12, slowk_period=3, slowk_matype=0, slowd_period=3, slowd_matype=0) # MACD_12_26 , sign, diff 추세지표 df['MACD'], df['MACDsign'], df['MACDhist'] = ta.MACD(np.array( df['종가'].astype(float)), fastperiod=12, slowperiod=26, signalperiod=9) # RSI_14 모멘텀지표 (상하한) df['RSI14'] = ta.RSI(np.array(df['종가'].astype(float)), timeperiod=14) #df['전일RSI']= df['RSI'].shift(1) # Williams_percent_r_14 모멘텀지표 (상하한) df['WILR14'] = ta.WILLR(np.array(df['고가'].astype(float)), np.array(df['저가'].astype(float)), np.array(df['종가'].astype(float))) df['DEMA20'] = ta.DEMA(np.array(df['종가'].astype(float)), timeperiod=20) df['ADX'] = ta.ADX(np.array(df['고가'].astype(float)), np.array(df['저가'].astype(float)), np.array(df['종가'].astype(float)), timeperiod=14) df['CCI'] = ta.CCI(np.array(df['고가'].astype(float)), np.array(df['저가'].astype(float)), np.array(df['종가'].astype(float)), timeperiod=14) df['ATR'] = ta.ATR(np.array(df['고가'].astype(float)), np.array(df['저가'].astype(float)), np.array(df['종가'].astype(float)), timeperiod=14) df['ROC'] = ta.ROC(np.array(df['종가'].astype(float)), timeperiod=10) df['OBV'] = ta.OBV(np.array(df['종가'].astype(float)), np.array(df['거래량'].astype(float))) df.dropna(inplace=True) # 결측값 삭제 df.set_index('날짜', inplace=True) # 날짜를 index로 만든다. return df
def dmi(self, df, index): MINUS_DI = talib.MINUS_DI(df.high, df.low, df.close, timeperiod=14) #DX = talib.DX(df.high,df.low,df.close,timeperiod=14) PLUS_DI = talib.PLUS_DI(df.high, df.low, df.close, timeperiod=14) #PLUS_DM = talib.PLUS_DM(df.high,df.low, timeperiod=14) ADX = talib.ADX(df.high, df.low, df.close, timeperiod=6) ADXR = talib.ADXR(df.high, df.low, df.close, timeperiod=6) return MINUS_DI, PLUS_DI, ADX, ADXR
def getCustomData(df): open = df['Open'] high = df['High'] low = df['Low'] close = df['Close'] volume = df['Volume'] df['TRENDMODE'] = ta.HT_TRENDMODE(close) df['RSI'] = ta.RSI(close,timeperiod=14) df['RSI2'] = ta.RSI(close,timeperiod=7) df['RSI3'] = ta.RSI(close,timeperiod=28) df['ADX1'] = ta.ADX(high,low,close,timeperiod=7) df['ADX2'] = ta.ADX(high,low,close,timeperiod=28) df['ADX'] = ta.ADX(high,low,close,timeperiod=14) df['SLOWK'], df['SLOWD'] = ta.STOCH(high, low, close, fastk_period=5, slowk_period=3, slowk_matype=0, slowd_period=3, slowd_matype=0) df['FASTK'], df['FASTD'] = ta.STOCHF(high, low, close, fastk_period=5, fastd_period=3, fastd_matype=0) df['ULTOSC'] = ta.ULTOSC(high, low, close, timeperiod1=7, timeperiod2=14, timeperiod3=28) df['WILLR'] = ta.WILLR(high, low, close, timeperiod=14)
def adx(self, n: int, array: bool = False) -> Union[float, np.ndarray]: """ ADX. """ result = talib.ADX(self.high, self.low, self.close, n) if array: return result return result[-1]
def adx(self, n, array=False): """ ADX. """ result = talib.ADX(self.high, self.low, self.close, n) if array: return result return result[-1]
def add_adx_ft(df, daily_count, count): for idx in range(1, count + 1): col_name = 'ADX_' + str(idx) df[col_name] = talib.ADX(df.high, df.low, df.close, timeperiod=daily_count * idx) return df
def AddADX(df, indicator_list, askbidmid, timeperiod=14): df['adx'] = talib.ADX(df['{}_h'.format(askbidmid)].values, df['{}_l'.format(askbidmid)].values, df['{}_c'.format(askbidmid)].values, timeperiod=timeperiod) indicator_list.extend(['adx']) return df, indicator_list
def IND_ADX(high, low, close, number): t_high = numpy.array(high.getRawData()) t_low = numpy.array(low.getRawData()) t_close = numpy.array(close.getRawData()) adx = talib.ADX(t_high, t_low, t_close, number) return adx
def etf_should_buy(li,l2): for i in range(len(li)): h = ts.pro_bar(li[i],asset="FD",start_date="20200101",end_date=get_now_time(),ma=[5,10]).iloc[::-1] n = h.shape[0] if n > 33: # ----------- 获取kdj值 ---------------# slowk, slowd = tb.STOCH(h['high'].values, h['low'].values, h['close'].values, fastk_period=9, slowk_period=3, slowk_matype=0, slowd_period=3, slowd_matype=0) slowj = 3 * slowk - 2 * slowd # ------------- 获取ma5 ma10 --------------- # ma5 = h["ma5"].tolist() ma10 = h["ma10"].tolist() # -------------- 获取macd值 ----------------- # macd,signal,hist = tb.MACD(h["close"].values, 12, 26, 9) # -------------- 获取adx值 ----------------- # adx = tb.ADX(h["high"].values, h["low"].values, h["close"].values, timeperiod=14) # -------------- 获取当前价格 ----------------- # price = h["close"].tolist() # ---------------- 格式化数据 ---------------------# slowj[-1] = round(slowj[-1],3) ma5[-1] = round(ma5[-1], 3) ma10[-1] = round(ma10[-1],3) macd[-1] = round(macd[-1],3) adx[-1] = round(adx[-1],3) if slowj[-1] > slowk[-1] > slowd[-1] and \ macd[-2] < macd[-1]: if price[-1] < 10: print(li[i],if_price_increase(price),if_ma5_big_ma10(ma5,ma10),if_macd_increase(macd),if_slowj_big_slowkd(slowj,slowk,slowd)) # 56#符合特征的 # if slowj[n-2] < 20 < slowj[n-1] and slowj[n-1] > slowk[n-1] > slowd[n-1]: # print(li[i],"BUY++",get_now_time()) # if slowj[n-2] > 80 > slowj[n-1] and slowj[n-1] < slowk[n-1] < slowd[n-1] and slowj[n-2] > slowk[n-2] > slowd[n-2]: # print(li[i],"SELL--",get_now_time()) # # if slowj[n-1] > 80 > slowj[n - 2] and slowj[n-1] > slowk[n-1] > slowd[n-1] and slowj[n-2] < slowk[n-2] > slowd[n-2]: # print(li[i],"BUY+",get_now_time()) # # if 50 > slowj[n-1] and slowj[n-1] < slowk[n-1] < slowd[n-1] and slowj[n-2] > slowk[n-2] > slowd[n-2]: # print(li[i], "SELL--",get_now_time()) time.sleep(0.2)
def create_technical_indicators(df, indicators=['MA_4'], only_close_colum=False): if only_close_colum: if isinstance(df, pd.DataFrame): close = np.array(df['Close']).reshape(len(df), ) else: if isinstance(df, pd.DataFrame): close = np.array(df['Close']).reshape(len(df), ) # OPEN = np.array(df['Open']).reshape(len(df), ) high = np.array(df['High']).reshape(len(df), ) low = np.array(df['Low']).reshape(len(df), ) df_2_return = pd.DataFrame() for indicator in indicators: if indicator is None: pass else: if indicator.split('_')[0].strip() == 'MA': smavg = talib.MA(close, timeperiod=int(indicator.split('_')[1])) df_2_return[indicator] = smavg if indicator.split('_')[0].strip() == 'BBANDS': upperband, middleband, lowerband = talib.BBANDS(close, timeperiod=int(indicator.split('_')[1])) df_2_return['lowerband'] = lowerband df_2_return[indicator] = middleband df_2_return['upperband'] = upperband if indicator.split('_')[0].strip() == 'MACD': indicator = indicator + '_12' + '_26' + '_9' _, macdsignal, macdhist = talib.MACD(close, fastperiod=int(indicator.split('_')[1]), slowperiod=int(indicator.split('_')[2]), signalperiod=int(indicator.split('_')[3])) df_2_return['macdsignal'] = macdsignal df_2_return['macdhist'] = macdhist if indicator.split('_')[0].strip() == 'RSI': real_RSI = talib.RSI(close, timeperiod=int(indicator.split('_')[1])) df_2_return[indicator] = real_RSI if indicator.split('_')[0].strip() == 'CMO': real_CMO = talib.CMO(close, timeperiod=int(indicator.split('_')[1])) df_2_return[indicator] = real_CMO if indicator.split('_')[0].strip() == 'ADX': if only_close_colum: pass else: real_ADX = talib.ADX(high, low, close, timeperiod=int(indicator.split('_')[1])) df_2_return[indicator] = real_ADX if indicator.split('_')[0].strip() == 'STOCH': if only_close_colum: pass else: slowk, slowd = talib.STOCH(high, low, close, fastk_period=5, slowk_period=3, slowk_matype=0, slowd_period=3, slowd_matype=0) df_2_return[indicator] = slowd - slowk return(df_2_return)
def ADX(self, timeperiod=14): real_data = np.array([self.df.high, self.df.low, self.df.close], dtype='f8') adx = talib.ADX(real_data[0], real_data[1], real_data[2], timeperiod=timeperiod) # return go.Scatter( # x=self.df.index, # y=adx, # name='ADX' # ) return adx