Пассивный массив в N кусков с помощью Numpy

Ответ 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, если хотите.

Ответ 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:
Если вы даете массив или список в качестве второго аргумента, вы в основном указываете индексы (до), которые нужно "вырезать"

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

Целое число в качестве второго аргумента. указывает количество равных кусков:

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

Ответ 3

Я считаю, что вы ищете numpy.split или, возможно, numpy.array_split, если количество разделов не должно правильно делить размер массива.

Ответ 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]