Eu tenho dois dicionários Python e quero escrever uma única expressão que retorne esses dois dicionários, mesclados. O update()método seria o que eu precisava, se retornasse o resultado em vez de modificar um dicionário no local.

>>> x = {'a': 1, 'b': 2}
>>> y = {'b': 10, 'c': 11}
>>> z = x.update(y)
>>> print(z)
None
>>> x
{'a': 1, 'b': 10, 'c': 11}

Como posso obter esse dicionário mesclado final z, não x?

(Para ser mais claro, o último que ganha é a manipulação de conflitos, dict.update()é o que estou procurando também.)

Como mesclar dois dicionários Python em uma única expressão?

Para dicionários xe y, ztorna-se um dicionário superficialmente mesclado com valores da ysubstituição daqueles de x.

• No Python 3.5 ou superior:

  z = {**x, **y}

• No Python 2, (ou 3.4 ou menos) escreva uma função:

  def merge_two_dicts(x, y):
      z = x.copy()   # start with x's keys and values
      z.update(y)    # modifies z with y's keys and values & returns None
      return z

  e agora:

  z = merge_two_dicts(x, y)

• No Python 3.9.0a4 ou superior (data de lançamento final aproximadamente outubro de 2020): PEP-584 , discutido aqui , foi implementado para simplificar ainda mais isso:

  z = x | y          # NOTE: 3.9+ ONLY

Explicação

Digamos que você tenha dois ditados e deseja mesclá-los em um novo ditado sem alterar os ditados originais:

x = {'a': 1, 'b': 2}
y = {'b': 3, 'c': 4}

O resultado desejado é obter um novo dicionário (z ) com os valores mesclados, e os valores do segundo ditado substituindo os do primeiro.

>>> z
{'a': 1, 'b': 3, 'c': 4}

Uma nova sintaxe para isso, proposta no PEP 448 e disponível a partir do Python 3.5 , é

z = {**x, **y}

E é de fato uma expressão única.

Observe que também podemos nos fundir com notação literal:

z = {**x, 'foo': 1, 'bar': 2, **y}

e agora:

>>> z
{'a': 1, 'b': 3, 'foo': 1, 'bar': 2, 'c': 4}

Agora está sendo exibido conforme implementado no cronograma de lançamento do 3.5, PEP 478 , e agora chegou ao What's New in Python 3.5 .

No entanto, como muitas organizações ainda estão no Python 2, convém fazer isso de uma maneira compatível com versões anteriores. A maneira classicamente Pythonic, disponível no Python 2 e Python 3.0-3.4, é fazer isso como um processo de duas etapas:

z = x.copy()
z.update(y) # which returns None since it mutates z

Em ambas as abordagens, yvirá segunda e seus valores irá substituir x's valores, portanto, 'b'irá apontar para3 nosso resultado final.

Ainda não está no Python 3.5, mas quer um única expressão

Se você ainda não está no Python 3.5 ou precisa escrever um código compatível com versões anteriores, e deseja isso em uma única expressão , o melhor desempenho enquanto a abordagem correta é colocá-lo em uma função:

def merge_two_dicts(x, y):
    """Given two dicts, merge them into a new dict as a shallow copy."""
    z = x.copy()
    z.update(y)
    return z

e então você tem uma única expressão:

z = merge_two_dicts(x, y)

Você também pode criar uma função para mesclar um número indefinido de dictos, de zero a um número muito grande:

def merge_dicts(*dict_args):
    """
    Given any number of dicts, shallow copy and merge into a new dict,
    precedence goes to key value pairs in latter dicts.
    """
    result = {}
    for dictionary in dict_args:
        result.update(dictionary)
    return result

Esta função funcionará no Python 2 e 3 para todos os dictos. por exemplo, ditados dados apara g:

z = merge_dicts(a, b, c, d, e, f, g) 

e os pares de valores-chave gterão precedência sobre os ditados apara fe assim por diante.

Críticas de outras respostas

Não use o que vê na resposta anteriormente aceita:

z = dict(x.items() + y.items())

No Python 2, você cria duas listas na memória para cada ditado, cria uma terceira lista na memória com comprimento igual ao comprimento dos dois primeiros juntos e, em seguida, descarta as três listas para criar o ditado. No Python 3, isso falhará porque você adiciona dois dict_itemsobjetos, não duas listas -

>>> c = dict(a.items() + b.items())
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'dict_items' and 'dict_items'

e você teria que criá-los explicitamente como listas, por exemplo z = dict(list(x.items()) + list(y.items())). Isso é um desperdício de recursos e poder computacional.

Da mesma forma, aceitar a união do items()Python 3 ( viewitems()no Python 2.7) também falhará quando os valores forem objetos laváveis ​​(como listas, por exemplo). Mesmo que seus valores sejam hasháveis, uma vez que os conjuntos são semanticamente desordenados, o comportamento é indefinido em relação à precedência. Então não faça isso:

