How to increment a value (in defaultdict of defaultdicts)?

Question

How to increment d['a']['b']['c'][1][2][3] if d is defaultdict of defaultdict without code dublication?

from collections import defaultdict
nested_dict_type = lambda: defaultdict(nested_dict_type)
nested_dict = nested_dict_type()

# incrementation
if type(nested_dict['a']['b']['c']['d'][1][2][3][4][5][6]) != int:
    nested_dict['a']['b']['c']['d'][1][2][3][4][5][6] = 0
nested_dict['a']['b']['c']['d'][1][2][3][4][5][6] += 1  # ok, now it contains 1

Here we can see that we duplicated (in the code) a chain of keys 3 times.

Question: Is it possible to write a function inc that will take nested_dict['a']['b']...[6] and do the same job as above? So:

def inc(x):
    if type(x) != int:
        x = 0
    x += 1
inc(nested_dict['a']['b']['c']['d'][1][2][3][4][5][6])  # ok, now it contains 1

Update (20 Aug 2018):

There is still no answer to the question. It's clear that there are options "how to do what I want", but the question is straightforward: there is "value", we pass it to a function, function modifies it. It looks that it's not possible. Just a value, without any "additional keys", etc. If it is so, can we make an answer more generic?

Notes:

1. What is defaultdict of defaultdicts - SO.
2. This question is not about "storing of integers in a defaultdict", so I'm not looking for a hierarchy of defaultdicts with an int type at the leaves.
3. Assume that type (int in the examples) is known in advance / can be even parametrized (including the ability to perform += operator) - the question is how to dereference the object, pass it for modification and store back in the context of defaultdict of defaultdicts.
4. Is the answer to this question related to the mutability? See example below:

Example:

def inc(x):
    x += 1

d = {'a': int(0)}
inc(d['a'])  
# d['a'] == 0, immutable

d = {'a': Int(0)}
inc(d['a'])  
# d['a'] == 1, mutated

Where Int is:

class Int:
    def __init__(self, value):
        self.value = value
    def __add__(self, v):
        self.value += v
        return self
    def __repr__(self):
        return str(self.value)

Answer 1

It's not exactly abut mutability, more about how assignment performs name binding.

When you do x = 0 in your inc function you bind a new object to the name x, and any connection between that name and the previous object bound to that name is lost. That doesn't depend on whether or not x is mutable.

But since x is an item in a mutable object we can achieve what you want by passing the parent mutable object to inc along with the key needed to access the desired item.

from collections import defaultdict

nested_dict_type = lambda: defaultdict(nested_dict_type)
nested_dict = nested_dict_type()

# incrementation
def inc(ref, key):
    if not isinstance(ref[key], int):
        ref[key] = 0
    ref[key] += 1

d = nested_dict['a']['b']['c']['d'][1][2][3][4][5]
inc(d, 6)
print(d)

output

defaultdict(<function <lambda> at 0xb730553c>, {6: 1})

Now we aren't binding a new object, we're merely mutating an existing one, so the original d object gets updated correctly.

---

BTW, that deeply nested dict is a bit painful to work with. Maybe there's a better way to organize your data... But anyway, one thing that can be handy when working with deep nesting is to use lists or tuples of keys. Eg,

q = nested_dict
keys = 'a', 'b', 'c', 'd', 1, 2, 3, 4, 5
for k in keys:
    q = q[k]

q now refers to nested_dict['a']['b']['c']['d'][1][2][3][4][5]

Answer 2

You can't have multiple default types with defaultdict. You have the following options:

1. Nested defaultdict of defaultdict objects indefinitely;
2. defaultdict of int objects, which likely won't suit your needs;
3. defaultdict of defaultdict down to a specific level with int defined for the last level, e.g. d = defaultdict(lambda: defaultdict(int)) for a single nesting;
4. Similar to (3), but for counting you can use collections.Counter instead, i.e. d = defaultdict(Counter).

I recommend the 3rd or 4th options if you are always going to go down to a set level. In other words, a scalar value will only be supplied at the nth level, where n is constant.

Otherwise, one manual option is to have a function perform the type-testing. In this case, try / except may be a good alternative. Here we also define a recursive algorithm to allow you to feed a list of keys rather than defining manual __getitem__ calls.

from collections import defaultdict
from functools import reduce
from operator import getitem

nested_dict_type = lambda: defaultdict(nested_dict_type)
d = nested_dict_type()

d[1][2] = 10

def inc(d_in, L):
    try:
        reduce(getitem, L[:-1], d_in)[L[-1]] += 1
    except TypeError:
        reduce(getitem, L[:-1], d_in)[L[-1]] = 1

inc(d, [1, 2])
inc(d, [1, 3])

print(d)

defaultdict({1: defaultdict({2: 11, 3: 1})})