23

我有一个大文件，我需要读入并从中制作字典。我希望这尽可能快。但是我在 python 中的代码太慢了。这是一个显示问题的最小示例。

先做一些假数据

paste <(seq 20000000) <(seq 2 20000001)  > largefile.txt

现在这是一段最小的 Python 代码，用于读取它并制作字典。

import sys
from collections import defaultdict
fin = open(sys.argv[1])

dict = defaultdict(list)

for line in fin:
    parts = line.split()
    dict[parts[0]].append(parts[1])

时间：

time ./read.py largefile.txt
real    0m55.746s

但是，可以更快地读取整个文件：

time cut -f1 largefile.txt > /dev/null    
real    0m1.702s

我的 CPU 有 8 个内核，是否可以在 python 中并行化这个程序以加快速度？

一种可能性可能是读取输入的大块，然后在不同的非重叠子块上并行运行 8 个进程，从内存中的数据并行创建字典，然后读取另一个大块。这在python中是否可能以某种方式使用多处理？

更新。假数据不是很好，因为每个键只有一个值。更好的是

perl -E 'say int rand 1e7, $", int rand 1e4 for 1 .. 1e7' > largefile.txt

（与读取大文件并制作字典有关。）

4

6 回答 6

6

可以将其并行化以加快速度，但并行执行多次读取不太可能有帮助。

您的操作系统不太可能有效地并行执行多个读取（例外情况是像条带化 RAID 阵列，在这种情况下，您仍然需要知道步幅才能充分利用它）。

您可以做的是在读取的同时运行相对昂贵的字符串/字典/列表操作。

因此，一个线程读取（大）块并将其推送到同步队列，一个或多个消费者线程从队列中拉取块，将它们分成行，并填充字典。

（如果你使用多个消费者线程，正如 Pappnese 所说，每个线程构建一个字典，然后加入它们）。

提示：

回覆。赏金：

C 显然没有 GIL 可抗衡，因此多个消费者可能会更好地扩展。读取行为并没有改变。不利的一面是 C 缺乏对哈希映射（假设您仍然需要 Python 样式的字典）和同步队列的内置支持，因此您必须找到合适的组件或编写自己的组件。多个消费者各自构建自己的字典然后最后合并它们的基本策略仍然可能是最好的。

使用strtok_r代替str.split可能会更快，但请记住，您也需要手动管理所有字符串的内存。哦，你也需要逻辑来管理行片段。老实说，C 为您提供了很多选择，我认为您只需要对其进行分析并查看即可。

于 2013-08-07T13:29:02.157 回答
3

认为使用处理池可以解决这样的问题似乎很诱人，但最终会比这更复杂，至少在纯 Python 中是这样。

因为 OP 提到每个输入行上的列表实际上比两个元素长，所以我使用以下方法制作了一个稍微更真实的输入文件：

paste <(seq 20000000) <(seq 2 20000001) <(seq 3 20000002) |
  head -1000000 > largefile.txt

在分析原始代码后，我发现该过程中最慢的部分是行分割例程。（.split()大约比.append()我的机器长 2 倍。）

1000000    0.333    0.000    0.333    0.000 {method 'split' of 'str' objects}
1000000    0.154    0.000    0.154    0.000 {method 'append' of 'list' objects}

所以我将拆分分解为另一个函数，并使用一个池来分配拆分字段的工作：

import sys
import collections
import multiprocessing as mp

d = collections.defaultdict(list)

def split(l):
    return l.split()

pool = mp.Pool(processes=4)
for keys in pool.map(split, open(sys.argv[1])):
    d[keys[0]].append(keys[1:])

不幸的是，添加池会使速度减慢 2 倍以上。原始版本如下所示：

$ time python process.py smallfile.txt 
real    0m7.170s
user    0m6.884s
sys     0m0.260s

与并行版本相比：

$ time python process-mp.py smallfile.txt 
real    0m16.655s
user    0m24.688s
sys     0m1.380s

因为.map()调用基本上必须序列化（pickle）每个输入，将其发送到远程进程，然后反序列化（unpickle）来自远程进程的返回值，这种方式使用池要慢得多。通过向池中添加更多核心确实可以获得一些改进，但我认为这从根本上是分配这项工作的错误方式。

为了真正加快跨内核的速度，我的猜测是您需要使用某种固定块大小读取大块输入。然后你可以将整个块发送到一个工作进程并取回序列化列表（尽管仍然不知道这里的反序列化会花费你多少）。以固定大小的块读取输入听起来对预期的输入可能很棘手，但是，因为我的猜测是每行不一定是相同的长度。

于 2013-08-12T02:09:28.283 回答
2

几年前，在 Tim Bray 的网站 [1] 上有一篇关于此的博文系列“Wide Finder Project”。您可以在那里找到 ElementTree [3] 和 PIL [4] 的 Fredrik Lundh 的解决方案 [2]。我知道在这个网站上发布链接通常是不鼓励的，但我认为这些链接比复制粘贴他的代码给你更好的答案。

[1] http://www.tbray.org/ongoing/When/200x/2007/10/30/WF-Results
[2] http://effbot.org/zone/wide-finder.htm
[3] http ://docs.python.org/3/library/xml.etree.elementtree.html
[4] http://www.pythonware.com/products/pil/

于 2013-08-16T09:28:26.733 回答
1

您可以尝试的一件事是从文件中获取行数，然后生成 8 个线程，每个线程从文件的 1/8 生成一个字典，然后在所有线程完成后加入字典。如果附加需要时间而不是读取行，这可能会加快速度。

于 2013-08-07T13:26:32.697 回答
1

慢速字典附加的更多基本解决方案：用字符串对数组替换字典。填充它然后排序。

于 2013-08-16T20:28:57.630 回答
-1

如果您存档的数据不经常更改，您可以选择对其进行序列化。Python 解释器将更快地反序列化它。您可以使用 cPickle 模块。

或者创建 8 个单独的进程是另一种选择。因为，拥有唯一的 dict 使它更有可能。您可以通过“多处理”模块或“套接字”模块中的管道在这些进程之间进行交互。

此致

BarışÇUHADAR。

于 2013-11-09T21:07:08.960 回答