You can't use == on the dict.values() dictionary view objects, as that specific type doesn't act like a set. Instead values_view_foo == values_view_bar is only ever true if both refer to the same dictionary view object. The contents don't matter.
It'll depend entirely on the types of values that the dictionary contains on what techniques can be used here. The following options will cover many different types of values, but not all. It is not really possible to make a generic one-size-fits-all comparison function for all possible types of values in a dictionary.
In this specific case, you can turn your values views into sets, because the values happen to both be unique and hashable:
def compare_dict_values(dv1, dv2):
"""Compare two dictionary values views
Values are assumed to be unique and hashable
"""
return set(dv1) == set(dv2)
Where the values are not unique, and / or not hashable, you'll have to find another way to compare the values.
If they are, say, sortable (orderable), then you could compare them by first sorting the values:
def compare_dict_values(dv1, dv2):
"""Compare two dictionary value views
Values are assumed to be orderable, but do not need to be unique
or hashable.
"""
return len(dv1) == len(dv2) and sorted(dv1) == sorted(dv2)
By sorting you remove the issue with the values view being unordered. The len() check is there because it is much cheaper than sorting and so let’s you avoid the sort when it is not necessary.
If the values are hashable but not unique (and so the values collection ('foo', 'bar', 'foo') is different from ('foo', 'bar', 'bar')), you can use Counter() objects to capture both the values and their counts:
from collections import Counter
def compare_dict_values(dv1, dv2):
"""Compare two dictionary value views
Values are assumed to be hashable, but do not need to be unique.
"""
return Counter(dv1) == Counter(dv2)
Note: Each of these techniques assume that the individual values in the dictionary support equality testing and you only need them to be exactly equal. For floating point values, you can run into issues where the values are almost equal, but not exactly equal. If your values need to be close and not just exactly equal, you can use the math.isclose() function on each pair of values. Use zip(sorted(dv1), sorted(dv2)) to pair up the values:
def float_dict_values_close(dv1, dv2, **kwargs):
"""Compare two dictionary view objects with floats
Returns true if the values in both dictionary views are
*close* in value.
"""
if len(dv1) != len(dv2):
return False
v1, v2 = sorted(dv1), sorted(dv2)
return all(is_close(*vs, **kwargs) for vs in zip(v1, v2))
Things get more complicated if your values can be different types; you generally can't sort a dictionary values view with a mix of different types in it. If you have a mix of types where not all the types are hashable, you'd have to separate out the different types first and then use a mixture of techniques to compare the values of the same type. This gets complicated when you have a hierarchy of types where subclasses can be compared with superclasses, etc. I'm declaring that as outside the scope of this answer.
