使用Numpy将Paritition阵列分成N个块

Question

有这个如何将列表拆分成大小均匀的块？ 用于将数组拆分为块.无论如何使用Numpy为巨型阵列更有效地做到这一点？

Answer 1

试试numpy.array_split.

从文档:

>>> x = np.arange(8.0)
>>> np.array_split(x, 3)
    [array([ 0.,  1.,  2.]), array([ 3.,  4.,  5.]), array([ 6.,  7.])]

numpy.split如果组的长度不相等,则相同但不会引发异常.

如果块数> len(数组)你得到嵌套的空白数组,为了解决这个问题 - 如果保存了拆分数组a,那么你可以通过以下方式删除空数组:

[x for x in a if x.size > 0]

a如果你愿意,只需将其保存回来.

Answer 2

对使用只是一些例子array_split,split,hsplit和vsplit:

n [9]: a = np.random.randint(0,10,[4,4])

In [10]: a
Out[10]: 
array([[2, 2, 7, 1],
       [5, 0, 3, 1],
       [2, 9, 8, 8],
       [5, 7, 7, 6]])

关于使用的一些例子array_split:
如果你给一个数组或列表作为第二个参数,你基本上给出'cut'的索引(之前)

# split rows into 0|1 2|3
In [4]: np.array_split(a, [1,3])
Out[4]:                                                                                                                       
[array([[2, 2, 7, 1]]),                                                                                                       
 array([[5, 0, 3, 1],                                                                                                         
       [2, 9, 8, 8]]),                                                                                                        
 array([[5, 7, 7, 6]])]

# split columns into 0| 1 2 3
In [5]: np.array_split(a, [1], axis=1)                                                                                           
Out[5]:                                                                                                                       
[array([[2],                                                                                                                  
       [5],                                                                                                                   
       [2],                                                                                                                   
       [5]]),                                                                                                                 
 array([[2, 7, 1],                                                                                                            
       [0, 3, 1],
       [9, 8, 8],
       [7, 7, 6]])]

一个整数作为第二个arg.指定相等块的数量:

In [6]: np.array_split(a, 2, axis=1)
Out[6]: 
[array([[2, 2],
       [5, 0],
       [2, 9],
       [5, 7]]),
 array([[7, 1],
       [3, 1],
       [8, 8],
       [7, 6]])]

split 如果不能进行相等的拆分,则会产生相同的效果,但会引发异常

除了array_split你可以使用快捷方式vsplit和hsplit.
vsplit并且hsplit几乎是自我解释:

In [11]: np.vsplit(a, 2)
Out[11]: 
[array([[2, 2, 7, 1],
       [5, 0, 3, 1]]),
 array([[2, 9, 8, 8],
       [5, 7, 7, 6]])]

In [12]: np.hsplit(a, 2)
Out[12]: 
[array([[2, 2],
       [5, 0],
       [2, 9],
       [5, 7]]),
 array([[7, 1],
       [3, 1],
       [8, 8],
       [7, 6]])]

Answer 3

我相信你正在寻找numpy.split或者可能numpy.array_split的部分数量不需要正确地划分数组的大小.

Answer 4

不是一个答案,而是一个很长的评论,很好的格式化代码到其他(正确的)答案.如果您尝试以下操作,您将看到所获得的是原始数组的视图,而不是副本,而您链接的问题中的接受答案的情况并非如此.注意可能的副作用!

>>> x = np.arange(9.0)
>>> a,b,c = np.split(x, 3)
>>> a
array([ 0.,  1.,  2.])
>>> a[1] = 8
>>> a
array([ 0.,  8.,  2.])
>>> x
array([ 0.,  8.,  2.,  3.,  4.,  5.,  6.,  7.,  8.])
>>> def chunks(l, n):
...     """ Yield successive n-sized chunks from l.
...     """
...     for i in xrange(0, len(l), n):
...         yield l[i:i+n]
... 
>>> l = range(9)
>>> a,b,c = chunks(l, 3)
>>> a
[0, 1, 2]
>>> a[1] = 8
>>> a
[0, 8, 2]
>>> l
[0, 1, 2, 3, 4, 5, 6, 7, 8]