Python pandas 模块，rolling_sum() 实例源码
我们从Python开源项目中，提取了以下26个代码示例，用于说明如何使用pandas.rolling_sum()。
def KST(df, r1, r2, r3, r4, n1, n2, n3, n4):
M = df['close'].diff(r1 - 1)
N = df['close'].shift(r1 - 1)
ROC1 = M / N
M = df['close'].diff(r2 - 1)
N = df['close'].shift(r2 - 1)
ROC2 = M / N
M = df['close'].diff(r3 - 1)
N = df['close'].shift(r3 - 1)
ROC3 = M / N
M = df['close'].diff(r4 - 1)
N = df['close'].shift(r4 - 1)
ROC4 = M / N
KST = pd.Series(pd.rolling_sum(ROC1, n1) + pd.rolling_sum(ROC2, n2) * 2 + pd.rolling_sum(ROC3, n3) * 3 + pd.rolling_sum(ROC4, n4) * 4, name = 'KST' + str(r1) + '_' + str(r2) + '_' + str(r3) + '_' + str(r4) + '_' + str(n1) + '_' + str(n2) + '_' + str(n3) + '_' + str(n4))
return KST
#Relative Strength Index
def SVAPO(df, period = 8, cutoff = 1, stdev_h = 1.5, stdev_l = 1.3, stdev_period = 100):
HA = HEIKEN_ASHI(df, 1)
haCl = (HA.HAopen + HA.HAclose + HA.HAhigh + HA.HAlow)/4.0
haC = TEMA( haCl, 0.625 * period )
vave = MA(df, 5 * period, field = 'volume').shift(1)
vc = pd.concat([df['volume'], vave*2], axis=1).min(axis=1)
vtrend = TEMA(LINEAR_REG_SLOPE(df.volume, period), period)
UpD = pd.Series(vc)
DoD = pd.Series(-vc)
UpD[(haC<=haC.shift(1)*(1+cutoff/1000.0))|(vtrend < vtrend.shift(1))] = 0
DoD[(haC>=haC.shift(1)*(1-cutoff/1000.0))|(vtrend > vtrend.shift(1))] = 0
delta_sum = pd.rolling_sum(UpD + DoD, period)/(vave+1)
svapo = pd.Series(TEMA(delta_sum, period), name = 'SVAPO_%s' % period)
svapo_std = pd.rolling_std(svapo, stdev_period)
svapo_ub = pd.Series(svapo_std * stdev_h, name = 'SVAPO_UB%s' % period)
svapo_lb = pd.Series(-svapo_std * stdev_l, name = 'SVAPO_LB%s' % period)
return pd.concat([svapo, svapo_ub, svapo_lb], join='outer', axis=1)
def Vortex(df, n):
i = 0
TR = [0]
while i < df.index[-1]:
Range = max(df.get_value(i + 1, 'High'), df.get_value(i, 'Close')) - min(df.get_value(i + 1, 'Low'), df.get_value(i, 'Close'))
TR.append(Range)
i = i + 1
i = 0
VM = [0]
while i < df.index[-1]:
Range = abs(df.get_value(i + 1, 'High') - df.get_value(i, 'Low')) - abs(df.get_value(i + 1, 'Low') - df.get_value(i, 'High'))
VM.append(Range)
i = i + 1
VI = pd.Series(pd.rolling_sum(pd.Series(VM), n) / pd.rolling_sum(pd.Series(TR), n), name = 'Vortex_' + str(n))
df = df.join(VI)
return df
#KST Oscillator
def KST(df, r1, r2, r3, r4, n1, n2, n3, n4):
M = df['Close'].diff(r1 - 1)
N = df['Close'].shift(r1 - 1)
ROC1 = M / N
M = df['Close'].diff(r2 - 1)
N = df['Close'].shift(r2 - 1)
ROC2 = M / N
M = df['Close'].diff(r3 - 1)
N = df['Close'].shift(r3 - 1)
ROC3 = M / N
M = df['Close'].diff(r4 - 1)
N = df['Close'].shift(r4 - 1)
ROC4 = M / N
KST = pd.Series(pd.rolling_sum(ROC1, n1) + pd.rolling_sum(ROC2, n2) * 2 + pd.rolling_sum(ROC3, n3) * 3 + pd.rolling_sum(ROC4, n4) * 4, name = 'KST_' + str(r1) + '_' + str(r2) + '_' + str(r3) + '_' + str(r4) + '_' + str(n1) + '_' + str(n2) + '_' + str(n3) + '_' + str(n4))
df = df.join(KST)
return df
#Relative Strength Index
def Vortex(df, n):
i = 0
TR = [0]
while i < df.index[-1]:
Range = max(df.get_value(i + 1, 'High'), df.get_value(i, 'Close')) - min(df.get_value(i + 1, 'Low'), df.get_value(i, 'Close'))
TR.append(Range)
i = i + 1
i = 0
VM = [0]
while i < df.index[-1]:
Range = abs(df.get_value(i + 1, 'High') - df.get_value(i, 'Low')) - abs(df.get_value(i + 1, 'Low') - df.get_value(i, 'High'))
VM.append(Range)
i = i + 1
VI = pd.Series(pd.rolling_sum(pd.Series(VM), n) / pd.rolling_sum(pd.Series(TR), n), name = 'Vortex_' + str(n))
df = df.join(VI)
return df
#KST Oscillator
def KST(df, r1, r2, r3, r4, n1, n2, n3, n4):
M = df['Close'].diff(r1 - 1)
N = df['Close'].shift(r1 - 1)
ROC1 = M / N
M = df['Close'].diff(r2 - 1)
N = df['Close'].shift(r2 - 1)
ROC2 = M / N
M = df['Close'].diff(r3 - 1)
N = df['Close'].shift(r3 - 1)
ROC3 = M / N
M = df['Close'].diff(r4 - 1)
N = df['Close'].shift(r4 - 1)
ROC4 = M / N
KST = pd.Series(pd.rolling_sum(ROC1, n1) + pd.rolling_sum(ROC2, n2) * 2 + pd.rolling_sum(ROC3, n3) * 3 + pd.rolling_sum(ROC4, n4) * 4, name = 'KST_' + str(r1) + '_' + str(r2) + '_' + str(r3) + '_' + str(r4) + '_' + str(n1) + '_' + str(n2) + '_' + str(n3) + '_' + str(n4))
df = df.join(KST)
return df
#Relative Strength Index
def getRSI(close):
'''
calculate RSI value
:param DataFrame close: close price
:return: DataFrame RSI: RSI value
'''
n = 3
# calculate increment of close price of two succeeding days
close_increment = close.diff()
close_increment.dropna(inplace=True)
close_increment.index = range(close_increment.shape[0])
close_pos = close_increment.copy()
close_pos[close_pos < 0] = 0
close_abs = np.abs(close_increment)
sum_pos = pd.rolling_sum(close_pos, n)
sum_pos.dropna(inplace=True)
sum_pos.index = range(sum_pos.shape[0])
sum_abs = pd.rolling_sum(close_abs, n)
sum_abs.dropna(inplace=True)
sum_abs.index = range(sum_abs.shape[0])
RSI = sum_pos / sum_abs
RSI.replace([np.nan, np.inf,-np.inf], 0, inplace=True)
return RSI
def Vortex(df, n):
i = 0
TR = [0]
while i < df.index[-1]:
Range = max(df.get_value(i + 1, 'High'), df.get_value(i, 'Close')) - min(df.get_value(i + 1, 'Low'), df.get_value(i, 'Close'))
TR.append(Range)
i = i + 1
i = 0
VM = [0]
while i < df.index[-1]:
Range = abs(df.get_value(i + 1, 'High') - df.get_value(i, 'Low')) - abs(df.get_value(i + 1, 'Low') - df.get_value(i, 'High'))
VM.append(Range)
i = i + 1
VI = pd.Series(pd.rolling_sum(pd.Series(VM), n) / pd.rolling_sum(pd.Series(TR), n), name = 'Vortex_' + str(n))
df = df.join(VI)
return df
#KST Oscillator
def KST(df, r1, r2, r3, r4, n1, n2, n3, n4):
M = df['Close'].diff(r1 - 1)
N = df['Close'].shift(r1 - 1)
ROC1 = M / N
M = df['Close'].diff(r2 - 1)
N = df['Close'].shift(r2 - 1)
ROC2 = M / N
M = df['Close'].diff(r3 - 1)
N = df['Close'].shift(r3 - 1)
ROC3 = M / N
M = df['Close'].diff(r4 - 1)
N = df['Close'].shift(r4 - 1)
ROC4 = M / N
KST = pd.Series(pd.rolling_sum(ROC1, n1) + pd.rolling_sum(ROC2, n2) * 2 + pd.rolling_sum(ROC3, n3) * 3 + pd.rolling_sum(ROC4, n4) * 4, name = 'KST_' + str(r1) + '_' + str(r2) + '_' + str(r3) + '_' + str(r4) + '_' + str(n1) + '_' + str(n2) + '_' + str(n3) + '_' + str(n4))
df = df.join(KST)
return df
#Relative Strength Index
def SUM(self, param):
if param[1] == 0:
return pd.expanding_sum(param[0])
return pd.rolling_sum(param[0], param[1])
def EVERY(self, param):
norm = self.IF([param[0], 1, 0])
result = pd.rolling_sum(norm, param[1])
return result == param[1]
def EXIST(self, param):
norm = self.IF([param[0], 1, 0])
result = pd.rolling_sum(norm, param[1])
return result > 0
def COUNT(self, param):
norm = self.IF([param[0], 1, 0])
result = pd.rolling_sum(norm, param[1])
return result
def INSIST(self, param):
norm = self.IF([param[0], 1, 0])
x1 = pd.rolling_sum(norm, param[1])
x2 = pd.rolling_sum(norm, param[2])
ret =((x1 - x2) == np.abs(param[1] - param[2]))
return ret
def MassI(df):
Range = df['high'] - df['low']
EX1 = pd.ewma(Range, span = 9, min_periods = 8)
EX2 = pd.ewma(EX1, span = 9, min_periods = 8)
Mass = EX1 / EX2
MassI = pd.Series(pd.rolling_sum(Mass, 25), name = 'MassIndex')
return MassI
#Vortex Indicator
def Vortex(df, n):
tr = TR(df)
vm = abs(df['high'] - df['low'].shift(1)) - abs(df['low']-df['high'].shift(1))
VI = pd.Series(pd.rolling_sum(vm, n) / pd.rolling_sum(tr, n), name = 'Vortex' + str(n))
return VI
#KST Oscillator
def ULTOSC(df):
TR_l = TR(df)
BP_l = df['close'] - pd.concat([df['low'], df['close'].shift(1)], axis=1).min(axis=1)
UltO = pd.Series((4 * pd.rolling_sum(BP_l, 7) / pd.rolling_sum(TR_l, 7)) + (2 * pd.rolling_sum(BP_l, 14) / pd.rolling_sum(TR_l, 14)) + (pd.rolling_sum(BP_l, 28) / pd.rolling_sum(TR_l, 28)), name = 'UltOsc')
return UltO
def MassI(df):
Range = df['High'] - df['Low']
EX1 = pd.ewma(Range, span = 9, min_periods = 8)
EX2 = pd.ewma(EX1, span = 9, min_periods = 8)
Mass = EX1 / EX2
MassI = pd.Series(pd.rolling_sum(Mass, 25), name = 'Mass Index')
df = df.join(MassI)
return df
#Vortex Indicator: http://www.vortexindicator.com/VFX_VORTEX.PDF
def ULTOSC(df):
i = 0
TR_l = [0]
BP_l = [0]
while i < df.index[-1]:
TR = max(df.get_value(i + 1, 'High'), df.get_value(i, 'Close')) - min(df.get_value(i + 1, 'Low'), df.get_value(i, 'Close'))
TR_l.append(TR)
BP = df.get_value(i + 1, 'Close') - min(df.get_value(i + 1, 'Low'), df.get_value(i, 'Close'))
BP_l.append(BP)
i = i + 1
UltO = pd.Series((4 * pd.rolling_sum(pd.Series(BP_l), 7) / pd.rolling_sum(pd.Series(TR_l), 7)) + (2 * pd.rolling_sum(pd.Series(BP_l), 14) / pd.rolling_sum(pd.Series(TR_l), 14)) + (pd.rolling_sum(pd.Series(BP_l), 28) / pd.rolling_sum(pd.Series(TR_l), 28)), name = 'Ultimate_Osc')
df = df.join(UltO)
return df
#Donchian Channel
def _roll_exp(self, sample):
ts = sample
result = pd.DataFrame([], index=ts.index.rename("time"))
for key, value in self._column_names["M"].items():
result[value[0]] = pd.rolling_sum(ts, key).apply(self.calculator_arithmetic_mean, axis=1)
return result
def ar_window_compound(self):
ts = self.pnl_compound_ratio("MS")
result = pd.DataFrame([], index=ts.index.rename("time"))
for key, value in self._column_names["M"].items():
result[value[0]] = pd.rolling_sum(ts, key).apply(self.calculator_arithmetic_mean, axis=1)
return result
def MassI(df):
Range = df['High'] - df['Low']
EX1 = pd.ewma(Range, span = 9, min_periods = 8)
EX2 = pd.ewma(EX1, span = 9, min_periods = 8)
Mass = EX1 / EX2
MassI = pd.Series(pd.rolling_sum(Mass, 25), name = 'Mass Index')
df = df.join(MassI)
return df
#Vortex Indicator: http://www.vortexindicator.com/VFX_VORTEX.PDF
def ULTOSC(df):
i = 0
TR_l = [0]
BP_l = [0]
while i < df.index[-1]:
TR = max(df.get_value(i + 1, 'High'), df.get_value(i, 'Close')) - min(df.get_value(i + 1, 'Low'), df.get_value(i, 'Close'))
TR_l.append(TR)
BP = df.get_value(i + 1, 'Close') - min(df.get_value(i + 1, 'Low'), df.get_value(i, 'Close'))
BP_l.append(BP)
i = i + 1
UltO = pd.Series((4 * pd.rolling_sum(pd.Series(BP_l), 7) / pd.rolling_sum(pd.Series(TR_l), 7)) + (2 * pd.rolling_sum(pd.Series(BP_l), 14) / pd.rolling_sum(pd.Series(TR_l), 14)) + (pd.rolling_sum(pd.Series(BP_l), 28) / pd.rolling_sum(pd.Series(TR_l), 28)), name = 'Ultimate_Osc')
df = df.join(UltO)
return df
#Donchian Channel
def MassI(df):
Range = df['High'] - df['Low']
EX1 = pd.ewma(Range, span = 9, min_periods = 8)
EX2 = pd.ewma(EX1, span = 9, min_periods = 8)
Mass = EX1 / EX2
MassI = pd.Series(pd.rolling_sum(Mass, 25), name = 'Mass Index')
df = df.join(MassI)
return df
#Vortex Indicator: http://www.vortexindicator.com/VFX_VORTEX.PDF
def ULTOSC(df):
i = 0
TR_l = [0]
BP_l = [0]
while i < df.index[-1]:
TR = max(df.get_value(i + 1, 'High'), df.get_value(i, 'Close')) - min(df.get_value(i + 1, 'Low'), df.get_value(i, 'Close'))
TR_l.append(TR)
BP = df.get_value(i + 1, 'Close') - min(df.get_value(i + 1, 'Low'), df.get_value(i, 'Close'))
BP_l.append(BP)
i = i + 1
UltO = pd.Series((4 * pd.rolling_sum(pd.Series(BP_l), 7) / pd.rolling_sum(pd.Series(TR_l), 7)) + (2 * pd.rolling_sum(pd.Series(BP_l), 14) / pd.rolling_sum(pd.Series(TR_l), 14)) + (pd.rolling_sum(pd.Series(BP_l), 28) / pd.rolling_sum(pd.Series(TR_l), 28)), name = 'Ultimate_Osc')
df = df.join(UltO)
return df
#Donchian Channel
def getKDJ(close, high, low):
'''
calculate KDJ value
:param DataFrame close:close price
:param DataFrame high:highest price of a day
:param DataFrame low: lowest price of a day
:return: [DataFrame,DataFrame,DataFrame,DataFrame] [RSV, K, D, KDJ]:KDJ value and some subproducts
'''
# interval over which KDJ is calculated
kdj_interval = 9
N = 3
# calculate RSV
# get the close value to be used
close = pd.DataFrame(close.iloc[(kdj_interval - 1):, :].values)
# calculate maximum in (kdj_interval) days in high value
high_max_in_interval = pd.rolling_max(high, kdj_interval)
# rolling_sum function will set the first (kdj_interval-1) days as np.nan,drop them
high_max_in_interval.dropna(inplace=True)
# set index with 0,1,2...,otherwise it will be kdj_interval,kdj_interval+1,...(may not be explicit but fuck the index)
high_max_in_interval.index = range(high_max_in_interval.shape[0])
low_min_in_interval = pd.rolling_min(low, kdj_interval)
low_min_in_interval.dropna(inplace=True)
low_min_in_interval.index = range(low_min_in_interval.shape[0])
# calculate RSV
RSV = 100 * (close - low_min_in_interval) / (high_max_in_interval - low_min_in_interval)
# replace np.nan and np.inf in RSV because there might be 0 in the denominator of the last formula
RSV.replace([np.nan, np.inf,-np.inf], 0, inplace=True)
# get matrix shape
[row, col] = RSV.shape
# calculate K
# assuming N equals n in the formula
# initialize both N and K with 50
K = pd.DataFrame(np.zeros([row, col]))
D = pd.DataFrame(np.zeros([row, col]))
K.iloc[0, :] = 50 * np.ones([1, col])
D.iloc[0, :] = 50 * np.ones([1, col])
# calculate K and D iteratively
for i in range(1, row):
K.iloc[i, :] = (RSV.iloc[i, :] + K.iloc[(i - 1), :]) / N
D.iloc[i, :] = (K.iloc[i, :] - D.iloc[(i - 1), :]) / N
KDJ = 3 * K - 2 * D
return [RSV, K, D, KDJ]