Jak wyodrębnić podciąg między dwoma markerami?

Powiedzmy, że mam ciąg znaków 'gfgfdAAA1234ZZZuijjk'i chcę wyodrębnić tylko '1234'część.

Wiem tylko, jakie będą te postacie bezpośrednio przed AAAi po ZZZczęści, którą jestem zainteresowany 1234.

Dzięki sedtemu można zrobić coś takiego za pomocą łańcucha:

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

I to da mi 1234w rezultacie.

Jak zrobić to samo w Pythonie?

Używanie wyrażeń regularnych - dokumentacja do wglądu

import re

text = 'gfgfdAAA1234ZZZuijjk'

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

# found: 1234

lub:

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'

Następnie możesz użyć wyrażeń regularnych z modułem re, jeśli chcesz, ale nie jest to konieczne w twoim przypadku.

Wyrażenie regularne

import re

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

Powyższe takie, jakie jest, zakończy się niepowodzeniem, AttributeErrorjeśli nie ma „AAA” i „ZZZ” wyour_text

metody strunowe

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

Powyższe zwróci pusty ciąg, jeśli „AAA” lub „ZZZ” nie istnieją your_text.

Wyzwanie PS Python?

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

Zaskoczony, że nikt nie wspomniał o tym, co jest moją szybką wersją jednorazowych skryptów:

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

możesz to zrobić za pomocą tylko jednego wiersza kodu

>>> import re

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

>>> ['1234']

wynik otrzyma listę ...

Możesz użyć do tego modułu re :

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

Za pomocą sed można zrobić coś takiego za pomocą łańcucha:

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

A to da mi 1234 wynik.

Możesz zrobić to samo z re.subfunkcją używając tego samego wyrażenia regularnego.

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

W podstawowym sedu grupa przechwytująca jest reprezentowana przez \(..\), ale w pythonie była reprezentowana przez (..).

W Pythonie wyodrębnianie ciągu formularza podłańcuchowego można wykonać za pomocą findallmetody w remodule wyrażenia regularnego ( ).

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

Możesz znaleźć pierwszy podciąg z tą funkcją w swoim kodzie (według indeksu znaków). Możesz także znaleźć to, co jest po podciągu.

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

Daje

string

Na wypadek, gdyby ktoś musiał zrobić to samo, co ja. Musiałem wyodrębnić wszystko z nawiasu w linii. Na przykład, jeśli mam takie zdanie, jak „prezydent USA (Barack Obama) spotkał się z ...” i chcę uzyskać tylko „Barack Obama”, oto rozwiązanie:

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

Tzn. Musisz zablokować nawias ze slash \znakiem. Chociaż problem dotyczy bardziej wyrażeń regularnych niż Python.

Ponadto w niektórych przypadkach przed definicją wyrażenia regularnego możesz zobaczyć symbole „r”. Jeśli nie ma przedrostka r, musisz użyć znaków zmiany znaczenia jak w C. Oto więcej dyskusji na ten temat.

Korzystanie z 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)

co daje:

[['1234']]

Oto rozwiązanie bez wyrażenia regularnego, które uwzględnia również scenariusze, w których pierwszy podłańcuch zawiera drugi podłańcuch. Ta funkcja znajdzie podciąg tylko wtedy, gdy drugi znacznik znajduje się za pierwszym znacznikiem.

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

Innym sposobem na to jest użycie list (zakładając, że szukany podciąg składa się tylko z liczb):

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

Jeden wkładka, który zwraca inny ciąg, jeśli nie było dopasowania. Edycja: ulepszona wersja korzysta z nextfunkcji, "not-found"w razie potrzeby zastąp ją inną:

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

Moja inna metoda, aby to zrobić, mniej optymalna, używa wyrażenia regularnego 2. raz, wciąż nie znalazłem krótszej drogi:

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