目录
1 概述
1.1 字典基本操作
1.2 字典常用方法
2 字典基本操作
2.1 创建字典
2.2 遍历字典
2.3 判断键是否在字典里面
3 字典常用方法
3.1 clear
3.2 copy
3.3 get
3.4 setdefault
3.5 update
3.6 items/iteritems
3.7 keys/iterkeys
3.8 values/itervalues
3.9 pop
3.10 popitem
3.11 对元素为字典的列表排序
1 概述
在前面，我们已经对Python学习做了系统的知识梳理（ Python思维导图）。
字典是 Python 中唯一的映射类型，每个元素由键（ key ）和值（ value ）构成，键必须是不可变类 型，比如数字、字符串和元组。
2 字典基本操作
2.1 创建字典
字典可以通过下面的方式创建：
1. >>> d0 = {} # 空字典
2. >>> d0
3. {}
4. >>> d1 = { 'name' : 'ethan' , 'age' : 20 }
5. >>> d1
6. { 'age' : 20 , 'name' : 'ethan' }
7. >>> d1 [ 'age' ] = 21 # 更新字典
8. >>> d1
9. { 'age' : 21 , 'name' : 'ethan' }
10. >>> d2 = dict ( name = 'ethan' , age = 20 ) # 使用 dict 函数
11. >>> d2
12. { 'age' : 20 , 'name' : 'ethan' }
13. >>> item = [( 'name' , 'ethan' ), ( 'age' , 20 )]
14. >>> d3 = dict ( item )
15. >>> d3
16. { 'age' : 20 , 'name' : 'ethan' }
2.2 遍历字典
遍历字典有多种方式，这里先介绍一些基本的方式，后文会介绍一些高效的遍历方式。
1. >>> d = { 'name' : 'ethan' , 'age' : 20 }
2. >>> for key in d :
3. ... print '%s: %s' % ( key , d [ key ])
4. ...
5. age : 20
6. name : ethan
7. >>> d [ 'name' ]
8. 'ethan'
9. >>> d [ 'age' ]
10. 20
11. >>> for key in d :
12. ... if key == 'name' :
13. ... del d [ key ] # 要删除字典的某一项
14. ...
15. Traceback ( most recent call last ):
16. File "<stdin>" , line 1 , in < module >
17. RuntimeError : dictionary changed size during iteration
18. >>>
19. >>> for key in d . keys (): # python2 应该使用这种方式 , python3 使用 list(d.keys())
20. ... if key == 'name' :
21. ... del d [ key ]
22. ...
23. >>> d
24. { 'age' : 20 }
在上面，我们介绍了两种遍历方式： for key in d 和 for key in d.keys() ，如果在遍历的
时候，要删除键为 key 的某项，使用第一种方式会抛出 RuntimeError ，使用第二种方式则不会。
2.3 判断键是否在字典里面
有时，我们需要判断某个键是否在字典里面，这时可以用 in 进行判断，如下：
1. >>> d = { 'name' : 'ethan' , 'age' : 20 }
2. >>> 'name' in d
3. True
4. >>> d [ 'score' ] # 访问不存在的键，会抛出 KeyError
5. Traceback ( most recent call last ):
6. File "<stdin>" , line 1 , in < module >
7. KeyError : 'score'
8. >>> 'score' in d # 使用 in 判断 key 是否在字典里面
9. False
3 字典常用方法
3.1 clear
clear 方法用于清空字典中的所有项，这是个原地操作，所以无返回值（或者说是 None ）。
看看例子：
1. >>> d = { 'name' : 'ethan' , 'age' : 20 }
2. >>> rv = d . clear ()
3. >>> d
4. {}
5. >>> print rv
6. None
(2) 再看看一个例子：
1. >>> d1 = {}
2. >>> d2 = d1
3. >>> d2 [ 'name' ] = 'ethan'
4. >>> d1
5. { 'name' : 'ethan' }
6. >>> d2
7. { 'name' : 'ethan' }
8. >>> d1 = {} # d1 变为空字典
9. >>> d2
10. { 'name' : 'ethan' } # d2 不受影响
在上面， d1 和 d2 最初对应同一个字典，而后我们使用 d1 = {} 使其变成一个空字典，但此时
d2 不受影响。如果希望 d1 变成空字典之后， d2 也变成空字典，则可以使用 clear 方法：
1. >>> d1 = {}
2. >>> d2 = d1
3. >>> d2 [ 'name' ] = 'ethan'
4. >>> d1
5. { 'name' : 'ethan' }
6. >>> d2
7. { 'name' : 'ethan' }
8. >>> d1 . clear () # d1 清空之后， d2 也为空
9. >>> d1
10. {}
11. >>> d2
12. {}
3.2 copy
copy 方法实现的是 浅复制（shallow copy） 。它具有以下特点：
对可变对象的修改保持同步；
对不可变对象的修改保持独立；
看看例子：
1. # name 的值是不可变对象， books 的值是可变对象
2. >>> d1 = { 'name' : 'ethan' , 'books' : [ 'book1' , 'book2' , 'book3' ]}
3. >>> d2 = d1 . copy ()
4. >>> d2 [ 'name' ] = 'peter' # d2 对不可变对象的修改不会改变 d1
5. >>> d2
6. { 'books' : [ 'book1' , 'book2' , 'book3' ], 'name' : 'peter' }
7. >>> d1
8. { 'books' : [ 'book1' , 'book2' , 'book3' ], 'name' : 'ethan' }
9. >>> d2 [ 'books' ]. remove ( 'book2' ) # d2 对可变对象的修改会影响 d1
10. >>> d2
11. { 'books' : [ 'book1' , 'book3' ], 'name' : 'peter' }
12. >>> d1
13. { 'books' : [ 'book1' , 'book3' ], 'name' : 'ethan' }
14. >>> d1 [ 'books' ]. remove ( 'book3' ) # d1 对可变对象的修改会影响 d2
15. >>> d1
16. { 'books' : [ 'book1' ], 'name' : 'ethan' }
和浅复制对应的是 深复制（deep copy） ，它会创造出一个副本，跟原来的对象没有关系，可以通过copy 模块的 deepcopy 函数来实现：
1. >>> from copy import deepcopy
2. >>> d1 = { 'name' : 'ethan' , 'books' : [ 'book1' , 'book2' , 'book3' ]}
3. >>> d2 = deepcopy ( d1 ) # 创造出一个副本
4. >>>
5. >>> d2 [ 'books' ]. remove ( 'book2' ) # 对 d2 的任何修改不会影响到 d1
6. >>> d2
7. { 'books' : [ 'book1' , 'book3' ], 'name' : 'ethan' }
8. >>> d1
9. { 'books' : [ 'book1' , 'book2' , 'book3' ], 'name' : 'ethan' }
10. >>>
11. >>> d1 [ 'books' ]. remove ( 'book3' ) # 对 d1 的任何修改也不会影响到 d2
12. >>> d1
13. { 'books' : [ 'book1' , 'book2' ], 'name' : 'ethan' }
14. >>> d2
15. { 'books' : [ 'book1' , 'book3' ], 'name' : 'ethan' }
3.3 get
当我们试图访问字典中不存在的项时会出现 KeyError ，但使用 get 就可以避免这个问题。
看看例子：
1. >>> d = {}
2. >>> d [ 'name' ]
3. Traceback ( most recent call last ):
4. File "<stdin>" , line 1 , in < module >
5. KeyError : 'name'
6. >>> print d . get ( 'name' )
7. None
8. >>> d . get ( 'name' , 'ethan' ) # 'name' 不存在，使用默认值 'ethan'
9. 'ethan'
10. >>> d
11. {}
3.4 setdefault
setdefault 方法用于对字典设定键值。使用形式如下：
dict.setdefault(key, default=None)
看看例子：
1. >>> d = {}
2. >>> d . setdefault ( 'name' , 'ethan' ) # 返回设定的默认值 'ethan'
3. 'ethan'
4. >>> d # d 被更新
5. { 'name' : 'ethan' }
6. >>> d [ 'age' ] = 20
7. >>> d
8. { 'age' : 20 , 'name' : 'ethan' }
9. >>> d . setdefault ( 'age' , 18 ) # age 已存在，返回已有的值，不会更新字典
10. 20
11. >>> d
12. { 'age' : 20 , 'name' : 'ethan' }
可以看到，当键不存在的时候， setdefault 返回设定的默认值并且更新字典。当键存在的时候，会返回已有的值，但不会更新字典。
3.5 update
update 方法用于将一个字典添加到原字典，如果存在相同的键则会进行覆盖。
看看例子：
1. >>> d = {}
2. >>> d1 = { 'name' : 'ethan' }
3. >>> d . update ( d1 ) # 将字典 d1 添加到 d
4. >>> d
5. { 'name' : 'ethan' }
6. >>> d2 = { 'age' : 20 }
7. >>> d . update ( d2 ) # 将字典 d2 添加到 d
8. >>> d
9. { 'age' : 20 , 'name' : 'ethan' }
10. >>> d3 = { 'name' : 'michael' } # 将字典 d3 添加到 d ，存在相同的 key ，则覆盖
11. >>> d . update ( d3 )
12. >>> d
13. { 'age' : 20 , 'name' : 'michael' }
3.6 items/iteritems
items 方法将所有的字典项 以列表形式返回 ，这些列表项的每一项都来自于（键，值）。我们也经常使用这个方法来对字典进行遍历。
看看例子：
1. >>> d = { 'name' : 'ethan' , 'age' : 20 }
2. >>> d . items ()
3. [( 'age' , 20 ), ( 'name' , 'ethan' )]
4. >>> for k , v in d . items ():
5. ... print '%s: %s' % ( k , v )
6. ...
7. age : 20
8. name : ethan
iteritems 的作用大致相同，但会 返回一个迭代器对象 而不是列表，同样，我们也可以使用这个方法来对字典进行遍历，而且这也是推荐的做法：
1. >>> d = { 'name' : 'ethan' , 'age' : 20 }
2. >>> d . iteritems ()
3. < dictionary - itemiterator object at 0x109cf2d60 >
4. >>> for k , v in d . iteritems ():
5. ... print '%s: %s' % ( k , v )
6. ...
7. age : 20
8. name : ethan
3.7 keys/iterkeys
keys 方法将字典的键以列表形式返回， iterkeys 则返回针对键的迭代器。
看看例子：
1. >>> d = { 'name' : 'ethan' , 'age' : 20 }
2. >>> d . keys ()
3. [ 'age' , 'name' ]
4. >>> d . iterkeys ()
5. < dictionary - keyiterator object at 0x1077fad08 >
3.8 values/itervalues
values 方法将字典的值以列表形式返回， itervalues 则返回针对值的迭代器。
看看例子:
1. >>> d = { 'name' : 'ethan' , 'age' : 20 }
2. >>> d . values ()
3. [ 20 , 'ethan' ]
4. >>> d . itervalues ()
5. < dictionary - valueiterator object at 0x10477dd08 >
3.9 pop
pop 方法用于将某个键值对从字典移除，并返回给定键的值。
看看例子：
1. >>> d = { 'name' : 'ethan' , 'age' : 20 }
2. >>> d . pop ( 'name' )
3. 'ethan'
4. >>> d
5. { 'age' : 20 }
3.10 popitem
popitem 用于随机移除字典中的某个键值对。
看看例子：
1. >>> d = { 'id' : 10 , 'name' : 'ethan' , 'age' : 20 }
2. >>> d . popitem ()
3. ( 'age' , 20 )
4. >>> d
5. { 'id' : 10 , 'name' : 'ethan' }
6. >>> d . popitem ()
7. ( 'id' , 10 )
8. >>> d
9. { 'name' : 'ethan' }
3.11 对元素为字典的列表排序
事实上，我们很少直接对字典进行排序，而是对元素为字典的列表进行排序。
比如，存在下面的 students 列表，它的元素是字典：
1. students = [
2. { 'name' : 'john' , 'score' : 'B' , 'age' : 15 },
3. { 'name' : 'jane' , 'score' : 'A' , 'age' : 12 },
4. { 'name' : 'dave' , 'score' : 'B' , 'age' : 10 },
5. { 'name' : 'ethan' , 'score' : 'C' , 'age' : 20 },
6. { 'name' : 'peter' , 'score' : 'B' , 'age' : 20 },
7. { 'name' : 'mike' , 'score' : 'C' , 'age' : 16 }
8. ]
(1)按 score 从小到大排序
1. >>> sorted ( students , key = lambda stu : stu [ 'score' ])
2. [{ 'age' : 12 , 'name' : 'jane' , 'score' : 'A' },
3. { 'age' : 15 , 'name' : 'john' , 'score' : 'B' },
4. { 'age' : 10 , 'name' : 'dave' , 'score' : 'B' },
5. { 'age' : 20 , 'name' : 'peter' , 'score' : 'B' },
6. { 'age' : 20 , 'name' : 'ethan' , 'score' : 'C' },
7. { 'age' : 16 , 'name' : 'mike' , 'score' : 'C' }]
需要注意的是，这里是按照字母的 ascii 大小排序的，所以 score 从小到大，即从 ‘A’ 到 ‘C’。
Python中lambda表达式学习
(2)按 score 从大到小排序
1.>>> sorted ( students , key = lambda stu : stu [ 'score' ], reverse = True ) # reverse 参数
2. [{ 'age' : 20 , 'name' : 'ethan' , 'score' : 'C' },
3. { 'age' : 16 , 'name' : 'mike' , 'score' : 'C' },
4. { 'age' : 15 , 'name' : 'john' , 'score' : 'B' },
5. { 'age' : 10 , 'name' : 'dave' , 'score' : 'B' },
6. { 'age' : 20 , 'name' : 'peter' , 'score' : 'B' },
7. { 'age' : 12 , 'name' : 'jane' , 'score' : 'A' }]
(3)按 score 从小到大，再按 age 从小到大
1. >>> sorted ( students , key = lambda stu : ( stu [ 'score' ], stu [ 'age' ]))
2. [{ 'age' : 12 , 'name' : 'jane' , 'score' : 'A' },
3. { 'age' : 10 , 'name' : 'dave' , 'score' : 'B' },
4. { 'age' : 15 , 'name' : 'john' , 'score' : 'B' },
5. { 'age' : 20 , 'name' : 'peter' , 'score' : 'B' },
6. { 'age' : 16 , 'name' : 'mike' , 'score' : 'C' },
7. { 'age' : 20 , 'name' : 'ethan' , 'score' : 'C' }]
(4)按 score 从小到大，再按 age 从大到小
1. >>> sorted ( students , key = lambda stu : ( stu [ 'score' ], - stu [ 'age' ]))
2. [{ 'age' : 12 , 'name' : 'jane' , 'score' : 'A' },
3. { 'age' : 20 , 'name' : 'peter' , 'score' : 'B' },
4. { 'age' : 15 , 'name' : 'john' , 'score' : 'B' },
5. { 'age' : 10 , 'name' : 'dave' , 'score' : 'B' },
6. { 'age' : 20 , 'name' : 'ethan' , 'score' : 'C' },
7. { 'age' : 16 , 'name' : 'mike' , 'score' : 'C' }]
