For Python as well as JSON, the order within a dict bears no meaning. Use lists instead of dicts if you mind.

If you only want to order the JSON output (that is, prefer {1:0, 2:0} over {2:0, 1:0}, even if they are equivalent), you can use the collections.OrderedDict which will remember the order the items were inserted.

Looks like you are trying to substitute dynamic values within a json file with their runtime counterparts. You can use PLACEHOLDER in this scenario. Construct your json using PLACEHOLDER values where you would like to substitute them with dynamic values.

For example:

{
    "services": [{
            "name": "service_a",
            "config": {
                "dynamic_value_1": "PLACEHOLDER",
                "dynamic_value_2": "PLACEHOLDER"
            }
        },
        {
            "name": "service_b",
            "config": {
                "dynamic_value_1": "PLACEHOLDER",
                "dynamic_value_2": "PLACEHOLDER"
            }
        }
    ]
}

You can then read the json file and perform an update by passing a dictionary of values you want to substitute.

def dynamic_values() -> Dict:
        """
        Provides a map of placeholder values with their dynamic counterparts
        """
        return {
            "service_a": {
                "dynamic_value_1": service_a_method_1(),
                "dynamic_value_2": service_a_method_2(),
            },
            "service_b": {
                "dynamic_value_1": service_b_method_1(),
                "dynamic_value_2": service_b_method_1(),
            },
        }


def load_dynamic_values(dynamic_values) -> List:
        """
        Overrides placeholder values in json file with dynamic values at runtime
        """
        with open(file_name, "r") as f:
            data = json.load(f)

        services = data["services"]
        for s in services:
            override = dynamic_values.get(s["name"], None)
            if override:
                s["config"].update(override)
        return services

If you are building these strings yourself or have control over them, have a different format be sent, or build the value as a dictionary and use json.dumps.

However, if you really need to do this, if it's guaranteed that the substitution values will be in the format {X}, then you can escape the string with this kludge:

import re
s = '{"key1":{0}, "key2":{1}}'
begin = re.compile(r'{(?!\d)')
end = re.compile(r'(?<!\d)}')
escaped = end.sub('}}', begin.sub('{{', s))
print(escaped.format(1, 2))

results in

{"key1":1, "key2":2}

Note that this is not the best solution. Considering you have control of the strings, you should be escaping them in some other way. Maybe use the % syntax instead of str.format?

As mentioned by Tudor in a comment to another answer, the Template class was the solution that worked best for me. I'm dealing with nested dictionaries or list of dictionaries and handling those were not as straightforward.

Using Template though the solution is quite simple.

I start with a dictionary that is converted into a string. I then replace all instances of { with ${ which is the Template identifier to substitute a placeholder.

The key point of getting this to work is using the Template method safe_substitute. It will replace all valid placeholders like ${user_id} but ignore any invalid ones that are part of the dictionary structure, like ${'name': 'John', ....

After the substitution is done I remove any leftovers $ and convert the string back to a dictionary.

In the code bellow, resolve_placeholders returns a dictionary where each key matches a placeholder in the payload string and the value is substituted by the Template class.

from string import Template
.
.
.
payload = json.dumps(payload)
payload = payload.replace('{', '${')
replace_values = self.resolve_placeholders(payload)
if replace_values:
    string_template = Template(payload)
    payload = string_template.safe_substitute(replace_values)
payload = payload.replace('${', '{')
payload = json.loads(payload)

I think for a true JSON object print, it's probably as good as it gets. timeit(number=10000) for the following took about 5.659214497s:

import json
d = {   
        'breakfast': [
            'spam', 'spam', 'eggs', 
            {
                'another': 'level', 
                'nested': [
                    {'a':'b'}, 
                    {'c':'d'}
                ]
            }
        ], 
        'foo': True,
        'bar': None
    }
s = json.dumps(d)
q = json.dumps(json.loads(s), indent=2)
print(q)

I tried with pprint, but it actually wouldn't print the pure JSON string unless it's converted to a Python dict, which loses your true, null and false etc valid JSON as mentioned in the other answer. As well it doesn't retain the order in which the items appeared, so it's not great if order is important for readability.

Just for fun I whipped up the following function:

def pretty_json_for_savages(j, indentor='  '):
    ind_lvl = 0
    temp = ''
    for i, c in enumerate(j):
        if c in '{[':
            print(indentor*ind_lvl + temp.strip() + c)
            ind_lvl += 1
            temp = ''
        elif c in '}]':
            print(indentor*ind_lvl + temp.strip() + '\n' + indentor*(ind_lvl-1) + c, end='')
            ind_lvl -= 1
            temp = ''
        elif c in ',':
            print(indentor*(0 if j[i-1] in '{}[]' else ind_lvl) + temp.strip() + c)
            temp = ''
        else:
            temp += c
    print('')

# {
#   "breakfast":[
#     "spam",
#     "spam",
#     "eggs",
#     {
#       "another": "level",
#       "nested":[
#         {
#           "a": "b"
#         },
#         {
#           "c": "d"
#         }        
#       ]      
#     }    
#   ],
#   "foo": true,
#   "bar": null
# }

It prints pretty alright, and unsurprisingly it took a whooping 16.701202023s to run in timeit(number=10000), which is 3 times as much as a json.dumps(json.loads()) would get you. It's probably not worthwhile to build your own function to achieve this unless you spend some time to optimize it, and with the lack of a builtin for the same, it's probably best you stick with your gun since your efforts will most likely give diminishing returns.