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

Question

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

pythonarrayspython-3.xnumpyconcatenation

4

我有一个返回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个元素。我想把它们垂直排列，使其导出后的效果如下：

我不希望使用零或NaN来填充数据中的空缺，因为这样会增加更多的工作量。

为了使输出的数据像这样组织起来，必须使用列宽为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或使用数据框来完成，如果那行得通，我可以在导出之前更正那些空格。我希望它看起来像这样：

- Killian Tallman

Numpy不处理ragged arrays，所以列表中的列表可能是更合适的方法。 - Warren Weckesser

2个回答

0

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

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对于列表中的不同数组可能是不同的。

- fountainhead

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- hpaulj · Accepted Answer

首先，针对数组的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]])

但是不规则数组不起作用。

大小不同的列表/数组的数组具有对象数据类型，并且在许多情况下类似于列表的列表：

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)]

使用这个填充，我们可以创建一个二维数组（对象数据类型，因为有 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]])]

我可以将该列表转换为对象数据类型数组：

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]

但是要显示第四行，这只存在于中间数组中，我必须添加更多的代码来测试我们是否超出了边界，以及是否添加填充等。如果真的很重要，我会把这个练习留给你。 :)