连接/附加多个不同大小的垂直数组

Posted 2023-02-24

【中文标题】连接/附加多个不同大小的垂直数组

【英文标题】：Concatenating/Appending Multiple Vertical Arrays of Different Sizes

【发布时间】：2019-08-04 22:17:15

【问题描述】：

我有一个返回 numpy 数组的函数。我用不同的数据文件循环这个函数，但最终每个循环都会给出一个不同大小的数组（这是所需的输出），但我不知道如何正确附加这些数组。示例数组和我从文件中获取数据后用于排列它们的方法如下所示：

a1 = np.array([1,2,3]) 
a2 = np.vstack(a1)
# array([[1],
   [2],
   [3]])
b1 = np.array([4,5,6,7])
b2 = np.vstack(b2)
# array([[4],
   [5],
   [6],
   [7]])

我有这两个数组，一个有 3 个元素，一个有 4 个元素。我想将它们垂直排列，使其看起来像这样以便导出：

1  4 
2  5
3  6
   7

我不希望用零或 Na 来填补数据中的空白，因为那样会做更多工作。

这需要适用于列宽为 2 的垂直数组，以使输出数据按如下方式组织：

1  2   5  6   10  11
2  3   6  7   11  12
3  4   7  8   12  13
       8  9 

所以第一个循环会产生这个垂直的 3,2 数组，而循环的第二次迭代会产生 4,2 数组，我想将 4,2 数组附加或连接到原始 3,2 数组和很快。这些数组组的宽度始终为 2，但长度会随着每组 2 的变化而变化。

我曾尝试使用基本的np.column_stack、np.concatenate 和np.append 函数，但它们没有奏效。这些可以是列表而不是 numpy 数组，如果这样可以更好地工作，或者甚至将输出的数据组织在数据框中就可以了。

======= 更新=======

更具体地说，在尝试了此处提供的一些解决方案之后，我会详细了解我的问题。 我的函数从数据文件中获取数据（工作正常），该文件返回 2 个相同维度的值的列表或数组（其中任何一个）（这里也没有问题）。

现在我正在尝试在遍历目录中的所有文件时执行此操作，并且我想将每个文件的这两个列表（或数组）附加/连接在一起，但它们的大小可能不同。当我尝试将它们垂直放在一起以产生输出数据的列时，问题就出现了。我还需要对循环中的值进行简单的数学运算，所以我认为它们可能需要是 numpy 数组（或类似的东西）而不是列表。

循环 #1 返回：

outdata1 = [0.0012, 0.0013, 0.00124, 0.00127] outdata2 = [0.0016, 0.0014, 0.00134, 0.0013]

循环 #2 返回：

outdata1 = [0.00155, 0.00174, 0.0018] outdata2 = [0.0019, 0.0020, 0.0021]

等等……

现在我需要对这些进行数学运算并将它们吐出到垂直组织的列数据中，而不切断任何数据。这可以通过将 Na 放入空间或使用数据框来完成，如果可行的话，我可以在导出之前更正这些空间。我希望它看起来像这样：

0.0012 0.0016 0.00155 0.0019 0.0013 0.0014 0.00174 0.0020 0.00124 0.00134 0.0018 0.0021 0.00127 0.0013

【问题讨论】：

Numpy 不处理ragged arrays，因此列表列表可能是更合适的方法。

【参考方案1】：

首先，数组上的vstack 将数组视为第一个维度上的列表。然后它将每个“行/元素”变成一个二维数组，并将它们连接起来。

这些都做同样的事情：

In [94]: np.vstack(np.array([1,2,3]))                                           
Out[94]: 
array([[1],
       [2],
       [3]])
In [95]: np.vstack([[1],[2],[3]])                                               
Out[95]: 
array([[1],
       [2],
       [3]])
In [96]: np.concatenate(([[1]],[[2]],[[3]]), axis=0)                            
Out[96]: 
array([[1],
       [2],
       [3]])

匹配的数组或列表可以是 'column_stack' - 数组被转换为 (n,1) 数组，然后在第二维上加入：

In [97]: np.column_stack(([1,2,3], [4,5,6]))                                    
Out[97]: 
array([[1, 4],
       [2, 5],
       [3, 6]])

但是参差不齐的数组不起作用。

不同大小的列表/数组的数组具有对象 dtype，并且在许多用途中类似于列表：

In [98]: np.array(([1,2,3],[4,5,6,7]))                                          
Out[98]: array([list([1, 2, 3]), list([4, 5, 6, 7])], dtype=object)

