Question

我有以下字典：

dict = {'A': [1,1,2], 'B': [1,1,1], 'C': [2,2,2,1,2]}

我希望输出告诉我每个键有多少个值，例如：

if value == 1  -> A, 2; B,3; C,1
if value == 2   -> A, 1; B,0; C,4

到目前为止，我有：

for i in dict[i]:
    if i == 1:
        participants_luck += 1
    elif i == 2:
        participants_skill += 1

Answer 1

这是一种灵活的解决方案，可以计算字典中每个不同值的出现

dict = {"A": [1,1,2], "B": [1,1,1], "C": [2,2,2,1,2]}
different_values = set()

for values in dict.values():
    for el in values:
        different_values.add(el)

for possible_value in different_values:
    print(possible_value)
    for key, values in dict.items():
        print(key, sum(value == possible_value for value in values))
    print("\n")

输出：

1
A 2
B 3
C 1


2
A 1
B 0
C 4

更新：如果您要还处理字典中的非列表项，则可以这样：

from collections.abc import Iterable

dict = {"A": [1,1,2], "B": [1,1,1], "C": [2,2,2,1,2], "D": 1}
different_values = set()

for values in dict.values():
    if isinstance(values, Iterable):
        for el in values:
                different_values.add(el)
    else:
        different_values.add(values)


for possible_value in different_values:
    print(possible_value)
    for key, values in dict.items():
        if isinstance(values, Iterable):
            print(key, sum(value == possible_value for value in values))
        else:
            print(key, int(values == possible_value))
    print("\n")

输出将是：

1
A 2
B 3
C 1
D 1


2
A 1
B 0
C 4
D 0

Answer 2

定义一个函数，以便在需要时可以搜索不同的值。使用count方法使事情变得很轻松。

d = {'A': [1,1,2], 'B': [1,1,1], 'C': [2,2,2,1,2]}

def foo(value, dictionary):
    for key,l in dictionary.items():
        print(f"{key} : {l.count(value)}")

foo(1,d)
foo(2,d)

Answer 3

创建一个函数来做会很有趣。

def count_stuff(any_dict, wanted_val):
    counted_dict = {}
    for key in any_dict.keys():
        count = 0
        for element in any_dict[key]:
            count += (element == wanted_val)
        counted_dict[key] = count
    
    return counted_dict

运行示例...

your_dict = {"A": [1,1,2], "B": [1,1,1], "C": [2,2,2,1,2]}
for i in [1, 2]:
    print(i, count_stuff(your_dict, i))

打印

1 {'A': 2, 'B': 3, 'C': 1}
2 {'A': 1, 'B': 0, 'C': 4}

Answer 4

这是单线！您可以编写字典理解。我们有一个字典mydict和一个value要计数。我们首先遍历字典中的项目。对于字典中的每个列表，我们遍历该列表，并找到i == value的总和。由于True计为1，而False计为0，因此sum(i == value for i in lst)将在i中给出等于lst的{{1}}数。或者，您可以执行value。当您要计算除lst.count(value)之外的其他条件时，例如，如果您要计算多少个元素小于给定值，则使用sum(...)技术很有用。

==

然后您可以像这样访问计数：

def count(mydict, value):
    return {k: sum(i == value for i in lst) for k, lst in mydict.items()}
    # Or, 
    # return {k: lst.count(value) for k, lst in mydict.items()}

d = {'A': [1,1,2], 'B': [1,1,1], 'C': [2,2,2,1,2]}
count(d, 1) # out: {'A': 2, 'B': 3, 'C': 1}
count(d, 2) # out: {'A': 1, 'B': 0, 'C': 4}

或者，如果您不想对result = count(d, 1) print(f"A: {result['A']}, B: {result['B']}, C: {result['C']}")的键进行硬编码：

result

Answer 5

您可以使用计数器：

from collections import Counter
cnts={k: Counter(v) for k,v in di.items()}

# {'A': Counter({1: 2, 2: 1}), 'B': Counter({1: 3}), 'C': Counter({2: 4, 1: 1})}

然后只需使用一种理解即可根据需要获取子计数：

>>> {k:v[1] for k,v in cnts.items()}
{'A': 2, 'B': 3, 'C': 1}
>>> ({k:v[2] for k,v in cnts.items()}
{'A': 1, 'B': 0, 'C': 4}

如何计算包含列表的字典中每个键的每个唯一值？

5 个答案: