Hacker News Reader

Comment by Kpourdeilami | Hacker News Reader

Unrelated to python 3.7, but they recently added this feature that you can add two dictionaries together in 3.5 by doing:

  new_dict = {**dict1, **dict2}

It is so handy and nice

View on HN

I didn't know about that. It's also unbounded:

    >>> d = {**{1:2,2:2,3:2}
            ,**{4:2,5:2,6:2}
            ,**{7:2,8:2,9:2}}
    >>> d
    { 1: 2, 2: 2, 3: 2
    , 4: 2, 5: 2, 6: 2
    , 7: 2, 8: 2, 9: 2}

What happens to duplicate keys?

I think it raises an exception.

https://www.python.org/dev/peps/pep-0448/

EDIT: yeah, nvm, it's what everyone else said.

No it doesn't, you simply get the value from the last dict:

  >>> a = {'x': 1}
  >>> b = {'x': 2}
  >>> {**a, **b}
  {'x': 2}
  >>> {**b, **a}
  {'x': 1}

They get overwritten by the value of the dictionary that came last.

  >>> dict1 = {"key1": 1, "key2": "hello", "key3": [1, 2, 3]}
  >>> dict2 = {key1": 1, "key2": "world", "key3": [1, 4], "key4": "4"}

  >>> {**dict1, **dict2}
  {'key1': 1, 'key2': 'world', 'key3': [1, 4], 'key4': '4'}

Lots of code to show that. How 'bout this: ;-)

  >>> {**{'a': 'first'}, **{'a': 'second'}}
  {'a': 'second'}

Last pair wins, same as setting an existing key or doing an update() with an existing key.

Looks like this came from https://www.python.org/dev/peps/pep-0448/

Seems similar to the spread operator in JavaScript: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Refe...

Why doesn't the + symbol work?

+ is not a supported operand for dict. You can probably subclass dict and add the plus operand

Why add that crazy syntax when a + would be a lot clearer?

It makes sense in context. {} is a dict literal, and * * dict is already used other places to expand a dict into key-value pairs.

Given

  a = {1: 1}
  b = {2: 2}

This

  c = {**a, **b}

is equivalent to

  c = {1: 1, 2: 2}

a|b would be the obvious choice, because it already works for set:

    {1,2}|{2,3} == {1,2,3}

I guess the reason they went for the weird {∗∗a, ∗∗b} syntax is that it is not a commutative operation.

Wouldn't mind that either.

I guess I didn't explain it clearly enough. ∗∗a is not new syntax, it's just applicable in a new context.

Correct. This is called orthogonality. I just used it now to discover that this same syntax works for both sets and lists (using * instead of )

  >>> s1 = {'a', 'b', 'c'}
  >>> s2 = {1, 2, 3}
  >>> {*s1, *s2}
  {'b', 1, 2, 3, 'c', 'a'}

  >>> l1 = ['a', 'b', 'c']
  >>> l2 = [1, 2, 3]
  >>> [*l1, *l2]
  ['a', 'b', 'c', 1, 2, 3]

It's fun that I use it every day but my linter still thinks is a syntax error :)

A linter for a dynamic language has got to be the hardest thing ever to implement.

In PyCharm if you return from within a contextlib.suppress context it'll think any code following it is unreachable code.

https://youtrack.jetbrains.com/issue/PY-25809 https://youtrack.jetbrains.com/issue/PY-16419

Ah, great. This used to be rather clunky to do.

Really? This is how that was done in Python 2.7 and it doesn't seem that much clunkier to me...

    dict(dict1, **dict2)

Interesting. I never thought of that. I also asked a question about this on StackOver flow once and no one suggested that. Very useful.

It has a lot of issues. The biggest one for me is the following: Dicts are intended to take hashable keys (e.g. frozensets or tuples), but this method fails in Python 3 when keys are not strings.

Source: https://stackoverflow.com/questions/38987/how-to-merge-two-d...

That's only allowed if the keys in the second dictionary are valid Python identifiers (don't contain spaces etc.). I think CPython is OK with this, but PyPy is not.

Reply on news.ycombinator.com