Question

我正在尝试将数组存储在多个密钥组中以生成分组摘要。我认为dict of dicts可能是一个解决方案。基于this回答，我试图写出一个dict的词典。这是代码

import numpy
from collections import defaultdict

s1 = numpy.array([[1L, 'B', 4],
       [1L, 'A', 3],
       [1L, 'B', 10],
       [1L, 'A', 0.0],
       [2L, 'A', 11],
       [2L, 'B', 13],
       [2L, 'B', 1],
       [2L, 'A', 6]], dtype=object)

def make_dict():
    return defaultdict(make_dict)

d = defaultdict(make_dict)

for x in s1:
    d[x[0]][x[1]] = x[2]

所以，d[1]['B']给出10，而我期待[4,10]。看起来d正在拿起最后一个组合。有没有办法追加适合特定组合键的所有值？我认为defaultdict应该照顾好这一点。我哪里错了？还有其他解决方案吗？我可以在pandas中轻松完成，我喜欢图书馆。但我要求一个非pandas解决方案。

更新问题得到解答（@ juanpa.arrivillaga），但看起来我的示例数据不合适。如果我们将以下数据作为数据怎么样？

s1 = numpy.array([
        [1L, 'B', 4,3],
        [1L, 'A', 3,5],
        [1L, 'B', 10,23],
        [2L, 'A', 11,1],
        [2L, 'B', 1,8],
        [2L, 'A', 6,23]
        ], dtype=object)

我们可能无法使用defaultdict(lambda:defaultdict(list))作为字典容器。如何扩展解决方案以包含和附加2D数组而不是列表。我希望d[1]['A']应该给我[[3,5],[11,1]]

Answer 1

如果您已经在使用numpy - 您真的不应该使用异构数据类型，那么您应该只使用pandas：

In [8]: data = [[1, 'B', 4],
   ...:        [1, 'A', 3],
   ...:        [1, 'B', 10],
   ...:        [1, 'A', 0.0],
   ...:        [2, 'A', 11],
   ...:        [2, 'B', 13],
   ...:        [2, 'B', 1],
   ...:        [2, 'A', 6]]
In [9]: import pandas as pd

In [10]: df = pd.DataFrame(data, columns=['c1','c2','c3'])

In [11]: df
Out[11]:
   c1 c2    c3
0   1  B   4.0
1   1  A   3.0
2   1  B  10.0
3   1  A   0.0
4   2  A  11.0
5   2  B  13.0
6   2  B   1.0
7   2  A   6.0

In [12]: df.groupby(['c1','c2']).describe()
Out[12]:
         c3
      count mean       std  min   25%  50%    75%   max
c1 c2
1  A    2.0  1.5  2.121320  0.0  0.75  1.5   2.25   3.0
   B    2.0  7.0  4.242641  4.0  5.50  7.0   8.50  10.0
2  A    2.0  8.5  3.535534  6.0  7.25  8.5   9.75  11.0
   B    2.0  7.0  8.485281  1.0  4.00  7.0  10.00  13.0

如果必须在没有pandas的情况下执行此操作：

In [13]: from collections import defaultdict

In [14]: grouper = defaultdict(lambda:defaultdict(list))

In [15]: for c1,c2,c3 in data:
    ...:     grouper[c1][c2].append(c3)
    ...:

In [16]: grouper
Out[16]:
defaultdict(<function __main__.<lambda>>,
            {1: defaultdict(list, {'A': [3, 0.0], 'B': [4, 10]}),
             2: defaultdict(list, {'A': [11, 6], 'B': [13, 1]})})
In [17]: grouper[1]['B']
Out[17]: [4, 10]

如果您总是要对前两列进行分组，请执行以下操作：

In [6]: grouper = defaultdict(lambda:defaultdict(list))

In [7]: for c1, c2, *rest in s1:
   ...:     grouper[c1][c2].append(rest)
   ...:

In [8]: grouper
Out[8]:
defaultdict(<function __main__.<lambda>>,
            {1: defaultdict(list, {'A': [[3, 5]], 'B': [[4, 3], [10, 23]]}),
             2: defaultdict(list, {'A': [[11, 1], [6, 23]], 'B': [[1, 8]]})})

In [9]: grouper[1]['A']
Out[9]: [[3, 5]]

In [10]: grouper[1]['B']
Out[10]: [[4, 3], [10, 23]]

In [11]: grouper[2]['B']
Out[11]: [[1, 8]]

In [12]: grouper[2]['A']
Out[12]: [[11, 1], [6, 23]]

对于Python 2，你必须稍微修改一下，因为它缺乏对可迭代解包的支持：

In [8]: for arr in s1:
   ...:     c1, c2 = arr[:2]
   ...:     rest = list(arr[2:])
   ...:     grouper[c1][c2].append(rest)
   ...:

In [9]: grouper
Out[9]:
defaultdict(<function __main__.<lambda>>,
            {1L: defaultdict(list, {'A': [[3, 5]], 'B': [[4, 3], [10, 23]]}),
             2L: defaultdict(list, {'A': [[11, 1], [6, 23]], 'B': [[1, 8]]})})

使用字典在多个密钥组中存储数据（数组）

1 个答案: