CODEWITHSUNDEEP
pythondictionary
Tapajit Dey
Tapajit Dey

Reputation: 1396

dynamically nesting a python dictionary

I want to create a function that will create dynamic levels of nesting in a python dictionary. e.g. if I call my function nesting, I want the outputs like the following:

nesting(1)  :  dict = {key1:<value>}
nesting(2)  :  dict = {key1:{key2:<value>}}
nesting(3)  :  dict = {key1:{key2:{key3:<value>}}}

and so on. I have all the keys and values before calling this function, but not before I start executing the code.

I have the keys stored in a variable 'm' where m is obtained from:

m=re.match(pattern,string)

the pattern is constructed dynamically for this case.

Upvotes: 1

Views: 1721

Answers (2)

nameless
nameless

Reputation: 1979

You can iterate over the keys like this:

def nesting(level):
    ret = 'value'
    for l in range(level, 0, -1):
        ret = {'key%d' % l: ret}
    return ret

Replace the range(...) fragment with the code which yields the keys in the desired order. So, if we assume that the keys are the captured groups, you should change the function as follows:

def nesting(match): # `match' is a match object like your `m' variable
    ret = 'value'
    for key in match.groups():
        ret = {key: ret}
    return ret

Or use reversed(match.groups()) if you want to get the keys in the opposite order.

Upvotes: 1

Volatility
Volatility

Reputation: 32300

def nesting(level, l=None):
    # assuming `m` is accessible in the function
    if l is None:
        l = level
    if level == 1:
        return {m[l-level]: 'some_value'}
    return {m[l-level]: nesting(level-1, l)

For reasonable levels, this won't exceed the recursion depth. This is also assuming that the value is always the same and that m is of the form:

['key1', 'key2', ...]

An iterative form of this function can be written as such:

def nesting(level):
    # also assuming `m` is accessible within the function
    d = 'some_value'
    l = level
    while level > 0:
        d = {m[l-level]: d}
        level -= 1
    return d

Or:

def nesting(level):
    # also assuming `m` is accessible within the function
    d = 'some_value'
    for l in range(level, 0, -1):  # or xrange in Python 2
        d = {m[l-level]: d}
    return d

Upvotes: 1

Related Questions