Skip to main content

How to Check If Keys Are Sorted in Python Dictionary

Dictionaries in Python (since version 3.7) maintain insertion order, but they do not automatically sort their keys. However, for tasks like generating reports, displaying configuration settings, or ensuring consistent JSON output, you often need to process keys in a specific (usually alphabetical) order.

This guide explains how to sort dictionary keys for iteration and how to programmatically verify if a dictionary's keys are already sorted.

Sorting Keys for Iteration​

While you cannot "sort" a dictionary in-place (because dictionaries are hash maps, not lists), you can extract the keys, sort them, and iterate over the dictionary in that specific order.

The sorted() function takes any iterable (like my_dict.keys()) and returns a new sorted list.

data = {"c": 3, "a": 1, "b": 2}

# ✅ Correct: Get a sorted list of keys
sorted_keys = sorted(data.keys())

print(f"Sorted Keys: {sorted_keys}")

# Iterate in alphabetical order
for key in sorted_keys:
    print(f"{key}: {data[key]}")

Output:

Sorted Keys: ['a', 'b', 'c']
a: 1
b: 2
c: 3

Comparing keys() vs. sorted()​

It is important to distinguish between the Dictionary View returned by .keys() and the List returned by sorted().

  • my_dict.keys(): A dynamic view object. It reflects changes to the dictionary immediately but is not indexable or sorted.
  • sorted(my_dict.keys()): A static list. It is a snapshot of the keys at that moment, sorted. It does not update if the dictionary changes.
my_dict = {"z": 10, "x": 5}

# 1. Get View and Snapshot
keys_view = my_dict.keys()
sorted_snapshot = sorted(my_dict.keys())

print(f"Before update - View: {list(keys_view)}")
print(f"Before update - Sorted: {sorted_snapshot}")

# 2. Modify Dictionary
my_dict["y"] = 7

# 3. Observe Differences
# The view sees 'y', the sorted list does not
print(f"After update  - View: {list(keys_view)}")
print(f"After update  - Sorted: {sorted_snapshot}")

Output:

Before update - View: ['z', 'x']
Before update - Sorted: ['x', 'z']
After update  - View: ['z', 'x', 'y']
After update  - Sorted: ['x', 'z']

Verifying Key Order Programmatically​

If you are writing tests or validation logic, you might need to check if a specific list of keys matches the sorted order of a dictionary. This is done using list comparison.

def are_keys_sorted(dictionary):
    """Checks if the dictionary's insertion order happens to be sorted."""
    current_keys = list(dictionary.keys())
    sorted_keys = sorted(dictionary.keys())
    return current_keys == sorted_keys

# Example 1: Insertion order matches sorted order
dict_sorted = {"a": 1, "b": 2, "c": 3}
print(f"Is dict_sorted ordered? {are_keys_sorted(dict_sorted)}")

# Example 2: Insertion order is NOT sorted
dict_unsorted = {"b": 2, "a": 1}
print(f"Is dict_unsorted ordered? {are_keys_sorted(dict_unsorted)}")

Output:

Is dict_sorted ordered? True
Is dict_unsorted ordered? False
note

Since Python 3.7+, list(dict.keys()) returns keys in insertion order. The function above checks if the user inserted keys in alphabetical order.

Conclusion​

To handle dictionary key sorting in Python:

  1. Use sorted(dict.keys()) to create a sorted list for ordered iteration.
  2. Understand keys(): It is a dynamic view into the dictionary, not a static list.
  3. Compare Lists: Use list(d.keys()) == sorted(d.keys()) to verify if the dictionary's current insertion order is sorted.

Table of Contents