列表的 Python 列表与 numpy

Question

所以，我有一段脚本:

lol = []
latv1 = 0
latv2 = 0
latv3 = 0

#Loop a
for a in range(100):

    #Refresh latv2 after each iteration of loop a
    latv2 = 0

    #Loop b
    for b in range(100):

        #Refresh latv3 after each iteration of loop b
        latv3 = 0

        #Loop c        
        for c in range(100):

            #Make 4 value list according to iteration and append to lol
            midl2 = [latv1,latv2,latv3,0]
            lol.append(midl2)

            #Iterate after loop
            latv3 = latv3 + 1
        latv2 = latv2 + 1
    latv1 = latv1 + 1

它会做我想让它做的事....但是非常慢。它给出:

[[0,0,0,0]
 [0,0,1,0]
 ...
 [0,1,0,0]
 [0,1,1,0]
 ...
 [9,9,8,0]
 [9,9,9,0]]

我读过有关 numpy 及其速度和优化的文章。我无法弄清楚如何用 numpy 实现上面的内容。我已经通过手册学习了如何使用 numpy 制作一个零数组:

numpy_array = np.zeroes((100,4))

给予:

[[ 0.  0.  0.  0.]
 [ 0.  0.  0.  0.]
 [ 0.  0.  0.  0.]
 ..., 
 [ 0.  0.  0.  0.]
 [ 0.  0.  0.  0.]
 [ 0.  0.  0.  0.]]

并且可以更改每列的值:

numpA  = np.arange(0,100,1)
numpB  = np.arange(0,100,1
numpC  = np.arange(0,100,1)
numArr[:,0] = numpA
numArr[:,1] = numpB
numArr[:,2] = numpC

给予:

[[   0.    0.    0.    0.]
 [   1.    1.    1.    0.]
 [   2.    2.    2.    0.]
 ..., 
 [ 997.  997.  997.    0.]
 [ 998.  998.  998.    0.]
 [ 999.  999.  999.    0.]]

但我无法创建一个 1000000 行长的 numpy 数组，并且无法像原始示例那样使列递增。如果我用 1000000 而不是 100 调用零数组创建，则列替换不起作用，这是有道理的，因为数组的长度和替换不相等 - 但我不确定如何正确地迭代替换数组以使其工作。

如何复制通过 numpy 数组输出的原始脚本？

注意:这是一台 python 2.7 机器，但至少是 64 位。我知道 RAM 使用是一个问题，但我应该能够更改数组的 dtype 以满足我的需要。

Answer 1

方法 #1

要创建与已发布代码等效的 NumPy 并将 NumPy 数组作为输出，您还可以使用 itertools , 像这样 -

from itertools import product

out = np.zeros((N**3,4),dtype=int)
out[:,:3] = list(product(np.arange(N), repeat=3))

请注意，它是 N = 100 以使其等同于发布的代码。

方法 #2

另一种可能更快的方法基于纯 NumPy 并使用它的矢量化 broadcasting可以像这样建议功能 -

out = np.zeros((N**3,4),dtype=int)
out[:,:3] = (np.arange(N**3)[:,None]/[N**2,N,1])%N

我认为这比之前基于 itertools 的方法更快，因为它创建了一个要设置到 NumPy 数组中的元组列表。我们将在下一节中检验这一理论。

---

运行时测试

In [111]: def itertools_based(N):
     ...:     out = np.zeros((N**3,4),dtype=int)
     ...:     out[:,:3] = list(product(np.arange(N), repeat=3))
     ...:     return out
     ...: 
     ...: def broadcasting_based(N):
     ...:     out = np.zeros((N**3,4),dtype=int)
     ...:     out[:,:3] = (np.arange(N**3)[:,None]/[N**2,N,1])%N
     ...:     return out


In [112]: N = 20

In [113]: np.allclose(itertools_based(N),broadcasting_based(N)) # Verify results
Out[113]: True

In [114]: %timeit itertools_based(N)
100 loops, best of 3: 7.42 ms per loop

In [115]: %timeit broadcasting_based(N)
1000 loops, best of 3: 1.23 ms per loop

现在，让我们为那些迭代元素的元组列表的创建计时，并将其与基于 NumPy 的列表进行比较 -

In [116]: %timeit list(product(np.arange(N), repeat=3))
1000 loops, best of 3: 746 µs per loop

In [117]: %timeit (np.arange(N**3)[:,None]/[N**2,N,1])%N
1000 loops, best of 3: 1.09 ms per loop

好吧，itertools-based 的创建部分现在更快了，正如之前预测/想到的那样!因此，如果您对前三列作为输出感到满意并且它们是元组列表，那么请使用 itertools。