Skip to content
CodeMDD.io | Coding Tutorials

Effortlessly Implement OrderedDict in Python

[

OrderedDict vs dict in Python: The Right Tool for the Job

Sometimes you need a Python dictionary that remembers the order of its items. In the past, you had only one tool for solving this specific problem: Python’s OrderedDict. It’s a dictionary subclass specially designed to remember the order of items, which is defined by the insertion order of keys.

This changed in Python 3.6. The built-in dict class now keeps its items ordered as well. Because of that, many in the Python community now wonder if OrderedDict is still useful. A closer look at OrderedDict will uncover that this class still provides valuable features.

Choosing Between OrderedDict and dict

For years, Python dictionaries were unordered data structures. Python developers were used to this fact, and they relied on lists or other sequences when they needed to keep their data in order. With time, developers found a need for a new type of dictionary, one that would keep its items ordered.

Back in 2008, PEP 372 introduced the idea of adding a new dictionary class to collections. Its main goal was to remember the order of items as defined by the order in which keys were inserted. That was the origin of OrderedDict.

Core Python developers wanted to fill in the gap and provide a dictionary that could preserve the order of inserted keys. That, in turn, allowed for a more straightforward implementation of certain algorithms that require a consistent order of elements.

However, with the introduction of Python 3.6, the built-in dict class now keeps its items ordered. This change was implemented as an implementation detail, but it has been widely adopted since then. This has led some developers to question the need for OrderedDict in modern Python development.

When choosing between OrderedDict and dict, consider the following factors:

Use Cases:

  • If you need to keep track of the order in which items were inserted, regardless of other operations such as deletion, use OrderedDict.
  • If you need a simple, unordered dictionary, use dict.

Performance:

  • OrderedDict is slower than dict due to the additional bookkeeping it requires to maintain order. Consider the size of your data and the specific requirements of your application when deciding between the two.

Compatibility:

  • If you need to support Python versions prior to 3.6, you will need to use OrderedDict, as the built-in dict class does not preserve order in earlier versions.

Getting Started With Python’s OrderedDict

To start using OrderedDict in your code, you first need to import it from the collections module:

from collections import OrderedDict

Creating OrderedDict Objects

You can create an OrderedDict in several ways. One common way is to pass a list of key-value pairs as arguments to the constructor:

# Creating an OrderedDict using a list of key-value pairs
ordered_dict = OrderedDict([('one', 1), ('two', 2), ('three', 3)])
print(ordered_dict)

Output:

OrderedDict([('one', 1), ('two', 2), ('three', 3)])

Here, the order of items in the OrderedDict is based on the order in which the key-value pairs were passed.

Managing Items in an OrderedDict

You can add, remove, and modify items in an OrderedDict using the same methods as a regular dictionary:

# Adding items to an OrderedDict
ordered_dict['four'] = 4
ordered_dict['five'] = 5


# Modifying an item in an OrderedDict
ordered_dict['two'] = 22


# Removing an item from an OrderedDict
del ordered_dict['three']

Iterating Over an OrderedDict

When you iterate over an OrderedDict, the order of items will be the same as the order in which they were inserted:

# Iterating over an OrderedDict
for key, value in ordered_dict.items():
    print(key, value)

Output:

one 1
two 22
four 4
five 5

Iterating in Reversed Order With reversed()

You can also iterate over an OrderedDict in reversed order using the reversed() function:

# Iterating over an OrderedDict in reversed order
for key, value in reversed(ordered_dict.items()):
    print(key, value)

Output:

five 5
four 4
two 22
one 1

Exploring Unique Features of Python’s OrderedDict

In addition to preserving the order of items, OrderedDict provides some unique features that are not available in regular dictionaries.

Reordering Items With .move_to_end()

The OrderedDict class provides a method called .move_to_end() that allows you to move an existing item to either end of the OrderedDict:

# Moving an item to the end of an OrderedDict
ordered_dict.move_to_end('two')

By default, .move_to_end() moves the item to the end of the OrderedDict. You can also specify “last=False” to move the item to the beginning of the OrderedDict:

# Moving an item to the beginning of an OrderedDict
ordered_dict.move_to_end('two', last=False)

Removing Items With .popitem()

The OrderedDict class also provides the .popitem() method, which removes and returns the last inserted item by default:

# Removing and returning the last item from an OrderedDict
key, value = ordered_dict.popitem()
print(key, value)

Output:

five 5

You can also specify “last=False” to remove and return the first inserted item:

# Removing and returning the first item from an OrderedDict
key, value = ordered_dict.popitem(last=False)
print(key, value)

Output:

one 1

Testing for Equality Between Dictionaries

With regular dictionaries, testing for equality only compares the contents of the dictionaries. However, with OrderedDict, testing for equality also takes into account the order of items:

# Testing for equality between OrderedDicts
ordered_dict1 = OrderedDict([('one', 1), ('two', 2)])
ordered_dict2 = OrderedDict([('two', 2), ('one', 1)])


print(ordered_dict1 == ordered_dict2)  # Output: False


ordered_dict3 = OrderedDict([('one', 1), ('two', 2)])


print(ordered_dict1 == ordered_dict3)  # Output: True

In this example, ordered_dict1 and ordered_dict2 have the same key-value pairs, but in different orders, so they are considered not equal. However, ordered_dict1 and ordered_dict3 have the same key-value pairs in the same order, so they are considered equal.

Appending New Attributes to a Dictionary Instance

While this feature is also available in regular dictionaries, it is worth mentioning that you can append new attributes to an OrderedDict instance:

# Appending new attributes to an OrderedDict instance
ordered_dict.new_attribute = 'value'
print(ordered_dict.new_attribute)

Output:

value

Merging and Updating Dictionaries With Operators

Both OrderedDict and dict classes support merging and updating dictionaries using the ”+” and ”+=” operators:

# Merging dictionaries using the "+" operator
dict1 = {'one': 1, 'two': 2}
dict2 = {'three': 3, 'four': 4}
merged_dict = dict1 + dict2
print(merged_dict)

Output:

{'one': 1, 'two': 2, 'three': 3, 'four': 4}
# Updating a dictionary using the "+=" operator
dict1 = {'one': 1, 'two': 2}
dict2 = {'three': 3, 'four': 4}
dict1 += dict2
print(dict1)

Output:

{'one': 1, 'two': 2, 'three': 3, 'four': 4}

Considering Performance

When it comes to performance, there is a trade-off between using OrderedDict and dict. OrderedDict provides the additional functionality of preserving insertion order but requires more memory and has slower performance compared to dict.

The performance difference becomes more noticeable when working with large amounts of data. Therefore, it is important to consider the specific requirements of your application and the size of your data when deciding between OrderedDict and dict.

If preserving the order of items is not a requirement for your application, using the built-in dict class will generally provide better performance.

Selecting the Right Dictionary for the Job

In conclusion, both OrderedDict and dict have their own strengths and use cases. When choosing between the two, consider the specific requirements of your application, including the need for item ordering and performance considerations.

If you need to preserve the order of inserted items and are working with Python versions prior to 3.6, OrderedDict is still a valuable tool. However, if item order is not relevant, or you are using Python 3.6 or later, the built-in dict class should be sufficient.

Building a Dictionary-Based Queue

As an example of using OrderedDict in a practical scenario, let’s see how you can implement a dictionary-based queue using OrderedDict. This implementation would be more challenging if you used a regular dict object.

from collections import OrderedDict


class Queue:
    def __init__(self, size):
        self.size = size
        self.queue = OrderedDict()


    def enqueue(self, item):
        if len(self.queue) >= self.size:
            self.queue.popitem(last=False)
        self.queue[item] = None


    def dequeue(self):
        if self.queue:
            return self.queue.popitem(last=False)[0]


    def __str__(self):
        return ', '.join(self.queue.keys())


# Example usage
queue = Queue(3)
queue.enqueue("item1")
queue.enqueue("item2")
queue.enqueue("item3")
queue.enqueue("item4")  # This will remove the first inserted item ("item1")
print(queue)  # Output: item2, item3, item4
queue.dequeue()  # This will remove the first item ("item2")
print(queue)  # Output: item3, item4

In this example, the Queue class uses an OrderedDict to store the items. The enqueue method adds items to the queue, while limiting the size to a specified maximum. When the size limit is reached, the first inserted item is automatically removed. The dequeue method removes and returns the first item in the queue.

Conclusion

In this tutorial, you’ve learned about the differences between OrderedDict and dict in Python. Although the built-in dict class now keeps its items ordered as well, OrderedDict still provides valuable features and can be useful in certain scenarios.

When choosing between OrderedDict and dict, consider the specific requirements of your application, including the need for item ordering and performance considerations.

With this knowledge, you can confidently choose the right dictionary class for the job and utilize the features provided by OrderedDict to efficiently work with ordered data structures in Python.