python字典和集合

1. 字典字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。Python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变类型，如：数字、字符串、只含不可变类型元素的元组（1,2,3,’abc’）、实现__hash__()方法的自定义对象（因为__hash__()须返回一个整数，否则会出现异常：TypeError: an integer is required）。可以用hash(obj)检测对象是否是可哈希的。 
 
>>> class HashEnable(object):  
...    def  __hash__(self):  
...         return 1 
>>> he = HashEnable()  
>>> hash(he)  
1 
>>> d = {he:1}  
>>> d = {['1',2]:2}  
Traceback (most recent call last): 
   File "<stdin>", line 1, in <module> TypeError: unhashable type: 'list'  
 
1.1 字典常用操作 
（1）创建字典 
 
>>> d1 = {}  
>>> d2 = {'player':'QVOD','game':'kw'}  
>>> d1,d2 
({}, {'player': 'QVOD', 'game': 'kw'})    
>>> d3 = dict((['name','alex'],['sex','man']))  
>>> d3  
{'name': 'alex', 'sex': 'man'}  
>>> d33 = d3.copy()  
>>> d33  
{'name': 'alex', 'sex': 'man'}    
>>> d4 = {}.fromkeys(('alex','zhou'),1)  
>>> d4  
{'alex': 1, 'zhou': 1}  
>>> d5 = {}.fromkeys(('alex','zhou'))  
>>> d5  
{'alex': None, 'zhou': None}  
 
（2）遍历字典 
ps：访问一个不存在的key时，会发生KeyError异常，访问前可使用in或not in判断一下。 
 
>>> d = {'name':'alexzhou','sex':'man'}    
>>> for key in d:  
...     print '%s,%s' %(key,d[key])  
...   
name,alexzhou  
sex,man    
>>> d['name']  
'alexzhou' 
>>> d2 = {'name':'alexzhou','age':100}  
>>> print 'name: %s,age: %d' %(d2['name'],d2['age'])  
name: alexzhou,age: 100   
>>> d2['sex']  
Traceback (most recent call last):    
   File "<stdin>", line 1, in <module> KeyError: 'sex'   
>>> 'sex' in d2  
False 
>>> 'name' in d2  
True  
 
（3）更新字典 
 
>>> d = {'name':'alexzhou','age':100}  
>>> d['age'] = 88 
>>> d  
{'age': 88, 'name': 'alexzhou'}  
>>> d.pop('age')  
88 
>>> d {'name': 'alexzhou'}  
>>> d.clear()  
>>> d  
{}  
 
1.2 常用内建函数 
（1）cmp() 
字典的比较：首先是字典的大小，然后是键，最后是值 
 
>>> d1 = {'abc':1,'efg':2}  
>>> d2 = {'abc':1,'efg':2,'h':3}  
>>> cmp(d1,d2)  
-1 
>>> d3 = {'ab':1,'efg':2}  
>>> cmp(d1,d3)  
1 
>>> d4 = {'abc':1,'efg':3}  
>>> cmp(d1,d4)  
-1 
>>> d5 = {'abc':1,'efg':2}  
>>> cmp(d1,d5)  
0  
 
（2）len() 
返回键值对的数目 
 
>>> d = {'abc':1,'efg':2} 
>>> len(d)  
2  
 
（3）keys()、values() 、items() 
keys()返回一个包含字典所有键的列表 
values()返回一个包含字典所有值的列表 
items()返回一个包含键值元组的列表 
 
>>> d = {'name':'alex','sex':'man'}  
>>> d.keys()  
['name', 'sex']  
>>> d.values()  
['alex', 'man']  
>>> d.items()  
[('name', 'alex'), ('sex', 'man')]  
 
（4）dict.get(key,default=None) 
返回字典中key对应的value，若key不存在则返回default 
 
>>> d = {'name':'alex','sex':'man'}  
>>> d.get('name','not exists')  
'alex' 
>>> d.get('alex','not exists')  
'not exists'  
 
（5）dict.setdefault(key,default=None) 
若key存在，则覆盖之前的值，若key不存在，则给字典添加key-value对 
 
>>> d.setdefault('name','zhou')  
'alex' 
>>> d  
{'name': 'alex', 'sex': 'man'}  
>>> d.setdefault('haha','xixi')  
'xixi' 
>>> d  
{'haha': 'xixi', 'name': 'alex', 'sex': 'man'}  
 
（6）dict.update(dict2) 
将字典dict2的键值对添加到dict 
 
