Регулярное выражение, совпадающее с многострочным блоком текста

Question

У меня возникли некоторые проблемы с настройкой регулярного выражения Python при сопоставлении с текстом, который занимает несколько строк. Текст примера ('\ n' является новой строкой)

some Varying TEXT\n
\n
DSJFKDAFJKDAFJDSAKFJADSFLKDLAFKDSAF\n
[more of the above, ending with a newline]\n
[yep, there is a variable number of lines here]\n
\n
(repeat the above a few hundred times).

Я хотел бы захватить две вещи: часть 'some_Varying_TEXT' и все строки заглавного текста, которые идут на две строки ниже его в одном захвате (я могу удалить символы новой строки позже). Я пробовал с несколькими подходами:

re.compile(r"^>(\w+)$$([.$]+)^$", re.MULTILINE) # try to capture both parts
re.compile(r"(^[^>][\w\s]+)$", re.MULTILINE|re.DOTALL) # just textlines

и множество вариантов без удачи. Последний, кажется, соответствует строкам текста одна за другой, что я не хочу. Я могу поймать первую часть, без проблем, но я не могу уловить 4-5 строк заглавного текста. Мне бы хотелось, чтобы match.group (1) была some_Varying_Text, а group (2) - line1 + line2 + line3 + и т. Д., Пока не встретится пустая строка.

Если кому-то интересно, предполагается, что это последовательность аминокислот, из которых состоит белок.

Answer 1

Попробуйте это:

re.compile(r"^(.+)\n((?:\n.+)+)", re.MULTILINE)

Я думаю, что вашей самой большой проблемой является то, что вы ожидаете, что якоря ^ и $ будут соответствовать переводу строки, но они этого не делают. В многострочном режиме ^ соответствует позиции немедленно после новой строки, а $ соответствует позиции немедленно предшествующей новой строке.

Также следует помнить, что перевод строки может состоять из перевода строки (\ n), возврата каретки (\ r) или возврата каретки + перевода строки (\ r \ n). Если вы не уверены, что ваш целевой текст использует только перевод строки, вам следует использовать более инклюзивную версию регулярного выражения:

re.compile(r"^(.+)(?:\n|\r\n?)((?:(?:\n|\r\n?).+)+)", re.MULTILINE)

Кстати, вы не хотите использовать модификатор DOTALL здесь; вы полагаетесь на тот факт, что точка соответствует всему кроме новых строк.

Answer 2

Это будет работать:

>>> import re
>>> rx_sequence=re.compile(r"^(.+?)\n\n((?:[A-Z]+\n)+)",re.MULTILINE)
>>> rx_blanks=re.compile(r"\W+") # to remove blanks and newlines
>>> text="""Some varying text1
...
... AAABBBBBBCCCCCCDDDDDDD
... EEEEEEEFFFFFFFFGGGGGGG
... HHHHHHIIIIIJJJJJJJKKKK
...
... Some varying text 2
...
... LLLLLMMMMMMNNNNNNNOOOO
... PPPPPPPQQQQQQRRRRRRSSS
... TTTTTUUUUUVVVVVVWWWWWW
... """
>>> for match in rx_sequence.finditer(text):
...   title, sequence = match.groups()
...   title = title.strip()
...   sequence = rx_blanks.sub("",sequence)
...   print "Title:",title
...   print "Sequence:",sequence
...   print
...
Title: Some varying text1
Sequence: AAABBBBBBCCCCCCDDDDDDDEEEEEEEFFFFFFFFGGGGGGGHHHHHHIIIIIJJJJJJJKKKK

Title: Some varying text 2
Sequence: LLLLLMMMMMMNNNNNNNOOOOPPPPPPPQQQQQQRRRRRRSSSTTTTTUUUUUVVVVVVWWWWWW

---

Некоторое объяснение этого регулярного выражения может быть полезным: ^(.+?)\n\n((?:[A-Z]+\n)+)

• Первый символ (^) означает «начиная с начала строки». Имейте в виду, что он не совпадает с самой новой строкой (то же самое для $: это означает «непосредственно перед новой строкой», но он не соответствует самой новой строке).
• Тогда (.+?)\n\n означает «сопоставить как можно меньше символов (все символы разрешены), пока вы не достигнете двух символов новой строки». Результат (без перевода строки) помещается в первую группу.
• [A-Z]+\n означает «сопоставлять как можно больше букв верхнего регистра, пока вы не достигнете новой строки. Это определяет то, что я буду называть текстовой строкой .
• ((?: textline )+) означает совпадение с одной или несколькими textlines , но не помещает каждую строку в группу. Вместо этого поместите все текстовые строки в одну группу.
• Вы могли бы добавить окончательный \n в регулярное выражение, если вы хотите применить двойной перевод строки в конце.
• Кроме того, если вы не уверены, какой тип новой строки вы получите (\n или \r или \r\n), просто исправьте регулярное выражение, заменив каждое вхождение \n на (?:\n|\r\n?).

Answer 3

Если бы в каждом файле была только одна последовательность аминокислот, я бы вообще не использовал регулярные выражения. Просто как то так:

def read_amino_acid_sequence(path):
    with open(path) as sequence_file:
        title = sequence_file.readline() # read 1st line
        aminoacid_sequence = sequence_file.read() # read the rest

    # some cleanup, if necessary
    title = title.strip() # remove trailing white spaces and newline
    aminoacid_sequence = aminoacid_sequence.replace(" ","").replace("\n","")
    return title, aminoacid_sequence

Answer 4

найти:

^>([^\n\r]+)[\n\r]([A-Z\n\r]+)

\ 1 = some_varying_text

\ 2 = строки всех CAPS

Редактировать (доказательство того, что это работает):

text = """> some_Varying_TEXT

DSJFKDAFJKDAFJDSAKFJADSFLKDLAFKDSAF
GATACAACATAGGATACA
GGGGGAAAAAAAATTTTTTTTT
CCCCAAAA

> some_Varying_TEXT2

DJASDFHKJFHKSDHF
HHASGDFTERYTERE
GAGAGAGAGAG
PPPPPAAAAAAAAAAAAAAAP
"""

import re

regex = re.compile(r'^>([^\n\r]+)[\n\r]([A-Z\n\r]+)', re.MULTILINE)
matches = [m.groups() for m in regex.finditer(text)]

for m in matches:
    print 'Name: %s\nSequence:%s' % (m[0], m[1])

Answer 5

Следующее является регулярным выражением, совпадающим с многострочным блоком текста:

import re
result = re.findall('(startText)(.+)((?:\n.+)+)(endText)',input)

Answer 6

Мои предпочтения.

lineIter= iter(aFile)
for line in lineIter:
    if line.startswith( ">" ):
         someVaryingText= line
         break
assert len( lineIter.next().strip() ) == 0
acids= []
for line in lineIter:
    if len(line.strip()) == 0:
        break
    acids.append( line )

На данный момент у вас есть someVaryingText в виде строки, а acid - в виде списка строк. Вы можете сделать "".join( acids ), чтобы сделать одну строку.

Я нахожу это менее расстраивающим (и более гибким), чем многострочные регулярные выражения.