python3基础-字典 dictionary

blake

字典是Python里面一种无序存储结构，存储的是键值对 key - value。关键字应该为不可变类型，如字符串、整数、包含不可变对象的元组。

字典的创建很简单，用 d = {key1 : value2, key2 : value2}的形式就可以创建一个新的字典，当然也可以通过 dict 接受一个含有键，值的序列对或者关键字参数来创建字典。

键可以是多种类型，但键是唯一的不重复的，值可以不唯一

1. >>> d = {'a':1, 'b':2}  
   
2. >>> d  
   
3. {'b': 2, 'a': 1}  
   
4. >>> L = [('Jonh',18), ('Nancy',19)]  
   
5. >>> d = dict(L)  #通过包含键值的列表创建  
   
6. >>> d  
   
7. {'Jonh': 18, 'Nancy': 19}   
   
8. >>> T = tuple(L)  
   
9. >>> T  
   
10. (('Jonh', 18), ('Nancy', 19))  
    
11. >>> d = dict(T) #通过包含键值的元组创建  
    
12. >>> d  
    
13. {'Jonh': 18, 'Nancy': 19}  
    
14. >>> d = dict(x = 1, y = 3)  #通过关键字参数创建  
    
15. >>> d  
    
16. {'x': 1, 'y': 3}  
    
17. >>> d[3] = 'z'  
    
18. >>> d  
    
19. {3: 'z', 'x': 1, 'y': 3}  

复制代码

还有一个创建字典的方法就是 fromkeys(S [ , v]) python里的解释是 New dict with key from S and value equal to v ，即将S里的元素作为键，v作为所有键的值，v 的默认值为 None。可以通过已存在的字典 d 调用 d.fromkeys(S [, v] ) 也可以通过类型调用 dict.fromkeys( S [, v] )

1. >>> d  
   
2. {3: 'z', 'y': 3}  
   
3. >>> L1 = [1,2,3]  
   
4. >>> d.fromkeys(L1)  
   
5. {1: None, 2: None, 3: None}  
   
6. >>> {}.fromkeys(L1,'nothing')  
   
7. {1: 'nothing', 2: 'nothing', 3: 'nothing'}  
   
8. >>> dict.fromkeys(L1,'over')  
   
9. {1: 'over', 2: 'over', 3: 'over'}  

复制代码

字典是无序的，所以不能通过索引来获取值，要通过键来找到关联值。对于不存在的键，会出现错误KeyError

1. >>> d  
   
2. {3: 'z', 'x': 1, 'y': 3}  
   
3. >>> d[3]  
   
4. 'z'  
   
5. >>> d['x']  
   
6. 1  
   
7. >>> d[0]  
   
8. Traceback (most recent call last):  
   
9.   File "<pyshell#26>", line 1, in <module>  
   
10.     d[0]  
    
11. KeyError: 0  

复制代码

字典操作和方法：

len( d )  返回字典d里面的键值对数目

x in d   查询字典d中是否有键 x

1. >>> d = {'x':1,'y':3}  
   
2. >>> len(d)  
   
3. 2  
   
4. >>> 'x' in d  
   
5. True  
   
6. >>> 'z' not in d  
   
7. True  

复制代码

d [ x ] = y  若键 x 存在，则修改 x 对应的值为 y， 若键 x 不存在，则在字典 d 中增加键值对 x : y

1. >>> d  
   
2. {'x': 1, 'y': 3}  
   
3. >>> d['x'] = 1.5  
   
4. >>> d  
   
5. {'x': 1.5, 'y': 3}  
   
6. >>> d['z'] = 5  
   
7. >>> d  
   
8. {'z': 5, 'x': 1.5, 'y': 3}  

复制代码

del d[x]  删除字典 d 中键为 x 的键值对，若 x 不存在会出现 KeyError

1. >>> d = {'z': 5, 'x': 1.5, 'y': 3}  
   
2. >>> del d['x']  
   
3. >>> d  
   
4. {'z': 5, 'y': 3}  
   
5. >>> del d['x']  
   
6. Traceback (most recent call last):  
   
7.   File "<pyshell#66>", line 1, in <module>  
   
8.     del d['x']  
   
9. KeyError: 'x'  

复制代码

d.clear() 清空字典d

d.copy() 对字典 d 进行浅复制，返回一个和d有相同键值对的新字典

1. >>> d  
   
2. {'z': 5, 'y': 3}  
   
3. >>> d.copy()  
   
4. {'z': 5, 'y': 3}  

复制代码

d.get( x [ , y]) 返回字典 d 中键 x 对应的值，键 x 不存在的时候返回 y， y 的默认值为None

1. >>> d = {'z': 5, 'x': 1.5, 'y': 3}  
   
2. >>> d.get('x')  
   
3. 1.5  
   
4. >>> del d['x']  
   
5. >>> d.get('x')  
   
6. >>> d.get('x','nothing')  
   
7. 'nothing'  

复制代码

d.items() 将字典 d 中所有键值对以dict_items的形式返回（python 2中d.iteritems() 返回一个针对键值对的迭代器对象，Python 3中没有 iteritems 方法了）

1. >>> d = {'z': 5, 'x': 1.5, 'y': 3}  
   
2. >>> d.items()  
   
3. dict_items([('z', 5), ('x', 1.5), ('y', 3)])  
   
4. >>> list(d.items())  
   
5. [('z', 5), ('x', 1.5), ('y', 3)]  

复制代码

d.keys() 将字典 d 中所有的键以dict_keys形式返回（Python 2 中d.iterkeys() 返回一个针对键的迭代器对象，Python 3 没有此语法）

1. >>> d.keys()  
   
2. dict_keys(['z', 'x', 'y'])  
   
3. >>> for x in d.keys():  
   
4.     print(x)  
   
5.   
   
6.       
   
7. z  
   
8. x  
   
9. y  

复制代码

d.pop( x ) 返回给定键 x 对应的值，并将该键值对从字典中删除

1. >>> d = {'z': 5, 'x': 1.5, 'y': 3}  
   
2. >>> d.pop('x')  
   
3. 1.5  
   
4. >>> d.pop('x')  
   
5. Traceback (most recent call last):  
   
6.   File "<pyshell#92>", line 1, in <module>  
   
7.     d.pop('x')  
   
8. KeyError: 'x'  

复制代码

d.popitem( ) 返回并删除字典 d 中随机的键值对

1. >>> d = {'z': 5, 'x': 1.5, 'y': 3}  
   
2. >>> d.popitem()  
   
3. ('z', 5)  
   
4. >>> d.popitem()  
   
5. ('x', 1.5)  

复制代码

d.setdefault( x, [ , y ] )  返回字典 d 中键 x 对应的值，若键 x 不存在，则返回 y， 并将 x : y 作为键值对添加到字典中，y 的默认值为 None

1. >>> d = {'z': 5, 'x': 1.5, 'y': 3}  
   
2. >>> d.setdefault('x')  
   
3. 1.5  
   
4. >>> del d['x']  
   
5. >>> d.setdefault('x','Look!')  
   
6. 'Look!'  
   
7. >>> d  
   
8. {'z': 5, 'x': 'Look!', 'y': 3}  

复制代码

d.update( x ) 将字典 x 所有键值对添加到字典 d 中（不重复，重复的键值对用字典 x 中的键值对替代字典 d 中）

1. >>> d1 = {'x':1, 'y':3}  
   
2. >>> d2 = {'x':2, 'z':1.4}  
   
3. >>> d1.update(d2)  
   
4. >>> d1  
   
5. {'z': 1.4, 'x': 2, 'y': 3}  

复制代码

d.values( ) 将字典里所有的值以dict_values 的形式返回（Python 2 中d.itervalues() 返回针对字典d里所有值的迭代器对象，Python 3无此语法）

1. >>> d1  
   
2. {'z': 1.4, 'x': 2, 'y': 3}  
   
3. >>> d1.values()  
   
4. dict_values([1.4, 2, 3])  
   
5. >>> list(d1.values())  
   
6. [1.4, 2, 3]  

复制代码