Méthode de fonctionnement de la structure du dictionnaire dict de Python

Cet article présente principalement la méthode de fonctionnement de la structure du dictionnaire dict de Python. Le fonctionnement du dictionnaire est la connaissance de base pour l'apprentissage d'introduction à Python. Les amis dans le besoin peuvent se référer à

1. Méthode de base du dictionnaire

1. Créer un nouveau dictionnaire

1), créer un dictionnaire vide

>>> dict1={} 
>>> dict2=dict() 
>>> dict1,dict2 
({}, {})

2), initialiser une valeur lors de la création d'une nouvelle

>>> dict1={1:'a',2:'b',3:'c'} 
>>> dict1 
{1: 'a', 2: 'b', 3: 'c'}

3), utiliser un tuple

>>> dict1=dict([(1,'a'),(2,'b'),(3,'c')]) 
>>> dict1 
{1: 'a', 2: 'b', 3: 'c'}

2. Méthode d'obtention

1), obtenir (clé) Obtenez-en une du dictionnaire La valeur correspondant à la clé renvoie la valeur

>>> dict1={1:'a',2:'b',3:'c'} 
>>> dict1.get(1) 
'a'

Si elle n'existe pas dans le dictionnaire. , un NoneType

est renvoyé

>>> type(dict1.get(4)) 
<type &#39;NoneType&#39;>

Si la valeur de clé requise n'existe pas, spécifiez une autre valeur à renvoyer

.

>>> dict1.get(4,'not found') 
'not found'

2), key() Récupère toutes les valeurs clés du dictionnaire et renvoie une liste

>>> dict1.keys() 
[1, 2, 3]

3), valeurs () Correspondant à la méthode clés(), la liste renvoyée de toutes les valeurs du dictionnaire

>>> dict1.values() 
['a', 'b', 'c']

4), items() renvoie un tuple correspondant (clé, valeur)

>>> dict1.items() 
[(1, 'a'), (2, 'b'), (3, 'c')]

5), iterkeys(), itervalues() , iteritems() obtient également toutes les clés et valeurs respectivement, (clé, valeur) tuple, ne renvoie tout simplement plus une liste, mais un itérateur

>>> for key in dict1.iterkeys(): 
 print key 
1 
2 
3

3. Définir la valeur du dictionnaire La méthode

1), la méthode directe est

>>> dict1[4]='d' 
>>> dict1 
{1: 'a', 2: 'b', 3: 'c', 4: 'd'}

Cependant, cette méthode est la suivante : si la valeur clé que je souhaite ajouter est déjà dans le dictionnaire, la valeur d'origine sera écrasée

>>> dict1[4]='e' 
>>> dict1 
{1: 'a', 2: 'b', 3: 'c', 4: 'e'}

2), setdefault (clé, valeur) L'avantage de cette méthode est que si la clé insérée n'existe pas dans le dictionnaire, alors insérez-la dans le dictionnaire et renvoyez la valeur. Sinon, s'il existe dans le dictionnaire, renvoie la valeur existante et n'écrasera pas

>>> dict1 
{1: 'a', 2: 'b', 3: 'c', 4: 'e'} 
>>> dict1.setdefault(5,'f') 
'f' 
>>> dict1.setdefault(5,'g') 
'f' 
>>> dict1 
{1: 'a', 2: 'b', 3: 'c', 4: 'e', 5: 'f'}

4. 1) pop(key) Supprime un élément de la clé spécifiée et renvoie avec succès une suppression. Si la valeur de l'élément n'existe pas, une exception sera levée. Par conséquent, lorsque vous utilisez cette méthode, vous devez juger si la clé. existe, ou intercepter l'exception

>>> def pop_key(d,key): 
 try: 
 d.pop(key) 
 print "sucess" 
 except: 
 print "key is not in dict" 
>>> dict1 
{1: 'a', 2: 'b'} 
>>> pop_key(dict1,3) 
key is not in dict

ou

>>> def sub_dict2(d,key): 
 if d.has_key(key): 
 d.pop(key) 
 print "sucess" 
 else:print "key is not in dict" 
 
>>> pop_key(dict1,3) 
key is not in dict

Le has_key (key) ici sert à déterminer si la clé est dans le dictionnaire, bien sûr, vous pouvez également utiliser key in d à la place

2) popitem() est similaire à pop(), sauf qu'il supprime un tuple (clé, valeur)

En utilisant la méthode ci-dessus, vous pouvez utiliser une utilisation avancée

A Nous créons un dictionnaire à travers 2 listes. la liste contient toutes les clés, et la deuxième liste contient toutes les valeurs

>>> list1=[1,2,3] 
>>> list2=['a','b','c'] 
>>> dict1=dict(zip(list1,list2)) 
>>> dict1 
{1: 'a', 2: 'b', 3: 'c'}

B. dictionnaire d'un dictionnaire

>>> dict1 
{1: 'a', 2: 'b', 3: 'c'} 
>>> dict1=dict([(1,'a'),(2,'b'),(3,'c')]) 
>>> dict1 
{1: 'a', 2: 'b', 3: 'c'} 
>>> subkeys=[1,3] 
>>> def sub_dict(d,subkeys): 
 return dict([(k,d.get(k)) for k in subkeys if k in d]) 
 
>>> print sub_dict(dict1,subkeys) 
{1: 'a', 3: 'c'}

