Python 创建Numpy数组而不枚举数组

从这一点开始：

x = range(30,60,2)[::-1];
x = np.asarray(x); x

array([58, 56, 54, 52, 50, 48, 46, 44, 42, 40, 38, 36, 34, 32, 30])

创建这样一个数组：（注意，第一项重复）但是如果我可以在不重复第一项的情况下更快地得到它，我可以

np.hstack

first item

[[58 58 56 54 52]
 [56 56 54 52 50]
 [54 54 52 50 48]
 [52 52 50 48 46]
 [50 50 48 46 44]
 [48 48 46 44 42]
 [46 46 44 42 40]
 [44 44 42 40 38]
 [42 42 40 38 36]
 [40 40 38 36 34]
 [38 38 36 34 32]
 [36 36 34 32 30]
 [34 34 32 30 None]
 [32 32 30 None None]
 [30 30 None None None]]

下面的代码可以工作，希望在没有“for”循环和枚举的情况下更快

arr = np.empty((0,5), int)

for i,e in enumerate(x):
    arr2 = np.hstack((x[i], x[i:i+4], np.asarray([None]*5)))[:5]
    arr  = np.vstack((arr,arr2))

---

通过避免使用

\u stack（）

，并且只使用浮点数，我的速度提高了大约一个数量级

编辑：将@Divakar的帖子添加到计时赛中

import numpy as np
from time import time

t = time()
for _ in range(1000):  #1000 iterations of my soln.
    width = 3
    x = np.array(range(58,28,-2) + [float('nan')]*width)
    arr = np.empty([len(x)-width, width+2])
    arr[:,0] = x[:len(x)-width]
    for i in xrange(len(x)-width): 
        arr[i,1:] = x[i:i+width+1]
print(time()-t)

t = time()
for _ in range(1000):  #1000 iterations of OP code
    x = range(30,60,2)[::-1];
    x = np.asarray(x)
    arr = np.empty((0,5), int)
    for i,e in enumerate(x):
        arr2 = np.hstack((x[i], x[i:i+4], np.asarray([None]*5)))[:5]
        arr  = np.vstack((arr,arr2))
print(time()-t)

t = time()
for _ in range(1000): 
    x = np.array(range(58,28,-2))
    N = 4 # width factor
    x_ext = np.hstack((x,[None]*(N-1)))
    arr2D = x_ext[np.arange(N) + np.arange(x_ext.size-N+1)[:,None]]
    out = np.column_stack((x,arr2D))
print(time()-t)

打印出：

>>> runfile('...temp.py', wdir='...')
0.0160000324249
0.374000072479
0.0319998264313
>>> 

---

通过避免使用

\u stack（）

，并且只使用浮点数，我的速度提高了大约一个数量级

编辑：将@Divakar的帖子添加到计时赛中

import numpy as np
from time import time

t = time()
for _ in range(1000):  #1000 iterations of my soln.
    width = 3
    x = np.array(range(58,28,-2) + [float('nan')]*width)
    arr = np.empty([len(x)-width, width+2])
    arr[:,0] = x[:len(x)-width]
    for i in xrange(len(x)-width): 
        arr[i,1:] = x[i:i+width+1]
print(time()-t)

t = time()
for _ in range(1000):  #1000 iterations of OP code
    x = range(30,60,2)[::-1];
    x = np.asarray(x)
    arr = np.empty((0,5), int)
    for i,e in enumerate(x):
        arr2 = np.hstack((x[i], x[i:i+4], np.asarray([None]*5)))[:5]
        arr  = np.vstack((arr,arr2))
print(time()-t)

t = time()
for _ in range(1000): 
    x = np.array(range(58,28,-2))
    N = 4 # width factor
    x_ext = np.hstack((x,[None]*(N-1)))
    arr2D = x_ext[np.arange(N) + np.arange(x_ext.size-N+1)[:,None]]
    out = np.column_stack((x,arr2D))
print(time()-t)

打印出：

>>> runfile('...temp.py', wdir='...')
0.0160000324249
0.374000072479
0.0319998264313
>>> 

---

我建议构造一个具有相等列的初始矩阵，然后使用

np.roll（）

旋转它们：

import numpy as np
import timeit as ti
import numpy.matlib

x = range(30,60,2)[::-1];
x = np.asarray(x);

