Python：匹配字符串中的多个子串

Question

我正在使用 Python，我想将给定的字符串与多个子字符串匹配。 我试图以两种不同的方式解决这个问题。 我的第一个解决方案是将 substring 与以下字符串匹配：

str = "This is a test string from which I want to match multiple substrings"
value = ["test", "match", "multiple", "ring"]
temp = []
temp.extend([x.upper() for x in value if x.lower() in str.lower()])
print(temp)

结果是 temp = ["TEST", "MATCH", "MULTIPLE", "RING"]

然而，这不是我想要的结果。 子字符串应完全匹配，因此“ring”不应与“string”匹配。

这就是为什么我试图用正则表达式来解决这个问题，就像这样：

str = "This is a test string from which I want to match multiple substrings"
value = ["test", "match", "multiple", "ring"]
temp = []
temp.extend([x.upper() for x in value if regex.search(r"\b" + regex.escape(x) + r"\b", str,
                                                   regex.IGNORECASE) is not None])
print(temp)

结果是 ["TEST", "MATCH", "MULTIPLE"]，正确的解决方案。 尽管如此，这个解决方案的计算时间太长了。 我必须对大约 100 万个字符串进行此检查，与使用第一个解决方案所需的 1.5 小时相比，使用正则表达式的解决方案将需要数天才能完成。

我想知道是否有办法让第一个解决方案起作用，或者让第二个解决方案运行得更快。 提前致谢

编辑： value也可以包含数字，或者像“test1 test2”这样的短语

Answer 1

在不查看实际数据的情况下很难提出最佳解决方案，但是您可以尝试以下操作：

• 生成匹配所有值的单个模式。 这样，您只需要搜索一次字符串（而不是每个值一次）。
• 跳过转义的值，除非它们包含特殊字符（例如'^'或'*' ）。
• 将结果直接分配给temp ，避免使用temp.extend()不必要的复制。

import regex

# 'str' is a built-in name, so use 'string' instead
string = 'This is a Test string from which I want to match multiple substrings'
values = ['test', 'test2', 'Multiple', 'ring', 'match']
pattern = r'\b({})\b'.format('|'.join(map(regex.escape, values)))

# unique matches, lowercased
matches = set(map(str.lower, regex.findall(pattern, string, regex.IGNORECASE)))

# arrange the results as they appear in `values`
temp = [x.upper() for x in values if x.lower() in matches]
print(temp)  # ['TEST', 'MULTIPLE', 'MATCH']

Answer 2

我想到了两种可能的优化方法：

• 用re.compile预编译模式，这样每次调用match时都不会重新编译。
• 而不是与四个独立的正则表达式匹配，而是创建一个与所有值都匹配的正则表达式。

import re

str = "This is a test string from which I want to match test1 test2 multiple substrings"
values = ["test", "match", "multiple", "ring", "test1 test2"]

pattern = re.compile("|".join(r"\b" + re.escape(x) + r"\b" for x in values))
temp = []

temp.extend([x.upper() for x in pattern.findall(str, re.IGNORECASE)])
print(temp)

结果：

['TEST', 'MATCH', 'TEST1 TEST2', 'MULTIPLE']

这种方法的潜在缺点：

• 输出可能会以不同的顺序。 您最初的方法将结果按在values出现的顺序排列。 这种方法将结果按顺序出现在str 。
• 如果相同的值在str出现多次，则该值将在temp出现多次。 与您的原始方法相反，该值最多在temp出现一次。
• 找到匹配项后， search终止。 findall始终搜索整个字符串。 如果您期望大多数字符串与value中的每个单词匹配，并且期望大多数匹配项出现在字符串的早期，则findall可能比search慢。 另一方面，如果您希望搜索经常打开None ，那么findall可能会更快。

Answer 3

您可以按空格分割str ，然后将value中的元素与==进行匹配

编辑：

因此，您说过， values中的某些字符串可以在它们之前或之后具有空格。 您可以使用以下行解决此问题：

values = [i.strip() for i in values]

这将删除字符串之前和之后的所有空白字符（在您的情况下为每个元素）。

此外，您提到如果按空格分割str ，则某些单词在分割时会留下标点符号-> 'Hi, how are you?' 会导致['Hi,', 'how', 'are', 'you?'] 。 您可以通过使用内置的字符串startswith()方法来过滤来自以下values所有以元素开头的单词的方式来解决此问题：

str = ['Hi,', 'how', 'are', 'you?']`
values = ['how', 'you', 'time', 'space']

new_str = []
for word in str:
  for j in values:
    if word.startswith(j):
      new_str.append(word)

# result -> ['how', 'you?']

然后，您可以使用正则表达式从结果列表中删除标点符号，但是现在您可以使用更小的列表进行迭代。 删除所有标点符号后，即可按照我在原始答案中建议的方式匹配整个字符串。

我希望现在更加清楚。

Answer 4

使用以下代码在我的笔记本电脑上执行 100 万次“statement”变量大约需要 3 秒：

from timeit import timeit
import re

# I inserted punctuation to cover more situations
string = """
This, is a ; test string from which I want to match multiple substrings
"""
substrings = ['test', 'match', 'multiple', 'ring']

statement = """
string_normalized = (re.sub(r'[^\w\s]', '', string)
                       .strip()
                       .lower()
                       .split(' '))
result = list(filter(lambda x: x in string_normalized, substrings))
"""

if __name__ == '__main__':
    time_it_takes = timeit(stmt=statement, globals=globals(), number=1_000_000)
    print(time_it_takes)