![](/img/trans.png)
[英]Is there a way to make a dictionary from a single list where the key and value for the dict are taken from a specific index
[英]Fastest way to generate a dict from list where key == value
我有一个清单,说:
NUM = 100
my_list = list(range(NUM))
我想生成一个键等于值的dict
,例如:
my_dict = {item: item for item in my_list}
或者:
my_dict = dict(zip(my_list, my_list))
我已经运行了一些微基准测试,看起来它们的速度相似,但我希望第二个会更快,因为循环应该在 C 中发生。
例如,以下构造:
my_dict = {key: SOMETHING for key in keys}
翻译成更快:
my_dict = dict.fromkeys(k, SOMETHING)
所以,我的问题是:对于{x: x for x in my_list}
是否有类似的结构?
我已经检查了dir(dict)
并且在这个方向上似乎没有任何东西(我希望它被称为dict.fromitems()
类的东西)。
像dict.fromitems()
这样的方法比这个特定用例有更广泛的应用,因为:
dict.fromitems(keys, values)
原则上可以同时替代两者:
{k, v for k, v in zip(keys, values)}
和:
dict(zip(keys, values))
不,没有更快的方法可用于字典。
那是因为性能成本全部在于处理迭代器中的每个项目、计算其散列并将键插入字典数据散列表结构中(包括动态增长这些结构)。 相比之下,执行字典理解字节码真的微不足道。
dict(zip(it, it))
, {k: k for k in it}
和dict.fromkeys(it)
在速度上都接近:
>>> from timeit import Timer
>>> tests = {
... 'dictcomp': '{k: k for k in it}',
... 'dictzip': 'dict(zip(it, it))',
... 'fromkeys': 'dict.fromkeys(it)',
... }
>>> timings = {n: [] for n in tests}
>>> for magnitude in range(2, 8):
... it = range(10 ** magnitude)
... for name, test in tests.items():
... peritemtimes = []
... for repetition in range(3):
... count, total = Timer(test, 'from __main__ import it').autorange()
... peritemtimes.append(total / count / (10 ** magnitude))
... timings[name].append(min(peritemtimes)) # best of 3
...
>>> for name, times in timings.items():
... print(f'{name:>8}', *(f'{t * 10 ** 9:5.1f} ns' for t in times), sep=' | ')
...
dictcomp | 46.5 ns | 47.5 ns | 50.0 ns | 79.0 ns | 101.1 ns | 111.7 ns
dictzip | 49.3 ns | 56.3 ns | 71.6 ns | 109.7 ns | 132.9 ns | 145.8 ns
fromkeys | 33.9 ns | 37.2 ns | 37.4 ns | 62.7 ns | 87.6 ns | 95.7 ns
这是每项技术的每项成本表,从 100 到 1000 万项。 随着哈希表结构增长的额外成本的累积,时间会增加。
当然, dict.fromkeys()
可以处理项目得快一点,但它不是一个数量级比其他进程更快。 它的(小)速度优势并非来自能够在 C 中迭代; 区别纯粹在于不必每次迭代更新值指针; 所有键都指向单个值引用。
zip()
速度较慢,因为它构建了额外的对象(为每个键值对创建一个 2 项元组不是一项免费操作),并且它增加了该过程中涉及的迭代器数量,您从单个迭代器开始对于字典理解和dict.fromkeys()
,到 3 个迭代器( dict()
迭代通过zip()
委托给两个单独的键和值迭代器)。
在dict
类中添加一个单独的方法来在 C 中处理这个问题是没有意义的,因为
这是禅宗的答案。 字典理解循环本身很快,这不是瓶颈。 正如 Martijn Pieters 所说,时间是用来花的:
__hash__
。__hash__
不好,你有很多冲突,导致字典插入很昂贵。不要担心循环。 如果构建字典需要很长时间,那是因为这些操作很慢。
使用这里答案的结果,我们创建一个新类,该类将 defaultdict 子类化,并覆盖其缺失的属性以允许将密钥传递给 default_factory:
from collections import defaultdict
class keydefaultdict(defaultdict):
def __missing__(self, key):
if self.default_factory is None:
raise KeyError(key)
else:
ret = self[key] = self.default_factory(key)
return ret
现在,您可以通过执行以下操作来创建您正在寻找的那种字典:
my_dict = keydefaultdict(lambda x: x)
然后,每当您需要为不映射到自身的键进行映射时,您只需更新这些值。
时间。
子类化defaultdict
:
%%timeit
my_dict = keydefaultdict(lambda x: x)
for num in some_numbers: my_dict[num] == num
结果:
4.46 s ± 71.1 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
字典理解
%%timeit
my_dict = {x: x for x in some_numbers}
for num in some_numbers: my_dict[num] == num
结果:
1.19 s ± 20.4 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
当您最终需要访问大约 17% 的原始值时,这两者变得具有可比性。 如果您需要更少,则更好:
仅访问原始值的一部分
子类化defaultdict
:
%%timeit
frac = 0.17
my_dict = keydefaultdict(lambda x: x)
for num in some_numbers[:int(len(some_numbers)*frac)]: my_dict[num] == num
结果:
770 ms ± 4.69 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
字典理解
%%timeit
frac = 0.175
my_dict = {x: x for x in some_numbers}
for num in some_numbers[:int(len(some_numbers)*frac)]: my_dict[num] == num
结果:
781 ms ± 4.03 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.