Python 如何删除字典多元组中的重复项？

我需要关于如何删除字典元组中重复项的帮助

dict of {tuple of (str, str, str, str): int}) -> tuple of (str, None)

这是字典：

   {('ALPHA', 'BETA', 'GAMMA', 'DELTA'): 5
    ('BETA', 'GAMMA', 'ALPHA', 'DELTA'): 3
    ('DELTA', 'BETA', 'GAMMA', 'ALPHA'): 1
    ('GAMMA', 'DELTA', 'ALPHA', 'BETA'): 3
    ('BETA', 'ALPHA', 'DELTA', 'GAMMA'): 4}

整数是

元组的第一个索引的值，因此我可以通过以下方式对它们进行分组：

def rad_type(particle):

   my_dict = {}

   for (k, v) in particle.items():
        if (k[0] in my_dict):
            my_dict[k[0]] += v
        else:
            my_dict[k[0]] = v

   return my_dict

这将返回：

{'ALPHA': 5, 'BETA': 7, 'GAMMA': 3, 'DELTA': 1}

因为
'DELTA'
的值最小，在本例中为1，但我想删除如下元素：

   {('ALPHA', 'BETA', 'GAMMA'): 5
    ('BETA', 'GAMMA', 'ALPHA'): 7
    ('BETA', 'GAMMA', 'ALPHA'): 1
    ('GAMMA', 'ALPHA', 'BETA'): 3}

这使得α=5，β=8，γ=3；这就是我真正需要的词典

dict of {tuple of (str, str, str, str): int}) -> tuple of (str, None)

我试图移除最小的元素，但它不起作用

