Учитывая список фрагментов, как мне разделить их на них?

Учитывая список срезов, как я могу отделить последовательность, основанную на них?

У меня есть длинные аминокислотные строки, которые я хотел бы разбить на основе значений start-stop в списке. Пример, вероятно, самый ясный способ объяснить это:

str = "MSEPAGDVRQNPCGSKAC"
split_points = [[1,3], [7,10], [12,13]]

output >> ['M', '(SEP)', 'AGD', '(VRQN)', 'P', '(CG)', 'SKAC']

Дополнительные круглые скобки - показать, какие элементы были выбраны из списка split_points. Я не ожидаю, что точки начала-остановки будут перекрываться.

У меня есть куча идей, которые будут работать, но кажутся ужасно неэффективными (длина кода мудрая), и кажется, что должен быть хороший питонический способ сделать это.

Ответ 1

Странный способ разделить строки, которые у вас есть:

def splitter( s, points ):
    c = 0
    for x,y in points:
        yield s[c:x]
        yield "(%s)" % s[x:y+1]
        c=y+1
    yield s[c:]

print list(splitter(str, split_points))
# => ['M', '(SEP)', 'AGD', '(VRQN)', 'P', '(CG)', 'SKAC']

# if some start and endpoints are the same remove empty strings.
print list(x for x in splitter(str, split_points) if x != '')

Ответ 2

Вот вам простое решение. для захвата каждого из множеств, заданных точкой.

In[4]:  str[p[0]:p[1]+1] for p in split_points]
Out[4]: ['SEP', 'VRQN', 'CG']

Чтобы получить скобки:

In[5]:  ['(' + str[p[0]:p[1]+1] + ')' for p in split_points]
Out[5]: ['(SEP)', '(VRQN)', '(CG)']

Вот более чистый способ сделать это, чтобы выполнить всю сделку:

results = []

for i in range(len(split_points)):
    start, stop = split_points[i]
    stop += 1

    last_stop = split_points[i-1][1] + 1 if i > 0 else 0

    results.append(string[last_stop:start])        
    results.append('(' + string[start:stop] + ')')

results.append(string[split_points[-1][1]+1:])

Все приведенные ниже решения являются плохими и более интересными, чем что-либо еще, не используют их!

Это скорее решение WTF, но я решил, что опубликую его, поскольку он был запрошен в комментариях:

split_points = [(x, y+1) for x, y in split_points]
split_points = [((split_points[i-1][1] if i > 0 else 0, p[0]), p) for i, p in zip(range(len(split_points)), split_points)]
results = [string[n[0]:n[1]] + '\n(' + string[m[0]:m[1]] + ')' for n, m in split_points] + [string[split_points[-1][1][1]:]]
results = '\n'.join(results).split()

все еще пытается разобраться в одном лайнере, вот два:

split_points = [((split_points[i-1][1]+1 if i > 0 else 0, p[0]), (p[0], p[1]+1)) for i, p in zip(range(len(split_points)), split_points)]
print '\n'.join([string[n[0]:n[1]] + '\n(' + string[m[0]:m[1]] + ')' for n, m in split_points] + [string[split_points[-1][1][1]:]]).split()

И один вкладыш, который никогда не должен использоваться:

print '\n'.join([string[n[0]:n[1]] + '\n(' + string[m[0]:m[1]] + ')' for n, m in (((split_points[i-1][1]+1 if i > 0 else 0, p[0]), (p[0], p[1]+1)) for i, p in zip(range(len(split_points)), split_points))] + [string[split_points[-1][1]:]]).split()

Ответ 3

Вот какой код будет работать.

result = []
last_end = 0
for sp in split_points:
  result.append(str[last_end:sp[0]])
  result.append('(' + str[sp[0]:sp[1]+1] + ')')
  last_end = sp[1]+1
result.append(str[last_end:])

print result

Если вам просто нужны части в скобках, это станет немного проще:

result = [str[sp[0]:sp[1]+1] for sp in split_points]

Ответ 4

Наверное, не для элегантности, а только потому, что я могу сделать это в oneliner:)

>>> reduce(lambda a,ij:a[:-1]+[str[a[-1]:ij[0]],'('+str[ij[0]:ij[1]+1]+')',
            ij[1]], split_points, [0])[:-1] + [str[split_points[-1][-1]+1:]]

['M', '(SEP)', 'PAGD', '(VRQN)', 'NP', '(CG)', 'SKAC']

Может вам это нравится. Вот несколько объяснений:

В вашем вопросе вы передаете один набор срезов, и неявно вы хотите также иметь набор дополнений к фрагментам (для генерации срезанных в скобках [это английские?] срезы). Таким образом, в основном, каждый срез [i, j] не имеет предыдущего j. например [7,10] не хватает 3 и [1,3] не хватает 0.

reduce обрабатывает списки и на каждом шаге передает вывод (a) плюс следующий элемент ввода (ij). Хитрость заключается в том, что помимо создания простого выхода мы добавляем каждый раз дополнительную переменную --- вид памяти --- который находится на следующем шаге, полученном в a[-1]. В этом конкретном примере мы сохраняем последнее значение j, и, следовательно, во все времена у нас есть полная информация, чтобы предоставить как неровную, так и подстроку в скобках.

Наконец, память разделяется на [: -1] и заменяется на оставшуюся часть исходной строки в [str[split_points[-1][-1]+1:]].

Ответ 5

Здесь решение, которое преобразует ваши split_points в обычные срезы строк, а затем выводит соответствующие фрагменты:

str = "MSEPAGDVRQNPCGSKAC"
split_points = [[1, 3], [7, 10], [12, 13]]

adjust = [s for sp in [[x, y + 1] for x, y in split_points] for s in sp]
zipped = zip([None] + adjust, adjust + [None])

out = [('(%s)' if i % 2 else '%s') % str[x:y] for i, (x, y) in
       enumerate(zipped)]

print out

>>> ['M', '(SEP)', 'AGD', '(VRQN)', 'P', '(CG)', 'SKAC']

Ответ 6

>>> str = "MSEPAGDVRQNPCGSKAC"
>>> split_points = [[1,3], [7,10], [12,13]]
>>>
>>> all_points = sum(split_points, [0]) + [len(str)-1]
>>> map(lambda i,j: str[i:j+1], all_points[:-1], all_points[1:])
['MS', 'SEP', 'PAGDV', 'VRQN', 'NPC', 'CG', 'GSKAC']
>>>
>>> str_out = map(lambda i,j: str[i:j+1], all_points[:-1:2], all_points[1::2])
>>> str_in = map(lambda i,j: str[i:j+1], all_points[1:-1:2], all_points[2::2])
>>> sum(map(list, zip(['(%s)' % s for s in str_in], str_out[1:])), [str_out[0]])
['MS', '(SEP)', 'PAGDV', '(VRQN)', 'NPC', '(CG)', 'GSKAC']