>>> c = dict(a.items() | b.items())

Este exemplo demonstra o que acontece quando os valores são laváveis:

>>> x = {'a': []}
>>> y = {'b': []}
>>> dict(x.items() | y.items())
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

Aqui está um exemplo em que y deve ter precedência, mas o valor de x é retido devido à ordem arbitrária dos conjuntos:

>>> x = {'a': 2}
>>> y = {'a': 1}
>>> dict(x.items() | y.items())
{'a': 2}

Outro truque que você não deve usar:

z = dict(x, **y)

Isso usa o dictconstrutor e é muito rápido e eficiente em memória (até um pouco mais do que o nosso processo de duas etapas), mas a menos que você saiba exatamente o que está acontecendo aqui (ou seja, o segundo ditado está sendo passado como argumentos de palavra-chave para o ditado construtor), é difícil de ler, não é o uso pretendido e, portanto, não é Pythonic.

Aqui está um exemplo do uso sendo remediado no django .

Os dicts destinam-se a levar chaves hash (por exemplo, frozensets ou tuplas), mas esse método falha no Python 3 quando as chaves não são cadeias de caracteres.

>>> c = dict(a, **b)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: keyword arguments must be strings

Da lista de discussão , Guido van Rossum, o criador da linguagem, escreveu:

Estou bem em declarar o dict ({}, ** {1: 3}) ilegal, pois, afinal, é abuso do mecanismo **.

e

Aparentemente, o dict (x, ** y) está sendo exibido como "cool hack" para "chame x.update (y) e retorne x". Pessoalmente, acho isso mais desprezível do que legal.

Entendo (assim como o criador da linguagem ) que o uso pretendido dict(**y)é para criar dictos para fins de legibilidade, por exemplo:

dict(a=1, b=10, c=11)

ao invés de

{'a': 1, 'b': 10, 'c': 11}

Resposta a comentários

Apesar do que Guido diz, dict(x, **y)está alinhado com a especificação de ditado, que se encaixa. funciona para Python 2 e 3. O fato de que isso funciona apenas para chaves de seqüência de caracteres é uma conseqüência direta de como os parâmetros de palavra-chave funcionam e não um ditado. O uso do ** operador neste local também não é um abuso do mecanismo, de fato ** foi projetado precisamente para passar dict como palavras-chave.

Novamente, ele não funciona para 3 quando as chaves não são cadeias de caracteres. O contrato de chamada implícita é que os namespaces assumem dicionários comuns, enquanto os usuários devem passar apenas argumentos de palavras-chave que são strings. Todos os outros callables o aplicaram. dictquebrou essa consistência no Python 2:

>>> foo(**{('a', 'b'): None})
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: foo() keywords must be strings
>>> dict(**{('a', 'b'): None})
{('a', 'b'): None}

Essa inconsistência foi ruim, devido a outras implementações do Python (Pypy, Jython, IronPython). Portanto, ele foi corrigido no Python 3, pois esse uso pode ser uma mudança de última hora.

Eu afirmo a você que é incompetência maliciosa escrever intencionalmente código que funciona apenas em uma versão de um idioma ou que funciona apenas devido a certas restrições arbitrárias.

Mais comentários:

dict(x.items() + y.items()) ainda é a solução mais legível para o Python 2. A legibilidade conta.

Minha resposta: merge_two_dicts(x, y)na verdade, parece muito mais claro para mim, se estamos realmente preocupados com a legibilidade. E não é compatível com o futuro, pois o Python 2 está cada vez mais obsoleto.

{**x, **y}parece não manipular dicionários aninhados. o conteúdo das chaves aninhadas é simplesmente sobrescrito, não mesclado [...] acabei sendo queimado por essas respostas que não se mesclam recursivamente e fiquei surpreso que ninguém mencionou. Na minha interpretação da palavra "mesclando", essas respostas descrevem "atualizando um ditado com outro", e não mesclando.

Sim. Devo encaminhá-lo de volta à pergunta, que está pedindo uma mesclagem superficial de dois dicionários, com os valores do primeiro sendo substituídos pelos do segundo - em uma única expressão.

Supondo que dois dicionários de dicionários, um pode recursivamente mesclá-los em uma única função, mas você deve tomar cuidado para não modificar os dictos de nenhuma das fontes, e a maneira mais segura de evitar isso é fazer uma cópia ao atribuir valores. Como as chaves devem ser laváveis ​​e geralmente são imutáveis, não faz sentido copiá-las:

from copy import deepcopy

def dict_of_dicts_merge(x, y):
    z = {}
    overlapping_keys = x.keys() & y.keys()
    for key in overlapping_keys:
        z[key] = dict_of_dicts_merge(x[key], y[key])
    for key in x.keys() - overlapping_keys:
        z[key] = deepcopy(x[key])
    for key in y.keys() - overlapping_keys:
        z[key] = deepcopy(y[key])
    return z

