标签: defaultdict

我的代码目前必须将事物大量嵌套dict到另一个中.我有需要用3个值索引的项目,然后计算.所以,在我的循环之前,我初始化一个嵌套,defaultdict如下所示:

from collections import defaultdict

type_to_count_dic = defaultdict(
        lambda: defaultdict(
            lambda: defaultdict(int)
        )
    )

这允许我在紧密循环内计算项目,如下所示:

for a in ...:
    for b in ...:
        for c in ...:
            type_to_count_dic[a][b][c] += 1

我觉得初始化所有这些defaultdict感觉就像在Java之类的东西中做类型声明一样.做这样的事情有更多的惯用/ Pythonic方式吗？

有没有办法在创建后更改defaultdict的default_factory(在调用不存在的键时返回的值)？

例如,当一个defaultdict如

d = defaultdict(lambda:1)

创建时,d只要d['absent']调用不存在的键,就会返回1 .在初始定义之后,如何将此默认值更改为其他值(例如,2)？

我有点困惑为什么你需要一个lambda函数来嵌套defaultdict

为什么你不能这样做？

test = defaultdict(defaultdict(list))

代替

test = defaultdict(lambda:defaultdict(float))

有没有办法从defaultdict获取原始/一致的密钥列表,即使请求了非现有密钥？

from collections import defaultdict
>>> d = defaultdict(lambda: 'default', {'key1': 'value1', 'key2' :'value2'})
>>>
>>> d.keys()
['key2', 'key1']
>>> d['bla']
'default'
>>> d.keys() # how to get the same: ['key2', 'key1']
['key2', 'key1', 'bla']

我在pythontips看到了这个例子.当defaultdict接受参数"tree"并返回"tree"时,我不明白第二行.

import collections
tree = lambda: collections.defaultdict(tree)
some_dict = tree()
some_dict['color']['favor'] = "yellow"
# Works fine

运行此代码后,我检查了some_dict的类型

defaultdict(< function < lambda > at 0x7f19ae634048 >, 
            {'color': defaultdict(
                  < function < lambda > at 0x7f19ae634048 >, {'favor': 'yellow'})})

我最近发现并开始使用默认字典来替换几个更庞大的结构。我在《Python 之禅》中读到，Python 的关键点之一是“应该有一种——最好只有一种——明显的方法来做到这一点。”

基于该标准（或者更实际地基于内存使用情况或速度）以下哪一项（或完全不同的东西）是最好的？我有预感第一个是正确的，但想听听其他人的意见。

my_dict = defaultdict(int)
for generic in iterable:
    my_dict[generic] +=1

或者：

my_dict = {}
for generic in iterable:
    if generic not in my_dict:
        my_dict[generic] = 1
    else:
        my_dict[generic]+=1

或者：

my_dict = {}
for generic in iterable:
    try:
        my_dict[generic] += 1
    except(KeyError):
        my_dict[generic] = 1

使用 my_dict = defaultdict(list) 和使用附加函数也可以这样说。假设使用多个 for 循环或其他条件，而不是简单地从单个可迭代中计算泛型值，因为这显然会具有不同的功能。

在以下数据中,我试图运行一个简单的马尔可夫模型.

假设我有一个具有以下结构的数据:

pos   M1  M2  M3  M4  M5  M6  M7  M8  hybrid_block    S1    S2    S3    S4  S5  S6  S7  S8
1     A   T   T   A   A   G   A   C       A|C         C     G     C     T    T   A   G   A
2     T   G   C   T   G   T   T   G       T|A         A     T     A     T    C   A   A   T
3     C   A   A   C   A   G   T   C       C|G         G     A     C     G    C   G   C   G
4     G   T   G   T   A …

以下代码使用 {} 运算符组合两个 defaultdict。

from collections import defaultdict
aa=defaultdict(str)
bb=defaultdict(str)
aa['foo']+= '1'
bb['bar']+= '2'
cc = {**aa,**bb}
type(cc)

但是，正如我们看到的，如果我们运行它，{}操作符返回一个dict类型而不是一个defaultdict类型。

有没有办法将dict返回到 defaultdict ？

在Python中，我想要类似的东西

dict = defaultdict((list,list))

本质上，对于每个键我都想要两个列表！

通过上面的代码片段，我得到错误第一个参数必须是可调用的。我怎样才能做到这一点？

我需要一个字典，它会自动填充每个缺失的访问键的默认值。我已经找到了defaultdict一些其他方法来实现此目的，但我的情况的问题是我希望每个键的默认值特定于键本身。

例如，defaultdict我可以实现这样的目标：

from collections import defaultdict
d = defaultdict(lambda: 5)
> d[1] = 3
> d[1]
> 3
> d[2]
> 5

但是，如果我需要每个访问的缺失键的默认值，该怎么办key + 5？就像是：

from collections import defaultdict
d = defaultdict(lambda key: key + 5)  # <-- This does not work as defaultdict expects lambda function to be without any parameters
> d[1] = 3
> d[1]
> 3
> d[2]
> 7         <- Calculated from accessed key + 5 (2+5)
> d[5] …