3

I have a list as follows

['item1', 'item2', 'item3', 'item4']

I want to construct a dictionary from the above list as follows

{
    "item1": {
        "item2": {
            "item3": "item4"
        }
    }
}

The number of items in the list is dynamic. The dictionary will be a nested dictionary till it reaches the last element of the list. Is there any way in python to do this?

thefourtheye
  • 233,700
  • 52
  • 457
  • 497
NagaLakshmi
  • 715
  • 3
  • 12
  • 24

3 Answers3

12

Simple one-liner:

a = ['item1', 'item2', 'item3','item4']
print reduce(lambda x, y: {y: x}, reversed(a))

For better understanding the above code can be expanded to:

def nest_me(x, y):
    """
    Take two arguments and return a one element dict with first
    argument as a value and second as a key
    """
    return {y: x}

a = ['item1', 'item2', 'item3','item4']
rev_a = reversed(a) # ['item4', 'item3', 'item2','item1']
print reduce(
    nest_me, # Function applied until the list is reduced to one element list
    rev_a # Iterable to be reduced
)
# {'item1': {'item2': {'item3': 'item4'}}}
ElmoVanKielmo
  • 10,907
  • 2
  • 32
  • 46
6

Use recursion:

def list2dict(src_list):
    if len(src_list) > 1:
        return {src_list[0] : list2dict(src_list[1:])}
    return src_list[0]

Output:

>>> list2dict(['item1', 'item2', 'item3', 'item4'])
{'item1': {'item2': {'item3': 'item4'}}}
ddejohn
  • 8,775
  • 3
  • 17
  • 30
volcano
  • 3,578
  • 21
  • 28
  • It's a pity that @thefourtheye deleted his answer - while this solution is more natural, I must say that his had the advantage of eliminating slicing overhead - this has complexity of O(n!), his is O(n) – volcano Mar 03 '15 at 13:00
  • How does slicing make this `O(n!)`? – ddejohn Apr 01 '22 at 14:44
3

Using the reduce() function to access and set elements:

try:
    # Python 3 moved reduce to the functools module
    from functools import reduce
except ImportError:
    # Python 2 reduce is a built-in
    pass

def get_target(d, keys):
    return reduce(lambda d, k: d.setdefault(k, {}), keys, d)

def set_target(d, keys, value):
    parent = get_target(d, keys[:-1])
    parent[keys[-1]] = value

result = {}
set_target(result, yourlist[:-1], yourlist[-1])

The get_target() and set_target() functions are re-usable on already-built nested structures, they are not limited to building a dictionary from scratch. I adapted get_target() from an earlier, related post.

Demo:

>>> def get_target(d, keys):
...     return reduce(lambda d, k: d.setdefault(k, {}), keys, d)
... 
>>> def set_target(d, keys, value):
...     parent = get_target(d, keys[:-1])
...     parent[keys[-1]] = value
... 
>>> result = {}
>>> yourlist = ['item1', 'item2', 'item3', 'item4']
>>> set_target(result, yourlist[:-1], yourlist[-1])
>>> result
{'item1': {'item2': {'item3': 'item4'}}}
Community
  • 1
  • 1
Martijn Pieters
  • 1,048,767
  • 296
  • 4,058
  • 3,343
  • Again - that solution has the advantage of complexity - recursion is O(n!), that one is O(n) – volcano Mar 03 '15 at 13:03
  • @martijn `set_target` is breaking for this case as it doesn't replace the primitive key if it's already assigned. https://imgur.com/a/TGTVoO3 – nehem Dec 03 '18 at 01:15
  • @nehemiah: that's because you are mixing leaves and branch nodes here. `a -> b -> c` references a leaf node (`hello`), so you can't then turn `c` into a branch node (where `c` references another dictionary). Making the call there, to just replace `c`, is a decision you need to make for your own usecases. You can't just assume that the collision here is not an error in the application logic. – Martijn Pieters Dec 03 '18 at 13:44
  • @MartijnPieters Keeping it generic is the best option here. Overriding data on a same dict key is perfectly okay behavior for Dict/Hashmap. I had to come to this implementation after countless scenarios. Here's the detailed answer https://stackoverflow.com/a/33704530/968442 – nehem Dec 03 '18 at 23:20