What is OrderedDict in Python?

Introduction

Key-value pairs can be stored in dictionaries, which are reliable data structures. Ordinary dictionaries, however, did not preserve the order of items as they were introduced before to version 3.7. This is the use case for OrderedDict. A dictionary subclass called OrderedDict keeps track of the order in which keys are added. This article will go into great detail on OrderedDict, including its features, applications, and differences from standard dictionaries.

Overview

• Recognize the concept behind and function of Python’s OrderedDict.
• Acquire the understanding needed to create and work with OrderedDict objects.
• Check the main characteristics that set OrderedDict apart from conventional dictionaries.
• Analyse useful applications of OrderedDict in real-world contexts.
• In Python 3.7+, compare OrderedDict with normal dictionaries.

What is OrderedDict?

An ordered dictionary is provided in the collections module via the OrderedDict class. It keeps the elements in the order that they were originally put. This can be especially helpful if your application’s elemental order is important.

Let’s start with a basic example:

from collections import OrderedDict

# Creating an OrderedDict
od = OrderedDict()
od['apple'] = 1
od['banana'] = 2
od['cherry'] = 3
print(od)

Output:

OrderedDict([('apple', 1), ('banana', 2), ('cherry', 3)])

Creating an OrderedDict

There are multiple ways to create an OrderedDict:

from collections import OrderedDict
# Method 1: Creating an empty OrderedDict and adding items
od1 = OrderedDict()
od1['a'] = 1
od1['b'] = 2

# Method 2: Creating from a list of tuples
od2 = OrderedDict([('x', 10), ('y', 20), ('z', 30)])

# Method 3: Creating from another dictionary
regular_dict = {'p': 100, 'q': 200, 'r': 300}
od3 = OrderedDict(regular_dict)

print("od1:", od1)
print("od2:", od2)
print("od3:", od3)

Output:

#od1: OrderedDict([('a', 1), ('b', 2)])
#od2: OrderedDict([('x', 10), ('y', 20), ('z', 30)])
#od3: OrderedDict([('p', 100), ('q', 200), ('r', 300)])

Key Features of OrderedDict

Let us now explore key features of OrderedDict with example.

Maintaining Insertion Order

The most significant feature of OrderedDict is its ability to maintain the order of insertion.

od = OrderedDict()
od['first'] = 1
od['second'] = 2
od['third'] = 3

for key, value in od.items():
    print(f"{key}: {value}")

Output: 

#first: 1
#second: 2
#third: 3

Reordering

OrderedDict provides methods to move items to the beginning or end of the dictionary.

od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
print("Original:", od)

# Move 'c' to the beginning
od.move_to_end('c', last=False)
print("After moving 'c' to the beginning:", od)

# Move 'a' to the end
od.move_to_end('a')
print("After moving 'a' to the end:", od)

Output :

#Original: OrderedDict([('a', 1), ('b', 2), ('c', 3)])
#After moving 'c' to the beginning: OrderedDict([('c', 3), ('a', 1), ('b', 2)])
#After moving 'a' to the end: OrderedDict([('c', 3), ('b', 2), ('a', 1)])

Equality Comparison

OrderedDict considers the order when comparing for equality.

od1 = OrderedDict([('a', 1), ('b', 2)])
od2 = OrderedDict([('b', 2), ('a', 1)])
regular_dict1 = {'a': 1, 'b': 2}
regular_dict2 = {'b': 2, 'a': 1}

print("od1 == od2:", od1 == od2)
print("regular_dict1 == regular_dict2:", regular_dict1 == regular_dict2)

Output : 

#od1 == od2: False
#regular_dict1 == regular_dict2: True

Use Cases for OrderedDict

Let us now explore use cases of OrderedDict.

LRU (Least Recently Used) Cache

OrderedDict is perfect for implementing an LRU cache.

from collections import OrderedDict

class LRUCache:
    def __init__(self, capacity):
        self.cache = OrderedDict()
        self.capacity = capacity

    def get(self, key):
        if key not in self.cache:
            return -1
        self.cache.move_to_end(key)
        return self.cache[key]

    def put(self, key, value):
        if key in self.cache:
            self.cache.move_to_end(key)
        self.cache[key] = value
        if len(self.cache) > self.capacity:
            self.cache.popitem(last=False)

# Usage
lru = LRUCache(3)
lru.put(1, 1)
lru.put(2, 2)
lru.put(3, 3)
print(lru.cache)
lru.put(4, 4)  # This will remove the least recently used item (1)
print(lru.cache)

Output:

#OrderedDict([(1, 1), (2, 2), (3, 3)])
#OrderedDict([(2, 2), (3, 3), (4, 4)])

Maintaining Order in JSON

When working with JSON data where order matters, OrderedDict can be useful.

import json
from collections import OrderedDict

data = OrderedDict([
    ("name", "John Doe"),
    ("age", 30),
    ("city", "New York")
])

json_str = json.dumps(data)
print("JSON string:", json_str)

# Parsing back to OrderedDict
parsed_data = json.loads(json_str, object_pairs_hook=OrderedDict)
print("Parsed data:", parsed_data)

Output:

#JSON string: {"name": "John Doe", "age": 30, "city": "New York"}

#Parsed data: OrderedDict([('name', 'John Doe'), ('age', 30), ('city', 'New York')])

OrderedDict vs. Regular Dict ( 3.7+)

Since  3.7, regular dictionaries also maintain insertion order. However, there are still some differences:

# Regular dict in  3.7+
regular_dict = {}
regular_dict['a'] = 1
regular_dict['b'] = 2
regular_dict['c'] = 3

# OrderedDict
from collections import OrderedDict
od = OrderedDict()
od['a'] = 1
od['b'] = 2
od['c'] = 3

print("Regular dict:", regular_dict)
print("OrderedDict:", od)

# Equality comparison
print("regular_dict == od:", regular_dict == od)
print("type(regular_dict) == type(od):", type(regular_dict) == type(od))

Output:

Regular dict: {‘a’: 1, ‘b’: 2, ‘c’: 3}
OrderedDict: OrderedDict([(‘a’, 1), (‘b’, 2), (‘c’, 3)])
regular_dict == od: True
type(regular_dict) == type(od): False

While both maintain order, OrderedDict provides additional methods like `move_to_end()` and considers order in equality comparisons.

Conclusion

One effective tool for keeping dictionary items in their correct order is OrderedDict. Even if standard dictionaries in 3.7+ also keep things organised, OrderedDict still has special capabilities that come in handy sometimes. You may write more effective and organised code by knowing when and how to utilise OrderedDict, particularly when working with order-sensitive data or constructing specialised data structures like LRU caches.

Frequently Asked Questions

Shikha Sen

With 4 years of experience in model development and deployment, I excel in optimizing machine learning operations. I specialize in containerization with Docker and Kubernetes, enhancing inference through techniques like quantization and pruning. I am proficient in scalable model deployment, leveraging monitoring tools such as Prometheus, Grafana, and the ELK stack for performance tracking and anomaly detection.

My skills include setting up robust data pipelines using Apache Airflow and ensuring data quality with stringent validation checks. I am experienced in establishing CI/CD pipelines with Jenkins and GitHub Actions, and I manage model versioning using MLflow and DVC.

Committed to data security and compliance, I ensure adherence to regulations like GDPR and CCPA. My expertise extends to performance tuning, optimizing hardware utilization for GPUs and TPUs. I actively engage with the LLMOps community, staying abreast of the latest advancements to continually improve large language model deployments. My goal is to drive operational efficiency and scalability in AI systems.