Wycinanie we wzorze za pomocą Python regex

Question

Cel: Próbuję wykonać cięcie w języku Python RegEx, w którym podział nie wykonuje dokładnie tego, co chcę. Muszę przeciąć wzór, ale między postaciami.

Co szukam:

muszę rozpoznać wzór poniżej w łańcuchu, i podzielić ciąg w miejscu rury. Rura nie znajduje się w łańcuchu, pokazuje tylko to, co chcę podzielić.

Wzór: CDE|FG

String: ABCDEFGHIJKLMNOCDEFGZYPE

Wyniki: ['ABCDE', 'FGHIJKLMNOCDE', 'FGZYPE']

Co próbowałem:

I wydaje się, że za pomocą split z nawiasu jest blisko, ale nie robi” t zachowaj wzór wyszukiwania dołączony do wyników, tak jak tego potrzebuję.

re.split('CDE()FG', 'ABCDEFGHIJKLMNOCDEFGZYPE')

Daje,

['AB', 'HIJKLMNO', 'ZYPE']

Kiedy rzeczywiście trzeba,

['ABCDE', 'FGHIJKLMNOCDE', 'FGZYPE']

Motywacja:

Ćwicząc z RegEx, i chciałem zobaczyć, czy mógłbym użyć RegEx do stworzenia skryptu, który przewidywałby fragmenty trawienia białka przy użyciu konkretnych proteaz.

Answer 1

Non regex sposobem byłoby replace wzór z wartością rurami a następnie split.

>>> pattern = 'CDE|FG' 
>>> s = 'ABCDEFGHIJKLMNOCDEFGZYPE' 
>>> s.replace('CDEFG',pattern).split('|') 
['ABCDE', 'FGHIJKLMNOCDE', 'FGZYPE'] 

Answer 2

Można go rozwiązać z re.split() i pozytywnej "look arounds":

>>> re.split(r"(?<=CDE)(\w+)(?=FG)", s) 
['ABCDE', 'FGHIJKLMNOCDE', 'FGZYPE'] 

---

pamiętać, że jeśli jedna z sekwencji ciętych jest pusty ciąg znaków, co można uzyskać ciąg pusty wewnątrz otrzymanej listy. Można sobie z tym poradzić „ręcznie”, próbkę (muszę przyznać, że nie jest tak całkiem):

import re 

s = "ABCDEFGHIJKLMNOCDEFGZYPE" 

cut_sequences = [ 
    ["CDE", "FG"], 
    ["FGHI", ""], 
    ["", "FGHI"] 
] 

for left, right in cut_sequences: 
    items = re.split(r"(?<={left})(\w+)(?={right})".format(left=left, right=right), s) 

    if not left: 
     items = items[1:] 

    if not right: 
     items = items[:-1] 

    print(items) 

Wydruki:

['ABCDE', 'FGHIJKLMNOCDE', 'FGZYPE'] 
['ABCDEFGHI', 'JKLMNOCDEFGZYPE'] 
['ABCDE', 'FGHIJKLMNOCDEFGZYPE'] 

Answer 3

Bezpieczniejsze rozwiązanie non-regex może być to:

import re 

def split(string, pattern): 
    """Split the given string in the place indicated by a pipe (|) in the pattern""" 
    safe_splitter = "#@#@SPLIT_HERE@#@#" 
    safe_pattern = pattern.replace("|", safe_splitter) 
    string = string.replace(pattern.replace("|", ""), safe_pattern) 
    return string.split(safe_splitter) 

s = "ABCDEFGHIJKLMNOCDEFGZYPE" 
print(split(s, "CDE|FG")) 
print(split(s, "|FG")) 
print(split(s, "FGH|")) 

https://repl.it/C448

Answer 4

Aby zachować wzór łupania kiedy rozstał się z re.split, lub jego części, należy ująć je w nawiasach.

>>> data 
'ABCDEFGHIJKLMNOCDEFGZYPE' 
>>> pieces = re.split(r"(CDE)(FG)", data) 
>>> pieces 
['AB', 'CDE', 'FG', 'HIJKLMNO', 'CDE', 'FG', 'ZYPE'] 

Wystarczająco łatwe. Wszystkie części są tam, ale jak widać, zostały rozdzielone. Więc musimy je ponownie złożyć. To trudniejsza część. Przyjrzyj się uważnie, a zobaczysz, że musisz dołączyć do dwóch pierwszych części, dwóch ostatnich części, a reszta do trzech. Upraszczam kod, wypełniając listę, ale można to zrobić z oryginalną listą (i odrobiną dodatkowego kodu), jeśli wydajność jest problemem.

>>> pieces = [""] + pieces 
>>> [ "".join(pieces[i:i+3]) for i in range(0,len(pieces), 3) ] 
['ABCDE', 'FGHIJKLMNOCDE', 'FGZYPE'] 

re.split() gwarantuje kawałek dla każdego ujęcia (w nawiasach) grupy, plus kawałek za to, co jest między nimi. W przypadku bardziej złożonych wyrażeń regularnych, które wymagają własnej grupy, należy używać grup niezapisujących, aby zachować format zwracanych danych. (W przeciwnym razie musisz dostosować krok ponownego składania).

PS. Podoba mi się również sugestia Bhargava Rao, aby wstawić znak separatora w ciągu znaków. Jeśli wydajność nie jest problemem, myślę, że to kwestia gustu.

Edit: Oto (mniej przezroczysty) sposób to zrobić bez dodawania pusty ciąg do listy:

pieces = re.split(r"(CDE)(FG)", data) 
result = [ "".join(pieces[max(i-3,0):i]) for i in range(2,len(pieces)+2, 3) ]