>>> d = {'name':'alex','sex':'man'}  
>>> d1 = {'age':100,'address':'shenzhen'}  
>>> d.update(d1)  
>>> d  
{'age': 100, 'address': 'shenzhen', 'name': 'alex', 'sex': 'man'  
 
（7）sorted(dict) 
返回一个有序的包含字典所有key的列表 
 
>>> sorted(d)  
['address', 'age', 'name', 'sex']  
 
2. 集合set 
python中集合对象（set）是一组无序排列的可哈希的值，包含两种类型：可变集合（set）和不可变集合（frozenset），所以set不是可哈希的，frozenset是可哈希的，能当作字典的键。 
 
>>> s = set('a')  
>>> hash(s) Traceback (most recent call last): 
File "<stdin>", line 1, in <module>  
TypeError: unhashable type: 'set'   
>>> fs = frozenset('a')  
>>> hash(fs)  
-1305064881317614714  
 
2.1 集合常用操作（1）创建集合 
 
>>> s = set('alexzhou')  
>>> s  
set(['a', 'e', 'h', 'l', 'o', 'u', 'x', 'z'])  
>>> fs = frozenset('alexzhou')  
>>> fs  
frozenset(['a', 'e', 'h', 'l', 'o', 'u', 'x', 'z'])  
 
（2）遍历集合 
 
>>> for e in s:  
...     print e  
...   
a  
e  
h  
l  
o  
u  
x  
z  
 
（3）更新集合(add/update/remove/discard/pop/clear(-=)) 
s.add(obj):添加对象obj 
s.update(s1): 用s1中的成员修改s，s现在包含s1的成员 
s.remove(obj):从集合s中删除obj，若obj不存在，则引发KeyError错误 
s.discard(obj): 如果obj是s的成员，则删除obj 
s.pop(): 删除集合s中任意一个对象，并返回 
s.clear(): 删除集合s中所有元素 
 
>>> s = set('alexzhou')  
>>> s.update('hai')  
>>> s  
set(['a', 'e', 'i', 'h', 'l', 'o', 'u', 'x', 'z'])  
>>> s.add('hai')  
>>> s  
set(['a', 'hai', 'e', 'i', 'h', 'l', 'o', 'u', 'x', 'z'])  
>>> s.remove('hai')  
>>> s  
set(['a', 'e', 'i', 'h', 'l', 'o', 'u', 'x', 'z'])  
>>> s -= set('alex')  
>>> s  
set(['i', 'h', 'o', 'u', 'z'])  
>>> s.pop()  
'i' 
>>> s  
set(['h', 'z', 'u', 'o'])  
>>> s.discard('h')  
>>> s  
set(['z', 'u', 'o'])  
>>> s.clear()  
>>> s  
set([])  
>>> fs = frozenset('alexzhou')  
>>> fs.add('z')  
Traceback (most recent call last):    
File "<stdin>", line 1, in <module>  
AttributeError: 'frozenset' object has no attribute 'add'  
 
(4) 集合比较 
s1.issubset(s2)：检测s1是否是s2的子集，是则返回True，否则返回False 
s1.issuperset(s2)：检测s1是否是s2的超集，是则返回True，否则返回False 
 
>>> s = set('alexzhou')  
>>> fs = frozenset('alexzhou')  
>>> s == fs  
True 
>>> s2 = set('alexzhou')  
>>> s == s2  
True>>> s3 = set('alexzhouj')  
>>> s > s3  
False 
>>> s < s3  
True 
>>> s  
 
（5）联合uNIOn操作(s1|s2,s1.union(s2)) 
产生的集合的每个元素至少是其中一个集合的成员。如果左右两边的集合类型相同，则产生的结果是相同的，若不同，则产生的结果跟左操作数相同。 
 
>>> s1 = set('abc')  
>>> fs = frozenset('de')  
 
>>> s1 | fs  
set(['a', 'c', 'b', 'e', 'd'])    
>>> type(s1 | fs)  
<type 'set'>  
>>> type(fs | s1)  
<type 'frozenset'>    
>>> s2 = set('fg')  
>>> type(s1 | s2)  
<type 'set'>  
>>> s1.union(fs)  
set(['a', 'c', 'b', 'e', 'd'])  
>>> type(s1.union(fs))  
<TYPE ?set?>  
>>> type(fs.union(s1))  
<TYPE ?frozenset?>  
 
（6）交集s1&s2，补集s1-s2，异或s1^s2 
交集：新集合中的元素同时是s1和s2的元素 –> s1.intersection(s2) 
补集：新集合中的元素只属于s1,不属于 –> s1.difference(s2) 
异或：新集合中的元素不能同时属于s1和s2 –> s1.symmetric_difference(s2) 
 
>>> fs = frozenset('de')  
>>> s = set('def')  
>>> s & fs  
set(['e', 'd'])  
>>> s - fs  
set(['f'])  
>>> fs - s  
frozenset([])  
>>> s ^ fs  
set(['f'])  
>>> s.intersection(fs)  
set(['e', 'd'])  
>>> s.difference(fs)  
set(['f'])  
>>> s.symmetric_difference(fs)  
set(['f'])