Tagliare all'interno di un pattern usando Python regex

Question

Obiettivo: Sto tentando di eseguire un taglio in Python RegEx dove split non fa esattamente ciò che voglio. Ho bisogno di tagliare all'interno di un modello, ma tra i personaggi.

Quello che sto cercando:

Ho bisogno di riconoscere il modello di seguito in una stringa, e dividere la stringa in corrispondenza della posizione del tubo. La pipa non è effettivamente nella stringa, mostra solo dove voglio dividere.

Pattern: CDE|FG

String: ABCDEFGHIJKLMNOCDEFGZYPE

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

Quello che ho cercato:

Mi sembra che usando split con parentesi è vicino, ma doesn' t mantenere il modello di ricerca associato ai risultati come se ne avesse bisogno.

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

dona,

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

Quando ho effettivamente bisogno,

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

Motivazione:

Esercitarsi con RegEx e volevo vedere se potevo usare RegEx per creare uno script che prevedesse i frammenti di una digestione proteica utilizzando proteasi specifiche.

Answer 1

modo non regex sarebbe quella di replace il modello con il valore in filodiffusione e quindi split.

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

Answer 2

È possibile risolverlo con re.split() e positivo "look arounds":

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

---

Si noti che se una delle sequenze di taglio è una stringa vuota, si otterrebbe una stringa vuota all'interno della lista risultante. È possibile gestire che "manualmente", del campione (lo ammetto, non è che abbastanza):

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) 

Stampe:

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

Answer 3

una soluzione non-regex più sicuro potrebbe essere questo:

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

Per mantenere il modello di divisione quando si divide con re.split, o parti di esso, racchiuderli tra parentesi.

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

Abbastanza facile. Tutte le parti ci sono, ma come puoi vedere sono state separate. Quindi abbiamo bisogno di rimontarli. Questa è la parte più difficile. Guarda attentamente e vedrai che devi unire i primi due pezzi, gli ultimi due pezzi e il resto in triple. Semplifico il codice riempendo la lista, ma potresti farlo con la lista originale (e un po 'di codice extra) se le prestazioni sono un problema.

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

re.split() garantisce un pezzo per ogni gruppo di cattura (tra parentesi), più un pezzo di quello che c'è tra. Con espressioni regolari più complesse che richiedono il proprio raggruppamento, utilizzare gruppi non acquisibili per mantenere lo stesso formato dei dati restituiti. (In caso contrario sarà necessario adattare la fase di riassemblaggio.)

PS. Mi piace anche il suggerimento di Bhargav Rao di inserire un carattere separatore nella stringa. Se le prestazioni non sono un problema, immagino sia una questione di gusti.

Edit: Ecco un modo (meno trasparente) di farlo senza l'aggiunta di una stringa vuota alla lista:

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