# collections – Python defaultdict and lambda

## collections – Python defaultdict and lambda

I think the first line means that when I call `x[k]` for a nonexistent key `k` (such as a statement like `v=x[k]`), the key-value pair `(k,0)` will be automatically added to the dictionary, as if the statement `x[k]=0` is first executed.

Thats right. This is more idiomatically written

``````x = defaultdict(int)
``````

In the case of `y`, when you do `y[ham][spam]`, the key `ham` is inserted in `y` if it does not exist. The value associated with it becomes a `defaultdict` in which `spam` is automatically inserted with a value of `0`.

I.e., `y` is a kind of two-tiered `defaultdict`. If `ham not in y`, then evaluating `y[ham][spam]` is like doing

``````y[ham] = {}
y[ham][spam] = 0
``````

in terms of ordinary `dict`.

You are correct for what the first one does. As for `y`, it will create a defaultdict with default 0 when a key doesnt exist in `y`, so you can think of this as a nested dictionary. Consider the following example:

``````y = defaultdict(lambda: defaultdict(lambda: 0))
print y[k1][k2]   # 0
print dict(y[k1])   # {k2: 0}
``````

To create an equivalent nested dictionary structure without defaultdict you would need to create an inner dict for `y[k1]` and then set `y[k1][k2]` to 0, but defaultdict does all of this behind the scenes when it encounters keys it hasnt seen:

``````y = {}
y[k1] = {}
y[k1][k2] = 0
``````

The following function may help for playing around with this on an interpreter to better your understanding:

``````def to_dict(d):
if isinstance(d, defaultdict):
return dict((k, to_dict(v)) for k, v in d.items())
return d
``````

This will return the dict equivalent of a nested defaultdict, which is a lot easier to read, for example:

``````>>> y = defaultdict(lambda: defaultdict(lambda: 0))
>>> y[a][b] = 5
>>> y
defaultdict(<function <lambda> at 0xb7ea93e4>, {a: defaultdict(<function <lambda> at 0xb7ea9374>, {b: 5})})
>>> to_dict(y)
{a: {b: 5}}
``````

#### collections – Python defaultdict and lambda

`defaultdict` takes a zero-argument callable to its constructor, which is called when the key is not found, as you correctly explained.

`lambda: 0` will of course always return zero, but the preferred method to do that is `defaultdict(int)`, which will do the same thing.

As for the second part, the author would like to create a new `defaultdict(int)`, or a nested dictionary, whenever a key is not found in the top-level dictionary.