python - separar - Expresión regular que coincide con un bloque de texto multilínea

python string expresiones regulares

Question

Tengo problemas para conseguir que funcione una expresión regular de Python cuando se combina con texto que abarca varias líneas. El texto de ejemplo es (''/ n'' es una nueva línea)

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

Me gustaría capturar dos cosas: la parte ''some_Varying_TEXT'' y todas las líneas de texto en mayúsculas que aparecen dos líneas debajo de ella en una captura (puedo quitar los caracteres de la línea nueva más adelante). Lo he intentado con algunos enfoques:

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

y muchas variaciones de esto sin suerte. El último parece coincidir con las líneas de texto, una por una, que no es lo que realmente quiero. Puedo ver la primera parte, no hay problema, pero parece que no puedo captar las 4 o 5 líneas de texto en mayúsculas. Me gustaría que match.group (1) sea some_Varying_Text y group (2) para ser line1 + line2 + line3 + etc hasta que se encuentre la línea vacía.

Si alguien tiene curiosidad, se supone que es una secuencia de aminoácidos que forman una proteína.

Answer 1

Esto funcionará:

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

Alguna explicación sobre esta expresión regular podría ser útil: ^(.+?)/n/n((?:[AZ]+/n)+)

• El primer carácter ( ^ ) significa "comenzando al principio de una línea". Tenga en cuenta que no coincide con la nueva línea (lo mismo para $: significa "justo antes de una nueva línea", pero no coincide con la nueva línea).
• Entonces (.+?)/n/n significa "unir la menor cantidad posible de caracteres (todos los caracteres están permitidos) hasta que llegue a dos nuevas líneas". El resultado (sin las nuevas líneas) se coloca en el primer grupo.
• [AZ]+/n significa "unir tantas letras mayúsculas como sea posible hasta llegar a una línea nueva. Esto define lo que llamaré una línea de texto .
• ((?: textline )+) significa unir una o más líneas de texto, pero no poner cada línea en un grupo. En cambio, ponga todas las líneas de texto en un grupo.
• Podría agregar un /n final en la expresión regular si desea aplicar una nueva línea doble al final.
• Además, si no está seguro de qué tipo de nueva línea obtendrá ( /n o /r o /r/n ), simplemente corrija la expresión regular reemplazando cada aparición de /n por (?:/n|/r/n?) .

Answer 2

Mi preferencia.

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 )

En este punto, tiene someVaryingText como una cadena y los ácidos como una lista de cadenas. Puedes hacer "".join( acids ) para hacer una sola cuerda.

Encuentro esto menos frustrante (y más flexible) que las expresiones regulares multilínea.

Answer 3

Prueba esto:

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

Creo que su mayor problema es que espera que los anclajes ^ y $ coincidan con los avances de línea, pero no es así. En el modo multilínea, ^ coincide con la posición inmediatamente posterior a una nueva línea y $ coincide con la posición inmediatamente anterior a una nueva línea.

Tenga en cuenta, también, que una nueva línea puede constar de un salto de línea (/ n), un retorno de carro (/ r), o un retorno de carro + salto de línea (/ r / n). Si no está seguro de que el texto de su objetivo solo use avances de línea, debe usar esta versión más completa de la expresión regular:

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

Por cierto, no quiere usar el modificador DOTALL aquí; confía en el hecho de que el punto coincide con todo excepto las líneas nuevas.

Answer 4

Si cada archivo solo tiene una secuencia de aminoácidos, no usaría ninguna expresión regular. Solo algo como esto:

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 5

encontrar:

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

/ 1 = some_varying_text

/ 2 = líneas de todos los CAPS

Editar (prueba de que esto funciona):

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