如何更快地遍历这个文本文件？

Question

如何更快地遍历这个文本文件？

6

我有一个文件，其中有很多以这种格式为基础的部分：

section_name_1 <attribute_1:value> <attribute_2:value> ... <attribute_n:value> {
    field_1 finish_num:start_num some_text ;
    field_2 finish_num:start_num some_text ;
    ...
    field_n finish_num:start_num some_text;
};

section_name_2 ...
... and so on

文件可能有数十万行。每个部分的属性和字段数量可能不同。我想建立几个字典来保存其中一些值。我已经有一个单独的字典，其中包含所有可能的“属性”值。

import os, re
from collections import defaultdict

def mapFile(myFile, attributeMap_d):
        valueMap_d = {}
        fieldMap_d = defaultdict(dict)

        for attributeName in attributeMap_d:
            valueMap_d[attributeName] = {}

        count = 0
        with open(myFile, "rb") as fh:
            for line in fh:
                # only look for lines with <
                if '<' in line:
                    # match all attribute:value pairs inside <> brackets
                    attributeAllMatch = re.findall(r'<(\S+):(\S+)>', line)
                    attributeAllMatchLen = len(attributeAllMatch)
                    count = 0

                    sectionNameMatch = re.match(r'(\S+)\s+<', line)

                    # store each section name and its associated attribute and value into dict
                    for attributeName in attributeMap_d:
                        for element in attributeAllMatch:
                            if element[0] == attributeName:
                                valueMap_d[attributeName][sectionNameMatch.group(1).rstrip()] = element[1].rstrip()
                                count += 1
                        # stop searching if all attributes in section already matched
                        if count == attributeAllMatchLen: break

                    nextLine = next(fh)

                    #in between each squiggly bracket, store all the field names and start/stop_nums into dict
                    #this while loop is very slow...
                    while not "};" in nextLine:
                        fieldMatch = re.search(r'(\S+)\s+(\d+):(\d+)', nextLine)
                        if fieldMatch:
                            fieldMap_d[sectionNameMatch.group(1)][fieldMatch.group(1)] = [fieldMatch.group(2), fieldMatch.group(3)]
                        nextLine = next(fh)

        return valueMap_d

我的问题是匹配所有字段值的while循环比代码的其余部分明显慢：如果我删除while循环，根据cProfile，它只需要0.5秒而不是2.2秒。我想知道我可以做什么来加速它。

- Colin

1

你可以使用带有正则表达式的生成器 - 如果您提供一些真实的示例，可能会更好地帮助您。 - Jan

它会慢多少？ - Elis Byberi

@Jan，我无法提供原始文件，但我会尝试自己创建一个示例。 - Colin

@ElisByberi 0.5秒 vs. 2.2秒。我编辑了原帖以添加这个信息。 - Colin

必须要慢！引用你的帖子：“数十万行长”@Colin - Elis Byberi

1个回答

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- PM 2Ring · Accepted Answer

正则表达式在需要进行复杂模式匹配时非常有用，但当您不需要这样做时，使用str方法解析文本可能会更快。以下是一些比较使用正则表达式和使用str.split进行字段解析的时间的代码。

首先，我创建了一些虚假测试数据，将其存储在rows列表中。这样做使我的演示代码比从文件中读取数据更简单，但更重要的是，它消除了文件读取的开销，因此我们可以更准确地比较解析速度。

顺便说一下，在字段解析循环之外保存sectionNameMatch.group(1)，而不是在每个字段行上都进行调用，这样可以提高效率。

首先，我将说明我的代码正确解析了数据。 :)

import re
from pprint import pprint
from time import perf_counter

# Make some test data
num = 10
rows = []
for i in range(1, num):
    j = 100 * i
    rows.append(' field_{:03} {}:{} some_text here ;'.format(i, j, j - 50))
rows.append('};')
print('\n'.join(rows))

# Select whether to use regex to do the parsing or `str.split`
use_regex = True
print('Testing {}'.format(('str.split', 'regex')[use_regex]))

fh = iter(rows)
fieldMap = {}

nextLine = next(fh)
start = perf_counter()
if use_regex:
    while not "};" in nextLine: 
        fieldMatch = re.search(r'(\S+)\s+(\d+):(\d+)', nextLine)
        if fieldMatch:
            fieldMap[fieldMatch.group(1)] = [fieldMatch.group(2), fieldMatch.group(3)]
        nextLine = next(fh)
else:
    while not "};" in nextLine: 
        if nextLine:
            data = nextLine.split(maxsplit=2)
            fieldMap[data[0]] = data[1].split(':')
        nextLine = next(fh)

print('time: {:.6f}'.format(perf_counter() - start))
pprint(fieldMap)

输出

 field_001 100:50 some_text here ;
 field_002 200:150 some_text here ;
 field_003 300:250 some_text here ;
 field_004 400:350 some_text here ;
 field_005 500:450 some_text here ;
 field_006 600:550 some_text here ;
 field_007 700:650 some_text here ;
 field_008 800:750 some_text here ;
 field_009 900:850 some_text here ;
};
Testing regex
time: 0.001946
{'field_001': ['100', '50'],
 'field_002': ['200', '150'],
 'field_003': ['300', '250'],
 'field_004': ['400', '350'],
 'field_005': ['500', '450'],
 'field_006': ['600', '550'],
 'field_007': ['700', '650'],
 'field_008': ['800', '750'],
 'field_009': ['900', '850']}

这里是使用 use_regex = False 的输出结果；我不会再重新打印输入数据。

Testing str.split
time: 0.000100
{'field_001': ['100', '50'],
 'field_002': ['200', '150'],
 'field_003': ['300', '250'],
 'field_004': ['400', '350'],
 'field_005': ['500', '450'],
 'field_006': ['600', '550'],
 'field_007': ['700', '650'],
 'field_008': ['800', '750'],
 'field_009': ['900', '850']}

现在进行真正的测试。我将设置num = 200000并注释掉打印输入输出数据的行。

Testing regex
time: 3.640832

Testing str.split
time: 2.480094

正如你所见，正则表达式的版本要慢大约50%。

这些时间是在我的古老的2GHz 32位机器上运行Python 3.6.0时获得的，所以你的速度可能会有所不同。 ;) 如果你的Python没有time.perf_counter，你可以使用time.time代替。