Question

我有一个嵌套字典，例如;

dictionary =  {'cat_1' : {'age' : 5, 'height' : 15}, 'cat_2' :  {'age' : 1, 'height' : 7}, 'dog_1' : {'age' : 13, 'height' : 20}, 'dog_2' :  {'age' : 9, 'height' : 18}}

我想通过对外部id键进行分组（使用类似key.split('_')[0]的内容）来查找每种动物的内部词典键的平均值。

Answer 1

这个怎么样，它使用Pandas

import pandas as pd

df = pd.DataFrame.from_records(dictionary)

        cat_1  cat_2  dog_1  dog_2
age         5      1     13      9
height     15      7     20     18

df = df.T.reset_index()

   index  age  height
0  cat_1    5      15
1  cat_2    1       7
2  dog_1   13      20
3  dog_2    9      18

df['index'] = [elem.split('_',1)[0] for elem in df['index']]

  index  age  height
0   cat    5      15
1   cat    1       7
2   dog   13      20
3   dog    9      18

df.groupby('index').mean().T

index   cat  dog
age       3   11
height   11   19

如果输出需要是字典，那么：

df.groupby('index').mean().T.to_dict()

{'cat': {'age': 3, 'height': 11}, 'dog': {'age': 11, 'height': 19}}

Answer 2

您可以使用sum()模块中的groupby和itertools执行此类操作：

from itertools import groupby

a = {'cat_1' : {'age' : 5, 'height' : 15}, 'cat_2' :  {'age' : 1, 'height' : 7}, 'dog_1' : {'age' : 13, 'height' : 20}, 'dog_2' :  {'age' : 9, 'height' : 18}}

animals, final = {}, {}

for k,v in groupby(sorted(a.items(), key=lambda x:x[0].split('_')[0]), lambda x: x[0].split('_')[0]):
    animals[k] = [j for _, j in list(v)]


for k in animals:
    final[k] = {"height": sum(j["height"] for j in animals[k])/len(animals[k]),
    "age": sum(j["age"] for j in animals[k])/len(animals[k])}

print(final)

输出：

{'cat': {'height': 11.0, 'age': 3.0}, 'dog': {'height': 19.0, 'age': 11.0}}

Answer 3

可能会这样：

dictionary =  {'cat_1' : {'age' : 5, 'height' : 15}, 'cat_2' :  {'age' : 1, 'height' : 7}, 'dog_1' : {'age' : 13, 'height' : 20}, 'dog_2' :  {'age' : 9, 'height' : 18}}

cats = dict((k, v) for k, v in dictionary.items() if k.startswith("cat"))

cat_count = len(cats)
cat_average_ages = sum([cats[k]["age"] for k in cats]) / cat_count
cat_average_heights = sum([cats[k]["height"] for k in cats]) / cat_count

你可以只为狗复制它或创建一个返回平均值的函数，具体取决于你有多少种不同的动物：

def find_average_values(animals_dict, animal_name="cat"):
    animals = dict((k, v) for k, v in dictionary.items() if k.startswith(animal_name))

    animal_count = len(animals)
    animal_average_ages = sum([animals[k]["age"] for k in animals]) / animal_count
    animal_average_heights = sum([animals[k]["height"] for k in animals]) / animal_count

    return {"age": animal_average_ages, "height": animal_average_heights}

dog_averages = find_average_values(dictionary, "dog")

Answer 4

使用itertools.groupby和collections.defaultdict的另一个答案。具有额外的好处，不需要知道你的内部字典键。

from itertools import groupby
from collections import defaultdict

d =  {'cat_1' : {'age' : 5, 'height' : 15}, 'cat_2' :  {'age' : 1, 'height' : 7}, 'dog_1' : {'age' : 13, 'height' : 20}, 'dog_2' :  {'age' : 9, 'height' : 18}}
res = defaultdict(lambda : defaultdict(int))

# Group inner dicts by key
for k, g in groupby(d.items(), lambda t: t[0].split('_')[0]):
    for _, inner in g:
        # total the values
        for key, value in inner.items():
            res[k][key] += value

    # for each key average by the length of the dict
    res[k] = { _k : _v / len(inner) for _k, _v in res[k].items() }

Answer 5

另一个不需要您手动指定密钥的选项是：

"$(ARCHS_STANDARD_32_64_BIT)"

在对外键进行分组后查找内部字典键的平均值

5 个答案: