python - 使用字典存储多个键组中的数据(数组)

Question

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

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.arrivilillaga)，但看起来我的示例数据不足。如果我们有以下数据怎么样？

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))作为字典容器。如何扩展解决方案以包含和附加二维数组而不是列表。我希望 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]]})})