Utilisation dans le dictionnaire Python que vous devez connaître

La version Python de cet article est 3.7.X Avant de lire cet article, vous devez comprendre l'utilisation de base du dictionnaire Python.

Introduction

Le dictionnaire (dict) est une structure de données intégrée à Python, composée de plusieurs paires clé-valeur. (clé) et valeur (valeur) sont séparés par des deux-points, chaque paire clé-valeur est séparée par des virgules (,), l'intégralité du dictionnaire est incluse entre accolades ({}), la clé doit être unique et la valeur peut être de n'importe quel type. Mais les clés doivent être de type immuable comme une chaîne, un nombre ou un tuple.

Recommandé : "Tutoriel Python"

La couche inférieure utilise une table de hachage pour associer les clés et la valeur, dict n'est pas ordonné. Les fonctionnalités incluent :

● La vitesse de recherche et d'insertion est extrêmement rapide et ne ralentira pas à mesure que le nombre de clés augmente

● Elle nécessite plus de mémoire

Donc, dictez ; est une structure de données qui échange de l'espace contre du temps et est utilisée dans des scénarios où une recherche rapide est requise.

Opération : méthodes courantes

get()

Renvoyer la valeur de la clé spécifiée Si la clé n'existe pas, renvoyer la valeur par défaut. (la valeur par défaut est None ) sans signaler d'erreur, la syntaxe est dict.get(key).

