Python 由非均匀形状的一维阵列| numpy构造二维numpy阵列

在python中，有三个不同形状的一维数组（如下所示）

我假设数组

a0

对应于索引

I=0

，

a1

对应于索引

I=1

，

a2

对应于

I=2

。根据这些假设，我想构造一个新的二维数组，其中行将对应于数组的索引（

I=0,1,2

），列将是数组的条目

a0、a1、a2

在这里给出的示例中，我希望二维数组看起来像

result = np.array([ [0,5], [0,6], [0,7], [0,8], [0,9], [1,1], [1,2],\
           [1,3], [1,4], [2,11], [2,12]  ]) 

---

我将非常感谢您能回答我如何才能做到这一点。在我处理的实际问题中，我处理的不仅仅是三个一维数组。因此，如果答案考虑到这一点，那将非常好。

实现这一点的一种方法是简单的列表理解：

result = np.array([[i, arr_v] for i, arr in enumerate([a0, a1, a2]) 
                             for arr_v in arr])

>>> result
array([[ 0,  5],
       [ 0,  6],
       [ 0,  7],
       [ 0,  8],
       [ 0,  9],
       [ 1,  1],
       [ 1,  2],
       [ 1,  3],
       [ 1,  4],
       [ 2, 11],
       [ 2, 12]])

为了解决将此扩展到更多数组的问题，只需创建一个数组名称列表，并将该列表用作

枚举

的参数，即可轻松添加任意多个数组：

.... for i, arr in enumerate(my_list_of_arrays) ...

---

一种方法是简单的列表理解：

result = np.array([[i, arr_v] for i, arr in enumerate([a0, a1, a2]) 
                             for arr_v in arr])

>>> result
array([[ 0,  5],
       [ 0,  6],
       [ 0,  7],
       [ 0,  8],
       [ 0,  9],
       [ 1,  1],
       [ 1,  2],
       [ 1,  3],
       [ 1,  4],
       [ 2, 11],
       [ 2, 12]])

为了解决将此扩展到更多数组的问题，只需创建一个数组名称列表，并将该列表用作

枚举

的参数，即可轻松添加任意多个数组：

.... for i, arr in enumerate(my_list_of_arrays) ...

---

您可以使用

numpy

堆栈函数来加速：

aa = [a0, a1, a2]
np.hstack(tuple(np.vstack((np.full(ai.shape, i), ai)) for i, ai in enumerate(aa))).T

---

您可以使用

numpy

堆栈函数来加速：

aa = [a0, a1, a2]
np.hstack(tuple(np.vstack((np.full(ai.shape, i), ai)) for i, ai in enumerate(aa))).T

---

这是一种几乎矢量化的方法-

L = [a0,a1,a2] # list of all arrays
lens = [len(i) for i in L] # only looping part*
out = np.dstack(( np.repeat(np.arange(len(L)), lens), np.concatenate(L)))

*循环部分只是获取数组的长度，这对整个运行时的影响可以忽略不计

样本运行-

In [19]: L = [a0,a1,a2] # list of all arrays

In [20]: lens = [len(i) for i in L]

In [21]: np.dstack(( np.repeat(np.arange(len(L)), lens), np.concatenate(L)))
Out[21]: 
array([[[ 0,  5],
        [ 0,  6],
        [ 0,  7],
        [ 0,  8],
        [ 0,  9],
        [ 1,  1],
        [ 1,  2],
        [ 1,  3],
        [ 1,  4],
        [ 2, 11],
        [ 2, 12]]])

另一种方法是避免np.repeat，并使用一些数组初始化+cumsum方法，这对于大量数组会更好，如下所示-

col1 = np.concatenate(L)
col0 = np.zeros(len(col1), dtype=col1.dtype)
col0[np.cumsum(lens[:-1])] = 1
out = np.dstack((col0.cumsum(), col1))

或者使用

np.maximum.accumulate

替换第二个

cumsum

-

col0[np.cumsum(lens[:-1])] = np.arange(1,len(L))
out = np.dstack((np.maximum.accumulate(col0), col1))

---

这是一种几乎矢量化的方法-

L = [a0,a1,a2] # list of all arrays
lens = [len(i) for i in L] # only looping part*
out = np.dstack(( np.repeat(np.arange(len(L)), lens), np.concatenate(L)))

*循环部分只是获取数组的长度，这对整个运行时的影响可以忽略不计

样本运行-

In [19]: L = [a0,a1,a2] # list of all arrays

In [20]: lens = [len(i) for i in L]

In [21]: np.dstack(( np.repeat(np.arange(len(L)), lens), np.concatenate(L)))
Out[21]: 
array([[[ 0,  5],
        [ 0,  6],
        [ 0,  7],
        [ 0,  8],
        [ 0,  9],
        [ 1,  1],
        [ 1,  2],
        [ 1,  3],
        [ 1,  4],
        [ 2, 11],
        [ 2, 12]]])

另一种方法是避免np.repeat，并使用一些数组初始化+cumsum方法，这对于大量数组会更好，如下所示-

col1 = np.concatenate(L)
col0 = np.zeros(len(col1), dtype=col1.dtype)
col0[np.cumsum(lens[:-1])] = 1
out = np.dstack((col0.cumsum(), col1))

或者使用

np.maximum.accumulate

替换第二个

cumsum

-

col0[np.cumsum(lens[:-1])] = np.arange(1,len(L))
out = np.dstack((np.maximum.accumulate(col0), col1))

---

非常感谢。这个答案很有帮助。由于我有数千个一维数组，我试图看看是否可以避免手动创建数组的列表。不过，还是非常感谢你的回答非常感谢。这个答案很有帮助。由于我有数千个一维数组，我试图看看是否可以避免手动创建数组的列表。不过，还是非常感谢你的回答@谢谢你的回答。这很有帮助。我正在处理数千个数组。因此，我还试图看看是否可以找到避免在

aa

中手动列出所有数组的方法。不过，还是非常感谢你。：）@谢谢你的回答。这很有帮助。我正在处理数千个数组。因此，我还试图看看是否可以找到避免在

aa

中手动列出所有数组的方法。不过，还是非常感谢你。：）非常感谢你的来信。它速度非常快，非常有用。=）非常感谢你的来信。它速度非常快，非常有用。=）