你的最后一个结构可以写成一个参差不齐的列表：

In [100]: [[1,2,5,6,10,11],[2,3,6,7,11,12],[3,4,7,8,12,13],[8,9]]               
Out[100]: [[1, 2, 5, 6, 10, 11], [2, 3, 6, 7, 11, 12], [3, 4, 7, 8, 12, 13], [8, 9]]
In [101]: np.array(_)                                                           
Out[101]: 
array([list([1, 2, 5, 6, 10, 11]), list([2, 3, 6, 7, 11, 12]),
       list([3, 4, 7, 8, 12, 13]), list([8, 9])], dtype=object)

请注意，虽然这并没有将 [8,9] 与其他对齐。你需要某种填充物/垫片。 Python 列表zip_longest 提供：

In [102]: from itertools import zip_longest                                     
In [103]: alist = [[1,2,3],[2,3,4],[5,6,7,8],[11,12,13]]                        
In [104]: list(zip_longest(*alist))                                             
Out[104]: [(1, 2, 5, 11), (2, 3, 6, 12), (3, 4, 7, 13), (None, None, 8, None)]

通过这个填充，我们可以创建一个二维数组（对象 dtype 因为 None）：

In [105]: np.array(_)                                                           
Out[105]: 
array([[1, 2, 5, 11],
       [2, 3, 6, 12],
       [3, 4, 7, 13],
       [None, None, 8, None]], dtype=object)

===

我可以用一个小函数生成你上次显示的数字：

In [232]: def foo(i,n): 
     ...:     return np.column_stack((np.arange(i,i+n), np.arange(i+1,i+1+n))) 
     ...:                                                                       
In [233]: foo(1,3)                                                              
Out[233]: 
array([[1, 2],
       [2, 3],
       [3, 4]])
In [234]: foo(5,4)                                                              
Out[234]: 
array([[5, 6],
       [6, 7],
       [7, 8],
       [8, 9]])
In [235]: foo(10,3)                                                             
Out[235]: 
array([[10, 11],
       [11, 12],
       [12, 13]])

我可以将所有这些数组放在一个列表中：

In [236]: [Out[233], Out[234], Out[235]]                                        
Out[236]: 
[array([[1, 2],
        [2, 3],
        [3, 4]]), array([[5, 6],
        [6, 7],
        [7, 8],
        [8, 9]]), array([[10, 11],
        [11, 12],
        [12, 13]])]

我可以将该列表转换为对象 dtype 数组：

In [237]: np.array([Out[233], Out[234], Out[235]])                              
Out[237]: 
array([array([[1, 2],
       [2, 3],
       [3, 4]]),
       array([[5, 6],
       [6, 7],
       [7, 8],
       [8, 9]]),
       array([[10, 11],
       [11, 12],
       [12, 13]])], dtype=object)

我还可以显示这些数组的几行：

In [238]: for i in range(3): 
     ...:     print(np.hstack([a[i,:] for a in Out[236]])) 
     ...:                                                                       
[ 1  2  5  6 10 11]
[ 2  3  6  7 11 12]
[ 3  4  7  8 12 13]

但要显示仅存在于中间数组的第 4 行，我必须添加更多代码来测试我们是否结束，以及是否添加填充等。我将不再进行该练习对你来说，如果它真的很重要。 :)

【讨论】：

我的数组似乎与用作示例的数组不同。我的来自：array1 = myfunction(data)，然后离开：[1.74e-06, 0.00122, 0.00123, 0.00124, 0.001245]，这在尝试使用您的方法时似乎是个问题。我的数组应该是列表、括号、括号还是其他东西才能起作用？我的是一个浮点类型的列表。

我的 [103] 示例是一个列表列表。

一个大问题是具有不同长度列的显示不对应任何真正的 Python 数据结构。当我们不确切知道您需要什么或您打算如何使用生成的结构时，我们很难提供帮助。

我添加了一些代码来生成最后一个显示块中的数字。生成数组很容易，但是以您显示的方式打印出来，您的成本将超过您支付给我的费用。 :)

感谢 cmets。我更新了我的帖子，以提供有关我的具体问题的更多信息。

【参考方案2】：

既然你提到列表是可以的，为什么不使用这种“垂直数组”的列表呢？：

my_list = []
while (not_done_yet):
    two_col_array = your_func (some_param) # your_func returns (x,2) array
    my_list.append(two_col_array)

my_list 现在将是形状为(x,2) 的数组的列表，其中x 对于列表中的不同数组可能会有所不同。