두 마커 사이의 서브스트링을 추출하려면 어떻게 해야 합니까?

두 마커 사이의 서브스트링을 추출하려면 어떻게 해야 합니까?

끈이 있다고 칩시다.'gfgfdAAA1234ZZZuijjk'그리고 나는 단지 이 모든 것을 추출하고 싶다.'1234'일부.

몇 글자가 나올지 알 수 있는 건AAA, 및 그 이후ZZZ내가 관심 있는 부분1234.

와 함께sed스트링을 사용하여 다음과 같은 작업을 수행할 수 있습니다.

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

그리고 이것은 나에게1234결과적으로.

Python에서도 같은 일을 어떻게 하나요?

정규 표현식 사용 - 자세한 참조를 위한 문서

import re

text = 'gfgfdAAA1234ZZZuijjk'

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

# found: 1234

또는 다음과 같이 입력합니다.

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'

그 후 re모듈에서도 regexps를 사용할 수 있지만, 고객님의 경우에는 그럴 필요가 없습니다.

정규 표현

import re

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

상기의 현재 상태는, 다음과 같이 기능하지 않게 됩니다.AttributeError'AAA' 및 'ZZZ'가 없는 경우your_text

스트링 메서드

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

위의 문자열은 "AAA" 또는 "ZZZ"가 존재하지 않는 경우 빈 문자열을 반환합니다.your_text.

PS Python 챌린지?

단발 스크립트용 퀵버전이라는 것을 아무도 언급하지 않은 것에 놀랐습니다.

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

코드 한 줄만 사용하여 수행할 수 있습니다.

>>> import re

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

>>> ['1234']

결과가 목록을 수신합니다...

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

여기에는 re 모듈을 사용할 수 있습니다.

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

python에서는 서브스트링 형식의 문자열을 추출할 수 있습니다.findall정규 표현의 메서드(re모듈.

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

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

주다

string

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

sed를 사용하면 스트링으로 다음과 같은 작업을 수행할 수 있습니다.

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

그 결과 1234가 됩니다.

같은 작업을 할 수 있습니다.re.sub같은 regex를 사용하여 기능합니다.

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

기본 SED에서 캡처 그룹은 다음과 같이 표시됩니다.\(..\), 그러나 python에서는 그것은 다음과 같이 표현되었습니다.(..).

Python 3.8을 탑재한 라이너 1개:text에는 다음 서브스트링이 포함되어 있습니다.

text[text.find(start:='AAA')+len(start):text.find('ZZZ')]

이 함수의 첫 번째 서브스트링은 코드(문자 색인별)에서 찾을 수 있습니다.또한 서브스트링 뒤에 무엇이 있는지 찾을 수 있습니다.

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

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)

그 결과:

[['1234']]

혹시나 누군가 나와 같은 일을 해야 할지도 모르니까나는 괄호 안에 있는 모든 것을 한 줄로 빼야 했다.예를 들어, '미국 대통령(버락 오바마)이 만났던...'과 같은 대사가 있는데, '버락 오바마'만 받고 싶다면, 이것이 해결책입니다.

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

즉, 괄호를 차단할 필요가 있습니다.slash \Python보다 더 정규적인 표현에 대한 문제이지만.

또한 경우에 따라 정규식을 정의하기 전에 'r' 기호를 볼 수 있습니다.r 프리픽스가 없는 경우 C와 같이 이스케이프 문자를 사용해야 합니다.여기에 그것에 대한 더 많은 논의가 있다.

첫 번째 서브스트링이 두 번째 서브스트링을 포함하는 시나리오도 설명하는 regex 없는 솔루션을 다음에 나타냅니다.이 함수는 두 번째 마커가 첫 번째 마커 뒤에 있는 경우에만 하위 문자열을 찾습니다.

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

다른 방법은 목록을 사용하는 것입니다(찾고 있는 서브스트링이 숫자로만 구성되어 있는 경우).

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

타이프 스크립트다른 두 문자열 사이에 문자열을 가져옵니다.

프리픽스와 포스트픽스 사이의 최단 문자열을 검색합니다.

prefixs - 문자열/문자열 배열/null(처음부터 검색 필요).

postfixs - string / strings 배열 / null (끝까지 검색 필요)

public getStringInBetween(str: string, prefixes: string | string[] | null,
                          postfixes: string | string[] | null): string {

    if (typeof prefixes === 'string') {
        prefixes = [prefixes];
    }

    if (typeof postfixes === 'string') {
        postfixes = [postfixes];
    }

    if (!str || str.length < 1) {
        throw new Error(str + ' should contain ' + prefixes);
    }

    let start = prefixes === null ? { pos: 0, sub: '' } : this.indexOf(str, prefixes);
    const end = postfixes === null ? { pos: str.length, sub: '' } : this.indexOf(str, postfixes, start.pos + start.sub.length);

    let value = str.substring(start.pos + start.sub.length, end.pos);
    if (!value || value.length < 1) {
        throw new Error(str + ' should contain string in between ' + prefixes + ' and ' + postfixes);
    }

    while (true) {
        try {
            start = this.indexOf(value, prefixes);
        } catch (e) {
            break;
        }
        value = value.substring(start.pos + start.sub.length);
        if (!value || value.length < 1) {
            throw new Error(str + ' should contain string in between ' + prefixes + ' and ' + postfixes);
        }
    }

    return value;
}

또한 Bellow 기능에서 모든 조합을 찾을 수 있습니다.

s = 'Part 1. Part 2. Part 3 then more text'
def find_all_places(text,word):
    word_places = []
    i=0
    while True:
        word_place = text.find(word,i)
        i+=len(word)+word_place
        if i>=len(text):
            break
        if word_place<0:
            break
        word_places.append(word_place)
    return word_places
def find_all_combination(text,start,end):
    start_places = find_all_places(text,start)
    end_places = find_all_places(text,end)
    combination_list = []
    for start_place in start_places:
        for end_place in end_places:
            print(start_place)
            print(end_place)
            if start_place>=end_place:
                continue
            combination_list.append(text[start_place:end_place])
    return combination_list
find_all_combination(s,"Part","Part")

결과:

['Part 1. ', 'Part 1. Part 2. ', 'Part 2. ']

여러 번 발생하고 싶은 경우.

content ="Prefix_helloworld_Suffix_stuff_Prefix_42_Suffix_andsoon"
strings = []
for c in content.split('Prefix_'):
    spos = c.find('_Suffix')
    if spos!=-1:
        strings.append( c[:spos])
print( strings )

또는 보다 신속하게:

strings = [ c[:c.find('_Suffix')] for c in content.split('Prefix_') if c.find('_Suffix')!=-1 ]

일치하지 않는 경우 다른 문자열을 반환하는 라이너.은 " " " 를 사용합니다.next 치환, 치환, 치환"not-found"을 사용법

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

최적성이 떨어지는 다른 방법은 regex를 두 번째 사용했지만 더 짧은 방법을 찾을 수 없었습니다.

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

언급URL : https://stackoverflow.com/questions/4666973/how-to-extract-the-substring-between-two-markers