实际上，有一种更有效的方法可以做到这一点...使用vstack 等的缺点是您正在制作数组的副本。
顺便说一句，这实际上与@Paul 的答案相同，但我发布这个只是为了更详细地解释事情......
有一种方法可以只用视图来做到这一点，这样没有内存被复制。
我是直接从Erik Rigtorp's post to numpy-discussion 那里借来的，而后者又是从 Keith Goodman 的Bottleneck 那里借来的（这很有用！）。
基本技巧是直接操作strides of the array（对于一维数组）：
import numpy as np
def rolling(a, window):
shape = (a.size - window + 1, window)
strides = (a.itemsize, a.itemsize)
return np.lib.stride_tricks.as_strided(a, shape=shape, strides=strides)
a = np.arange(10)
print rolling(a, 3)
a 是您的输入数组，window 是您想要的窗口长度（在您的情况下为 3）。
这会产生：
[[0 1 2]
[1 2 3]
[2 3 4]
[3 4 5]
[4 5 6]
[5 6 7]
[6 7 8]
[7 8 9]]
但是，原始a 和返回的数组之间绝对没有内存重复。这意味着它比其他选项速度快并且可扩展性很多。
例如（使用a = np.arange(100000) 和window=3）：
%timeit np.vstack([a[i:i-window] for i in xrange(window)]).T
1000 loops, best of 3: 256 us per loop
%timeit rolling(a, window)
100000 loops, best of 3: 12 us per loop
如果我们将其推广到沿 N 维数组的最后一个轴的“滚动窗口”，我们会得到 Erik Rigtorp 的“滚动窗口”函数：
import numpy as np
def rolling_window(a, window):
"""
Make an ndarray with a rolling window of the last dimension
Parameters
----------
a : array_like
Array to add rolling window to
window : int
Size of rolling window
Returns
-------
Array that is a view of the original array with a added dimension
of size w.
Examples
--------
>>> x=np.arange(10).reshape((2,5))
>>> rolling_window(x, 3)
array([[[0, 1, 2], [1, 2, 3], [2, 3, 4]],
[[5, 6, 7], [6, 7, 8], [7, 8, 9]]])
Calculate rolling mean of last dimension:
>>> np.mean(rolling_window(x, 3), -1)
array([[ 1., 2., 3.],
[ 6., 7., 8.]])
"""
if window < 1:
raise ValueError, "`window` must be at least 1."
if window > a.shape[-1]:
raise ValueError, "`window` is too long."
shape = a.shape[:-1] + (a.shape[-1] - window + 1, window)
strides = a.strides + (a.strides[-1],)
return np.lib.stride_tricks.as_strided(a, shape=shape, strides=strides)
那么，让我们看看这里发生了什么... 操作数组的strides 可能看起来有点神奇，但是一旦你了解了发生了什么，它就完全没有了。 numpy 数组的步幅描述了沿给定轴递增一个值所必须采取的步骤的大小（以字节为单位）。所以，在 64 位浮点数的一维数组的情况下，每一项的长度为 8 个字节，x.strides 为(8,)。
x = np.arange(9)
print x.strides
现在，如果我们将其重塑为 2D、3x3 数组，则步长将为 (3 * 8, 8)，因为我们必须跳转 24 个字节以沿第一个轴递增一步，并跳转 8 个字节以沿第一个轴递增一步第二轴。
y = x.reshape(3,3)
print y.strides
类似地，转置与只是反转数组的步幅相同：
print y
y.strides = y.strides[::-1]
print y
显然，数组的步长和数组的形状密切相关。如果我们改变一个，我们就必须相应地改变另一个，否则我们将无法对实际保存数组值的内存缓冲区进行有效描述。
因此，如果你想同时改变数组的形状和大小，你不能只通过设置x.strides和x.shape来做到这一点，即使新的strides和形状兼容。
这就是numpy.lib.as_strided 的用武之地。它实际上是一个非常简单的函数，它只是同时设置数组的步长和形状。
它会检查两者是否兼容，但不会检查旧步幅和新形状是否兼容，如果您独立设置两者，则会发生这种情况。 （它实际上是通过numpy's __array_interface__ 做到这一点的，它允许任意类将内存缓冲区描述为一个numpy 数组。）
所以，我们所做的只是让一个项目沿一个轴前进（在 64 位数组的情况下为 8 个字节），但也仅沿另一个轴前进 8 个字节。
换句话说，在“窗口”大小为 3 的情况下，数组的形状为 (whatever, 3)，但不是为第二维步进完整的 3 * x.itemsize，它只步进一个项目向前，有效地使新数组的行成为原始数组的“移动窗口”视图。
（这也意味着x.shape[0] * x.shape[1] 与新数组的x.size 不同。）
无论如何，希望这能让事情变得更清楚..