def sol1():
    # Your solution, for comparison
    arr = np.empty((0,5), int)

    for i,e in enumerate(x):
        arr2 = np.hstack((x[i], x[i:i+4], np.asarray([None]*5)))[:5]
        arr  = np.vstack((arr,arr2))
    return arr

def sol2():
    # My proposal
    x2 = np.hstack((x, [None]*3))
    mat = np.matlib.repmat(x2, 5, 1)
    for i in range(3):
        mat[i+2, :] = np.roll(mat[i+2, :], -(i+1))
    return mat[:,:-3].T


print(ti.timeit(sol1, number=100))
print(ti.timeit(sol2, number=100))

哪些伪装：

0.026760146000015084
0.0038611710006080102

---

它使用for循环，但只在较短的轴上迭代。此外，将此代码用于其他配置而不是使用硬编码的数字也不难。

我建议构造一个列相等的初始矩阵，然后使用

np.roll（）

旋转它们：

import numpy as np
import timeit as ti
import numpy.matlib

x = range(30,60,2)[::-1];
x = np.asarray(x);

def sol1():
    # Your solution, for comparison
    arr = np.empty((0,5), int)

    for i,e in enumerate(x):
        arr2 = np.hstack((x[i], x[i:i+4], np.asarray([None]*5)))[:5]
        arr  = np.vstack((arr,arr2))
    return arr

def sol2():
    # My proposal
    x2 = np.hstack((x, [None]*3))
    mat = np.matlib.repmat(x2, 5, 1)
    for i in range(3):
        mat[i+2, :] = np.roll(mat[i+2, :], -(i+1))
    return mat[:,:-3].T


print(ti.timeit(sol1, number=100))
print(ti.timeit(sol2, number=100))

哪些伪装：

0.026760146000015084
0.0038611710006080102

它使用for循环，但只在较短的轴上迭代。此外，将此代码用于其他配置而不是使用硬编码数字也不难。

方法#1

这里有一个矢量化方法，使用-

---

方法#2

这是另一个正在使用的-

---

运行时测试

这是一个修改版本，它使用了一种与脚本中他在文章中使用的输入格式相同的输入格式，用于公平的基准测试，并将重点放在这两种方法上-

upper_limit = 58 # We will edit this to vary the dataset sizes

print "Timings are : "
t = time()
for _ in range(1000):  #1000 iterations of @Aaron's soln.
    width = 3
    x = np.array(range(upper_limit,28,-2) + [float('nan')]*width)
    arr = np.empty([len(x)-width, width+2])
    arr[:,0] = x[:len(x)-width]
    for i in xrange(len(x)-width): 
        arr[i,1:] = x[i:i+width+1]
print(time()-t)

t = time()
for _ in range(1000): 
    N = 4 # width factor
    x_ext = np.array(range(upper_limit,28,-2) + [float('nan')]*(N-1))
    arr2D = x_ext[np.arange(N) + np.arange(x_ext.size-N+1)[:,None]]
    out = np.column_stack((x_ext[:len(x_ext)-N+1],arr2D))
print(time()-t)

案例1（上限=58）：

案例2（上限=1058）：

案例3（上限=5058）：

方法#1

这里有一个矢量化方法，使用-

---

方法#2

这是另一个正在使用的-

---

运行时测试

这是一个修改版本，它使用了一种与脚本中他在文章中使用的输入格式相同的输入格式，用于公平的基准测试，并将重点放在这两种方法上-

upper_limit = 58 # We will edit this to vary the dataset sizes

print "Timings are : "
t = time()
for _ in range(1000):  #1000 iterations of @Aaron's soln.
    width = 3
    x = np.array(range(upper_limit,28,-2) + [float('nan')]*width)
    arr = np.empty([len(x)-width, width+2])
    arr[:,0] = x[:len(x)-width]
    for i in xrange(len(x)-width): 
        arr[i,1:] = x[i:i+width+1]
print(time()-t)

t = time()
for _ in range(1000): 
    N = 4 # width factor
    x_ext = np.array(range(upper_limit,28,-2) + [float('nan')]*(N-1))
    arr2D = x_ext[np.arange(N) + np.arange(x_ext.size-N+1)[:,None]]
    out = np.column_stack((x_ext[:len(x_ext)-N+1],arr2D))
print(time()-t)

案例1（上限=58）：

案例2（上限=1058）：

案例3（上限=5058）：

---

从Divaker的填充

x开始