Uso:

>>> x = {'a':{1:{}}, 'b': {2:{}}}
>>> y = {'b':{10:{}}, 'c': {11:{}}}
>>> dict_of_dicts_merge(x, y)
{'b': {2: {}, 10: {}}, 'a': {1: {}}, 'c': {11: {}}}

A criação de contingências para outros tipos de valor está muito além do escopo desta pergunta. Por isso, apontarei a minha resposta à pergunta canônica em uma "Mesclagem de dicionários de dicionários" .

Menos desempenho, mas ad-hocs corretos

Essas abordagens têm menos desempenho, mas fornecerão o comportamento correto. Eles serão muito menos eficaz do que copye updateou o novo descompactação porque iterar cada par de valores-chave em um nível mais alto de abstração, mas eles fazer respeitar a ordem de precedência (últimos dicts têm precedência)

Você também pode encadear os dictos manualmente dentro de uma compreensão de dict:

{k: v for d in dicts for k, v in d.items()} # iteritems in Python 2.7

ou no python 2.6 (e talvez já no 2.4 quando expressões de gerador foram introduzidas):

dict((k, v) for d in dicts for k, v in d.items())

itertools.chain irá encadear os iteradores sobre os pares de valores-chave na ordem correta:

import itertools
z = dict(itertools.chain(x.iteritems(), y.iteritems()))

Análise de desempenho

Eu só vou fazer a análise de desempenho dos usos conhecidos por se comportar corretamente.

import timeit

O seguinte é feito no Ubuntu 14.04

No Python 2.7 (sistema Python):

>>> min(timeit.repeat(lambda: merge_two_dicts(x, y)))
0.5726828575134277
>>> min(timeit.repeat(lambda: {k: v for d in (x, y) for k, v in d.items()} ))
1.163769006729126
>>> min(timeit.repeat(lambda: dict(itertools.chain(x.iteritems(), y.iteritems()))))
1.1614501476287842
>>> min(timeit.repeat(lambda: dict((k, v) for d in (x, y) for k, v in d.items())))
2.2345519065856934

No Python 3.5 (PPA mortal):

>>> min(timeit.repeat(lambda: {**x, **y}))
0.4094954460160807
>>> min(timeit.repeat(lambda: merge_two_dicts(x, y)))
0.7881555100320838
>>> min(timeit.repeat(lambda: {k: v for d in (x, y) for k, v in d.items()} ))
1.4525277839857154
>>> min(timeit.repeat(lambda: dict(itertools.chain(x.items(), y.items()))))
2.3143140770262107
>>> min(timeit.repeat(lambda: dict((k, v) for d in (x, y) for k, v in d.items())))
3.2069112799945287

Recursos em dicionários

• Minha explicação da implementação do dicionário Python , atualizada para 3.6.
• Responda sobre como adicionar novas chaves a um dicionário
• Mapeando duas listas em um dicionário
• Os documentos oficiais do Python sobre dicionários
• Dicionário ainda mais poderoso - por Brandon Rhodes no Pycon 2017
• Dicionários Python modernos, uma confluência de grandes idéias - por Raymond Hettinger no Pycon 2017

No seu caso, o que você pode fazer é:

z = dict(x.items() + y.items())

Isso, como você quiser, coloca o comando final ze faz com que o valor da chave bseja substituído adequadamente pelo valor do segundo ycomando ( ):

>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> z = dict(x.items() + y.items())
>>> z
{'a': 1, 'c': 11, 'b': 10}

Se você usa o Python 3, é apenas um pouco mais complicado. Para criar z:

>>> z = dict(list(x.items()) + list(y.items()))
>>> z
{'a': 1, 'c': 11, 'b': 10}

Se você usa o Python versão 3.9.0a4 ou superior, pode usar diretamente:

x = {'a':1, 'b': 2}
y = {'b':10, 'c': 11}
z = x | y
print(z)

Output: {'a': 1, 'c': 11, 'b': 10}

Uma alternativa:

z = x.copy()
z.update(y)

Outra opção mais concisa:

z = dict(x, **y)

Nota : essa se tornou uma resposta popular, mas é importante ressaltar que, se yhouver alguma chave não-string, o fato de que isso funcione é um abuso de detalhes de implementação do CPython e não funciona no Python 3, ou em PyPy, IronPython ou Jython. Além disso, Guido não é fã . Portanto, não posso recomendar esta técnica para código portátil compatível com a frente ou de implementação cruzada, o que realmente significa que deve ser totalmente evitado.

Provavelmente, essa não será uma resposta popular, mas você quase certamente não deseja fazer isso. Se você deseja uma cópia mesclada, use copy (ou deepcopy , dependendo do que você deseja) e atualize. As duas linhas de código são muito mais legíveis - mais Pythonic - do que a criação de uma única linha com .items () + .items (). Explícito é melhor que implícito.

