有序 dict 是否也按顺序返回键？

Question

For example:

my_dict = OrderedDict([('apple', 4), ('banana', 3), ('orange', 2), ('pear', 1)])

If an operation to get keys ie my_dict.keys() or my_dict.iterkeys() is done, is it guaranteed to return: ['apple','banana','orange','pear'] ?

This is not explicitly mentioned in the docs.

Answer 1

Yes, all iterations are guaranteed to use the same order.

If they didn't, that'd be a very big exception that would have to be explicitly documented. The documentation contains no such exceptions.

You can always check the implementation , explicitly linked from the top of the module documentation. You'll note that all method implementations use iteration over self , either directly or via iter(self) or list(self) ; all these are fed by the OrderedDict.__iter__ method, which produces keys in order:

def __iter__(self):
    'od.__iter__() <==> iter(od)'
    # Traverse the linked list in order.
    root = self.__root
    curr = root[1]                                  # start at the first node
    while curr is not root:
        yield curr[2]                               # yield the curr[KEY]
        curr = curr[1]                              # move to next node

For example, the OrderedDict.values() method uses those keys to map to values:

def values(self):
    'od.values() -> list of values in od'
    return [self[key] for key in self]

Answer 2

Yes, OrderedDict will return the keys in order. It is worth mentioning, however, that the keys views compare order insensitive which is somewhat surprising.

Here is the 2.7 reference python implementation of __iter__ , which both of .keys and .iterkeys methods will delegate to:

def __iter__(self):
    'od.__iter__() <==> iter(od)'
    # Traverse the linked list in order.
    root = self.__root
    curr = root[1]                                  # start at the first node
    while curr is not root:
        yield curr[2]                               # yield the curr[KEY]
        curr = curr[1]                              # move to next node

self.__root is just a list here.

Note: actual implementation is in C code.

Answer 3

Short answer: yes

Longer answer:

the implementation of the keys (and also the values) method is based upon the __iter__ method which "Traverse the linked list in order."

    def keys(self):
        return list(self)

    def values(self):
        return [self[key] for key in self]

You can check the source code linked in the documentation :