在两个子串之间查找字符串

Question

如何在两个子串('123STRINGabc' -> 'STRING')之间找到一个字符串？

我目前的方法是这样的:

>>> start = 'asdf=5;'
>>> end = '123jasd'
>>> s = 'asdf=5;iwantthis123jasd'
>>> print((s.split(start))[1].split(end)[0])
iwantthis

然而,这似乎是非常低效和非pythonic.做这样的事情有什么更好的方法？

忘记提及:字符串可能无法以start和开头和结尾end.他们之前和之后可能会有更多的角色.

Answer 1

import re

s = 'asdf=5;iwantthis123jasd'
result = re.search('asdf=5;(.*)123jasd', s)
print(result.group(1))

Answer 2

s = "123123STRINGabcabc"

def find_between( s, first, last ):
    try:
        start = s.index( first ) + len( first )
        end = s.index( last, start )
        return s[start:end]
    except ValueError:
        return ""

def find_between_r( s, first, last ):
    try:
        start = s.rindex( first ) + len( first )
        end = s.rindex( last, start )
        return s[start:end]
    except ValueError:
        return ""


print find_between( s, "123", "abc" )
print find_between_r( s, "123", "abc" )

得到:

123STRING
STRINGabc

我认为应该注意 - 根据你需要的行为,你可以混合index和rindex调用或使用上述版本之一(它相当于正则表达式(.*)和(.*?)组).

Answer 3

start = 'asdf=5;'
end = '123jasd'
s = 'asdf=5;iwantthis123jasd'
print s[s.find(start)+len(start):s.rfind(end)]

给

iwantthis

Answer 4

s[len(start):-len(end)]

Answer 5

字符串格式化为Nikolaus Gradwohl建议提供了一些灵活性.start并且end根据需要,现在可以修改.

import re

s = 'asdf=5;iwantthis123jasd'
start = 'asdf=5;'
end = '123jasd'

result = re.search('%s(.*)%s' % (start, end), s).group(1)
print(result)

Answer 6

只需将OP自己的解决方案转换为答案:

def find_between(s, start, end):
  return (s.split(start))[1].split(end)[0]

Answer 7

这是一种方法

_,_,rest = s.partition(start)
result,_,_ = rest.partition(end)
print result

另一种使用regexp的方法

import re
print re.findall(re.escape(start)+"(.*)"+re.escape(end),s)[0]

要么

print re.search(re.escape(start)+"(.*)"+re.escape(end),s).group(1)

Answer 8

source='your token _here0@df and maybe _here1@df or maybe _here2@df'
start_sep='_'
end_sep='@df'
result=[]
tmp=source.split(start_sep)
for par in tmp:
  if end_sep in par:
    result.append(par.split(end_sep)[0])

print result

必须显示:here0,here1,here2

正则表达式更好,但它需要额外的lib,你可能只想去python

Answer 9

如果您不想导入任何内容，请尝试使用字符串方法.index()：

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

# Output: 'string'
print text[text.index(left)+len(left):text.index(right)]

Answer 10

这是我所做的一个函数，用于返回一个列表，其中包含搜索到的 string1 和 string2 之间的字符串。

def GetListOfSubstrings(stringSubject,string1,string2):
    MyList = []
    intstart=0
    strlength=len(stringSubject)
    continueloop = 1

    while(intstart < strlength and continueloop == 1):
        intindex1=stringSubject.find(string1,intstart)
        if(intindex1 != -1): #The substring was found, lets proceed
            intindex1 = intindex1+len(string1)
            intindex2 = stringSubject.find(string2,intindex1)
            if(intindex2 != -1):
                subsequence=stringSubject[intindex1:intindex2]
                MyList.append(subsequence)
                intstart=intindex2+len(string2)
            else:
                continueloop=0
        else:
            continueloop=0
    return MyList


#Usage Example
mystring="s123y123o123pp123y6"
List = GetListOfSubstrings(mystring,"1","y68")
for x in range(0, len(List)):
               print(List[x])
output:


mystring="s123y123o123pp123y6"
List = GetListOfSubstrings(mystring,"1","3")
for x in range(0, len(List)):
              print(List[x])
output:
    2
    2
    2
    2

mystring="s123y123o123pp123y6"
List = GetListOfSubstrings(mystring,"1","y")
for x in range(0, len(List)):
               print(List[x])
output:
23
23o123pp123

Answer 11

要提取STRING，请尝试：

myString = '123STRINGabc'
startString = '123'
endString = 'abc'

mySubString=myString[myString.find(startString)+len(startString):myString.find(endString)]