Além disso, quando você usa .items () (antes do Python 3.0), está criando uma nova lista que contém os itens do dict. Se seus dicionários forem grandes, isso representa uma sobrecarga considerável (duas listas grandes que serão jogadas fora assim que o ditado mesclado for criado). update () pode funcionar com mais eficiência, porque pode ser executado através do segundo ditado item por item.

Em termos de tempo :

>>> timeit.Timer("dict(x, **y)", "x = dict(zip(range(1000), range(1000)))\ny=dict(zip(range(1000,2000), range(1000,2000)))").timeit(100000)
15.52571702003479
>>> timeit.Timer("temp = x.copy()\ntemp.update(y)", "x = dict(zip(range(1000), range(1000)))\ny=dict(zip(range(1000,2000), range(1000,2000)))").timeit(100000)
15.694622993469238
>>> timeit.Timer("dict(x.items() + y.items())", "x = dict(zip(range(1000), range(1000)))\ny=dict(zip(range(1000,2000), range(1000,2000)))").timeit(100000)
41.484580039978027

Na OMI, a pequena desaceleração entre os dois primeiros vale a pena pela legibilidade. Além disso, argumentos de palavras-chave para criação de dicionário foram adicionados apenas no Python 2.3, enquanto copy () e update () funcionarão em versões mais antigas.

Em uma resposta de acompanhamento, você perguntou sobre o desempenho relativo dessas duas alternativas:

z1 = dict(x.items() + y.items())
z2 = dict(x, **y)

Na minha máquina, pelo menos (um x86_64 bastante comum executando o Python 2.5.2), a alternativa z2não é apenas mais curta e mais simples, mas também significativamente mais rápida. Você pode verificar isso por si mesmo usando otimeit módulo que acompanha o Python.

Exemplo 1: dicionários idênticos mapeando 20 números inteiros consecutivos para si mesmos:

% python -m timeit -s 'x=y=dict((i,i) for i in range(20))' 'z1=dict(x.items() + y.items())'
100000 loops, best of 3: 5.67 usec per loop
% python -m timeit -s 'x=y=dict((i,i) for i in range(20))' 'z2=dict(x, **y)' 
100000 loops, best of 3: 1.53 usec per loop

z2ganha por um fator de 3,5 ou mais. Dicionários diferentes parecem produzir resultados bastante diferentes, mas z2sempre parecem sair à frente. (Se você obtiver resultados inconsistentes para o mesmo teste, tente passar -rcom um número maior que o padrão 3).

Exemplo 2: dicionários sem sobreposição mapeando 252 cadeias curtas para números inteiros e vice-versa:

% python -m timeit -s 'from htmlentitydefs import codepoint2name as x, name2codepoint as y' 'z1=dict(x.items() + y.items())'
1000 loops, best of 3: 260 usec per loop
% python -m timeit -s 'from htmlentitydefs import codepoint2name as x, name2codepoint as y' 'z2=dict(x, **y)'               
10000 loops, best of 3: 26.9 usec per loop

z2 ganha por um fator de 10. Essa é uma grande vitória no meu livro!

Depois de comparar esses dois, perguntei-me se z1o baixo desempenho poderia ser atribuído à sobrecarga de construir as duas listas de itens, o que me levou a pensar se essa variação poderia funcionar melhor:

from itertools import chain
z3 = dict(chain(x.iteritems(), y.iteritems()))

Alguns testes rápidos, por exemplo

% python -m timeit -s 'from itertools import chain; from htmlentitydefs import codepoint2name as x, name2codepoint as y' 'z3=dict(chain(x.iteritems(), y.iteritems()))'
10000 loops, best of 3: 66 usec per loop

levou-me a concluir que z3é um pouco mais rápido do que z1, mas não tão rápido quantoz2 . Definitivamente não vale toda a digitação extra.

Ainda falta a essa discussão algo importante, que é uma comparação de desempenho dessas alternativas com a maneira "óbvia" de mesclar duas listas: usando o updatemétodo Para tentar manter as coisas em pé de igualdade com as expressões, nenhuma das quais modifica x ou y, vou fazer uma cópia de x em vez de modificá-la no local, da seguinte maneira:

z0 = dict(x)
z0.update(y)

Um resultado típico:

% python -m timeit -s 'from htmlentitydefs import codepoint2name as x, name2codepoint as y' 'z0=dict(x); z0.update(y)'
10000 loops, best of 3: 26.9 usec per loop

Em outras palavras, z0e z2parecem ter desempenho essencialmente idêntico. Você acha que isso pode ser uma coincidência? Eu não....

Na verdade, eu chegaria ao ponto de afirmar que é impossível para o código Python puro fazer melhor que isso. E se você puder se sair significativamente melhor em um módulo de extensão C, imagino que o pessoal do Python possa estar interessado em incorporar seu código (ou uma variação na sua abordagem) ao núcleo do Python. Python usadict em muitos lugares; otimizar suas operações é um grande negócio.

