相关疑难解决方法(0)

有没有办法defaultdict(defaultdict(int))让以下代码工作？

for x in stuff:
    d[x.a][x.b] += x.c_int

d需要根据x.a和x.b元素进行临时构建.

我可以用:

for x in stuff:
    d[x.a,x.b] += x.c_int

但后来我无法使用:

d.keys()
d[x.a].keys()

我有一个看起来像这样的defaultdict:

dict1 = defaultdict(lambda: defaultdict(int))

问题是,我不能用cPickle来腌制它.我在这里找到的解决方案之一是使用模块级函数而不是lambda.我的问题是,什么是模块级功能？如何在cPickle中使用字典？

在python中,您可以使用defaultdict(int)将int存储为值.如果您尝试对字典中不存在的键执行'get',则默认值为零.

你能在javascript/jquery中做同样的事吗？

我有以下mongoengine型号:

class MyModel(Document):
    date        = DateTimeField(required = True)
    data_dict_1 = DictField(required = False)
    data_dict_2 = DictField(required = True)

在某些情况下,DB中的文档可能非常大(大约5-10MB),而data_dict字段包含复杂的嵌套文档(dicts列表的字典等等).

我遇到过两个(可能是相关的)问题:

1. 当我运行本机pymongo find_one()查询时,它会在一秒钟内返回.当我运行MyModel.objects.first()时需要5-10秒.

2. 当我从数据库查询单个大型文档,然后访问其字段时,只需执行以下操作需要10-20秒:

   m = MyModel.objects.first()
   val = m.data_dict_1.get(some_key)
   

   Run Code Online (Sandbox Code Playgroud)

对象中的数据不包含对任何其他对象的任何引用,因此它不是取消引用的对象的问题.
我怀疑它与mongoengine的内部数据表示的某些低效率有关,这会影响文档对象的构造以及字段访问.我能做些什么来改善这个吗？

我有一个包含以下列的DataFrame,没有重复项:

['region', 'type', 'name', 'value']

可以看作层次结构如下

grouped = df.groupby(['region','type', 'name'])

我想将此层次结构序列化为JSON对象.

如果有人感兴趣,那么这背后的动机就是最终将这样一个需要JSON文件的可视化组合在一起.

为此,我需要转换grouped为以下内容:

new_data['children'][i]['name'] = region
new_data['children'][i]['children'][j]['name'] = type
new_data['children'][i]['children'][j]'children'][k]['name'] = name
new_data['children'][i]['children'][j]'children'][k]['size'] = value
...

其中region,type,name对应于不同的水平层次结构的(由索引i,j和k)

在Pandas/Python中有一种简单的方法可以做到这一点吗？

我有一个dicts列表,并希望设计一个函数来输出一个新的dict,其中包含列表中所有dicts的每个唯一键的总和.

对于列表:

[
    {
         'apples': 1,
         'oranges': 1,
         'grapes': 2
    },
    {
         'apples': 3,
         'oranges': 5,
         'grapes': 8
    },
    {
         'apples': 13,
         'oranges': 21,
         'grapes': 34
    }
]

到目前为止一切都很好,这可以通过一个计数器完成:

def sumDicts(listToProcess):
    c = Counter()
    for entry in listToProcess:
        c.update(entry)
    return (dict(c))

哪个正确返回:

{'apples': 17, 'grapes': 44, 'oranges': 27}

当我的列表中的dicts开始包含嵌套的dicts时出现问题:

[
    {
        'fruits': {
            'apples': 1,
            'oranges': 1,
            'grapes': 2
            },
        'vegetables': {
            'carrots': 6,
            'beans': 3,
            'peas': 2
        },
        'grains': 4,
        'meats': 1  
    },
    {
        'fruits': {
            'apples': 3,
            'oranges': …

我在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'})})

我有一个 4 列的 DataFrame

Subject_id    Subject         Time  Score    
Subject_1        Math          Day      1     
Subject_1        Math        Night      2                           
Subject_1       Music          Day      3
Subject_1       Music        Night      4
Subject_2        Math          Day      5       
Subject_2        Math        Night      6                              
Subject_2       Music          Day      7
Subject_2       Music        Night      8

我想对这些列进行分层分组并将它们转换为字典，如下所示：

result = {
    'Subject_1': {
        'Math': {
            'Day': 1,
            'Night': 2 
        },
        'Music': {
            'Day': 3,
            'Night': 4
        }
    }
    'Subject_2': {
        'Math': {
            'Day': 5,
            'Night': 6
        },
        'Music': {
            'Day': 7,
            'Night': 8
        }
    }
}

我设法 …

有一个python列表

[('schema1', 'table1', 'column_name1'), ('schema1', 'table1', 'column_name2'), ('schema1', 'table2', 'column_name3'), ('schema2', 'table3', 'column_name4')]

我需要将它转换为具有以下结构的python dict

schema1:
            table1:
                    (column_name1,
                    column_name2)
            table2:
                    (column_name3)
schema2:
            table3:
                    (column_name4)

有没有有效的转换方式？

我想创建一个字典，我可以在嵌套字典的深处分配一个值，而无需首先显式创建外层。这是我希望能够做到的：

d = {} # or whatever Python object works
d['a']['b']['c'] = 3

到目前为止，这是我尝试过的：

如果我有一本普通的字典，我可以像这样分配一个键：

d = {}
d['a'] = 1

但不是这样的：

d['a']['b'] = 2

但是，我可以使用 adefaultdict来做到这一点，如下所示：

from collections import defaultdict
dd = defaultdict(dict)
dd['a']['b'] = 2

但是，我仍然做不到深度嵌套的字典

from collections import defaultdict
dd = defaultdict(dict)
dd['a']['b']['c'] = 3

我知道我可以使用递归函数来做到这一点，但我希望有一种简单的方法来做到这一点。有没有？

编辑：

我也尝试过这个但没有成功：

from collections import defaultdict
dd = defaultdict(defaultdict)
dd['a']['b']['c'] = 3

我想从保存密钥的任意元组/列表创建一个空的嵌套字典.我试图找到一种在Python中执行此操作的简单方法.它看起来像集合defaultdict应该处理的东西,但我似乎无法搞清楚.

keys = ('a', 'b', 'c')

一本字典最终看起来像这样:

d = {
    'a': {
          'b': {
                'c': {}
               }
          }
     }

在搜索Python Doc之后，一个愚蠢的问题，对于defaultdict的构造函数，只有一个参数，即值的类型。有没有办法指定密钥类型？我读了一些示例，似乎没有人指定键的类型，而只是指定了值的类型。以及是否需要-有兴趣了解为什么defaultdict只需要指定值的类型。

预先感谢林