[Python-ideas] Unpacking a dict

[Steven D'Aprano]

On Wed, May 25, 2016 at 01:11:35PM +0000, Michael Selik wrote:

> Clojure also supports mapping destructuring. Let's add that to Python!
> 
>     py> mapping = {"a": 1, "b": 2, "c": 3}
>     py> {"a": x, "b": y, "c": z} = mapping
>     py> x, y, z
>     (1, 2, 3)
>     py> {"a": x, "b": y} = mapping
>     Traceback:
>     ValueError: too many keys to unpack
> 
> 
> This will be approximately as helpful as iterable unpacking was before PEP
> 3132 (https://www.python.org/dev/peps/pep-3132/).

What is your evidence for this claim? So far I've only seen one real- 
world use-case for this, and that single use-case would be well served 
by a simpler syntax:

a, b, c = **mapping

which just requires that a, b, c etc are legal names (not general 
identifiers). The dict is then unpacked:

a = mapping['a']

etc. Two questions:

(1) For the use-case we've already seen, a "preferences" or "settings" 
mapping, do you think users will be prepared to use your syntax?

(2) Do you have any other concrete use cases for this, and if so, what 
are they?


For (1), I've taken a prefs dict from a rather small command line script 
I've written. This is taken from actual code in use. To unpack the dict 
using your syntax, I would have to write:

{'sort': sort, 'reverse': reverse, 'classify': classify, 
 'showlinks': showlinks, 'showsize': showsize, 'spacer': spacer, 
 'style': style, 'width': width} = prefs
# next line is optional, but I might not wish to pollute the namespace
del sort, reverse, showlinks, showsize, style

in order to unpack the three keys I actually want. Here's my suggestion:

classify, spacer, width = **prefs

I don't know about you, but there's no way I'd use your suggested 
syntax as-shown. I'd rather unpack manually:

classify, spacer, width = [prefs[key] for key in 'classify spacer width'.split()]

or variations of same.


For (2), here's another use-case I can think of. Unpacking **kwargs in 
functions/methods.

def spam(self, a, b, **kwargs):
    ...

I'd like to unpack a small number of keys:values from kwargs, extract 
them from the dict, and pass that on to another method:

    fnord = kwargs.pop('fnord', 'default')
    wibble = kwargs.pop('wibble', 42)
    super().spam(a, b, **kwargs)


I don't have a concise syntax for this use-case, and yours won't work 
either. There's no way to supply defaults, nor can you list *all* the 
keys because you don't know what they will be. (The caller can provide 
arbitrary keyword arguments.)

So I don't think this use-case can be handled by either your syntax or 
mine for dict unpacking.


I think your syntax is too verbose and repetitive for the simple case. 
It does have the advantage that it can deal with keys which aren't 
identifiers:

{'while': while_, 'foo bar': foobar} = mapping

but it only looks good in toy examples. In real code, I wouldn't use it, 
it would be too painful and repetitive.

If we add syntax to collect all the unused items, your syntax will be a 
bit less painful, but still repetitive:

{'classify': classify, 'spacer': spacer, 'width': width, **whocares} = prefs

but that has no advantage over what we already have:

classify, spacer, width = [prefs[key] for key in ('classify', 'spacer', 'width')]

(The two are almost the same length, and equally repetitive.)

As far as changing names, we can already do that, and use arbitrary 
references:

myobj.attr['key'][1], while_, foobar = [
        mapping[key] for key in ('something', 'while', 'foo bar')]


So I think that the problems your syntax solve are already easy to 
solve, and the things which are annoying to solve now, your syntax is 
too painful to use.

I'd rather have syntax which is less general but more useful in 
practice, than something which solves dict unpacking in its full 
generality but a pain to use.



-- 
Steve