Çok satırlı bir metin bloğuyla eşleşen normal ifade

Birden çok satıra yayılan metinle eşleşirken Python normal ifadesinin çalışmasını sağlamakta biraz sorun yaşıyorum. Örnek metin ('\ n' yeni satırdır)

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

İki şeyi yakalamak istiyorum: 'some_Varying_TEXT' bölümü ve bir yakalamada iki satırın altına gelen büyük harfli metnin tüm satırları (yeni satır karakterlerini daha sonra çıkarabilirim). Birkaç yaklaşımla denedim:

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

ve burada şanssız bir çok varyasyon. Sonuncusu, metin satırlarıyla tek tek eşleşiyor gibi görünüyor, bu gerçekten istediğim şey değil. İlk kısmı yakalayabilirim, sorun değil, ancak 4-5 satırlık büyük harfli metni yakalayamıyorum. Match.group (1) 'in some_Varying_Text olmasını ve group (2)' nin line1 + line2 + line3 + etc olmasını, boş satırla karşılaşılana kadar istiyorum.

Merak eden biri varsa, bunun bir protein oluşturan bir aminoasit dizisi olması gerekir.

Bunu dene:

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

Bence en büyük probleminiz, ^ve $çapaların hat beslemelerine uymasını beklemeniz, ama onlar değil. Çok satırlı modda, bir satırsonu satırının ^hemen ardından$ gelen konumla eşleşir ve satırsonu satırının hemen önündeki konumla eşleşir.

Bir satırsonu satırının satır besleme (\ n), satır başı (\ r) veya satır başı + satır besleme (\ r \ n) içerebileceğini de unutmayın. Hedef metninizin yalnızca satır beslemeleri kullandığından emin değilseniz, normal ifadenin bu daha kapsayıcı sürümünü kullanmalısınız:

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

BTW, burada DOTALL değiştiriciyi kullanmak istemezsiniz; noktanın yeni satırlar dışında her şeyle eşleştiğine güveniyorsunuz .

Bu çalışacak:

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

Bu normal ifade hakkında bazı açıklamalar yararlı olabilir: ^(.+?)\n\n((?:[A-Z]+\n)+)

• İlk karakter ( ^) "satırın başından başlamak" anlamına gelir. Yeni satırın kendisiyle eşleşmediğini unutmayın ($ için aynıdır: "yeni satırdan hemen önce" anlamına gelir, ancak satırsonunun kendisiyle eşleşmez).
• Bu (.+?)\n\n, "iki yeni satıra ulaşana kadar mümkün olduğunca az karakterle eşleştir (tüm karakterlere izin verilir)" anlamına gelir. Sonuç (satırsonu olmadan) ilk gruba konur.
• [A-Z]+\n"Bir satırsonu satırına ulaşana kadar olabildiğince çok büyük harf eşleştir. Bu, metin satırı olarak adlandıracağım şeyi tanımlar .
• ((?:metin çizgisi, bir )+)veya daha fazla metin satırıyla eşleştiği, ancak her satırı bir gruba koymadığı anlamına gelir . Bunun yerine, koymak tüm textlines bir grupta.
• \nSonunda çift yeni satırı zorlamak istiyorsanız, normal ifadeye bir final ekleyebilirsiniz .
• Ayrıca, emin (alacak yeni satır ne tür hakkında değilseniz \nya \rya \r\nsadece her olay değiştirerek normal ifade düzeltmek sonra) \ntarafından (?:\n|\r\n?).

Her dosyada yalnızca bir aminoasit dizisi varsa, düzenli ifadeler kullanmam. Sadece bunun gibi bir şey:

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

bul:

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

\ 1 = bir_değişen_metin

\ 2 = tüm CAPS satırları

Düzenleme (bunun işe yaradığının kanıtı):

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

Aşağıdaki, çok satırlı bir metin bloğu ile eşleşen normal bir ifadedir:

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

Benim tercihim.

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 )

Bu noktada, bir dizi olarak bir Değişken Metin ve dizelerin listesi olarak asitler var. "".join( acids )Tek bir dize yapmak için yapabilirsiniz.

Bunu çok satırlı normal ifadelerden daha az sinir bozucu (ve daha esnek) buluyorum.