N = 4 # width factor
x_ext = np.concatenate((x,[None]*(N-1)))

因为我们没有对它进行数学运算，所以用None填充（构成对象数组）或
np.nan
（构成浮点）应该不会有太大的区别

只需稍微更改索引即可消除列堆栈：

idx = np.r_[0,np.arange(N)] + np.arange(x_ext.size-N+1)[:,None]

这就产生了

array([[ 0,  0,  1,  2,  3],
       [ 1,  1,  2,  3,  4],
       [ 2,  2,  3,  4,  5],
       [ 3,  3,  4,  5,  6],
       [ 4,  4,  5,  6,  7],
       ...

因此，全部结果是

x_ext[idx]

================

另一种方法是使用跨步创建一种滚动窗口

as_strided = np.lib.stride_tricks.as_strided
arr2D = as_strided(x_ext, shape=(15,4), str‌​ides=(4,4))

这是
的一个更容易的应用程序，因为_大步向前
<代码>形状

是直接向前的-所需结果的形状（无重复列）

（x.shape[0]，N）

对于这种类型的1d数组，下一项的步骤是4字节。如果我用3列将数组重塑为2d，则到下一行的跨距为12-3*4（3偏移）

使用

strips=（4,4）

意味着到下一行的步骤只有4个字节，一个元素是原始的

as_strided(x_ext,shape=(8,4),strides=(8,4))

生成2项重叠

array([[58, 56, 54, 52],
       [54, 52, 50, 48],
       [50, 48, 46, 44],
       [46, 44, 42, 40],
       ....

的潜在危险部分在于，可以创建一个数组，对原始数据缓冲区之外的内存进行采样。在本例中，
None
通常显示为大随机数。如果在使用数组指针和索引时不小心，那么C代码也会遇到同样的错误

as_-stripped
数组是一个视图（重复的值不会被复制）。因此，写入该数组可能是危险的。带有
x
的
列堆栈
将进行复制，根据需要复制重复的值。
从Divaker的填充
x开始

N = 4 # width factor
x_ext = np.concatenate((x,[None]*(N-1)))

因为我们没有对它进行数学运算，所以用None填充（构成对象数组）或
np.nan
（构成浮点）应该不会有太大的区别

只需稍微更改索引即可消除列堆栈：

idx = np.r_[0,np.arange(N)] + np.arange(x_ext.size-N+1)[:,None]

这就产生了

array([[ 0,  0,  1,  2,  3],
       [ 1,  1,  2,  3,  4],
       [ 2,  2,  3,  4,  5],
       [ 3,  3,  4,  5,  6],
       [ 4,  4,  5,  6,  7],
       ...

因此，全部结果是

x_ext[idx]

================

另一种方法是使用跨步创建一种滚动窗口

as_strided = np.lib.stride_tricks.as_strided
arr2D = as_strided(x_ext, shape=(15,4), str‌​ides=(4,4))

这是
的一个更容易的应用程序，因为_大步向前
<代码>形状
是直接向前的-所需结果的形状（无重复列）
（x.shape[0]，N）

对于这种类型的1d数组，下一项的步骤是4字节。如果我用3列将数组重塑为2d，则到下一行的跨距为12-3*4（3偏移）

使用
strips=（4,4）
意味着到下一行的步骤只有4个字节，一个元素是原始的

as_strided(x_ext,shape=(8,4),strides=(8,4))

生成2项重叠

array([[58, 56, 54, 52],
       [54, 52, 50, 48],
       [50, 48, 46, 44],
       [46, 44, 42, 40],
       ....

的潜在危险部分在于，可以创建一个数组，对原始数据缓冲区之外的内存进行采样。在本例中，
None
通常显示为大随机数。如果在使用数组指针和索引时不小心，那么C代码也会遇到同样的错误

as_-stripped
数组是一个视图（重复的值不会被复制）。因此，写入该数组可能是危险的。带有
x
的
column\u stack
将创建一个副本，根据需要复制重复的值。
为了提高速度，我将去掉
np.\u stack（）
，因为它每次都需要构建一个全新的对象。另外，如果您可以将
None
表示为数字类型：inf可能。。您可以避免
dtype=object
的减速，如果您可以使用float，我会选择它，因为您可以使用NaN。None是一个数据库问题。@juanpa.arrivillaga。对于整数类型，可以使用-1或intmin之类的值。只要