C Inversez le dictionnaire, c'est-à-dire que la clé devient la valeur du nouveau dictionnaire et la valeur devient la clé. du nouveau dictionnaire (à noter que s'il y a des valeurs en double, le dictionnaire inversé n'en conservera qu'une

>>> def invert_dict(d): 
 return dict([(k,v) for v,k in d.iteritems()]) 
 
>>> print invert_dict(dict1) 
{'a': 1, 'c': 3, 'b': 2} 
>>>

5. Autres méthodes de base

1) has_key(key) Détermine si la clé est dans le dictionnaire

2) copy() renvoie une copie du dictionnaire (la copie est une copie superficielle)

>>> d2={1:[1],2:[2],3:[3]} 
>>> d3=d2.copy() 
>>> d3[1].append(4) 
>>> d2[1] 
[1, 4]

Si vous souhaitez faire une copie complète, vous devez utiliser copy.deepcopy(a)

>>> d2={1:[1],2:[2],3:[3]} 
>>> import copy 
>>> d3=copy.deepcopy(d2) 
>>> d3[1].append(4) 
>>> print d2[1] , d3[1] 
[1] [1, 4]

3) clear() pour effacer le dict

4) update(d) utiliser a Le dictionnaire est mis à jour avec un autre dictionnaire, ce qui est un peu similaire à la fusion de deux dictionnaires

>>> dict1={1: 'a', 2: 'b', 3: 'c'} 
>>> dict2={1:'x',4:'y'} 
>>> dict1.update(dict2) 
>>> dict1 
{1: 'x', 2: 'b', 3: 'c', 4: 'y'} 
>>>

2. Parcourir

Il existe de nombreuses façons de parcourir un dictionnaire

1. Utilisez dict directement

>>> d 
{'a': 'aa', 'c': 'cc', 'b': 'bb'} 
>>> for i in d: 
 print i,d[i] 
 
a aa 
c cc 
b bb

2. Utiliser les éléments()

>>> for i,v in d.items(): 
 print i,v 
 
a aa 
c cc 
b bb

Bien sûr, vous pouvez aussi faire cela

>>> for (i,v) in d.items(): 
 print i,v 
 
a aa 
c cc 
b bb

Je See More rappelez-vous qu'il y avait un article comparant l'efficacité de ces deux méthodes (avec et sans parenthèses). Il disait que lorsque la taille du dictionnaire est inférieure à 200, elle est plus rapide avec les parenthèses, et au-dessus de 200. En faisant cela, la vitesse sans parenthèses est. un peu plus rapide, mais je ne l'ai pas testé spécifiquement.

3. iteritems()

(Je pense que c'est une meilleure méthode)

>>> for k,v in d.iteritems(): 
 print k,v 
 
a aa 
c cc 
b bb

Autres Il existe également des méthodes de traversée, mais je pense que ces 3 suffisent

3. Quelques utilisations avancées

1. -tasking Valeurs

En général, les dictionnaires sont mappés un à un, mais si nous avons besoin d'un mappage un à plusieurs, comme un livre, nous devons compter le nombre de pages où apparaissent quelques mots. Ensuite, vous pouvez utiliser list comme valeur de dict. Cela peut être accompli en utilisant la méthode setdefault()

>>> d={'hello':[1,4,9],"good":[1,3,6]} 
>>> d 
{'good': [1, 3, 6], 'hello': [1, 4, 9]} 
>>> d.setdefault('good',[]).append(7) 
>>> d 
{'good': [1, 3, 6, 7], 'hello': [1, 4, 9]} 
>>> d.setdefault('bad',[]).append(2) 
>>> d 
{'bad': [2], 'good': [1, 3, 6, 7], 'hello': [1, 4, 9]} 
>>>

当然，如果写成一个函数话，就可以更方便的使用，
我们也可以利用set来代替list

>>> def addFunc(d,word,pag): 
 d.setdefault(word,set()).add(pag) 
>>> d={'hello':set([1,4,9]),"good":set([1,3,6])} 
>>> addFunc(d,'hello',8) 
>>> d 
{'good': set([1, 3, 6]), 'hello': set([8, 1, 4, 9])} 
>>> addFunc(d,'bad',8) 
>>> d 
{'bad': set([8]), 'good': set([1, 3, 6]), 'hello': set([8, 1, 4, 9])}

2、利用字典完成简单工厂模式
字典的value不单单只是一些常见的字符串，数值，还可以是类和方法，比如我们就可以这样来实现简单工厂模式

>>> class cat(object): 
 def __init__(self): 
 print 'cat init' 
>>> class dog(object): 
 def __init__(self): 
 print 'dag init' 
>>> d={'cat':cat,'dog':dog} 
>>> def factoryFunc(d,name): 
 if name in d: 
 return d[name]() 
 else: 
 raise Exception("error") 
>>> cat=factoryFunc(d,'cat') 
cat init

另外一个例子，利用变量来控制执行的函数

>>> def deal_cat(): 
 print 'cat run!!' 
 
>>> def deal_dog(): 
 print 'dag run!!' 
 
>>> d={'cat':deal_cat ,'dog':deal_dog } 
>>> animal='cat' 
>>> d[animal]() 
cat run!!

更多Python的dict字典结构操作方法相关文章请关注PHP中文网！