不如这样吧：

import pandas as pd

def masscenter(ser: pd.Series, df: pd.DataFrame):
    df_roll = df.loc[ser.index]
    return your_actual_masscenter(df_roll)

masscenter_output = df['price'].rolling(window=3).apply(masscenter, args=(df,))

它使用滚动逻辑通过任意列获得子集。不使用任意列本身，只使用滚动索引。这依赖于默认值raw=False，它为这些子集提供索引值。applied函数使用这些索引值从原始数据框架中获取多列切片。

您可以使用numpy_ext模块中的rolling_apply函数：

import numpy as np
import pandas as pd
from numpy_ext import rolling_apply

def masscenter(price, nQty):
    return np.sum(price * nQty) / np.sum(nQty)

df = pd.DataFrame( [['02:59:47.000282', 87.60, 739],
                    ['03:00:01.042391', 87.51, 10],
                    ['03:00:01.630182', 87.51, 10],
                    ['03:00:01.635150', 88.00, 792],
                    ['03:00:01.914104', 88.00, 10]], 
                   columns=['stamp', 'price','nQty'])
df['stamp'] = pd.to_datetime(df['stamp'], format='%H:%M:%S.%f')
df.set_index('stamp', inplace=True, drop=True)

window = 2
df['y'] = rolling_apply(masscenter, window, df.price.values, df.nQty.values)
print(df)

                            price  nQty          y
stamp                                             
1900-01-01 02:59:47.000282  87.60   739        NaN
1900-01-01 03:00:01.042391  87.51    10  87.598798
1900-01-01 03:00:01.630182  87.51    10  87.510000
1900-01-01 03:00:01.635150  88.00   792  87.993890
1900-01-01 03:00:01.914104  88.00    10  88.000000

参考@saninstein的精彩回答。
安装numpy_ext从：https://pypi.org/project/numpy-ext/

import numpy as np
import pandas as pd
from numpy_ext import rolling_apply as rolling_apply_ext

def box_sum(a,b):
    return np.sum(a) + np.sum(b)

df = pd.DataFrame({"x": [1,2,3,4], "y": [1,2,3,4]})

window = 2
df["sum"] = rolling_apply_ext(box_sum, window , df.x.values, df.y.values)

输出量：

print(df.to_string(index=False))
 x  y  sum
 1  1  NaN
 2  2  6.0
 3  3 10.0
 4  4 14.0

注意到

• 滚动功能是时间序列友好的。它默认总是向后看，因此6是数组中当前值和过去值的总和。
• 在上面的示例中，将rolling_apply导入为rolling_apply_ext，因此它不可能干扰对Pandas rolling_apply的任何现有调用（感谢@LudoSchmidt的评论）。

顺便说一句，我放弃了使用Pandas。它从根本上被打破了：它处理单列的aggreagate和apply几乎没有问题，但是当试图让它处理更多的两列或更多列时，它是一个过于复杂的Rube-Goldberg机器。

要执行滚动窗口操作并访问 Dataframe 的所有列，可以将mehtod='table'传递给rolling()。范例：

import pandas as pd
import numpy as np
from numba import jit

df = pd.DataFrame({'a': [1, 2, 3, 4, 5, 6], 'b': [1, 3, 5, 7, 9, 11]})

@jit
def f(w):
    # we have access to both columns of the dataframe here
    return np.max(w), np.min(w)

df.rolling(3, method='table').apply(f, raw=True, engine='numba')

需要注意的是，method='table'需要numba引擎（pip install numba）。示例中的@jit部分不是必需的，但有助于提高性能。以上示例代码的结果将是：
| 一|B|
| --|--|
| 楠|楠|
| 楠|楠|
| 5.0 |1.0|
| 7.0 |2.0|
| 9.0 |3.0|
| 11.0 |4.0|

所以我发现没有办法滚动两列，但是没有内置的pandas函数。代码如下所示。

# function to find an index corresponding
# to current value minus offset value
def prevInd(series, offset, date):
    offset = to_offset(offset)
    end_date = date - offset
    end = series.index.searchsorted(end_date, side="left")
    return end

# function to find an index corresponding
# to the first value greater than current
# it is useful when one has timeseries with non-unique
# but monotonically increasing values
def nextInd(series, date):
    end = series.index.searchsorted(date, side="right")
    return end

def twoColumnsRoll(dFrame, offset, usecols, fn, columnName = 'twoColRol'):
    # find all unique indices
    uniqueIndices = dFrame.index.unique()
    numOfPoints = len(uniqueIndices)
    # prepare an output array
    moving = np.zeros(numOfPoints)
    # nameholders
    price = dFrame[usecols[0]]
    qty   = dFrame[usecols[1]]

    # iterate over unique indices
    for ii in range(numOfPoints):
        # nameholder
        pp = uniqueIndices[ii]
        # right index - value greater than current
        rInd = afta.nextInd(dFrame,pp)
        # left index - the least value that 
        # is bigger or equal than (pp - offset)
        lInd = afta.prevInd(dFrame,offset,pp)
        # call the actual calcuating function over two arrays
        moving[ii] = fn(price[lInd:rInd], qty[lInd:rInd])
    # construct and return DataFrame
    return pd.DataFrame(data=moving,index=uniqueIndices,columns=[columnName])

这段代码可以工作，但相对较慢且效率较低。我认为可以使用How to invoke pandas.rolling.apply with parameters from multiple column?中的numpy.lib.stride_tricks来加速。然而，要么做大，要么回家--我结束了用C++写一个函数和它的 Package 器。
我不想把它作为答案贴出来，因为这是一个变通方案，我没有回答我的问题的任何一部分，但它太长了，不适合评论。

这个怎么样？

ggg = pd.DataFrame({"a":[1,2,3,4,5,6,7], "b":[7,6,5,4,3,2,1]})

def my_rolling_apply2(df, fun, window):
    prepend = [None] * (window - 1)
    end = len(df) - window
    mid = map(lambda start: fun(df[start:start + window]), np.arange(0,end))
    last =  fun(df[end:])
    return [*prepend, *mid, last]

my_rolling_apply2(ggg, lambda df: (df["a"].max(), df["b"].min()), 3)

结果是：

[None, None, (3, 5), (4, 4), (5, 3), (6, 2), (7, 1)]