İki işaretleyici arasında alt dize nasıl çıkarılır?

Diyelim ki bir dizem var 'gfgfdAAA1234ZZZuijjk've sadece '1234'parçayı çıkarmak istiyorum .

Sadece daha önce AAAve ZZZilgilendiğim bölümden sonra birkaç karakterin ne olacağını biliyorum 1234.

İle sedkendisine bir dize ile böyle bir şey yapmak mümkündür:

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

Bu da bana 1234sonuç verecek .

Python'da aynı şey nasıl yapılır?

Normal ifadeleri kullanma - daha fazla başvuru için belgeler

import re

text = 'gfgfdAAA1234ZZZuijjk'

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

# found: 1234

veya:

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'

Daha sonra, isterseniz re modülü ile re modülünü de kullanabilirsiniz, ancak bu sizin durumunuzda gerekli değildir.

Düzenli ifade

import re

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

Yukarıdaki olduğu gibi AttributeError"AAA" ve "ZZZ" yoksayour_text

string yöntemleri

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

Yukarıda "AAA" veya "ZZZ" yoksa boş bir dize döndürülür your_text.

PS Python Mücadelesi?

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

Kimsenin bir kerelik komut dosyaları için hızlı sürümüm olandan bahsetmediğini şaşırttı:

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

sadece bir satır kod kullanarak yapabilirsiniz

>>> import re

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

>>> ['1234']

sonuç listesi alınacak ...

Bunun için re modülünü kullanabilirsiniz :

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

Sed ile böyle bir şey bir dize ile yapmak mümkündür:

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

Ve sonuç olarak bu bana 1234 verecek.

Aynı işlemleri olabilir re.subaynı regex kullanarak fonksiyonu.

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

Temel sed'de, yakalama grubu ile temsil edilir \(..\), ancak python ile temsil edilir (..).

Python'da, findallnormal ifade ( re) modülündeki yöntem kullanılarak alt dize form dizesinin ayıklanması yapılabilir .

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

Bu işleve sahip ilk alt dizeyi kodunuzda bulabilirsiniz (karakter dizinine göre). Ayrıca, bir alt dize sonra ne olduğunu bulabilirsiniz.

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

verir

string

Birisi benim yaptığım şeyi yapmak zorunda kalırsa. Parantez içindeki her şeyi bir satırda çıkarmak zorunda kaldım. Örneğin, 'ABD başkanı (Barack Obama) ile bir araya geldi ...' gibi bir hattım varsa ve sadece 'Barack Obama' almak istiyorum bu çözüm:

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

Yani parantezin slash \işaretli olması gerekir. Python daha düzenli ifadeler hakkında bir sorun olsa da.

Ayrıca, bazı durumlarda normal ifade tanımından önce 'r' sembolleri görebilirsiniz. R öneki yoksa, C'deki gibi kaçış karakterleri kullanmanız gerekir. İşte bununla ilgili daha fazla tartışma.

PyParsing'i kullanma

import pyparsing as pp

word = pp.Word(pp.alphanums)

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

hangi verir:

[['1234']]

Aşağıda, ilk alt dizenin ikinci alt dizeyi içerdiği senaryoları da hesaba katan regex içermeyen bir çözüm bulunmaktadır. Bu işlev, yalnızca ikinci işaretçi ilk işaretleyiciden sonraysa bir alt dize bulur.

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

Bunu yapmanın başka bir yolu da listeleri kullanmaktır (aradığınız alt dizenin yalnızca sayılardan oluştuğunu varsayalım):

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

Eşleşme yoksa diğer dizeyi döndüren bir gömlek. Düzenleme: geliştirilmiş sürüm nextişlevi kullanır , "not-found"gerekirse başka bir şeyle değiştirin :

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

Bunu yapmak için diğer yöntemim, daha az optimal, regex 2. kez kullanıyor, yine de daha kısa bir yol bulamadı:

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