def OBV(df, n):
PosVol = pd.Series(df['volume'])
NegVol = pd.Series(-df['volume'])
PosVol[df['close'] <= df['close'].shift(1)] = 0
NegVol[df['close'] >= df['close'].shift(1)] = 0
OBV = pd.Series(pd.rolling_mean(PosVol + NegVol, n), name = 'OBV' + str(n))
return OBV
#Force Index
python类rolling_mean()的实例源码
def EOM(df, n):
EoM = (df['high'].diff(1) + df['low'].diff(1)) * (df['high'] - df['low']) / (2 * df['volume'])
Eom_ma = pd.Series(pd.rolling_mean(EoM, n), name = 'EoM' + str(n))
return Eom_ma
#Commodity Channel Index
def CCI(df, n):
PP = (df['high'] + df['low'] + df['close']) / 3
CCI = pd.Series((PP - pd.rolling_mean(PP, n)) / pd.rolling_std(PP, n) / 0.015, name = 'CCI' + str(n))
return CCI
def KELCH(df, n):
KelChM = pd.Series(pd.rolling_mean((df['high'] + df['low'] + df['close']) / 3, n), name = 'KelChM' + str(n))
KelChU = pd.Series(pd.rolling_mean((4 * df['high'] - 2 * df['low'] + df['close']) / 3, n), name = 'KelChU' + str(n))
KelChD = pd.Series(pd.rolling_mean((-2 * df['high'] + 4 * df['low'] + df['close']) / 3, n), name = 'KelChD' + str(n))
return pd.concat([KelChM, KelChU, KelChD], join='outer', axis=1)
#Ultimate Oscillator
def HEIKEN_ASHI(df, period1):
SM_O = pd.rolling_mean(df['open'], period1)
SM_H = pd.rolling_mean(df['high'], period1)
SM_L = pd.rolling_mean(df['low'], period1)
SM_C = pd.rolling_mean(df['close'], period1)
HA_C = pd.Series((SM_O + SM_H + SM_L + SM_C)/4.0, name = 'HAclose')
HA_O = pd.Series(SM_O, name = 'HAopen')
HA_H = pd.Series(SM_H, name = 'HAhigh')
HA_L = pd.Series(SM_L, name = 'HAlow')
for idx, dateidx in enumerate(HA_C.index):
if idx >= (period1):
HA_O[idx] = (HA_O[idx-1] + HA_C[idx-1])/2.0
HA_H[idx] = max(SM_H[idx], HA_O[idx], HA_C[idx])
HA_L[idx] = min(SM_L[idx], HA_O[idx], HA_C[idx])
return pd.concat([HA_O, HA_H, HA_L, HA_C], join='outer', axis=1)
def SPBFILTER(df, n1 = 40, n2 = 60, n3 = 0, field = 'close'):
if n3 == 0:
n3 = int((n1 + n2)/2)
a1 = 5.0/n1
a2 = 5.0/n2
B = [a1-a2, a2-a1]
A = [1, (1-a1)+(1-a2), -(1-a1)*(1-a2)]
PB = pd.Series(signal.lfilter(B, A, df[field]), name = 'SPB_%s_%s' % (n1, n2))
RMS = pd.Series(pd.rolling_mean(PB*PB, n3)**0.5, name = 'SPBRMS__%s_%s' % (n1, n2))
return pd.concat([PB, RMS], join='outer', axis=1)
def rolling_mean(self, df, window, shift=1):
"""
:param df: ??????? dataFrame
:param window: ????
:param shitf: ????1
:return: ??????7?? dataFrame
"""
rolling_df = pd.rolling_mean(df, window=window).shift(shift)
return rolling_df[60:]
def run(self):
for dir_path in listdir(self.src_dir):
src_dir = join(self.src_dir, dir_path)
target_dir = join(self.target_dir, dir_path)
makedirs(target_dir)
for file in listdir(src_dir):
df = pd.read_csv(join(src_dir, file))
if len(df) > 0:
df['date'] = pd.to_datetime(df['date'], format='%Y-%m-%d')
offset = pd.Timedelta(days=60)
date_range = pd.date_range((df['date'].min() + offset).date(),
df['date'].max().date())
averin1 = self.rolling_mean(df['aver'], 1)
averin7 = self.rolling_mean(df['aver'], 7)
averin15 = self.rolling_mean(df['aver'], 15)
averin30 = self.rolling_mean(df['aver'], 30)
averin90 = self.rolling_mean(df['aver'], 60)
assert len(averin1) == len(averin30) == len(averin7) == len(averin15) == len(averin90) == len(
df['aver'][60:])
target_df = pd.DataFrame({
'province': df['province'][0],
'market': df['market'][0],
'type': df['type'][0],
'key': df['key'][0],
'date': date_range,
'aver': df['aver'][60:],
'averin1': averin1,
'averin7': averin7,
'averin15': averin15,
'averin30': averin30,
'averin90': averin90
})
print(join(target_dir, file))
target_df.to_csv(join(target_dir, file), header=True, index=False,
columns=['province', 'market', 'type', 'key', 'date', 'averin1',
'averin7', 'averin15', 'averin30', 'averin90', 'aver'])
def get_rolling_mean(values, window):
"""Return rolling mean of given values, using specified window size."""
return values.rolling(window=window).mean()
# return pd.rolling_mean(values, window=window)
def addFeatures(dataframe, adjclose, returns, n):
"""
operates on two columns of dataframe:
- n >= 2
- given Return_* computes the return of day i respect to day i-n.
- given AdjClose_* computes its moving average on n days
"""
return_n = adjclose[9:] + "Time_" + str(n)
dataframe[return_n] = dataframe[adjclose].pct_change(n)
roll_n = returns[7:] + "RollMean_" + str(n)
dataframe[roll_n] = pd.rolling_mean(dataframe[returns], n)
def makeMa(self):
self.df.sort_values(by=('dateline'), ascending=False)
#print self.df
#sys.exit()
ma_list = [5, 89]
for ma in ma_list:
self.df['MA_' + str(ma)] = pandas.rolling_mean(self.df['close'], ma)
#self.df = self.df[self.df['MA_89'].notnull()]
#print self.df
#sys.exit()
#?? code[13]
self.df['dif'] = self.df['MA_5'] - self.df['MA_89']
#??code[14]
self.df['difma'] = pandas.rolling_mean(self.df['dif'], 36)
def MA(df, n):
MA = pd.Series(pd.rolling_mean(df['Close'], n), name = 'MA_' + str(n))
df = df.join(MA)
return df
#Exponential Moving Average
def BBANDS(df, n):
MA = pd.Series(pd.rolling_mean(df['Close'], n))
MSD = pd.Series(pd.rolling_std(df['Close'], n))
b1 = 4 * MSD / MA
B1 = pd.Series(b1, name = 'BollingerB_' + str(n))
df = df.join(B1)
b2 = (df['Close'] - MA + 2 * MSD) / (4 * MSD)
B2 = pd.Series(b2, name = 'Bollinger%b_' + str(n))
df = df.join(B2)
return df
#Pivot Points, Supports and Resistances
def EOM(df, n):
EoM = (df['High'].diff(1) + df['Low'].diff(1)) * (df['High'] - df['Low']) / (2 * df['Volume'])
Eom_ma = pd.Series(pd.rolling_mean(EoM, n), name = 'EoM_' + str(n))
df = df.join(Eom_ma)
return df
#Commodity Channel Index
def KELCH(df, n):
KelChM = pd.Series(pd.rolling_mean((df['High'] + df['Low'] + df['Close']) / 3, n), name = 'KelChM_' + str(n))
KelChU = pd.Series(pd.rolling_mean((4 * df['High'] - 2 * df['Low'] + df['Close']) / 3, n), name = 'KelChU_' + str(n))
KelChD = pd.Series(pd.rolling_mean((-2 * df['High'] + 4 * df['Low'] + df['Close']) / 3, n), name = 'KelChD_' + str(n))
df = df.join(KelChM)
df = df.join(KelChU)
df = df.join(KelChD)
return df
#Ultimate Oscillator
def calculateBollingerBandsValue(df):
simpleMovingAverage = pandas.rolling_mean(df,window=5)
stdDeviation = pandas.rolling_std(df,window=5)
bollingerBandsValue = (df - simpleMovingAverage)/(2*stdDeviation)
bollingerBandsValue = bollingerBandsValue.dropna()
return bollingerBandsValue
def calculateSimpleMovingAverage(df):
simpleMovingAverage = pandas.rolling_mean(df,window=5)
simpleMovingAverage = normalize(simpleMovingAverage)
simpleMovingAverage = simpleMovingAverage.dropna()
return simpleMovingAverage
def plot(df):
rollingMean = pandas.rolling_mean(df['Close Price'], window=100)
rollingStdv = pandas.rolling_std(df['Close Price'], window=100)
plotter.plot(rollingMean)
# plotting bollinger bands
plotter.plot(rollingMean + rollingStdv * 2)
plotter.plot(rollingMean - rollingStdv * 2)
# df1 = df[['Date','Close']]
plotter.plot(df)
plotter.show()
def get_rolling_mean(values, window,min_periods=None):
return pd.rolling_mean(values, window=window, min_periods=min_periods)
def apply_rolling_window(df, width):
df = df.ix[1:, :]
df_num = df.select_dtypes(include=[np.float, np.int])
df_non_num = df.select_dtypes(exclude=[np.float, np.int])
df_num_window = pd.rolling_mean(df_num, width, min_periods=1)
df_window = pd.concat([df_non_num, df_num_window], axis=1)
return df_window
