Python's dict dictionary structure operation method

This article mainly introduces the operation method of Python's dict dictionary structure. Learning notebook. The operation of dictionary is the basic knowledge for introductory learning of Python. Friends who need it can refer to

1. Dictionary Basic method

1. Create a new dictionary

1) Create an empty dictionary

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

2), initialize a value when creating a new one

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

3), use tuple

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

2. Obtaining method

1), get(key) Get the value corresponding to a key from the dictionary and return value

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

If it does not exist in the dictionary, return a NoneType

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

If the required key value does not exist, specify another value to return

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

2), keys () Get all the key values ​​​​in the dictionary and return a list

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

3), values() corresponds to the keys() method, and returns the keys in the dictionary List of all values

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

4), items() returns a tuple corresponding to (key, value)

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

5), iterkeys(), itervalues(), iteritems() also obtain all key, value, (key, value) ancestors respectively, but they no longer return a list, but an iterator

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

3. Method of setting dictionary value

1) The direct method is

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

However, this method is that if the key value I want to add is already in the dictionary, then the original one will be overwritten. The value

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

2), setdefault(key, value) The advantage of this method is that if the inserted key does not exist in the dictionary, then insert it into the dictionary and Return the value. Otherwise, if it exists in the dictionary, then the existing value will be returned and will not be overwritten.

>>> 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. Delete the dictionary

1) pop(key) deletes an item of the specified key and successfully returns the value of the deleted item. If it does not exist, an exception will be thrown. Therefore, when using this method, you must judge whether the key is Exists, or catch this 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

## or

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

The has_key (key) here is to determine whether the key is in the dictionary. Of course, you can also use key in d instead

2) popitem() is similar to pop(), except that it deletes A (key, value) tuple

Using the above method, you can use some advanced usage

A. We create a dictionary through 2 lists, the first list are all the keys, and the second list is all the values

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

B. Find the child of a dictionary Dictionary

>>> 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. Reverse the dictionary, that is, the key becomes the value of the new dictionary, and the value becomes the key of the new dictionary (note that if the value has Repeat, the reversed dictionary will only retain one

>>> 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. Other basic methods

1 ) has_key(key) Determine whether the key is in the dictionary

2) copy() returns a copy of the dictionary (the copy is a shallow copy)

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

If you want to deep copy, you need to use 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() clear dict

4) update(d) uses one dictionary to update another dictionary, which is somewhat similar to merging two dictionaries

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

There are many ways to traverse a dictionary

1. Directly use dict

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

2. Use items()

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

##Of course you can also do this

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

I remember that there was an article comparing the efficiency of these two methods (with brackets and without brackets). It said that when the dictionary size is below 200, brackets are faster. When it is above 200, the speed without brackets is a little faster, but I have not tested it specifically.

3. iteritems()

(I think it’s a better method)

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

There are others Traversal methods, but I feel that these 3 are enough

3. Some advanced usage

1. One-click multi-value

Generally, dictionaries are mapped one-to-one, but if we need one-to-many mapping, such as a book, we need to count the number of pages where some words appear. Then, you can use list as the value of dict. This can be accomplished by using the setdefault() method

>>> 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中文网！