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 :

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

 z = merge_two_dicts(x, y)

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

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

articles

Certaines personnes Cette méthode sera utilisé :

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

, 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()

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

.

z = dict(x, **y)

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

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

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

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