Tutoriel sur la façon de fusionner deux dictionnaires en Python

Le dictionnaire est le seul type de mappage dans le langage Python. Nous le rencontrons souvent dans notre travail quotidien. L'article suivant vous présente principalement les informations pertinentes sur la façon de fusionner élégamment deux dictionnaires (dict) en Python. L'introduction à travers l'exemple de code est très détaillée. Les amis dans le besoin peuvent s'y référer.

Préface

Les dictionnaires sont l'un des types de données les plus puissants de Python. Cet article vous donnera une introduction détaillée à la fusion de deux dictionnaires dans Python. Le contenu lié à Python (dict) est partagé pour la référence et l'étude de chacun. Pas grand chose à dire, jetons un coup d'œil à l'introduction détaillée.

Une ligne de code fusionne deux dicts

Supposons qu'il y ait deux dicts x et y, fusionnez-les dans un nouveau dict, non Changer les valeurs de x et y, telles que

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

devrait obtenir un nouveau résultat Z. Si la clé est la même, y couvre x . Le résultat souhaité est

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

Dans PEP448, il existe une nouvelle syntaxe qui peut être implémentée, et cette syntaxe est prise en charge dans python3.5. Le code fusionné est le suivant. suit

z = {**x, **y}

Une ligne de code appropriée. Étant donné que de nombreuses personnes utilisent encore python2, pour les personnes possédant python2 et python3.0-python3.4, il existe une méthode plus élégante, mais elle nécessite deux lignes de code.

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

Dans la méthode ci-dessus, y écrasera le contenu dans x, donc le résultat final est b=3.

Non Comment le faire en une seule ligne en utilisant python3.5 Ensuite, le moyen le plus efficace est de le mettre dans une fonction :

puis de terminer l'appel en une seule ligne de code :

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

Vous pouvez également définir une fonction pour fusionner plusieurs dicts, comme

 z = merge_two_dicts(x, y)

puis utilisez-le comme ceci

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

Dans tout cela, la même clé couvre toujours la précédente.

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

Quelques manifestations inélégantes

articles

Certaines personnes Cette méthode sera utilisé :

Il s'agit en fait de créer deux listes dans la mémoire, puis de créer une troisième liste. Une fois la copie terminée, créez un nouveau dict. , supprimez les trois premières listes. Cette méthode consomme des performances, et pour python3, elle ne peut pas être exécutée correctement car items() renvoie un objet.

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

Vous devez le convertir explicitement dans une liste,

, ce qui est un gaspillage de performances. De plus, la méthode d'union des listes renvoyées par
échouera également pour python3. De plus, la méthode d'union entraîne une incertitude dans les valeurs des clés répétées. Par conséquent, si vous comparez deux, il existe des exigences de priorité pour la fusion de dict. , cette méthode est donc totalement inappropriée.

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

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

Voici un exemple où y devrait avoir la priorité, mais en raison d'un ordre arbitraire, la valeur de x est conservée :

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

Constructeur

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

Certaines personnes l'utilisent également de cette façon

C'est très bon à utiliser, beaucoup plus efficace que la méthode précédente en deux étapes, mais la lisibilité est mauvaise et pas assez pythonique. Si la clé n'est pas une chaîne, l'opération échouera quand même en python3

.

z = dict(x, **y)

Le maître Guido van Rossum a dit : Déclarer

est illégal car c'est après tout un abus du mécanisme. Bien que cette méthode soit plus hacky, elle est trop opportuniste.

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

Quelques performances médiocres mais méthodes plus élégantesdict（{}， {1：3}）

Les méthodes suivantes, bien que peu performantes, sont bien meilleures que la méthode des éléments . Et prend en charge la priorité.

Cela peut être fait en python2.6

{k: v for d in dicts for k, v in d.items()}

itertools.chain sera dans l'ordre correct des itérateurs de chaîne sur les paires clé-valeur :

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

Test de performances

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

Ce qui suit a été réalisé sur Ubuntu 14.04, en Python 2.7 (Système Python) :

en python3.5

>>> 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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!