Python dict vs OrderedDict: When Order Still Matters

Why This Comparison Still Exists

Since Python 3.7, the language specification guarantees that a regular dict preserves insertion order. For most code, that removes the original reason to reach for OrderedDict: reliable ordering. The python dict vs ordereddict question now comes down to a narrower set of behaviors — order-sensitive equality, reordering methods, and memory overhead — rather than a question of whether order is preserved at all.

What a Regular dict Guarantees Today

A regular dict iterates in insertion order. Reassigning an existing key does not change its position; deleting a key and re-adding it moves that key to the end.

d = {"a": 1, "b": 2}
d["a"] = 10   # position unchanged
d["c"] = 3    # appended at the end
del d["b"]
d["b"] = 20   # now at the end
print(list(d))  # ['a', 'c', 'b']

This behavior is now part of the Python language specification, so it holds across CPython, PyPy, and other conforming implementations. Code written against this guarantee is safe on any Python 3.7+ interpreter.

What OrderedDict Adds Beyond Ordering

OrderedDict is a subclass of dict that keeps the same insertion-order guarantee and adds reordering and equality features that plain dict does not have.

The most commonly used extra method is move_to_end:

from collections import OrderedDict

od = OrderedDict([("a", 1), ("b", 2), ("c", 3)])
od.move_to_end("a")
print(list(od))  # ['b', 'c', 'a']
od.move_to_end("a", last=False)
print(list(od))  # ['a', 'b', 'c']

popitem also accepts a last argument, so you can remove either end of the mapping. A plain dict's popitem() removes the last inserted item, and there is no documented way to remove from the front.

OrderedDict also supports reversed() directly, which returns an iterator over keys in reverse insertion order.

Order-Sensitive Equality Is the Real Difference

This is the behavior that most often decides the choice. Two plain dicts are equal when they contain the same key-value pairs, regardless of insertion order. Two OrderedDict instances are equal only when they have the same pairs in the same order.

d1 = {"a": 1, "b": 2}
d2 = {"b": 2, "a": 1}
print(d1 == d2)  # True

from collections import OrderedDict
od1 = OrderedDict([("a", 1), ("b", 2)])
od2 = OrderedDict([("b", 2), ("a", 1)])
print(od1 == od2)  # False

If your code relies on order-sensitive equality — for example, when comparing configuration snapshots or request payloads where sequence matters — a plain dict will silently ignore the order difference. OrderedDict makes the order part of the comparison contract.

Performance and Memory Tradeoffs

OrderedDict maintains an additional doubly linked list of keys to support reordering operations in CPython. That bookkeeping costs extra memory per entry and adds overhead to insertion and deletion compared to a plain dict. The exact difference depends on the Python implementation and the size of the mapping, so the practical guidance is qualitative: use a plain dict when you only need insertion-order iteration, and use OrderedDict only when you need its reordering or equality semantics.

For long-lived mappings that are iterated frequently but never reordered, a plain dict is the lighter choice. For mappings that are repeatedly reordered with move_to_end, the convenience of OrderedDict usually outweighs the small per-operation cost.

Choosing Between dict and OrderedDict

Use a plain dict when:

• you only need insertion-order iteration
• you never compare mappings for order-sensitive equality
• you never need to move keys or pop from the front

Use OrderedDict when:

• equality must consider key order
• you need move_to_end or front-popping behavior
• you want reversed() over keys as a documented, portable operation

A common pattern is an LRU-style cache where move_to_end refreshes recently used entries. OrderedDict implements that pattern directly; a plain dict would require deleting and re-inserting keys, which changes their position but also makes the intent less explicit.

Compatibility Notes

If you support Python 2.7 or Python 3.5, a plain dict does not guarantee insertion order, so OrderedDict remains the only portable choice for ordered mappings. On Python 3.7 and later, the order guarantee is part of the language spec, but OrderedDict's extra methods and equality behavior remain unchanged. Code that relies on those features will keep working across versions, so migrating away from OrderedDict is only worth doing when you are certain none of the extra semantics are needed.