Example
Let's look at a more detailed example to see how OrderedDict works. We'll create an OrderedDict, add some items to it, and then access and modify the items.
Python
from collections import OrderedDict
# Create an OrderedDict with some initial items
od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
# Access items by key
print(od['a'])
# Modify an item's value
od['b'] = 20
print(od)
# Add a new item
od['d'] = 4
print(od)
# Remove an item
del od['c']
print(od)
# Check if a key exists
print('a' in od)
print('c' in od)
You can also try this code with Online Python Compiler
Output
1
OrderedDict([('a', 1), ('b', 20), ('c', 3)])
OrderedDict([('a', 1), ('b', 20), ('c', 3), ('d', 4)])
OrderedDict([('a', 1), ('b', 20), ('d', 4)])
True
False
In this example, we created an OrderedDict with some initial items. We accessed an item by its key, modified an item's value, added a new item, and removed an item. We also checked if certain keys existed in the OrderedDict.
Note: The output shows that the order of the items is maintained throughout these operations. This is the main advantage of using an OrderedDict over a regular dictionary.
Python Dictionary Ordered
In Python 3.6 and later versions, the built-in dict class has been updated to remember the insertion order of items, making it similar to OrderedDict. However, this behavior is considered an implementation detail and should not be relied upon for older versions of Python or for compatibility with other Python implementations.
Let’s look at an example showing how a regular dictionary maintains the insertion order in Python 3.6+:
Python
# Create a regular dictionary in Python 3.6+
regular_dict = {'a': 1, 'b': 2, 'c': 3}
# Add a new item
regular_dict['d'] = 4
print(regular_dict)
# The order is preserved
for key, value in regular_dict.items():
print(key, value)
You can also try this code with Online Python Compiler
Output
{'a': 1, 'b': 2, 'c': 3, 'd': 4}
a 1
b 2
c 3
d 4
Although regular dictionaries now maintain the insertion order, it's still a good practice to use OrderedDict when the order of items is important for your algorithm or application. This ensures that your code will work correctly across different Python versions and implementations.
Key Value Change
One of the essential features of OrderedDict is that it allows you to change the value associated with a key without affecting the order of the items. When you modify the value of an existing key, the position of the key-value pair remains unchanged in the OrderedDict.
For example :
Python
from collections import OrderedDict
# Create an OrderedDict
od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
print(od)
# Change the value of an existing key
od['b'] = 20
print(od)
You can also try this code with Online Python Compiler
Output
OrderedDict([('a', 1), ('b', 2), ('c', 3)])
OrderedDict([('a', 1), ('b', 20), ('c', 3)])
In this example, we create an OrderedDict with three key-value pairs. We then change the value associated with the key 'b' from 2 to 20. After modifying the value, we print the OrderedDict again, and we can see that the order of the key-value pairs remains the same, with only the value of 'b' updated.
This behavior is different from how regular dictionaries work in versions of Python prior to 3.6. In those versions, modifying the value of a key in a regular dictionary could potentially change the order of the items.
Deletion & Re-Inserting
When you delete an item from an OrderedDict and then re-insert it, the item is added back at the end of the OrderedDict, not at its original position. This is because the order of items in an OrderedDict is determined by the insertion order, and deleting an item removes it from the sequence.
For example :
Python
from collections import OrderedDict
# Create an OrderedDict
od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
print(od)
# Delete an item
del od['b']
print(od)
# Re-insert the deleted item
od['b'] = 2
print(od)
You can also try this code with Online Python Compiler
Output
OrderedDict([('a', 1), ('b', 2), ('c', 3)])
OrderedDict([('a', 1), ('c', 3)])
OrderedDict([('a', 1), ('c', 3), ('b', 2)])
In this example, we start with an OrderedDict containing three key-value pairs. We delete the item with the key 'b' using the del keyword. After deletion, the OrderedDict maintains the order of the remaining items: 'a' and 'c'.
When we re-insert the key-value pair ('b', 2) into the OrderedDict, it is added at the end of the sequence, not at its original position between 'a' and 'c'. The final order of the items becomes ('a', 1), ('c', 3), ('b', 2).
Equality Comparison
When comparing two OrderedDicts for equality, both the key-value pairs and their order are taken into account. Two OrderedDicts are considered equal if they have the same key-value pairs in the same order.
For example :
Python
from collections import OrderedDict
# Create two OrderedDicts with the same key-value pairs and order
od1 = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
od2 = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
print(od1 == od2)
# Create two OrderedDicts with the same key-value pairs but different order
od3 = OrderedDict([('a', 1), ('c', 3), ('b', 2)])
print(od1 == od3)
# Create two OrderedDicts with different key-value pairs
od4 = OrderedDict([('a', 1), ('b', 2), ('d', 4)])
print(od1 == od4)
You can also try this code with Online Python Compiler
Output
True
False
False
In this example, we create four OrderedDicts:
- `od1` & `od2` have the same key-value pairs in the same order.
- `od3` has the same key-value pairs as `od1` but in a different order.
- `od4` has different key-value pairs compared to `od1`.
When we compare `od1` & `od2` using the equality operator (`==`), the result is `True` because they have the same key-value pairs in the same order.
However, when we compare `od1` & `od3`, the result is `False` because although they have the same key-value pairs, the order of the items is different.
Similarly, comparing `od1` & `od4` returns `False` because they have different key-value pairs.
Note: This behavior differs from regular dictionaries, where the order of key-value pairs doesn't matter for equality comparisons.
OrderedDict Reversal
You can reverse the order of items in an OrderedDict using the `reversed()` function. This function returns a new iterator that yields the key-value pairs of the OrderedDict in reverse order.
For example :
Python
from collections import OrderedDict
# Create an OrderedDict
od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
print(od)
# Reverse the order of items
reversed_od = OrderedDict(reversed(od.items()))
print(reversed_od)
You can also try this code with Online Python Compiler
Output
OrderedDict([('a', 1), ('b', 2), ('c', 3)])
OrderedDict([('c', 3), ('b', 2), ('a', 1)])
In this example, we create an OrderedDict `od` with three key-value pairs in the order ('a', 1), ('b', 2), ('c', 3).
To reverse the order of items, we use the `reversed()` function in combination with the `items()` method of the OrderedDict. The `items()` method returns a list-like object containing the key-value pairs of the OrderedDict. We pass this object to `reversed()`, which returns an iterator yielding the key-value pairs in reverse order.
Finally, we create a new OrderedDict `reversed_od` using the reversed iterator. The resulting OrderedDict contains the key-value pairs in the reverse order: ('c', 3), ('b', 2), ('a', 1).
Note: This technique is useful when you need to process or display the items of an OrderedDict in reverse order without modifying the original OrderedDict.
OrderedDict Popitem Last
The `popitem()` method of an OrderedDict allows you to remove and return the last key-value pair from the OrderedDict. This method is useful when you want to remove items from the end of the OrderedDict in a last-in, first-out (LIFO) order.
For example :
Python
from collections import OrderedDict
# Create an OrderedDict
od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
print(od)
# Remove and return the last key-value pair
last_item = od.popitem(last=True)
print(last_item)
print(od)
# Remove and return the new last key-value pair
last_item = od.popitem(last=True)
print(last_item)
print(od)
You can also try this code with Online Python Compiler
Output
OrderedDict([('a', 1), ('b', 2), ('c', 3)])
('c', 3)
OrderedDict([('a', 1), ('b', 2)])
('b', 2)
OrderedDict([('a', 1)])
In this example, we create an OrderedDict `od` with three key-value pairs: ('a', 1), ('b', 2), ('c', 3).
We use the `popitem()` method with the `last=True` parameter to remove and return the last key-value pair from the OrderedDict. In the first call to `popitem()`, the last key-value pair ('c', 3) is removed and returned. The OrderedDict `od` now contains the remaining key-value pairs: ('a', 1) and ('b', 2).
We call `popitem()` again with `last=True`, which removes and returns the new last key-value pair ('b', 2). The OrderedDict `od` is now left with only one key-value pair: ('a', 1).
Note: The `popitem()` method with `last=True` is useful when you need to process or remove items from the end of an OrderedDict in a specific order.
Key Insertion at Arbitrary Position:
In an OrderedDict, you can insert a key-value pair at a specific position using the `move_to_end()` method. This method allows you to move an existing key to either the beginning or the end of the OrderedDict.
For example :
Python
from collections import OrderedDict
# Create an OrderedDict
od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
print(od)
# Move a key to the end
od.move_to_end('a')
print(od)
# Move a key to the beginning
od.move_to_end('c', last=False)
print(od)
You can also try this code with Online Python Compiler
Output:
OrderedDict([('b', 2), ('c', 3), ('a', 1)])
OrderedDict([('c', 3), ('b', 2), ('a', 1)])
OrderedDict([('a', 1), ('b', 2), ('c', 3)])
In this example, we create an OrderedDict `od` with three key-value pairs: ('a', 1), ('b', 2), and ('c', 3).
To move a key to the end of the OrderedDict, we use the `move_to_end()` method and specify the key we want to move. In the first call to `move_to_end('a')`, the key 'a' is moved to the end of the OrderedDict, resulting in the order: ('b', 2), ('c', 3), ('a', 1).
To move a key to the beginning of the OrderedDict, we use the `move_to_end()` method with the `last=False` parameter. In the second call to `move_to_end('c', last=False)`, the key 'c' is moved to the beginning of the OrderedDict, resulting in the order: ('c', 3), ('b', 2), ('a', 1).
Collections Module
The `OrderedDict` class is part of the `collections` module in Python. The `collections` module provides a number of specialized container datatypes that can be used as alternatives to the built-in containers like `dict`, `list`, and `tuple`.
For example :
1. `defaultdict`
A dictionary subclass that provides a default value for missing keys.
Python
from collections import defaultdict
# Create a defaultdict with a default value of 0
dd = defaultdict(int)
# Access a missing key
print(dd['a'])
You can also try this code with Online Python Compiler
Output
0
2. `Counter`
A dictionary subclass for counting hashable objects.
Python
from collections import Counter
# Create a Counter object
c = Counter(['a', 'b', 'a', 'c', 'b', 'a'])
# Print the count of each element
print(c)
You can also try this code with Online Python Compiler
Output
Counter({'a': 3, 'b': 2, 'c': 1})
3. `deque`
A double-ended queue that allows efficient insertion and deletion at both ends.
Python
from collections import deque
# Create a deque
d = deque([1, 2, 3])
# Append elements to the right
d.append(4)
# Append elements to the left
d.appendleft(0)
print(d)
You can also try this code with Online Python Compiler
Output
deque([0, 1, 2, 3, 4])
These are just a few examples of the useful classes available in the `collections` module. Each of these classes provides specialized functionality and can be used in specific scenarios to simplify and optimize your code.
Note: The `OrderedDict` class, is a valuable tool when you need to maintain the order of key-value pairs in a dictionary. It combines the features of a dictionary with the ability to remember the insertion order of items.
Frequently Asked Questions
Can I use an OrderedDict as a drop-in replacement for a regular dictionary?
Yes, an OrderedDict can be used as a replacement for a regular dictionary in most cases, as it provides all the functionality of a regular dictionary while also maintaining the order of key-value pairs.
Is the order of items in an OrderedDict guaranteed to be the same across different Python versions?
Yes, the order of items in an OrderedDict is guaranteed to be consistent across different Python versions and implementations, making it a reliable choice when the order of key-value pairs matters.
Can I sort an OrderedDict based on its keys or values?
To sort an OrderedDict, you need to create a new sorted dictionary using the sorted() function with a custom key function. You can sort based on keys using sorted(od.items()) or based on values using sorted(od.items(), key=lambda x: x[1]).
Conclusion
In this article, we've learned about OrderedDict, a special type of dictionary in Python that remembers the order in which key-value pairs are inserted. We've seen how to create an OrderedDict, modify its items, compare OrderedDicts for equality, reverse the order of items, remove items using popitem(), & insert items at arbitrary positions using move_to_end(). We've also explained the collections module & some of its useful classes.
27+ registered 