Você também pode escrever isso como

z0 = x.copy()
z0.update(y)

como Tony faz, mas (não surpreendentemente) a diferença na notação acaba por não ter nenhum efeito mensurável no desempenho. Use o que parecer melhor para você. Obviamente, ele está absolutamente correto ao apontar que a versão de duas instruções é muito mais fácil de entender.

No Python 3.0 e posterior , você pode usar collections.ChainMapquais grupos vários dictos ou outros mapeamentos juntos para criar uma visão única e atualizável:

>>> from collections import ChainMap
>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> z = dict(ChainMap({}, y, x))
>>> for k, v in z.items():
        print(k, '-->', v)

a --> 1
b --> 10
c --> 11

Atualização para o Python 3.5 e posterior : Você pode usar o dicionário estendido do PEP 448 compactando e descompactando. Isso é rápido e fácil:

>>> x = {'a':1, 'b': 2}
>>> y = y = {'b':10, 'c': 11}
>>> {**x, **y}
{'a': 1, 'b': 10, 'c': 11}

Eu queria algo semelhante, mas com a capacidade de especificar como os valores nas chaves duplicadas foram mesclados, então resolvi isso (mas não o testei muito). Obviamente, essa não é uma expressão única, mas é uma chamada de função única.

def merge(d1, d2, merge_fn=lambda x,y:y):
    """
    Merges two dictionaries, non-destructively, combining 
    values on duplicate keys as defined by the optional merge
    function.  The default behavior replaces the values in d1
    with corresponding values in d2.  (There is no other generally
    applicable merge strategy, but often you'll have homogeneous 
    types in your dicts, so specifying a merge technique can be 
    valuable.)

    Examples:

    >>> d1
    {'a': 1, 'c': 3, 'b': 2}
    >>> merge(d1, d1)
    {'a': 1, 'c': 3, 'b': 2}
    >>> merge(d1, d1, lambda x,y: x+y)
    {'a': 2, 'c': 6, 'b': 4}

    """
    result = dict(d1)
    for k,v in d2.iteritems():
        if k in result:
            result[k] = merge_fn(result[k], v)
        else:
            result[k] = v
    return result

Atualizar um ditado de forma recursiva / profunda

def deepupdate(original, update):
    """
    Recursively update a dict.
    Subdict's won't be overwritten but also updated.
    """
    for key, value in original.iteritems(): 
        if key not in update:
            update[key] = value
        elif isinstance(value, dict):
            deepupdate(value, update[key]) 
    return update

Demonstração:

pluto_original = {
    'name': 'Pluto',
    'details': {
        'tail': True,
        'color': 'orange'
    }
}

pluto_update = {
    'name': 'Pluutoo',
    'details': {
        'color': 'blue'
    }
}

print deepupdate(pluto_original, pluto_update)

Saídas:

{
    'name': 'Pluutoo',
    'details': {
        'color': 'blue',
        'tail': True
    }
}

Obrigado rednaw por edições.

A melhor versão que eu poderia pensar sem usar a cópia seria:

from itertools import chain
x = {'a':1, 'b': 2}
y = {'b':10, 'c': 11}
dict(chain(x.iteritems(), y.iteritems()))

É mais rápido que, dict(x.items() + y.items())mas não tão rápido quanto n = copy(a); n.update(b), pelo menos no CPython. Esta versão também funciona no Python 3 se você mudar iteritems()para items(), o que é feito automaticamente pela ferramenta 2to3.

Pessoalmente, eu gosto mais desta versão porque ela descreve razoavelmente bem o que eu quero em uma única sintaxe funcional. O único pequeno problema é que não fica completamente óbvio que os valores de y têm precedência sobre os valores de x, mas não acredito que seja difícil descobrir isso.

O Python 3.5 (PEP 448) permite uma opção de sintaxe melhor:

x = {'a': 1, 'b': 1}
y = {'a': 2, 'c': 2}
final = {**x, **y} 
final
# {'a': 2, 'b': 1, 'c': 2}

Ou até

final = {'a': 1, 'b': 1, **x, **y}

No Python 3.9 você também usa | e | = com o exemplo abaixo do PEP 584

d = {'spam': 1, 'eggs': 2, 'cheese': 3}
e = {'cheese': 'cheddar', 'aardvark': 'Ethel'}
d | e
# {'spam': 1, 'eggs': 2, 'cheese': 'cheddar', 'aardvark': 'Ethel'}

x = {'a':1, 'b': 2}
y = {'b':10, 'c': 11}
z = dict(x.items() + y.items())
print z

Para itens com chaves nos dois dicionários ('b'), você pode controlar qual deles termina na saída colocando esse último.

Embora a pergunta já tenha sido respondida várias vezes, esta solução simples para o problema ainda não foi listada.

x = {'a':1, 'b': 2}
y = {'b':10, 'c': 11}
z4 = {}
z4.update(x)
z4.update(y)