for (p, v) in my_dict.items():
        if (max(my_dict.values()) / sum(my_dict.values()):
            if (v == min(my_dict.values())):
                del my_dict[p]
        return my_dict

但这给出了
ALPHA=5，BETA=7，GAMMA=3

既然这返回了一个字典，那么我如何使用
元组删除重复项，并将其作为字典返回，而不导入任何内容

问题类似于。
您将需要某种类型的
计数器。我已经使用集合.Collections.Counter实现了一个解决方案，但如果不能直接导入计数器，则必须自己实现。或者，
Collections.Counter
是纯python，您可以将
Counter
的源代码复制到您自己的解决方案中，以避免导入它

def display_results(data):
    ''' Displays the sum of the first entries in a tuple in a given dictionary

    >>> display_results(data)
    ... {'ALPHA': 5, 'BETA': 7, 'GAMMA': 3, 'DELTA': 1}'''

    data = Counter(data)
    count = Counter()
    for i in data:
        count[i[0]] += data[i]
    return count

def process_data(data):
    ''' Generates a new Counter object with the contents of data, minus the least common
    object in the first tuple as defined by display_results().

    >>> data = process_data(data)
    >>> display_results(data)
    {'ALPHA' : 5, 'BETA' : 7, 'GAMMA' : 3} '''

    data = Counter(data)
    count = Counter()
    least_common = display_results(data).most_common()[-1][0]
    for i in data:
        j = list(i)
        j.remove(least_common)
        count[tuple(j)] += data[i]
    return count

您需要某种类型的计数器。我已经使用集合.Collections.Counter实现了一个解决方案，但如果不能直接导入计数器，则必须自己实现。或者，
Collections.Counter
是纯python，您可以将
Counter
的源代码复制到您自己的解决方案中，以避免导入它

def display_results(data):
    ''' Displays the sum of the first entries in a tuple in a given dictionary

    >>> display_results(data)
    ... {'ALPHA': 5, 'BETA': 7, 'GAMMA': 3, 'DELTA': 1}'''

    data = Counter(data)
    count = Counter()
    for i in data:
        count[i[0]] += data[i]
    return count

def process_data(data):
    ''' Generates a new Counter object with the contents of data, minus the least common
    object in the first tuple as defined by display_results().

    >>> data = process_data(data)
    >>> display_results(data)
    {'ALPHA' : 5, 'BETA' : 7, 'GAMMA' : 3} '''

    data = Counter(data)
    count = Counter()
    least_common = display_results(data).most_common()[-1][0]
    for i in data:
        j = list(i)
        j.remove(least_common)
        count[tuple(j)] += data[i]
    return count

这里有一个建议。

如果我们使用您的功能：

def rad_type(particle):

   my_dict = {}

   for (k, v) in particle.items():
        if (k[0] in my_dict):
            my_dict[k[0]] += v
        else:
            my_dict[k[0]] = v

   return my_dict  

如果我们定义了另一个使用您的函数的函数：

def filter(dict):
        filter1 = rad_type(dict)
        i = 0
        for k ,val in dict.items():
              dict[k] = filter1[k[0]]
              i +=1
        mini_key = [k for k , val in filter1.items() if val == min([value for key ,  value in filter1.items()])][0] 
        filter2 = {tuple(y for y in key if y != mini_key):value for key, value in dict.items()}
        filter3 = rad_type(filter2)
        return filter3  

如果我们对字典粒子应用此函数：

result = filter(particle)  

输出为：

{'ALPHA': 5, 'BETA': 8, 'GAMMA': 3}

这里有一个建议。

如果我们使用您的功能：

def rad_type(particle):

   my_dict = {}

   for (k, v) in particle.items():
        if (k[0] in my_dict):
            my_dict[k[0]] += v
        else:
            my_dict[k[0]] = v

   return my_dict  

如果我们定义了另一个使用您的函数的函数：

def filter(dict):
        filter1 = rad_type(dict)
        i = 0
        for k ,val in dict.items():
              dict[k] = filter1[k[0]]
              i +=1
        mini_key = [k for k , val in filter1.items() if val == min([value for key ,  value in filter1.items()])][0] 
        filter2 = {tuple(y for y in key if y != mini_key):value for key, value in dict.items()}
        filter3 = rad_type(filter2)
        return filter3  

如果我们对字典粒子应用此函数：

result = filter(particle)  

输出为：

{'ALPHA': 5, 'BETA': 8, 'GAMMA': 3}

粘贴中的“return”语句有误：它们位于“for”循环中。我的错误，复制和粘贴代码时出现缩进打字错误您的第二个代码块不会运行，如果我修复了语法错误，也不会给出您所说的答案。还不清楚您如何获得每组结果，例如，您为什么期望
BETA=8
？dict中的值是否在更改？它们是如何变化的？请发布一个完整的工作示例，我们可以运行该示例，以及预期的输出。我预期“BETA=8”，因为我想将元组的第一个索引与值相加。我不想直接从字典中删除最小的元素，而是想知道如何通过创建一个新的元组来删除最小的元素。我的想法是要实现“Condorcet投票”。这与[link]相似，粘贴中的“return”语句被误入：它们位于“for”循环中。我的错误，复制和粘贴代码时出现缩进打字错误。您的第二个代码块不会运行，如果我修复了语法错误，也不会给出您所说的答案。还不清楚您如何获得每组结果，例如，您为什么期望
BETA=8
？dict中的值是否在更改？它们是如何变化的？请发布一个完整的工作示例，我们可以运行该示例，以及预期的输出。我预期“BETA=8”，因为我想将元组的第一个索引与值相加。我不想直接从字典中删除最小的元素，而是想知道如何通过创建一个新的元组来删除最小的元素。我的想法是要实现“Condorcet投票”。与[link]类似，有没有不使用“filter”的方法？这里filter只是一个名称，您可以用任何其他名称替换它（例如helper），您可以尝试复制代码，然后用helper替换每个筛选器，它会给相同的输出提供一种不使用“filter”的方法？这里filter只是一个名称，您可以用任何其他名称替换它（例如helper），您可以尝试复制代码，然后用helper替换每个过滤器，它将给出相同的输出