假设我有一个字符串 'gfgfdAAA1234ZZZuijjk'，我只想提取 '1234' 部分。
我只知道AAA之前的几个字符，ZZZ之后我感兴趣的部分1234。
使用sed 可以用字符串做这样的事情：
echo "$STRING" | sed -e "s|.*AAA\(.*\)ZZZ.*|\1|"
结果，这会给我1234。
如何在 Python 中做同样的事情？
【问题讨论】：
text[text.find(start:='AAA')+len(start):text.find('ZZZ')]
>>> s = 'gfgfdAAA1234ZZZuijjk'
>>> start = s.find('AAA') + 3
>>> end = s.find('ZZZ', start)
>>> s[start:end]
'1234'
然后，如果您愿意，您也可以将正则表达式与 re 模块一起使用，但这在您的情况下不是必需的。
【讨论】：
re 方法不是更快吗？
s 中找不到任何令牌，s.find 将返回-1。切片运算符s[begin:end] 将接受它作为有效索引，并返回不需要的子字符串。
import re
print re.search('AAA(.*?)ZZZ', 'gfgfdAAA1234ZZZuijjk').group(1)
【讨论】：
AttributeError: 'NoneType' object has no attribute 'groups' - 如果字符串中没有AAA，ZZZ...
使用正则表达式 - documentation 供进一步参考
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
【讨论】：
您可以为此使用re 模块：
>>> import re
>>> re.compile(".*AAA(.*)ZZZ.*").match("gfgfdAAA1234ZZZuijjk").groups()
('1234,)
【讨论】：
import re
re.search(r"(?<=AAA).*?(?=ZZZ)", your_text).group(0)
如果your_text 中没有“AAA”和“ZZZ”，上述原样将失败并显示AttributeError
your_text.partition("AAA")[2].partition("ZZZ")[0]
如果your_text 中不存在“AAA”或“ZZZ”，则上述内容将返回一个空字符串。
PS Python 挑战赛？
【讨论】：
以防万一有人不得不做和我一样的事情。我必须在一行中提取括号内的所有内容。例如，如果我有一个像“美国总统（巴拉克奥巴马）会见......”这样的台词，而我只想得到“巴拉克奥巴马”，这就是解决方案：
regex = '.*\((.*?)\).*'
matches = re.search(regex, line)
line = matches.group(1) + '\n'
即你需要用slash \ 符号来阻止括号。虽然这是 Python 更多正则表达式的问题。
此外，在某些情况下，您可能会在正则表达式定义之前看到“r”符号。如果没有 r 前缀，则需要使用 C 中的转义字符。Here 对此进行了更多讨论。
【讨论】：
>>> s = '/tmp/10508.constantstring'
>>> s.split('/tmp/')[1].split('constantstring')[0].strip('.')
【讨论】：
使用 sed 可以用字符串做这样的事情：
echo "$STRING" | sed -e "s|.*AAA\(.*\)ZZZ.*|\1|"
这将给我 1234 作为结果。
您可以使用相同的正则表达式对 re.sub 函数执行相同的操作。
>>> re.sub(r'.*AAA(.*)ZZZ.*', r'\1', 'gfgfdAAA1234ZZZuijjk')
'1234'
在基本的sed中，捕获组由\(..\)表示，但在python中它由(..)表示。
【讨论】：
您可以在代码中使用此函数找到第一个子字符串（按字符索引）。此外，您可以找到子字符串之后的内容。
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]))
【讨论】：
如果没有匹配，则返回其他字符串的一个衬里。
编辑：改进版使用next 函数，如果需要，将"not-found" 替换为其他内容：
import re
res = next( (m.group(1) for m in [re.search("AAA(.*?)ZZZ", "gfgfdAAA1234ZZZuijjk" ),] if m), "not-found" )
我的其他方法不太理想，第二次使用正则表达式，仍然没有找到更短的方法：
import re
res = ( ( re.search("AAA(.*?)ZZZ", "gfgfdAAA1234ZZZuijjk") or re.search("()","") ).group(1) )
【讨论】：
只需一行代码即可完成
>>> import re
>>> re.findall(r'\d{1,5}','gfgfdAAA1234ZZZuijjk')
>>> ['1234']
结果将收到列表...
【讨论】：
在python中，可以使用正则表达式（re）模块中的findall方法来提取子字符串形式的字符串。
>>> import re
>>> s = 'gfgfdAAA1234ZZZuijjk'
>>> ss = re.findall('AAA(.+)ZZZ', s)
>>> print ss
['1234']
【讨论】：
很惊讶没有人提到这是我的一次性脚本的快速版本：
>>> x = 'gfgfdAAA1234ZZZuijjk'
>>> x.split('AAA')[1].split('ZZZ')[0]
'1234'
【讨论】：
if s.find("ZZZ") > s.find("AAA"): 可以避免字符串中没有'ZZZ` 的问题，这将返回'1234uuijjk'
partition 而不是 split 似乎更健壮（取决于您的需要），因为如果未找到其中一个子字符串，它将返回一个空字符串.
这是一个没有正则表达式的解决方案，它还考虑了第一个子字符串包含第二个子字符串的情况。如果第二个标记在第一个标记之后，此函数只会查找子字符串。
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)]
【讨论】：
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
【讨论】：
另一种方法是使用列表（假设您要查找的子字符串仅由数字组成）：
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
【讨论】：
使用 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']]
【讨论】：
打字稿。获取其他两个字符串之间的字符串。
搜索前缀和后缀之间的最短字符串
prefixes - 字符串/字符串数组/null（表示从头开始搜索）。
后缀 - 字符串/字符串数组/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;
}
【讨论】：
一个使用 Python 3.8 的衬垫：
text[text.find(start:='AAA')+len(start):text.find('ZZZ')]
【讨论】：
另外，您可以在下面的函数中找到所有组合
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. ']
【讨论】：