Come estrarre la sottostringa tra due marcatori?

Diciamo che ho una stringa 'gfgfdAAA1234ZZZuijjk'e voglio estrarre solo la '1234'parte.

So solo quali saranno i pochi personaggi direttamente prima AAAe dopo ZZZla parte che mi interessa 1234.

Con sedè possibile fare qualcosa del genere con una stringa:

echo "$STRING" | sed -e "s|.*AAA\(.*\)ZZZ.*|\1|"

E questo mi darà di 1234conseguenza.

Come fare la stessa cosa in Python?

Utilizzo di espressioni regolari: documentazione per ulteriori riferimenti

import re

text = 'gfgfdAAA1234ZZZuijjk'

m = re.search('AAA(.+?)ZZZ', text)
if m:
    found = m.group(1)

# found: 1234

o:

import re

text = 'gfgfdAAA1234ZZZuijjk'

try:
    found = re.search('AAA(.+?)ZZZ', text).group(1)
except AttributeError:
    # AAA, ZZZ not found in the original string
    found = '' # apply your error handling

# found: 1234

>>> s = 'gfgfdAAA1234ZZZuijjk'
>>> start = s.find('AAA') + 3
>>> end = s.find('ZZZ', start)
>>> s[start:end]
'1234'

Quindi puoi usare regexps anche con il modulo re, se vuoi, ma non è necessario nel tuo caso.

espressione regolare

import re

re.search(r"(?<=AAA).*?(?=ZZZ)", your_text).group(0)

Il precedente esempio non funzionerà con un AttributeErrorse non ci sono "AAA" e "ZZZ" inyour_text

metodi di stringa

your_text.partition("AAA")[2].partition("ZZZ")[0]

Quanto sopra restituirà una stringa vuota se "AAA" o "ZZZ" non esistono your_text.

PS Python Challenge?

import re
print re.search('AAA(.*?)ZZZ', 'gfgfdAAA1234ZZZuijjk').group(1)

Sorpreso che nessuno abbia menzionato questo, che è la mia versione rapida per gli script una tantum:

>>> x = 'gfgfdAAA1234ZZZuijjk'
>>> x.split('AAA')[1].split('ZZZ')[0]
'1234'

puoi farlo usando solo una riga di codice

>>> import re

>>> re.findall(r'\d{1,5}','gfgfdAAA1234ZZZuijjk')

>>> ['1234']

il risultato riceverà l'elenco ...

È possibile utilizzare re module per questo:

>>> import re
>>> re.compile(".*AAA(.*)ZZZ.*").match("gfgfdAAA1234ZZZuijjk").groups()
('1234,)

Con sed è possibile fare qualcosa del genere con una stringa:

echo "$STRING" | sed -e "s|.*AAA\(.*\)ZZZ.*|\1|"

E questo mi darà 1234 di conseguenza.

Puoi fare lo stesso con la re.subfunzione usando lo stesso regex.

>>> re.sub(r'.*AAA(.*)ZZZ.*', r'\1', 'gfgfdAAA1234ZZZuijjk')
'1234'

Nella sed di base, i gruppi di cattura sono rappresentati da \(..\), ma in pitone era rappresentato da (..).

In Python, l'estrazione della stringa del modulo di sottostringa può essere eseguita usando il findallmetodo nel remodulo espressione regolare ( ).

>>> import re
>>> s = 'gfgfdAAA1234ZZZuijjk'
>>> ss = re.findall('AAA(.+)ZZZ', s)
>>> print ss
['1234']

Puoi trovare la prima sottostringa con questa funzione nel tuo codice (per indice dei caratteri). Inoltre, puoi trovare ciò che è dopo una sottostringa.

def FindSubString(strText, strSubString, Offset=None):
    try:
        Start = strText.find(strSubString)
        if Start == -1:
            return -1 # Not Found
        else:
            if Offset == None:
                Result = strText[Start+len(strSubString):]
            elif Offset == 0:
                return Start
            else:
                AfterSubString = Start+len(strSubString)
                Result = strText[AfterSubString:AfterSubString + int(Offset)]
            return Result
    except:
        return -1

# Example:

Text = "Thanks for contributing an answer to Stack Overflow!"
subText = "to"

print("Start of first substring in a text:")
start = FindSubString(Text, subText, 0)
print(start); print("")

print("Exact substring in a text:")
print(Text[start:start+len(subText)]); print("")

print("What is after substring \"%s\"?" %(subText))
print(FindSubString(Text, subText))

# Your answer:

Text = "gfgfdAAA1234ZZZuijjk"
subText1 = "AAA"
subText2 = "ZZZ"

AfterText1 = FindSubString(Text, subText1, 0) + len(subText1)
BeforText2 = FindSubString(Text, subText2, 0) 

print("\nYour answer:\n%s" %(Text[AfterText1:BeforText2]))

>>> s = '/tmp/10508.constantstring'
>>> s.split('/tmp/')[1].split('constantstring')[0].strip('.')

text = 'I want to find a string between two substrings'
left = 'find a '
right = 'between two'

print(text[text.index(left)+len(left):text.index(right)])

dà

string

Nel caso in cui qualcuno dovrà fare la stessa cosa che ho fatto io. Ho dovuto estrarre tutto tra parentesi in una riga. Ad esempio, se ho una linea come "Il presidente degli Stati Uniti (Barack Obama) ha incontrato ..." e voglio ottenere solo "Barack Obama", questa è la soluzione:

regex = '.*\((.*?)\).*'
matches = re.search(regex, line)
line = matches.group(1) + '\n'

Vale a dire è necessario bloccare la parentesi con il slash \segno. Anche se è un problema di espressioni più regolari di Python.

Inoltre, in alcuni casi potresti vedere i simboli "r" prima della definizione di regex. Se non esiste un prefisso r, è necessario utilizzare caratteri di escape come in C. Ecco altre discussioni su questo.

Utilizzando PyParsing

import pyparsing as pp

word = pp.Word(pp.alphanums)

s = 'gfgfdAAA1234ZZZuijjk'
rule = pp.nestedExpr('AAA', 'ZZZ')
for match in rule.searchString(s):
    print(match)

che produce:

[['1234']]

Ecco una soluzione senza regex che tiene conto anche degli scenari in cui la prima sottostringa contiene la seconda sottostringa. Questa funzione troverà una sottostringa solo se il secondo marker è dopo il primo marker.

def find_substring(string, start, end):
    len_until_end_of_first_match = string.find(start) + len(start)
    after_start = string[len_until_end_of_first_match:]
    return string[string.find(start) + len(start):len_until_end_of_first_match + after_start.find(end)]

Un altro modo per farlo è usare gli elenchi (supponendo che la sottostringa che stai cercando sia fatta solo di numeri):

string = 'gfgfdAAA1234ZZZuijjk'
numbersList = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
output = []

for char in string:
    if char in numbersList: output.append(char)

print(f"output: {''.join(output)}")
### output: 1234

Un liner che restituisce altra stringa se non c'era corrispondenza. Modifica: la versione migliorata utilizza la nextfunzione, sostituirla "not-found"con qualcos'altro se necessario:

import re
res = next( (m.group(1) for m in [re.search("AAA(.*?)ZZZ", "gfgfdAAA1234ZZZuijjk" ),] if m), "not-found" )

Il mio altro metodo per farlo, meno ottimale, usa regex la seconda volta, ma non ho ancora trovato un modo più breve:

import re
res = ( ( re.search("AAA(.*?)ZZZ", "gfgfdAAA1234ZZZuijjk") or re.search("()","") ).group(1) )