字典搜索和插入优化

Question

当字典增加到几千个键时，我在使用字典时遇到了严重的速度下降。

我正在处理一个包含约 1,000,000 行数据的文件，我正在使用字典构建一个类似图形的数据结构

这是我的瓶颈函数

def create_edge(node_a, node_b, graph):
    if node_a not in graph.keys():
        graph[node_a] = {node_b: 1}
    elif node_b in graph[node_a].keys():
        graph[node_a][node_b] += 1
    else:
        graph[node_a][node_b] = 1

create_edge 将创建从 node_a 到 node_b 的边，或者将它们之间的现有边的权重加 1。

由于我的节点由字符串唯一 id 标识，因此我使用字典进行存储，假设搜索是否存在键，并且插入平均需要 O(1)。

如果我注释掉 create_edge，我每秒可以处理大约 20,000 条记录，create_edge 作为我管道的一部分，每秒大约可以处理 20 条记录。

前 100 条记录大约需要 500 毫秒来处理。 当字典大小增加到 10,000 左右时 - 处理 100 条记录大约需要 15,000 毫秒，每个记录进程平均调用 create_edge 大约 4 次 - 因此，当字典大小为 10,000 时，对 create_edge 的 400 次调用需要 15 秒。

首先，这些运行时有意义吗？对我来说似乎很重要，如果我错了，请纠正我。

其次，我们将不胜感激优化字典使用以获得更好的运行时间的建议。

我希望字典大小至少为 100,000 以完成对全部 1,000,000 条记录的处理。

---

编辑：结论

你在钱上是对的，在这里犯了两个菜鸟错误.. :)

keys() 调用显着增加了复杂性，将其从恒定时间变为每次边插入的多时间（平方），将 if node in graph.keys() 替换为 if node in graph 会在约 300 毫秒内产生 100 条记录的恒定处理时间。

第二个错误是 virtualenv 配置，这让我相信我在使用 python3 而我实际上是在使用 python2。

python3 确实将 keys() 代码优化为恒定时间搜索，这对运行时间有好处，但对于正确的代码风格则不太好。

非常感谢您的帮助。

---

我在删除 keys() 调用后执行了运行时间比较。

# graph = {}
python version: 3.6.3
start time 11:44:56
Number of records: 1029493
graph created, 1231630 nodes
end time 11:50:35
total ~05:39

# graph = defaultdict(lambda : defaultdict(int))
python version: 3.6.3
start time 11:54:52
Number of records: 1029493
graph created, 1231630 nodes
end time  12:00:34
total ~05:42

# graph = {}
python version: 2.7.10
start time 12:03:25
Number of records: 1029493
graph created, 1231630 nodes
end time 12:09:40
total ~06:15

Answer 1

在测试dict 中是否存在密钥时，只需使用key in d，而不是key in d.keys()。提取密钥来测试成员资格首先否定了使用dict 的好处。

尝试以下方法：

def create_edge(node_a, node_b, graph):
    if node_a not in graph:
        graph[node_a] = {node_b: 1}
    elif node_b in graph[node_a]:
        graph[node_a][node_b] += 1
    else:
        graph[node_a][node_b] = 1

请注意，keys() 根本没有被调用。这应该比你现在做的快很多。

请注意，在 Python 2 中，keys() 检查将比在 Python 3 中慢得多，因为在 Python 2 中，keys() 创建了整个键集的列表。它在 Python 3 中的工作方式有所不同，但即使在 Python 3 中直接检查成员资格，而不使用 keys()，也会更快。

Answer 2

你不能只使用带有 defaultdict(int) 的 defaultdict，如下所示：Python: defaultdict of defaultdict?

from collections import defaultdict

graph = defaultdict(lambda : defaultdict(int))

graph['a']['b'] += 1
graph['a']['b'] += 1
graph['a']['c'] += 1

graph

返回：

defaultdict(<function __main__.<lambda>>,
            {'a': defaultdict(int, {'b': 2, 'c': 1})})
# equal to: {'a': {'b': 2, 'c': 1}}

Answer 3

我尝试了几种方法，这是一种似乎有效的方法。此方法使用计数器首先计算所有出现次数，然后构建字典。感谢@Stefan Pochmann 提供基准脚本。我使用的一个来自ideone.com/ckF0X5

我使用的是 Python 3.6，结果在我的电脑上进行了测试。

from timeit import timeit
from collections import defaultdict, Counter
from random import shuffle
from itertools import product

def f():   # OP's method modified with Tom Karzes' answer above.
    d = {}
    for i, j in edges:
        if i not in d:
            d[i] = {j: 1}
        elif j in d[i]:
            d[i][j] += 1
        else:
            d[i][j] = 1

def count_first(): 
    d = dict()
    for (v, w), c in Counter(edges).items():
        if v not in d:
            d[v] = {w: c}
        else:
            d[v][w] = c
    # Alternatively, (Thanks to Jean-François Fabre to point it out.)
    # d = defaultdict(lambda : defaultdict(int)) 
    # for (v, w), c in Counter(edges).items(): 
    #     d[v][w] = c

edges = list(product(range(300), repeat=2)) * 10
shuffle(edges)

# %timeit f()
270 ms ± 23.6 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
# %timeit count_first()
180 ms ± 15.2 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

声明者：我从 ideone.com 获得的 count_first() 的结果比这里的 OP 的答案 f() 慢。

Stefan Pochmann 做了一个基准实验来比较 Python 2 和 3 中的不同方法。他在 Python 2 中的结果可以在here 找到。对于 Python 3，请检查 this。感谢他并感谢他的代码审查。