You can check whether Aux is available in JSON dictionary, if not, you can add it:

try:
    json_file = ('record.json')
    with open(json_file,'r+') as data_file:    
        data = json.load(data_file)
        if 'Aux' not in data:
          data['Movies']['Action']['Aux'] = {"director": "MR J", "Producer": "Mr K"}

except Exception, e:
    print e

I had the same issue just the other day. I wound up just searching through the entire object and accounted for both lists and dicts. The following snippets allows you to search for the first occurrence of a multiple keys.

import json

def deep_search(needles, haystack):
    found = {}
    if type(needles) != type([]):
        needles = [needles]

    if type(haystack) == type(dict()):
        for needle in needles:
            if needle in haystack.keys():
                found[needle] = haystack[needle]
            elif len(haystack.keys()) > 0:
                for key in haystack.keys():
                    result = deep_search(needle, haystack[key])
                    if result:
                        for k, v in result.items():
                            found[k] = v
    elif type(haystack) == type([]):
        for node in haystack:
            result = deep_search(needles, node)
            if result:
                for k, v in result.items():
                    found[k] = v
    return found

deep_search(["P1", "P3"], json.loads(json_string))

It returns a dict with the keys being the keys searched for. Haystack is expected to be a Python object already, so you have to do json.loads before passing it to deep_search.

Any comments for optimization are welcomed!

What do to with json ? Well, the same thing as with XML : parse it.

=> http://docs.python.org/2/library/json.html

when you try to use a for loop on a dict, without any special consideration, you get only the keys out of the dict. That is:

>>> my_dict = {'foo': 'bar', 'baz':'quux'}
>>> list(my_dict)
['foo', 'baz']
>>> for x in my_dict:
...     print repr(x)    
'foo'
'baz'

The most usual thing to do is to use dict.iteritems() (just dict.items() in python 3)

>>> for x in my_dict.iteritems():
...     print repr(x)
('foo', 'bar')
('baz', 'quux')

Or you can fetch the value for the key yourself:

>>> for x in my_dict:
...     print repr(x), repr(my_dict[x])    
'foo' 'bar'
'baz' 'quux'

code.py:

import sys


TREE = [
    {
        "id": 1,
        "child": [
            {
                "id": 4,
                "child": [],
            },
            {
                "id": 2,
                "child": [
                    {
                        "id": 37,
                        "child": [],
                    },
                    {
                        "id": 39,
                        "child": [],
                    }
                ]
            },
            {
                "id": 3,
                "child": [],
            },
        ]
    },
    {
        "id": 120,
        "child": [],
    },
    {
        "id": 121,
        "child": [
            {
                "id": 122,
                "child": [],
            }
        ]
    }
]


def get_chain_ids(tree_dict, target_id, depth=0):
    cur_id = tree_dict["id"]
    if cur_id == target_id:
        yield cur_id
    else:
        yield_cur_id = False
        for child_dict in tree_dict["child"]:
            for child_id in get_chain_ids(child_dict, target_id, depth=depth + 1):
                yield_cur_id = True
                yield child_id
        if yield_cur_id:
            yield cur_id


if __name__ == "__main__":
    print("Python {:s} on {:s}\n".format(sys.version, sys.platform))

    for item in TREE:
        print("\nSearching tree (id: {:d})...".format(item["id"]))
        ids = get_chain_ids(item, 37)
        if (ids):
            for item in ids:
                print(item)

Notes:

• Uses [Python]: Generators
• The json (TEXT dict) was incorrect, I had to adjust it (besides formatting)
• get_chain_ids takes the tree root (tree_dict) which is a dictionary, and target_id as arguments, and returns a generator yielding all the node ids from target_id to the root id
• depth is currently not used
• Since TREE is a list of nodes, I had to iterate over it and pass each element to the function
• It doesn't handle cases where a node is malformed (lacks "id" or "child" keys, or if their values are not as expected)

Output:

(py35x64_test) E:\Work\Dev\StackOverflow\q048865303>"e:\Work\Dev\VEnvs\py35x64_test\Scripts\python.exe" code.py
Python 3.5.4 (v3.5.4:3f56838, Aug  8 2017, 02:17:05) [MSC v.1900 64 bit (AMD64)] on win32


Searching tree (id: 1)...
37
2
1

Searching tree (id: 120)...

Searching tree (id: 121)...

Assumptions made:

1. I assumed that you are using python3.x

You can do it as follows:

import json
a = json.dumps({"Name": "Robert", "Date" : "January 17th, 2017", "Address" : "Jakarta"})
a_dict = json.loads(a)
for key in a_dict.keys():
    print (key)