用相同的键排序的Python字典

Question

I thought this must already have been answered, but I couldn't find anything on Google or here.

I'm aware that, in general, you cannot rely on the ordering of a Python dictionary. However, if you have two dictionaries with identical keys, can you rely on the values being in the same order as well?

I ask because I'm trying to compare two dictionaries of floating point numbers, so I cannot use dict1==dict2 . My function looks something like this:

def _compare_dict(self, d1, d2):
    """
    Compares two dictionaries of floating point numbers
    for equality.
    """
    if d1.keys() != d2.keys():
        return False

    zipped = zip(d1.itervalues(), d2.itervalues())
    return len(filter(lambda x: abs(x[0] - x[1]) > sys.float_info.epsilon, zipped)) == 0

Is this a dangerous game to play? In one test, the order seemed to hold:

In [126]: d1={'a': 3, 'b': 2, 'c': 10}
In [127]: d2={'b': 10, 'c': 7, 'a': 2}

In [128]: d1
Out[128]: {'a': 3, 'b': 2, 'c': 10}

In [129]: d2
Out[129]: {'a': 2, 'b': 10, 'c': 7}

But I don't know if this is something I can count on. Other solutions for comparing two dictionaries of floating point numbers are welcome too, of course.

Answer 1

Depending on how the dictionaries were built, you can't rely on that.

some example:

>>> a = dict.fromkeys(range(1000))
>>> b = dict.fromkeys(range(500,600))
>>> for i in range(500):
    del a[i]

>>> for i in range(600,1000):
    del a[i]

>>> all(i==j for i,j in zip(a,b))
False
>>> a == b
True

a is a much bigger hash table because it has allocated space for 1000 objects while b can only hold about 100 without growing a little. So the way the hashes are stored can change the iteration order

Answer 2

def _compare_dict(self, d1, d2):
    """
    Compares two dictionaries of floating point numbers
    for equality.
    """
    if len(d1) != len(d2): # comparing `.keys()` is futile and slow
        return False
    try:
        return all(abs(d1[k] - d2[k]) < sys.float_info.epsilon for k in d1)
    except KeyError:
        return False

This still won't work for numbers smaller than -2 or greater then 2 because you are thinking about epsilon wrongly

Instead you need to choose a way to compare floats that makes sense. You can choose to use a fixed epsilon, but that will only work up to a point. floats can be very very big.

It's usually better to use a relative comparison than absolute

Answer 3

I'd recommend something like this:

def _compare_dict(self, d1, d2):
    if set(d1.keys()) != set(d2.keys()):
        return False

    for key in d1:
        if abs(d1[key]-d2[key]) > sys.float_info.epsilon:
            return False

    return True

It's easy to read and it will return False as soon as it notices two values that are not within sys.float_info.epsilon rather than comparing all the values.

Answer 4

dictionaries are not ordered, they cannot be ordered unless you use a frozen dict which exist in python 3.3

Now to compare keys you could convert the keys into a set:

a = {'a': 0, 'b': 1}
b = set(a)
c = set(a.keys())  # just another way to be clearer

b == c
True

or you could create a list and order it to compare them, I like more the set approach.