1. 1. 字典字典是python中唯一的映射类型,采用键值对(key-value)的形式存储数据。python对key进行哈希函数运算,根据计算的结果决定value的存储地址,所以字典是无序存储的,且key必须是可哈希的。可哈希表示key必须是不可变类型,如:数字、字符串、只含不可变类型元素的元组(1,2,3,’abc’)、实现__hash__()方法的自定义对象(因为__hash__()须返回一个整数,否则会出现异常:TypeError: an integer is required)。可以用hash(obj)检测对象是否是可哈希的。 
  2.  
  3. >>> class HashEnable(object):  
  4. ...    def  __hash__(self):  
  5. ...         return 1 
  6. >>> he = HashEnable()  
  7. >>> hash(he)  
  8. 1 
  9. >>> d = {he:1}  
  10. >>> d = {['1',2]:2}  
  11. Traceback (most recent call last): 
  12.    File "<stdin>", line 1in <module> TypeError: unhashable type: 'list'  
  13.  
  14. 1.1 字典常用操作 
  15. 1)创建字典 
  16.  
  17. >>> d1 = {}  
  18. >>> d2 = {'player':'QVOD','game':'kw'}  
  19. >>> d1,d2 
  20. ({}, {'player''QVOD''game''kw'})    
  21. >>> d3 = dict((['name','alex'],['sex','man']))  
  22. >>> d3  
  23. {'name''alex''sex''man'}  
  24. >>> d33 = d3.copy()  
  25. >>> d33  
  26. {'name''alex''sex''man'}    
  27. >>> d4 = {}.fromkeys(('alex','zhou'),1)  
  28. >>> d4  
  29. {'alex'1'zhou'1}  
  30. >>> d5 = {}.fromkeys(('alex','zhou'))  
  31. >>> d5  
  32. {'alex'None'zhou'None}  
  33.  
  34. 2)遍历字典 
  35. ps:访问一个不存在的key时,会发生KeyError异常,访问前可使用innot in判断一下。 
  36.  
  37. >>> d = {'name':'alexzhou','sex':'man'}    
  38. >>> for key in d:  
  39. ...     print '%s,%s' %(key,d[key])  
  40. ...   
  41. name,alexzhou  
  42. sex,man    
  43. >>> d['name']  
  44. 'alexzhou' 
  45. >>> d2 = {'name':'alexzhou','age':100}  
  46. >>> print 'name: %s,age: %d' %(d2['name'],d2['age'])  
  47. name: alexzhou,age: 100   
  48. >>> d2['sex']  
  49. Traceback (most recent call last):    
  50.    File "<stdin>", line 1in <module> KeyError: 'sex'   
  51. >>> 'sex' in d2  
  52. False 
  53. >>> 'name' in d2  
  54. True  
  55.  
  56. 3)更新字典 
  57.  
  58. >>> d = {'name':'alexzhou','age':100}  
  59. >>> d['age'] = 88 
  60. >>> d  
  61. {'age'88'name''alexzhou'}  
  62. >>> d.pop('age')  
  63. 88 
  64. >>> d {'name''alexzhou'}  
  65. >>> d.clear()  
  66. >>> d  
  67. {}  
  68.  
  69. 1.2 常用内建函数 
  70. 1)cmp() 
  71. 字典的比较:首先是字典的大小,然后是键,最后是值 
  72.  
  73. >>> d1 = {'abc':1,'efg':2}  
  74. >>> d2 = {'abc':1,'efg':2,'h':3}  
  75. >>> cmp(d1,d2)  
  76. -1 
  77. >>> d3 = {'ab':1,'efg':2}  
  78. >>> cmp(d1,d3)  
  79. 1 
  80. >>> d4 = {'abc':1,'efg':3}  
  81. >>> cmp(d1,d4)  
  82. -1 
  83. >>> d5 = {'abc':1,'efg':2}  
  84. >>> cmp(d1,d5)  
  85. 0  
  86.  
  87. 2)len() 
  88. 返回键值对的数目 
  89.  
  90. >>> d = {'abc':1,'efg':2
  91. >>> len(d)  
  92. 2  
  93.  
  94. 3)keys()、values() 、items() 
  95. keys()返回一个包含字典所有键的列表 
  96. values()返回一个包含字典所有值的列表 
  97. items()返回一个包含键值元组的列表 
  98.  
  99. >>> d = {'name':'alex','sex':'man'}  
  100. >>> d.keys()  
  101. ['name''sex']  
  102. >>> d.values()  
  103. ['alex''man']  
  104. >>> d.items()  
  105. [('name''alex'), ('sex''man')]  
  106.  
  107. 4)dict.get(key,default=None
  108. 返回字典中key对应的value,若key不存在则返回default 
  109.  
  110. >>> d = {'name':'alex','sex':'man'}  
  111. >>> d.get('name','not exists')  
  112. 'alex' 
  113. >>> d.get('alex','not exists')  
  114. 'not exists'  
  115.  
  116. 5)dict.setdefault(key,default=None
  117. 若key存在,则覆盖之前的值,若key不存在,则给字典添加key-value对 
  118.  
  119. >>> d.setdefault('name','zhou')  
  120. 'alex' 
  121. >>> d  
  122. {'name''alex''sex''man'}  
  123. >>> d.setdefault('haha','xixi')  
  124. 'xixi' 
  125. >>> d  
  126. {'haha''xixi''name''alex''sex''man'}  
  127.  
  128. 6)dict.update(dict2) 
  129. 将字典dict2的键值对添加到dict 
  130.  
  131. >>> d = {'name':'alex','sex':'man'}  
  132. >>> d1 = {'age':100,'address':'shenzhen'}  
  133. >>> d.update(d1)  
  134. >>> d  
  135. {'age'100'address''shenzhen''name''alex''sex''man'  
  136.  
  137. 7)sorted(dict) 
  138. 返回一个有序的包含字典所有key的列表 
  139.  
  140. >>> sorted(d)  
  141. ['address''age''name''sex']  
  142.  
  143. 2. 集合set 
  144. python中集合对象(set)是一组无序排列的可哈希的值,包含两种类型:可变集合(set)和不可变集合(frozenset),所以set不是可哈希的,frozenset是可哈希的,能当作字典的键。 
  145.  
  146. >>> s = set('a')  
  147. >>> hash(s) Traceback (most recent call last): 
  148. File "<stdin>", line 1in <module>  
  149. TypeError: unhashable type: 'set'   
  150. >>> fs = frozenset('a')  
  151. >>> hash(fs)  
  152. -1305064881317614714  
  153.  
  154. 2.1 集合常用操作(1)创建集合 
  155.  
  156. >>> s = set('alexzhou')  
  157. >>> s  
  158. set(['a''e''h''l''o''u''x''z'])  
  159. >>> fs = frozenset('alexzhou')  
  160. >>> fs  
  161. frozenset(['a''e''h''l''o''u''x''z'])  
  162.  
  163. 2)遍历集合 
  164.  
  165. >>> for e in s:  
  166. ...     print e  
  167. ...   
  168. a  
  169. e  
  170. h  
  171. l  
  172. o  
  173. u  
  174. x  
  175. z  
  176.  
  177. 3)更新集合(add/update/remove/discard/pop/clear(-=)) 
  178. s.add(obj):添加对象obj 
  179. s.update(s1): 用s1中的成员修改s,s现在包含s1的成员 
  180. s.remove(obj):从集合s中删除obj,若obj不存在,则引发KeyError错误 
  181. s.discard(obj): 如果obj是s的成员,则删除obj 
  182. s.pop(): 删除集合s中任意一个对象,并返回 
  183. s.clear(): 删除集合s中所有元素 
  184.  
  185. >>> s = set('alexzhou')  
  186. >>> s.update('hai')  
  187. >>> s  
  188. set(['a''e''i''h''l''o''u''x''z'])  
  189. >>> s.add('hai')  
  190. >>> s  
  191. set(['a''hai''e''i''h''l''o''u''x''z'])  
  192. >>> s.remove('hai')  
  193. >>> s  
  194. set(['a''e''i''h''l''o''u''x''z'])  
  195. >>> s -= set('alex')  
  196. >>> s  
  197. set(['i''h''o''u''z'])  
  198. >>> s.pop()  
  199. 'i' 
  200. >>> s  
  201. set(['h''z''u''o'])  
  202. >>> s.discard('h')  
  203. >>> s  
  204. set(['z''u''o'])  
  205. >>> s.clear()  
  206. >>> s  
  207. set([])  
  208. >>> fs = frozenset('alexzhou')  
  209. >>> fs.add('z')  
  210. Traceback (most recent call last):    
  211. File "<stdin>", line 1in <module>  
  212. AttributeError: 'frozenset' object has no attribute 'add'  
  213.  
  214. (4) 集合比较 
  215. s1.issubset(s2):检测s1是否是s2的子集,是则返回True,否则返回False 
  216. s1.issuperset(s2):检测s1是否是s2的超集,是则返回True,否则返回False 
  217.  
  218. >>> s = set('alexzhou')  
  219. >>> fs = frozenset('alexzhou')  
  220. >>> s == fs  
  221. True 
  222. >>> s2 = set('alexzhou')  
  223. >>> s == s2  
  224. True>>> s3 = set('alexzhouj')  
  225. >>> s > s3  
  226. False 
  227. >>> s < s3  
  228. True 
  229. >>> s  
  230.  
  231. 5)联合union操作(s1|s2,s1.union(s2)) 
  232. 产生的集合的每个元素至少是其中一个集合的成员。如果左右两边的集合类型相同,则产生的结果是相同的,若不同,则产生的结果跟左操作数相同。 
  233.  
  234. >>> s1 = set('abc')  
  235. >>> fs = frozenset('de')  
  236.  
  237. >>> s1 | fs  
  238. set(['a''c''b''e''d'])    
  239. >>> type(s1 | fs)  
  240. <type 'set'>  
  241. >>> type(fs | s1)  
  242. <type 'frozenset'>    
  243. >>> s2 = set('fg')  
  244. >>> type(s1 | s2)  
  245. <type 'set'>  
  246. >>> s1.union(fs)  
  247. set(['a''c''b''e''d'])  
  248. >>> type(s1.union(fs))  
  249. <TYPE ?set?>  
  250. >>> type(fs.union(s1))  
  251. <TYPE ?frozenset?>  
  252.  
  253. 6)交集s1&s2,补集s1-s2,异或s1^s2 
  254. 交集:新集合中的元素同时是s1和s2的元素 –> s1.intersection(s2) 
  255. 补集:新集合中的元素只属于s1,不属于 –> s1.difference(s2) 
  256. 异或:新集合中的元素不能同时属于s1和s2 –> s1.symmetric_difference(s2) 
  257.  
  258. >>> fs = frozenset('de')  
  259. >>> s = set('def')  
  260. >>> s & fs  
  261. set(['e''d'])  
  262. >>> s - fs  
  263. set(['f'])  
  264. >>> fs - s  
  265. frozenset([])  
  266. >>> s ^ fs  
  267. set(['f'])  
  268. >>> s.intersection(fs)  
  269. set(['e''d'])  
  270. >>> s.difference(fs)  
  271. set(['f'])  
  272. >>> s.symmetric_difference(fs)  
  273. set(['f'])