É tão rápido quanto z0 e o z2 mal mencionado acima, mas fácil de entender e mudar.

def dict_merge(a, b):
  c = a.copy()
  c.update(b)
  return c

new = dict_merge(old, extras)

Entre essas respostas duvidosas e duvidosas, este exemplo brilhante é a única maneira de mesclar ditados em Python, endossado pelo ditador vitalício Guido van Rossum ! Alguém sugeriu metade disso, mas não o colocou em uma função.

print dict_merge(
      {'color':'red', 'model':'Mini'},
      {'model':'Ferrari', 'owner':'Carl'})

dá:

{'color': 'red', 'owner': 'Carl', 'model': 'Ferrari'}

Se você acha que as lambdas são más, não leia mais. Conforme solicitado, você pode escrever a solução rápida e com eficiência de memória com uma expressão:

x = {'a':1, 'b':2}
y = {'b':10, 'c':11}
z = (lambda a, b: (lambda a_copy: a_copy.update(b) or a_copy)(a.copy()))(x, y)
print z
{'a': 1, 'c': 11, 'b': 10}
print x
{'a': 1, 'b': 2}

Como sugerido acima, usar duas linhas ou escrever uma função é provavelmente o melhor caminho a percorrer.

Seja pitônico. Use uma compreensão :

z={i:d[i] for d in [x,y] for i in d}

>>> print z
{'a': 1, 'c': 11, 'b': 10}

No python3, o itemsmétodo não retorna mais uma lista , mas uma exibição , que age como um conjunto. Nesse caso, você precisará fazer a união do conjunto, pois concatenar com +não funcionará:

dict(x.items() | y.items())

Para um comportamento semelhante ao python3 na versão 2.7, o viewitemsmétodo deve funcionar no lugar de items:

dict(x.viewitems() | y.viewitems())

De qualquer forma, prefiro essa notação, pois parece mais natural pensar nela como uma operação de união de conjuntos, em vez de concatenação (como mostra o título).

Editar:

Mais alguns pontos para o python 3. Primeiro, observe que o dict(x, **y)truque não funcionará no python 3, a menos que as chaves ysejam cadeias de caracteres.

Além disso, a resposta do Chainmap de Raymond Hettinger é bastante elegante, pois pode usar um número arbitrário de dictes como argumentos, mas a partir dos documentos parece que ele sequencialmente examina uma lista de todos os dictos para cada pesquisa:

As pesquisas pesquisam os mapeamentos subjacentes sucessivamente até que uma chave seja encontrada.

Isso pode torná-lo mais lento se você tiver muitas pesquisas em seu aplicativo:

In [1]: from collections import ChainMap
In [2]: from string import ascii_uppercase as up, ascii_lowercase as lo; x = dict(zip(lo, up)); y = dict(zip(up, lo))
In [3]: chainmap_dict = ChainMap(y, x)
In [4]: union_dict = dict(x.items() | y.items())
In [5]: timeit for k in union_dict: union_dict[k]
100000 loops, best of 3: 2.15 µs per loop
In [6]: timeit for k in chainmap_dict: chainmap_dict[k]
10000 loops, best of 3: 27.1 µs per loop

Portanto, uma ordem de magnitude mais lenta para pesquisas. Sou fã do Chainmap, mas parece menos prático onde pode haver muitas pesquisas.

Abuso que leva a uma solução de expressão única para a resposta de Mateus :

>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> z = (lambda f=x.copy(): (f.update(y), f)[1])()
>>> z
{'a': 1, 'c': 11, 'b': 10}

Você disse que queria uma expressão, então eu abusei lambdade vincular um nome e as tuplas substituem o limite de expressão única de lambda. Sinta-se livre para encolher.

Você também pode fazer isso, é claro, se não se importar em copiá-lo:

>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> z = (x.update(y), x)[1]
>>> z
{'a': 1, 'b': 10, 'c': 11}

Solução simples usando ferramentas que preservam a ordem (os últimos dicionários têm precedência)

import itertools as it
merge = lambda *args: dict(it.chain.from_iterable(it.imap(dict.iteritems, args)))

E é uso:

>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> merge(x, y)
{'a': 1, 'b': 10, 'c': 11}

>>> z = {'c': 3, 'd': 4}
>>> merge(x, y, z)
{'a': 1, 'b': 10, 'c': 3, 'd': 4}

Dois dicionários

def union2(dict1, dict2):
    return dict(list(dict1.items()) + list(dict2.items()))

n dicionários

def union(*dicts):
    return dict(itertools.chain.from_iterable(dct.items() for dct in dicts))

sumtem um desempenho ruim. Consulte https://mathieularose.com/how-not-to-flatten-a-list-of-lists-in-python/

Embora as respostas sejam boas para este dicionário superficial , nenhum dos métodos definidos aqui realmente faz uma mesclagem profunda de dicionário.

Seguem exemplos:

a = { 'one': { 'depth_2': True }, 'two': True }
b = { 'one': { 'extra': False } }
print dict(a.items() + b.items())

Seria de esperar um resultado de algo assim:

{ 'one': { 'extra': False', 'depth_2': True }, 'two': True }

Em vez disso, obtemos o seguinte:

{'two': True, 'one': {'extra': False}}

A entrada 'one' deveria ter 'depth_2' e 'extra' como itens dentro de seu dicionário se realmente fosse uma mesclagem.

Usando cadeia também, não funciona:

from itertools import chain
print dict(chain(a.iteritems(), b.iteritems()))

Resulta em:

{'two': True, 'one': {'extra': False}}

A fusão profunda que rcwesick deu também cria o mesmo resultado.

Sim, funcionará para mesclar os dicionários de amostra, mas nenhum deles é um mecanismo genérico para mesclar. Atualizarei isso mais tarde, quando escrever um método que faça uma verdadeira mesclagem.

(Somente para Python2.7 *; existem soluções mais simples para Python3 *.)

Se você não tem aversão à importação de um módulo de biblioteca padrão, pode fazer

from functools import reduce

def merge_dicts(*dicts):
    return reduce(lambda a, d: a.update(d) or a, dicts, {})

(O or abit no lambdaé necessário porque dict.updatesempre retorna Nonecom sucesso.)

Se você não se importa de mudar x,

x.update(y) or x

Simples, legível, com bom desempenho. Você sabe update() sempre retorna None, que é um valor falso. Portanto, a expressão acima sempre será avaliada como xapós a atualização.

Os métodos de mutação na biblioteca padrão (como .update()) retornam Nonepor convenção, portanto esse padrão também funcionará nesses. Se você estiver usando um método que não segue esta convenção, ortalvez não funcione. Mas você pode usar uma exibição e índice de tupla para torná-lo uma única expressão. Isso funciona independentemente do que o primeiro elemento avalia.

(x.update(y), x)[-1]

Se você ainda não possui xuma variável, pode lambdacriar um local sem usar uma declaração de atribuição. Isso equivale a usar lambdacomo expressão let , que é uma técnica comum em linguagens funcionais, mas talvez não sintética.

(lambda x: x.update(y) or x)({'a': 1, 'b': 2})

Embora não seja tão diferente do uso a seguir do novo operador de morsa (somente Python 3.8 ou superior):

(x := {'a': 1, 'b': 2}).update(y) or x

Se você deseja uma cópia, o estilo PEP 448 é mais fácil {**x, **y}. Mas se isso não estiver disponível na sua versão (mais antiga) do Python, o padrão let também funcionará aqui.

(lambda z: z.update(y) or z)(x.copy())

(Isso é, obviamente, equivalente a (z := x.copy()).update(y) or z, mas se a sua versão do Python for nova o suficiente para isso, o estilo PEP 448 estará disponível.)

Com base em idéias aqui e em outros lugares, compreendi uma função:

def merge(*dicts, **kv): 
      return { k:v for d in list(dicts) + [kv] for k,v in d.items() }

Uso (testado em python 3):

assert (merge({1:11,'a':'aaa'},{1:99, 'b':'bbb'},foo='bar')==\
    {1: 99, 'foo': 'bar', 'b': 'bbb', 'a': 'aaa'})

assert (merge(foo='bar')=={'foo': 'bar'})

assert (merge({1:11},{1:99},foo='bar',baz='quux')==\
    {1: 99, 'foo': 'bar', 'baz':'quux'})

assert (merge({1:11},{1:99})=={1: 99})

Você poderia usar um lambda.

O problema que tenho com as soluções listadas até o momento é que, no dicionário mesclado, o valor da chave "b" é 10, mas, na minha opinião, deve ser 12. Nesse ponto, apresento o seguinte:

import timeit

n=100000
su = """
x = {'a':1, 'b': 2}
y = {'b':10, 'c': 11}
"""

def timeMerge(f,su,niter):
    print "{:4f} sec for: {:30s}".format(timeit.Timer(f,setup=su).timeit(n),f)

timeMerge("dict(x, **y)",su,n)
timeMerge("x.update(y)",su,n)
timeMerge("dict(x.items() + y.items())",su,n)
timeMerge("for k in y.keys(): x[k] = k in x and x[k]+y[k] or y[k] ",su,n)

#confirm for loop adds b entries together
x = {'a':1, 'b': 2}
y = {'b':10, 'c': 11}
for k in y.keys(): x[k] = k in x and x[k]+y[k] or y[k]
print "confirm b elements are added:",x

Resultados:

0.049465 sec for: dict(x, **y)
0.033729 sec for: x.update(y)                   
0.150380 sec for: dict(x.items() + y.items())   
0.083120 sec for: for k in y.keys(): x[k] = k in x and x[k]+y[k] or y[k]

confirm b elements are added: {'a': 1, 'c': 11, 'b': 12}

É tão bobo que .updatenão retorna nada.
Eu apenas uso uma função auxiliar simples para resolver o problema:

def merge(dict1,*dicts):
    for dict2 in dicts:
        dict1.update(dict2)
    return dict1

Exemplos:

merge(dict1,dict2)
merge(dict1,dict2,dict3)
merge(dict1,dict2,dict3,dict4)
merge({},dict1,dict2)  # this one returns a new copy

from collections import Counter
dict1 = {'a':1, 'b': 2}
dict2 = {'b':10, 'c': 11}
result = dict(Counter(dict1) + Counter(dict2))

Isso deve resolver seu problema.

Isso pode ser feito com uma única compreensão de ditado:

>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> { key: y[key] if key in y else x[key]
      for key in set(x) + set(y)
    }

Na minha opinião, a melhor resposta para a parte de "expressão única", pois não são necessárias funções extras, e é curta.

Haverá uma nova opção quando o Python 3.8 for lançado ( programado para 20 de outubro de 2019 ), graças ao PEP 572: Assignment Expressions . O novo operador de expressão de atribuição :=permite atribuir o resultado do copye ainda usá-lo para chamar update, deixando o código combinado em uma única expressão, em vez de duas instruções, alterando:

newdict = dict1.copy()
newdict.update(dict2)

para:

(newdict := dict1.copy()).update(dict2)

enquanto se comporta de maneira idêntica em todos os aspectos. Se você também deve retornar o resultado dict(você solicitou uma expressão retornando o dict; o acima cria e atribui a newdict, mas não a retorna, portanto, você não pode usá-la para passar um argumento para uma função como está, à la myfunc((newdict := dict1.copy()).update(dict2))) , adicione apenas or newdictaté o final (como updateretorna None, que é falso, ele avaliará e retornará newdictcomo resultado da expressão):

(newdict := dict1.copy()).update(dict2) or newdict

Advertência importante: Em geral, desencorajaria essa abordagem em favor de:

newdict = {**dict1, **dict2}

A abordagem de descompactação é mais clara (para quem sabe sobre descompactação generalizada em primeiro lugar, o que você deveria ), não exige um nome para o resultado (portanto, é muito mais conciso ao construir um temporário que é imediatamente passado para um ou incluída em um list/ tupleliteral ou similar) e é quase certamente mais rápida, sendo (no CPython) aproximadamente equivalente a:

newdict = {}
newdict.update(dict1)
newdict.update(dict2)

mas feito na camada C, usando a dictAPI concreta , portanto, nenhuma sobrecarga de pesquisa / ligação de método dinâmico ou sobrecarga de despacho de chamada de função está envolvida (onde (newdict := dict1.copy()).update(dict2)inevitavelmente é idêntico ao comportamento de duas linhas original, executando o trabalho em etapas discretas, com pesquisa dinâmica / ligação / invocação de métodos.

Também é mais extensível, pois a fusão de três dicts é óbvia:

 newdict = {**dict1, **dict2, **dict3}

onde o uso de expressões de atribuição não será escalado dessa maneira; o mais próximo que você poderia chegar seria:

 (newdict := dict1.copy()).update(dict2), newdict.update(dict3)

ou sem a tupla temporária de Nones, mas com o teste de veracidade de cada Noneresultado:

 (newdict := dict1.copy()).update(dict2) or newdict.update(dict3)

é obviamente muito mais feio e inclui outras ineficiências (um desperdício temporário tuplede Nones para separação por vírgula ou teste de veracidade inútil do retorno de cada updateum Nonepara a orseparação).

A única vantagem real da abordagem de expressão de atribuição ocorre se:

1. Você tem código genérico que precisa lidar com sets e dicts (ambos suportam copye update, portanto, o código funciona da maneira que você espera)
2. Você espera receber objetos arbitrários do tipo ditado , não apenas dictele próprio, e deve preservar o tipo e a semântica do lado esquerdo (em vez de terminar com um simples dict). Embora myspecialdict({**speciala, **specialb})possa funcionar, isso envolveria um temporário extra dicte, se myspecialdictpossui recursos simples, dictnão pode preservar (por exemplo, dicts regulares agora preservam a ordem com base na primeira aparência de uma chave e o valor com base na última aparência de uma chave; você pode querer aquele que preserva a ordem com base no último aparência de uma chave, para que a atualização de um valor também a mova para o final), então a semântica estaria errada. Como a versão da expressão de atribuição usa os métodos nomeados (que provavelmente são sobrecarregados para se comportarem adequadamente), ela nunca cria umdictde qualquer maneira (a menos que dict1já tenha sido a dict), preservando o tipo original (e a semântica do tipo original), evitando todos os temporários.

>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> x, z = dict(x), x.update(y) or x
>>> x
{'a': 1, 'b': 2}
>>> y
{'c': 11, 'b': 10}
>>> z
{'a': 1, 'c': 11, 'b': 10}