Processing dictionary keys in arbitrary order

Question

I want to transform dictionary into a string. What would be beginner-level question is complicated by few rules that I have to adhere to:

• There is a list of known keys that must come out in particular, arbitrary order
• Each of known keys is optional, i.e. it may not be present in dictionary
• It is guaranteed that at least one of known keys will be present in dictionary
• Dictionary may contain additional keys; they must come after known keys and their order is not important
• I cannot make assumptions about order in which keys will be added to dictionary

What is the pythonic way of processing some dictionary keys before others?

So far, I have following function:

def format_data(input_data):
    data = dict(input_data)
    output = []
    for key in ["title", "slug", "date", "modified", "category", "tags"]:
        if key in data:
            output.append("{}: {}".format(key.title(), data[key]))
            del data[key]

    if data:
        for key in data:
            output.append("{}: {}".format(key.title(), data[key]))

    return "\n".join(output)

data = {
    "tags": "one, two", 
    "slug": "post-title",
    "date": "2017-02-01",
    "title": "Post Title",
}

print(format_data(data))

data = {
    "format": "book",
    "title": "Another Post Title",
    "date": "2017-02-01",
    "slug": "another-post-title",
    "custom": "data",
}

print(format_data(data))

Title: Post Title
Slug: post-title
Date: 2017-02-01
Tags: one, two

Title: Another Post Title
Slug: another-post-title
Date: 2017-02-01
Custom: data
Format: book

While this function does provide expected results, it has some issues that makes me think there might be better approach. Namely, output.append() line is duplicated and input data structure is copied to allow it's modification without side-effects.

To sum up, how can I process some keys in particular order and before other keys?

Answer 1

I suggest that you simply run a pair of list comprehensions: one for the desired keys, and one for the rest. Concatenate them in the desired order in bulk, rather than one at a time. This reduces the critical step to a single command to build output.

The first comprehension looks for desired keys in the dict; the second looks for any dict keys not in the "desired" list.

def format_data(input_data):
    data = dict(input_data)
    key_list = ["title", "slug", "date", "modified", "category", "tags"]
    output = ["{}: {}".format(key.title(), data[key]) for key in key_list if key in data] + \
             ["{}: {}".format(key.title(), data[key]) for key in data if key not in key_list]
    return "\n".join(output)

Answer 2

To completely edit, the below will take a list of primary keys (you can pass them in if you want or set it in a config file) and then it will set those in the beginning of your dictionary.

I think I see what you mean now:

Try this:

from collections import OrderedDict
data = {'aaa': 'bbbb',
 'custom': 'data',
 'date': '2017-02-01',
 'foo': 'bar',
 'format': 'book',
 'slug': 'another-post-title',
 'title': 'Another Post Title'}

def format_data(input_data):
    primary_keys = ["title", "slug", "date", "modified", "category", "tags"]
    data = OrderedDict((k, input_data.get(k)) for k in primary_keys + input_data.keys())
    output = []
    for key, value in data.items():
        if value:
            output.append("{}: {}".format(key.title(), value))
    return "\n".join(output)

print(format_data(data))

Title: Another Post Title
Slug: another-post-title
Date: 2017-02-01
Aaa: bbbb
Format: book
Custom: data
Foo: bar

Answer 3

I'd suggest list comprehensions and pop():

def format_data(input_data):
    data = dict(input_data)

    keys = ["title", "slug", "date", "modified", "category", "tags"]
    output = ['{}: {}'.format(key.title(), data.pop(key)) for key in keys if key in data]

    output.extend(['{}: {}'.format(key.title(), val) for key, val in data.items()])

    return "\n".join(output)

To the concern about deleting during iteration - note that the iteration is over the list of keys, not the dictionary being evaluated, so I wouldn't consider that a red flag.

Answer 4

Find the difference between the known keys and the keys in the input dictionary; Use itertools.chain to iterate over both sets of keys; catch KeyErrors for missing keys and just pass. No need to copy the input and no duplication.

import itertools
def format_data(input_data):
    known_keys = ["title", "slug", "date", "modified", "category", "tags"]
    xtra_keys = set(input_data.keys()).difference(known_keys)
    output = []
    for key in itertools.chain(known_keys, xtra_keys):
        try:
            output.append("{}: {}".format(key.title(), data[key]))
        except KeyError as e:
            pass
    return '\n'.join(output)

data = {"tags": "one, two",
        "slug": "post-title",
        "date": "2017-02-01",
        "title": "Post Title",
        "foo": "bar"}

>>> print format_data(data)
Title: Post Title
Slug: post-title
Date: 2017-02-01
Tags: one, two
Foo: bar
>>>