Python - массив срезов, пока не будет выполнено определенное условие

Question

Мне нужно нарезать массив из заданного индекса, пока не будет выполнено определенное условие.

>>> a = numpy.zeros((10), dtype='|S1')
>>> a[2] = 'A'
>>> a[4] = 'X'
>>> a[8] = 'B'
>>> a
array(['', '', 'A', '', 'X', '', '', '', 'B', ''], dtype='|S1')

Например, для вышеуказанного массива я хочу подмножество от заданного индекса до первых ненулевых значений в обоих направлениях. Например, для значений индекса 2, 4, 8 результат будет:

['', '', A, '']      # 2
['', X, '', '', '']  # 4
['', '', '', B, '']  # 8

Есть предложения по простейшему способу сделать это с помощью numpy API? Изучая Python и NumPy, был бы признателен за любую помощь. Спасибо!

Answer 1

Если вы задали свою проблему следующим образом:

import numpy
a = numpy.zeros((10), dtype=str)
a[2] = 'A'
a[4] = 'X'
a[8] = 'B'

Вы можете легко получить индексы непустых строк, например:

i = numpy.where(a!='')[0]  # array([2, 4, 8])

В качестве альтернативы, numpy.argwhere(..) также хорошо работает.

Затем вы можете использовать этот массив:

out2 = a[:i[1]]        # 2   ['' '' 'A' '']
out4 = a[i[0]+1:i[2]]  # 4   ['' 'X' '' '' '']

и т.д.

Answer 2

это работа для замаскированных массивов, numpy.ma имеет множество функций для работы с подмножествами.

a = np.zeros((10), dtype=str)
a[2] = 'A'
a[4] = 'X'
a[8] = 'B'

давайте замаскируем непустые элементы:

am=np.ma.masked_where(a!='', a)

np.ma.notmasked_contiguous проходит через массив (очень эффективно) и находит все фрагменты смежных элементов, где массив не маскируется:

slices = np.ma.notmasked_contiguous(am)
[slice(0, 1, None), slice(3, 3, None), slice(5, 7, None), slice(9, 9, None)]

Итак, массив постоянно пуст, например, между элементами 5 и 7. Теперь вам нужно только объединить интересующие вас срезы, сначала вы получите начальный индекс каждого среза:

slices_start = np.array([s.start for s in slices])

тогда вы получите местоположение искомого индекса:

slices_start.searchsorted(4) #4
Out: 2

Итак, вы хотите срез 1 и 2: а [ломтиков [1] .start: ломтики [2] .stop + 1] массив (['', 'X', '', '', ''], DTYPE = '| S1')

или давайте попробуем 8:

i = slices_start.searchsorted(8)
a[slices[i-1].start:slices[i].stop+1]
Out: array(['', '', '', 'B', ''], 
  dtype='|S1')

Если, возможно, стоит немного поиграть с этим в ipython для лучшего понимания.

Answer 3

Обратите внимание, что это можно сделать чисто на чистом Python, используя itertools и functools.

import functools, itertools
arr = ['', '', 'A', '', 'X', '', '', '', 'B', '']

f = functools.partial(itertools.takewhile, lambda x: not x)
def g(a, i):
    return itertools.chain(f(reversed(a[:i])), [a[i]], f(a[i+1:]))

Мы определяем f как найденный подитератор, просматривая, пока элемент не оценивается как true, и g как комбинацию применения этого в обращенной области списка перед индексом и списка после индекса.

Возвращает генераторы, которые можно преобразовать в списки, содержащие наши результаты.

>>> list(g(arr, 2))
['', '', 'A', '']
>>> list(g(arr, 4))
['', 'X', '', '', '']
>>> list(g(arr, 8))
['', '', '', 'B', '']

Answer 4

def getSlice(a, n):
    try:
        startindex = a[:n].nonzero()[0][-1]
    except IndexError:
        startindex = 0
    try:
        endindex = a[(n+1):].nonzero()[0][0] + n+1
    except IndexError:
        endindex = len(a)
    return a[startindex: endindex]

Answer 5

Первое, что приходит на ум - две петли.Примерно так будет работать:

'''Given an array and an index...'''
def getNoneSlice(a, i):

    # get the first non-None index before i
    start = 0
    for j in xrange(i - 1, -1, -1):
        if a[j] is not None: # or whatever condition
            start = j + 1
            break

    # get the first non-None index after i
    end = len(a) - 1
    for j in xrange(i + 1, len(a)):
        if a[j] is not None: # or whatever condition
            end = j - 1
            break

    # return the slice
    return a[start:end + 1]