dict_1['age'] = 24
In [7]: print(dict_1.get('age'))
24
In [11]: print(dict_1.get('nama'))
None
In [12]: print(dict_1['nama'])
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-12-ef61a380920e> in <module>
----> 1 print(dict_1[&#39;nama&#39;])
KeyError: &#39;nama&#39;

key in dict

Utilisez l'opérateur in pour déterminer si la clé existe dans le dictionnaire. Si elle existe, elle renvoie True, sinon elle renvoie False. la syntaxe est : entrez la clé dans dict .

In [15]: dict_1
Out[15]: {'name': None, 'age': 24, 'sex': None}
In [16]: print('name' in dict_1)
True
In [17]: print('nama' in dict_1)
False

En python 2, cette fonction est implémentée à l'aide de la méthode has_key().

items()

Renvoie un tableau de tuples traversables (clé, valeur) sous forme de liste, la syntaxe est dict.items().

In [18]: dict_1
Out[18]: {'name': None, 'age': 24, 'sex': None}
In [19]: print(dict_1.items())
dict_items([('name', None), ('age', 24), ('sex', None)])
In [20]: for key, value in dict_1.items():
    ...:     print(key, value)
    ...:
name None
age 24
sex None

keys()

Renvoie toutes les clés d'un dictionnaire sous forme de liste : dict.keys()

In [21]: dict_1
Out[21]: {'name': None, 'age': 24, 'sex': None}
In [22]: print(dict_1.keys())
dict_keys(['name', 'age', 'sex'])

values()

Renvoie toutes les valeurs du dictionnaire sous forme de liste : dict.values()

In [27]: dict_1
Out[27]: {'name': None, 'age': 24, 'sex': None, 'sub_name': 'Tony'}
In [28]: print(dict_1.values())
dict_values([None, 24, None, 'Tony'])
setdefault()
和get()类似，用户获得与给顶尖相关联的值，不同的是，该方法如果键不存在时会添加键并将值设为默认值，语法为：dict.setdefault(key, default=None)。
In [23]: dict_1
Out[23]: {'name': None, 'age': 24, 'sex': None}
In [24]: print(dict_1.setdefault('name'))
None
In [25]: print(dict_1.setdefault('name', 'Tony'))
None
In [26]: print(dict_1.setdefault('sub_name', 'Tony'))
Tony
In [27]: dict_1
Out[27]: {'name': None, 'age': 24, 'sex': None, 'sub_name': 'Tony'}

update()

La syntaxe est : dict_1. update(dict_2) est utilisé pour mettre à jour les paires clé-valeur de dict_2 vers dict_1. S'il y a les mêmes clés, elles seront écrasées.

In [31]: dict_1
Out[31]: {'name': None, 'age': 24, 'sex': None, 'sub_name': 'Tony'}
In [32]: dict_2
Out[32]: {'name': 'Mary', 'age': 18, 'sex': None, 'sub_name': ''}
In [33]: dict_1.update(dict_2)
In [34]: dict_1
Out[34]: {'name': 'Mary', 'age': 18, 'sex': None, 'sub_name': ''}

clear()

Supprimez tous les éléments du dictionnaire, dict.clear(), par exemple :

In [1]: dict_1 = dict(name="Tony", age=24)
In [2]: dict_2 = dict_1
In [3]: print(dict_2)
{'name': 'Tony', 'age': 24}
In [4]: dict_2.clear()
In [5]: dict_2
Out[5]: {}
In [6]: dict_1
Out[6]: {}

copie ( )

Copie superficielle du dictionnaire original, renvoyant un nouveau dictionnaire avec les mêmes paires clé-valeur, dict.copy(), par exemple :

In [1]: dict_1 = dict(name='Tony', info=['boy', 24])
In [2]: dict_3 = dict_1.copy()
In [3]: dict_3['name'] = "Ring"
In [4]: dict_3['info'].remove('boy')
In [5]: dict_3
Out[5]: {'name': 'Ring', 'info': [24]}
In [6]: dict_1
Out[6]: {'name': 'Tony', 'info': [24]}

fromkeys( )

Créez un nouveau dictionnaire, dict.fromkeys(seq[, value]), en utilisant les éléments de la séquence seq comme clés du dictionnaire, et value est la valeur initiale correspondant à toutes les clés dans le dictionnaire, où la valeur correspond aux paramètres de sélection, la valeur par défaut est Aucun. Convient pour l'initialisation des données, par exemple :

In [1]: info = ['name', 'age', 'sex']
In [2]: dict_1 = dict.fromkeys(info)
In [3]: dict_1
Out[3]: {'name': None, 'age': None, 'sex': None}

Opérations communes

Fusionner les dictionnaires

Il existe quatre manières :

Traitement général

In [15]: dict_1
Out[15]: {'Tony': 24}
In [16]: dict_2
Out[16]: {'ben': 18}
In [17]: dict3 = dict()
In [18]: for key, value in dict_1.items():
    ...:     dict_3[key] = value
    ...:
In [19]: for key, value in dict_2.items():
    ...:     dict_3[key] = value
    ...:
In [20]: dict_3
Out[20]: {'Tony': 24, 'ben': 18}

update()

In [9]: dict_1
Out[9]: {'Tony': 24}
In [10]: dict_2
Out[10]: {'ben': 18}
In [12]: dict_3 = dict_1.copy()
In [13]: dict_3.update(dict_2)
In [14]: dict_3
Out[14]: {'Tony': 24, 'ben': 18}

Dict(d1, **d2) à l'aide de Méthode du dictionnaire

In [33]: dict_1
Out[33]: {'Tony': 24}
In [34]: dict_2
Out[34]: {'ben': 18}
In [35]: dict_3 = dict(dict_1, **dict_2)
In [36]: dict_3
Out[36]: {'Tony': 24, 'ben': 18}

Avancé

La compréhension du dictionnaire

est similaire à la compréhension de liste, avec l'avantage d'être utilisé au niveau inférieur, la mise en œuvre C sera beaucoup plus rapide et est recommandée.

Échanger les valeurs clés du dictionnaire

Utilisez les compréhensions du dictionnaire pour échanger facilement les valeurs clés d'un dictionnaire :

In [42]: dict_4
Out[42]: {24: 'Tony', 18: 'ben'}
In [43]: dict_3
Out[43]: {'Tony': 24, 'ben': 18}
In [44]: dict_4 = {k:v for v, k in dict_3.items()}
In [45]: dict_4
Out[45]: {24: 'Tony', 18: 'ben'}

Extraction du dictionnaire subsets from

veut créer un dictionnaire qui est lui-même un sous-ensemble d'un autre dictionnaire.

Par exemple :

In [88]: a = {'Ben': 18, 'Jack': 12, 'Ring': 23, 'Tony': 24}
In [89]: b = {k:v for k, v in a.items() if v > 18}
In [90]: b
Out[90]: {'Ring': 23, 'Tony': 24}

Générer un dictionnaire ordonné

Les dictionnaires avant Python3.6 ne sont pas ordonnés, mais nous devons parfois maintenir l'ordre du dictionnaire, orderDict peut obtenir l'ordre du dictionnaire sur la base de dict. L'ordre fait ici référence à l'arrangement dans l'ordre dans lequel les clés du dictionnaire sont insérées. Cela permet d'obtenir un dict premier entré, premier sorti. la limite est dépassée, la clé ajoutée la plus ancienne est supprimée en premier.

Exemple :

In [49]: from collections import OrderedDict
In [50]: ordered_dict = OrderedDict([('a', 2), ('b', 4), ('c', 5)])
In [51]: for key, value in ordered_dict.items():
    ...:     print(key, value)
    ...:
a 2
b 4
c 5

Vous pouvez voir que OrderedDict est trié selon l'ordre d'insertion lors de la création du dictionnaire.

Principe : OrderedDict maintient en interne une liste doublement chaînée, qui organise les positions clés en fonction de l'ordre dans lequel les éléments sont ajoutés, ce qui fait que la taille de OrderedDict est plus de deux fois supérieure à celle d'un dictionnaire ordinaire.

Fusionner les dictionnaires avec la même clé dans la liste

C'est-à-dire pour générer ce que l'on appelle le dictionnaire multi-valeurs à une clé, les valeurs multiples correspondantes doivent à enregistrer dans d'autres conteneurs tels que des listes ou une collection, selon que plusieurs valeurs doivent être uniques.

Par exemple :

In [64]: from collections import defaultdict
In [65]: a = [{'a': 1}, {'b': 3}, {'c': 4}, {'a':5}, {'b':2}, {'b': 4}]
In [66]: b = defaultdict(list)
In [67]: [b[k].append(v) for item in a for k, v in item.items()]
Out[67]: [None, None, None, None, None, None]
In [68]: b
Out[68]: defaultdict(list, {'a': [1, 5], 'b': [3, 2, 4], 'c': [4]})
In [69]: b['a']
Out[69]: [1, 5]

Trouver des similitudes et des différences entre deux dictionnaires

Scénario : Rechercher des similitudes et des différences dans deux dictionnaires, comprenant les mêmes clés ou même valeur.

Analyse : Un dictionnaire est une collection de mappages entre une série de valeurs clés. Il a les caractéristiques suivantes :

keys() renverra toutes les clés du dictionnaire et les clés du dictionnaire. le dictionnaire prend en charge les opérations d'ensemble. , de sorte que les clés du dictionnaire peuvent être traitées en utilisant l'intersection et le complément d'ensembles ;

items() renvoie un objet composé de (clé, valeur), prenant en charge les opérations d'ensemble

;

Les opérations Values() et Set ne sont pas prises en charge car il n'y a aucune garantie que toutes les valeurs soient uniques, mais si une opération de jugement est nécessaire, les valeurs peuvent d'abord être converties en ensembles.

Exemple :

In [78]: a = {'a':1, 'b':2, 'c':3}
In [79]: b = {'b':3, 'c':3, 'd':4}
In [80]: a.keys() & b.keys()
Out[80]: {'b', 'c'}
In [81]: a.keys() - b.keys()
Out[81]: {'a'}
In [82]: a.items() & b.items()
Out[82]: {('c', 3)}

Autre exemple, lors de la création d'un dictionnaire, il est prévu que certaines clés puissent être supprimées :

In [85]: a
Out[85]: {'a': 1, 'b': 2, 'c': 3}
In [86]: c = {k: a[key] for k in a.keys() - {'b'}}
In [87]: c
Out[87]: {'a': 3, 'c': 3}

Cet article est issu du tutoriel python Chronique, bienvenue pour apprendre !

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!