Question

我已经像这样拆分了一个numpy数组：

x = np.random.randn(10,3)
x_split = np.split(x,5)

将x分成五个numpy数组，每个数组都有形状（2,3）并将它们放在一个列表中。将这些子集重新组合在一起的最佳方法是什么（例如x_split[:k]和x_split[k+1:]），以便得到的形状与原始x相似，即（某事，3）？

我发现对于k＆gt; 0你可以这样做：

np.vstack((np.vstack(x_split[:k]),np.vstack(x_split[k+1:])))

但是当k = 0为x_split[:0] = []时这不起作用，所以必须有更好更清洁的方法。我在k = 0时得到的错误信息是：

ValueError：需要至少一个数组才能连接

Answer 1

Paul Panzer的评论是正确的，但是现在NumPy gently discourages vstack，这里是concatenate版本：

x = np.random.randn(10, 3)
x_split = np.split(x, 5, axis=0)
k = 0
np.concatenate(x_split[:k] + x_split[k+1:], axis=0)

注意显式轴参数两次传递（它必须相同）;这样可以根据需要轻松调整代码以适用于其他轴。例如，

x_split = np.split(x, 3, axis=1)
k = 0
np.concatenate(x_split[:k] + x_split[k+1:], axis=1)

Answer 2

np.r_可以将多个切片转换为索引列表。

In [20]: np.r_[0:3, 4:5]                                                                                                
Out[20]: array([0, 1, 2, 4])                                                                                                                                                                                                                    
In [21]: np.vstack([xsp[i] for i in _])                                                                                 
Out[21]:                                                                                                                
    array([[9, 7, 5],                                                                                                              
           [6, 4, 3],                                                                                                              
           [9, 8, 0],                                                                                                              
           [1, 2, 2],                                                                                                              
           [3, 3, 0],                                                                                                               
           [8, 1, 4],                                                                                                               
           [2, 2, 5],                                                                                                              
           [4, 4, 5]])                                                                                                                                                                                                                              

In [22]: np.r_[0:0, 1:5]                                                                                                
Out[22]: array([1, 2, 3, 4])                                                                                                                                                                                                                    
In [23]: np.vstack([xsp[i] for i in _])                                                                                 
Out[23]:                                                                                                                
    array([[9, 8, 0],                                                                                                              
           [1, 2, 2],                                                                                                              
           [3, 3, 0],                                                                                                              
           [8, 1, 4],                                                                                                              
           [3, 2, 0],                                                                                                              
           [0, 3, 8],                                                                                                              
           [2, 2, 5],                                                                                                              
           [4, 4, 5]])

内部np.r_有很多ifs和循环来处理切片及其边界，但它隐藏了所有这些。

如果xsp（您的x_split）是一个数组，我们可以xsp[np.r_[...]]，但由于它是一个列表，我们必须迭代。好吧，我们也可以使用operator.itemgetter对象隐藏该迭代。

In [26]: operator.itemgetter(*Out[22])
Out[26]: operator.itemgetter(1, 2, 3, 4)
In [27]: np.vstack(operator.itemgetter(*Out[22])(xsp))

将numpy数组与np.split（）重新组合在一起

2 个答案: