Reguläre Ausdrücke einen mehrzeiligen Textblock

Ich bin habend ein wenig Mühe, ein Python-regex zu arbeiten, wenn ein Abgleich mit text, der mehrere Zeilen umfasst. Beispiel text ('\n' ist ein Zeilenvorschub (newline))

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

Ich würde gerne erfassen zwei Dinge: die 'some_Varying_TEXT" Teil, und alle Zeilen von text in Großbuchstaben, zwei Zeilen darunter in one-capture (ich kann den Streifen aus dem newline-Zeichen später).
Ich habe versucht, mit ein paar Ansätze:

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

und viele Variationen hiervon mit kein Glück. Das Letzte scheint zu passen die Textzeilen nacheinander, das ist nicht das, was ich wirklich möchte. Ich kann fangen der erste Teil, ist das kein problem, aber ich kann nicht scheinen zu fangen die 4-5 Zeilen text in Großbuchstaben.
Ich würde gerne match.Gruppe(1) werden some_Varying_Text und Gruppe(2) zeile1+Zeile2+zeile3+etc, bis die leere Zeile gefunden wird.

Wenn jemand neugierig ist, sein soll eine Sequenz von Aminosäuren, eines proteins.

Gibt es etwas anderes in der Datei neben der ersten Zeile und den text in Großbuchstaben? Ich bin mir nicht sicher, warum Sie würde einen regex verwenden, anstatt die Spaltung der gesamte text bei Zeilenende-Zeichen und wobei das erste element als "some_Varying_TEXT".
ja, regex sind das falsche Werkzeug für diese.
Ihr Beispiel-text nicht mit einem der führenden > Charakter. Sollte es?

InformationsquelleAutor Jan | 2009-02-25

98

Versuchen Sie dies:
```
re.compile(r"^(.+)\n((?:\n.+)+)", re.MULTILINE)
```
Ich denke, dein größte problem ist, dass Sie erwarten, dass die ^ und $ Anker passend Zeilenwechsel, aber Sie nicht. Im multiline-Modus, ^ entspricht der position sofort folgenden ein newline und $ entspricht der position sofort vorhergehenden ein Zeilenumbruch.

Beachten Sie auch, dass ein Zeilenumbruch aus einem Zeilenvorschub (\n), carriage-return (\r), oder ein carriage-return+linefeed (\r\n). Wenn Sie nicht sicher sind, ob der Zieltext verwendet nur Zeilenvorschübe sind, sollten Sie diese mehr-inclusive-version der regex:
```
re.compile(r"^(.+)(?:\n|\r\n?)((?:(?:\n|\r\n?).+)+)", re.MULTILINE)
```
BTW, wollen Sie nicht verwenden die DOTALL modifier hier; Sie sind unter Berufung auf die Tatsache, dass der Punkt passt alles außer Zeilenumbrüche.

Möchten Sie vielleicht ersetzen Sie den zweiten Punkt in den regex [A-Z] wenn Sie nicht möchten, dass dieser reguläre Ausdruck, das gerade über jeden text-Datei mit einer leeren zweiten Zeile. 😉
Mein Eindruck ist, dass die target-Dateien entsprechen, um eine bestimmte (und sich wiederholende) Muster für leeren und nicht-leeren Zeilen, so sollte es nicht notwendig sein, geben Sie [A-Z], aber es wird wahrscheinlich nicht Schaden, entweder.
Diese Lösung hat wunderbar funktioniert. Als ein beiseite, ich entschuldige mich, da ich offensichtlich keine Klärung der situation genug (und auch für die Verspätung dieser Antwort). Vielen Dank für Ihre Hilfe!

InformationsquelleAutor Alan Moore
20

Dies funktionieren wird:
```
>>> 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
```
Einige Erklärungen zu diesem regulären Ausdruck die nützlich sein könnten: ^(.+?)\n\n((?:[A-Z]+\n)+)
- Das erste Zeichen (^) bedeutet ", beginnend am Anfang einer Zeile". Werden Sie sich bewusst, dass es nicht mit der newline selbst (das gleiche für $: es heißt "kurz vor einem newline", aber es entspricht nicht der Zeilenumbruch selbst).
- Dann (.+?)\n\n bedeutet "match so wenig Zeichen wie möglich (alle Zeichen sind erlaubt), bis Sie zwei Zeilenumbrüche". Das Ergebnis (ohne Zeilenumbrüche) in der ersten Gruppe.
- [A-Z]+\n bedeutet "Spiel so viele Großbuchstaben wie möglich, bis Sie ein newline. Dieser definiert, was ich nenne eine textline.
- ((?:textline)+) bedeutet entsprechend eine oder mehrere die einzelnen Zeilen aber setzen Sie nicht jede Zeile in eine Gruppe. Stattdessen setzen alle die die einzelnen Zeilen in einer Gruppe.
- Man könnte hinzufügen, eine endgültige \n im regulären Ausdruck, wenn Sie erzwingen möchten, mit einem doppelten Zeilenumbruch am Ende.
- Auch, wenn Sie nicht sicher sind, welche Art von newline, die Sie erhalten (\n oder \r oder \r\n) dann einfach fix den regulären Ausdruck durch ersetzen jedes vorkommen von \n durch (?:\n|\r\n?).
match() gibt nur ein Spiel, ganz am Anfang des Textes, aber der OP sagte, es sein würde, Hunderte von matches pro Datei. Ich denke, Sie würde wollen, finditer() statt.
Gerade behoben, danke.

InformationsquelleAutor MiniQuark

Wenn jede Datei hat nur eine Sequenz von Aminosäuren, ich würde nicht mit regulären Ausdrücken überhaupt. Nur so etwas wie dieses:

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

Definitiv der einfachste Weg, wenn es nur eine, und es ist auch praktikabel, mit mehr, wenn etwas mehr Logik Hinzugefügt wird. Es gibt ungefähr 885 Proteine in diesem speziellen Datensatz, obwohl, und ich fühlte, dass ein regex sollte in der Lage sein, dies zu behandeln.

InformationsquelleAutor MiniQuark

finden:

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

\1 = some_varying_text

\2 = Linien aller CAPS

Bearbeiten (Nachweis, dass dies funktioniert):

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

Sieht mir falsch zu sein. Hast du dies testen?
Tut es, ich habe einige code für Sie.
Leider ist dieser reguläre Ausdruck wird ebenfalls mit Gruppen von Großbuchstaben, getrennt durch Leerzeilen. Es könnte nicht eine große Sache, obwohl.
Sieht aus wie coonj mag FASTA-Dateien. 😉

InformationsquelleAutor Jason Coon

2

Den folgenden regulären Ausdruck übereinstimmenden einem mehrzeiligen Textblock:
```
import re
result = re.findall('(startText)(.+)((?:\n.+)+)(endText)',input)
```
InformationsquelleAutor Punnerud

Meine Vorliebe.

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 )

In diesem Punkt haben Sie someVaryingText als string, und die Säuren, die als eine Liste von strings.
Sie tun kann "".join( acids ) zu einer einzelnen Zeichenfolge.

Ich finde das weniger frustrierend (und flexibler) als multiline-regexes.

InformationsquelleAutor S.Lott

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.