摘要：然而對于它為什么要這樣實現我還不是很清楚，留待以后繼續探究。這里是我在上關于這個問題的提問。

在看 collections.OrderedDict 的源碼時，對于它如何構造有序的結構這一部分不是很理解，代碼如下:

class OrderedDict(dict):
    "Dictionary that remembers insertion order"
    # An inherited dict maps keys to values.
    # The inherited dict provides __getitem__, __len__, __contains__, and get.
    # The remaining methods are order-aware.
    # Big-O running times for all methods are the same as regular dictionaries.

    # The internal self.__map dict maps keys to links in a doubly linked list.
    # The circular doubly linked list starts and ends with a sentinel element.
    # The sentinel element never gets deleted (this simplifies the algorithm).
    # Each link is stored as a list of length three:  [PREV, NEXT, KEY].

    def __init__(*args, **kwds):
        """Initialize an ordered dictionary.  The signature is the same as
        regular dictionaries, but keyword arguments are not recommended because
        their insertion order is arbitrary.

        """
        if not args:
            raise TypeError("descriptor "__init__" of "OrderedDict" object "
                            "needs an argument")
        self = args[0]
        args = args[1:]
        if len(args) > 1:
            raise TypeError("expected at most 1 arguments, got %d" % len(args))
        try:
            self.__root
        except AttributeError:
            self.__root = root = []                     # sentinel node
            root[:] = [root, root, None]
            self.__map = {}
        self.__update(*args, **kwds)

    def __setitem__(self, key, value, dict_setitem=dict.__setitem__):
        "od.__setitem__(i, y) <==> od[i]=y"
        # Setting a new item creates a new link at the end of the linked list,
        # and the inherited dictionary is updated with the new key/value pair.
        if key not in self:
            root = self.__root
            last = root[0]
            last[1] = root[0] = self.__map[key] = [last, root, key]
        return dict_setitem(self, key, value)

    def __delitem__(self, key, dict_delitem=dict.__delitem__):
        "od.__delitem__(y) <==> del od[y]"
        # Deleting an existing item uses self.__map to find the link which gets
        # removed by updating the links in the predecessor and successor nodes.
        dict_delitem(self, key)
        link_prev, link_next, _ = self.__map.pop(key)
        link_prev[1] = link_next                        # update link_prev[NEXT]
        link_next[0] = link_prev                        # update link_next[PREV]

    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

    def __reversed__(self):
        "od.__reversed__() <==> reversed(od)"
        # Traverse the linked list in reverse order.
        root = self.__root
        curr = root[0]                                  # start at the last node
        while curr is not root:
            yield curr[2]                               # yield the curr[KEY]
            curr = curr[0]                              # move to previous node

    def clear(self):
        "od.clear() -> None.  Remove all items from od."
        root = self.__root
        root[:] = [root, root, None]
        self.__map.clear()
        dict.clear(self)

主要是對于初始化里和set方法里的做法不清楚, wtf doing here…:

            self.__root = root = []                     # sentinel node
            root[:] = [root, root, None]
            self.__map = {}
# 和
            root = self.__root
            last = root[0]
            last[1] = root[0] = self.__map[key] = [last, root, key]

后來在網上提問并且自己查詢了相關資料后明白這是個帶哨兵的雙向鏈表的實現，關于雙向鏈表的知識自己補了下，可以參見這里 和 這里。

然而對于它為什么要這樣實現我還不是很清楚，留待以后繼續探究。

這里 是我在v2ex上關于這個問題的提問。