在Python中找到几个子字符串之一的最有效方法是什么？

Question

我有一个可能的子字符串的列表，例如['cat', 'fish', 'dog']。实际上，该列表包含数百个条目。

我正在处理一个字符串，我正在寻找的是找到这些子字符串中任何一个的第一次出现的索引。

澄清'012cat'一下，结果是3，'0123dog789cat'结果是4。

我还需要知道找到了哪个子字符串（例如，其在子字符串列表中的索引或文本本身），或者至少是匹配的子字符串的长度。

有很明显的暴力方式可以实现这一目标，我想知道是否有任何优雅的Python / regex解决方案。

Answer 1

我认为正则表达式比单独检查每个子字符串要好，因为 从概念上讲
，正则表达式被建模为DFA，并且随着输入被消耗，所有匹配项都将同时被测试（导致对输入字符串进行一次扫描） ）。

因此，这是一个示例：

import re

def work():
  to_find = re.compile("cat|fish|dog")
  search_str = "blah fish cat dog haha"
  match_obj = to_find.search(search_str)
  the_index = match_obj.start()  # produces 5, the index of fish
  which_word_matched = match_obj.group()  # "fish"
  # Note, if no match, match_obj is None

更新： 将单词组合成单个备选单词模式时应 格外
小心。以下代码构建了一个正则表达式，但转义了所有正则表达式特殊字符并对单词进行排序，以便较长的单词有机会在同一单词的任何较短前缀之前匹配：

def wordlist_to_regex(words):
    escaped = map(re.escape, words)
    combined = '|'.join(sorted(escaped, key=len, reverse=True))
    return re.compile(combined)

>>> r.search('smash atomic particles').span()
(6, 10)
>>> r.search('visit usenet:comp.lang.python today').span()
(13, 29)
>>> r.search('a north\south division').span()
(2, 13)
>>> r.search('012cat').span()
(3, 6)
>>> r.search('0123dog789cat').span()
(4, 7)

结束更新

应该注意的是，您将希望尽可能少地形成正则表达式（即，调用re.compile（））。最好的情况是，您提前知道搜索的内容（或者您一次/很少计算一次），然后将re.compile的结果保存在某个地方。我的示例只是一个简单的废话功能，因此您可以看到正则表达式的用法。这里还有更多正则表达式文档：

http://docs.python.org/library/re.html

希望这可以帮助。

更新： 我不确定python如何实现正则表达式，但要回答Rax有关re.compile（）是否存在限制的问题（例如，您可以尝试同时将“
|”一起匹配的单词数）
，以及运行编译的时间：这似乎都不是问题。我试用了这段代码，足以说服我。（我可以通过添加时间安排和报告结果，以及将单词列表放入集合中以确保没有重复…来做得更好，但是这两项改进似乎都太过分了）。这段代码基本上是瞬时运行的，使我确信可以搜索2000个单词（大小为10），并且这些单词都将匹配。这是代码：

import random
import re
import string
import sys

def main(args):
    words = []
    letters_and_digits = "%s%s" % (string.letters, string.digits)
    for i in range(2000):
        chars = []
        for j in range(10):
            chars.append(random.choice(letters_and_digits))
        words.append(("%s"*10) % tuple(chars))
    search_for = re.compile("|".join(words))
    first, middle, last = words[0], words[len(words) / 2], words[-1]
    search_string = "%s, %s, %s" % (last, middle, first)
    match_obj = search_for.search(search_string)
    if match_obj is None:
        print "Ahhhg"
        return
    index = match_obj.start()
    which = match_obj.group()
    if index != 0:
        print "ahhhg"
        return
    if words[-1] != which:
        print "ahhg"
        return

    print "success!!! Generated 2000 random words, compiled re, and was able to perform matches."

if __name__ == "__main__":
    main(sys.argv)

更新： 应该注意的是，在正则表达式中进行或运算的事物的顺序很 重要
。看看以下受TZOTZIOY启发的测试：

>>> search_str = "01catdog"
>>> test1 = re.compile("cat|catdog")
>>> match1 = test1.search(search_str)
>>> match1.group()
'cat'
>>> match1.start()
2
>>> test2 = re.compile("catdog|cat")  # reverse order
>>> match2 = test2.search(search_str)
>>> match2.group()
'catdog'
>>> match2.start()
2

这表明顺序很重要：-/。我不确定这对Rax的应用意味着什么，但是至少行为是已知的。