检查字典的所有值是否相等 - 当值未知时

我有 2 字典：
每个字典中的值

应该

等于。

但

我不知道这个号码中的内容是什么......


dict1 = {'xx':A, 'yy':A, 'zz':A}

dict2 = {'xx':B, 'yy':B, 'zz':B}


N.B.

A 不平等 B

N.B.

和 A, 和 B 事实上是十进制数的字符串 /例如， '-2.304998'/, 由于它们是从文本文件中提取的

我想创建一个有效地总结此数据的另一种字典，但仅当每个字典中的所有值都是相同的。

它是。


summary = {}

if dict1['xx'] == dict1['yy'] == dict1['zz']:

 summary['s'] = dict1['xx']

if dict2['xx'] == dict2['yy'] == dict2['zz']:

 summary['hf'] = dict2['xx']


在一条线上有一种简洁的方式吗？

我知道你可以使用理解创建字典

summary = {k:v for /k,v/ in zip/iterable1, iterable2/}


但我与底层斗争 for loop, 所以和s。 if statement...

我会感激一些技巧。

我见过
https://coderoad.ru/35253971/
, 但所有答案似乎都依赖于可验证价值已经知道的内容。 /也就是说，字典中的所有条目都等于众所周知的数字。/ - 如果我不错过一些东西。
2021-03-21 添加评论
分享

没有找到相关结果

    已邀请:

    莫问

    赞同来自: 

    set

    S是一种可靠的方式来到这里，但仅适用于高尔夫球目标。这是一个可以处理没有哈希值的版本。 dict:


    expected_value = next/iter/dict1.values//// # check for an empty dictionary first if that's possible
    
all_equal = all/value == expected_value for value in dict1.values///



    all

    由于不一致而结束，但集合构造函数非常优化，以便我不说它在没有实际测试数据上进行分析的情况。 处理不可忽略的值是此版本的主要优势。
    2021-03-21 0 0
    分享

    涵秋

    赞同来自:

    这样做的一种方法是使用
    set

    . 你知道吗
    set

    迭代有一个长度 1, 如果其中只有一个值：


    if len/set/dct.values//// == 1:
    
 summary[k] = next/iter/dct.values////


    当然，这仅适用于您的字典值是哈希。
    2021-03-21 0 0
    分享

    窦买办

    赞同来自:

    虽然我们可以使用
    set

    为此，当输入数据很大时，它具有许多缺陷。 它可以采用与输入信号的大小成比例的存储器，并且即使在早期发现两个不同的值，也始终扫描整个输入信号。 此外，必须哈希输入数据。

    对于3个关键的迪克斯，它并不重要，但对于较大，而不是使用
    set

    , 我们可以用
    https://docs.python.org/3/libr ... oupby
    看看他是否创建了几组：


    import itertools
    

    
groups = itertools.groupby/dict1.values///
    

    
# Consume one group if there is one, then see if there's another.
    
next/groups, None/
    
if next/groups, None/ is None:
    
 # All values are equal.
    
 do_something//
    
else:
    
 # Unequal values detected.
    
 do_something_else//
    2021-03-21 0 0
    分享

    莫问

    赞同来自:

    除了可读性之外，所有与集合关联的答案 .values. 他们都是

    总是

    O/N/ 在时间和记忆中。 在实践中，这可能更快，尽管取决于值分布。

    此外，自从 set 使用散列操作，您还可以对您的时间成本具有速度大的常量倍数。 当你需要的一切时，你的价值观应该是Hashier。

    理论上

    从字典中获取第一个值，并在剩余值中查找不等于的剩余值中的第一个示例。

    放

    可能比下面的解决方案更快，因为他的工作可以减少到 C 执行。


    def all_values_equal/d/:
    
 if len/d/<=1: return True # Treat len0 len1 as all equal
    
 i = d.itervalues//
    
 firstval = i.next//
    
 try:
    
 # Incrementally generate all values not equal to firstval
    
 # .next raises StopIteration if empty.
    
 /j for j in i if j!=firstval/.next//
    
 return False
    
 except StopIteration:
    
 return True
    

    
print all_values_equal/{1:0, 2:1, 3:0, 4:0, 5:0}/ # False
    
print all_values_equal/{1:0, 2:0, 3:0, 4:0, 5:0}/ # True
    
print all_values_equal/{1:"A", 2:"B", 3:"A", 4:"A", 5:"A"}/ # False
    
print all_values_equal/{1:"A", 2:"A", 3:"A", 4:"A", 5:"A"}/ # True


    在上面的情况下：


    /j for j in i if j!=firstval/


    相当于：


    def gen_neq/i, val/:
    
 """
    
 Give me the values of iterator i that are not equal to val
    
 """
    
 for j in i:
    
 if j!=val:
    
 yield j
    2021-03-21 0 0
    分享

    董宝中

    赞同来自:

    我发现这个决定我发现了很多关于这里找到的另一个解决方案：
    https://coderoad.ru/42880043/

    user_min = {'test':1,'test2':2}
    
all/value == list/user_min.values///[0] for value in user_min.values///
    

    
>>> user_min = {'test':1,'test2':2}
    
>>> all/value == list/user_min.values///[0] for value in user_min.values///
    
False
    
>>> user_min = {'test':2,'test2':2}
    
>>> all/value == list/user_min.values///[0] for value in user_min.values///
    
True
    
>>> user_min = {'test':'A','test2':'B'}
    
>>> all/value == list/user_min.values///[0] for value in user_min.values///
    
False
    
>>> user_min = {'test':'A','test2':'A'}
    
>>> all/value == list/user_min.values///[0] for value in user_min.values///
    
True


    适合小词典，但我不确定大词典，因为我们得到了所有的值来选择第一个
    2021-03-21 0 0
    分享
    为什么被折叠? 0 个回复被折叠

    要回复问题请先登录或注册

    Copyright © 2023, All Rights Reserved