在集合中查找匹配的字符串

Question

我正在尝试比较两个大文件：b.txt 包含超过 2000 万行，a.txt 包含 50.000 行。以传统方式比较它们需要太多时间。例如以下代码在 5 小时内没有完成：

b = [line.rstrip('\n') for line in open("b.txt")]
a = [line.rstrip('\n') for line in open("a.txt")]
for i in a:
    for j in b:
        if i in j:
            print(j)

我在 Stackoverflow 中看到了针对类似问题的以下建议：

with open('b.txt') as b:
    blines = set(b)
    print(blines[0])
with open('a.txt') as a:
    for line in a:
        if line in blines:
            print(line)

set() 函数运行速度非常快，代码在几秒钟内终止。但是，我需要在包含line 变量的blines 中找到确切的字符串。由于索引无法访问set()，因此我无法实现。有没有办法找到匹配的字符串，或者你有什么其他建议可以让这个比较比第一个代码更快。

Answer 1

来自your comment，你说你需要处理（为清楚起见，略作编辑）：

line = 'abc' 与 blines = {'abcd', 'fg'};如果 line in blines 返回 true 但我需要 'abcd' 字符串，或者它是找到它的索引

如果没有组合爆炸，set 无法正确完成您正在做的事情。您想处理任意子字符串，而不仅仅是行或单词，这意味着 blines 需要在其中包含每一行的每个子字符串才能使查找成功（因此，您还需要存储 @ 而不仅仅是 'abcd' 987654332@、'b'、'c'、'd'、'ab'、'bc''、'cd'、'abc' 和 'bcd'，这只是一条短线，而不是 20M 长线） .

更好的解决方案是一种数据结构，它可以让您在给定字符串中找到所有目标词，该数据结构不会遭受组合爆炸，例如Aho-Corasick，为此a Python package, pyahocorasick, already exists to implement it efficiently。

不用将b 的所有 2000 万行（谁知道每行有多少子字符串）都加载到内存中，只需从 a 中的 50,000 个字符串构建一个自动机，然后检查 b 的每一行针对那个自动机：

import ahocorasick
auto = ahocorasick.Automaton()    
with open("a.txt") as needles:
    for needle in needles:
        needle = needle.rstrip('\n')
        auto.add_word(needle, needle)
auto.make_automaton()

with open("b.txt") as haystacks:
    for lineno, line in enumerate(haystacks):
        for end_ind, found in auto.iter(line):
            print(f"Found {found!r} on line {lineno} at index {end_ind - len(found) + 1}: {line!r}")

这会在O(n) 时间（相对于a.txt 的大小）生成一个单独的Aho-Corasick 自动机，然后在O(n) 时间（相对于b.txt 的大小）扫描它；内存使用量将与a.txt 的大小大致成比例（根据之前的测试，对于 50,000 个 3-12 个字符长的随机针，自动机的内存使用量可能在 10-20 MB 范围内），并且不会受到影响所有子串的set 的组合爆炸。它会找到所有a 的元素，无论它们出现在b 中的什么地方（即使在单词的中间，如您需要在abcd 中查找abc 的示例），而不会产生额外的内存开销。

如果您需要知道a.txt 中的行号，而不仅仅是b.txt 中的行号，只需更改自动机构建过程以存储行号以及针本身（您可以将任何内容与每个添加了单词，所以tuple 和str 一样好）：

for lineno, needle in enumerate(needles):
    needle = needle.rstrip('\n')
    auto.add_word(needle, (lineno, needle))

然后在以后迭代：

for blineno, bline in enumerate(haystacks):
    for end_ind, (alineno, found) in auto.iter(line):

根据需要调整输出。

Answer 2

如果您可以保证b.txt 中的行是唯一的，那么您可以使用查找表来查找任何给定行的位置。 （编辑： 行在使用 defaultdict 时实际上不必是唯一的。感谢 @ShadowRanger）

这意味着，您可以创建一个以行为键，行号为值的字典，然后使用line_in_a in b_dict 来检查文件 b 中的文件 a 中是否存在行。

这应该会给您类似的性能，因为 set 和 dict 都进行哈希查找，但会以内存空间为代价。

看起来像这样：

from io import StringIO
from collections import defaultdict
import itertools

b = StringIO('''321
543
654
123
123
234''')

a = StringIO('''123
234
345''')



with b:
    lines = (line.rstrip('\n') for line in b)
    blookup = defaultdict(set)
    for i, line in enumerate(lines):
        blookup[line].add(i)

with a:    
    for line in a:
        line = line.rstrip('\n')
        if line in blookup:
            line_nos = blookup[line]
            print(line, line_nos)

输出：

123 {3, 4}
234 {5}

---

注意：请记住，这种方法只考虑精确匹配，它不搜索子字符串。

Answer 3

注意：请记住，这种方法只考虑完全匹配，它不搜索子字符串 - 要搜索子字符串，请查看 @ShadowRanger 答案。

此脚本首先从大文件 (word:{set of line numbers where the word exists in large file}) 构建索引：

data_large_file = '''
Lorem ipsum dolor sit amet, consectetur adipiscing elit,
sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu
fugiat nulla pariatur.
Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia
deserunt mollit anim id est laborum.'''

data_search = '''
ad minim veniam
non proident
non NOTFOUND proident'''

data = [d.rstrip() for d in data_large_file.splitlines() if d.rstrip()]
data_s = [d.rstrip() for d in data_search.splitlines() if d.rstrip()]

#build index
from collections import defaultdict
index = defaultdict(set)
for row_number, row in enumerate(data):
    for word in row.split():
        index[word].add(row_number)

#search:
for line in data_s:
    first_word = line.split(maxsplit=1)[0]
    for line_num in index[first_word]:
        if line in data[line_num]:
            print(data[line_num])

打印：

Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia