«Étendre» Python pour un dictionnaire

Quelle est la meilleure façon d'étendre un dictionnaire avec un autre? Par exemple:

>>> a = { "a" : 1, "b" : 2 }
>>> b = { "c" : 3, "d" : 4 }
>>> a
{'a': 1, 'b': 2}
>>> b
{'c': 3, 'd': 4}

Je recherche une opération pour obtenir cette forboucle d' évitement :

{ "a" : 1, "b" : 2, "c" : 3, "d" : 4 }

Je souhaite faire quelque chose comme:

a.extend(b)  # This does not work

a.update(b)

Dernière documentation de la bibliothèque standard Python

Un beau bijou dans cette question fermée :

La "voie oneliner", ne modifiant aucun des dits d'entrée, est

basket = dict(basket_one, **basket_two)

Découvrez ce que **basket_two(le **) signifie ici .

En cas de conflit, les éléments de basket_tworemplaceront ceux de basket_one. En ce qui concerne les lignes simples, c'est assez lisible et transparent, et je n'ai aucun inconvénient à l'utiliser à chaque fois qu'un dicton qui est un mélange de deux autres est utile (tout lecteur qui a du mal à le comprendre sera en fait très bien servi par la façon dont cela l'incite à se renseigner sur dictle **formulaire ;-). Ainsi, par exemple, utilise comme:

x = mungesomedict(dict(adict, **anotherdict))

sont des occurrences assez fréquentes dans mon code.

Présenté à l'origine par Alex Martelli

Remarque: En Python 3, cela ne fonctionnera que si chaque clé de basket_two est un string.

Avez-vous essayé d'utiliser la compréhension du dictionnaire avec le mappage du dictionnaire:

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

c = {**a, **b}
# c = {"a": 1, "b": 2, "c": 3, "d": 4}

Une autre méthode consiste à utiliser dict (itérable, ** kwarg)

c = dict(a, **b)
# c = {'a': 1, 'b': 2, 'c': 3, 'd': 4}

Dans Python 3.9, vous pouvez ajouter deux dict en utilisant union | opérateur

# use the merging operator |
c = a | b
# c = {'a': 1, 'b': 2, 'c': 3, 'd': 4}

a.update(b)

Ajoutera les clés et les valeurs de b à a , écrasant s'il y a déjà une valeur pour une clé.

Comme d'autres l'ont mentionné, a.update(b)pour certains mourants a, vous bobtiendrez le résultat que vous avez demandé dans votre question. Cependant, je tiens à souligner que de nombreuses fois, j'ai vu la extendméthode de mappage / définition d'objets désirer que dans la syntaxe a.extend(b), ales valeurs de '' NE soient PAS écrasées par bles valeurs de ''. a.update(b)écrase ales valeurs de, et n'est donc pas un bon choix pour extend.

Notez que certaines langues appellent cette méthode defaultsou inject, comme cela peut être considéré comme un moyen d'injecter les valeurs de b (qui pourraient être un ensemble de valeurs par défaut) dans un dictionnaire sans écraser les valeurs qui pourraient déjà exister.

Bien sûr, vous pouvez simplement noter que a.extend(b)c'est presque la même chose que b.update(a); a=b. Pour supprimer l'affectation, vous pouvez le faire ainsi:

def extend(a,b):
    """Create a new dictionary with a's properties extended by b,
    without overwriting.

    >>> extend({'a':1,'b':2},{'b':3,'c':4})
    {'a': 1, 'c': 4, 'b': 2}
    """
    return dict(b,**a)

Merci à Tom Leys pour cette idée intelligente en utilisant un dictconstructeur sans effet secondaire pour extend.

Vous pouvez également utiliser les collections de python.Chainmap qui a été introduit dans python 3.3.

from collections import Chainmap
c = Chainmap(a, b)
c['a'] # returns 1

Cela présente quelques avantages possibles, selon votre cas d'utilisation. Ils sont expliqués plus en détail ici , mais je vais donner un bref aperçu:

• Un plan de chaîne utilise uniquement des vues des dictionnaires, donc aucune donnée n'est réellement copiée. Il en résulte un chaînage plus rapide (mais une recherche plus lente)
• Aucune clé n'est réellement remplacée, si nécessaire, vous savez si les données proviennent de a ou b.

Cela le rend principalement utile pour des choses comme les dictionnaires de configuration.

Si vous en avez besoin en tant que classe , vous pouvez l'étendre avec dict et utiliser la méthode de mise à jour :

Class a(dict):
  # some stuff
  self.update(b)