当你有很多书时，你会考虑买一个书柜，将你的书分门别类摆放进入。使用了书柜不仅仅使房间变得整洁，也便于以后使用书时方便查找。在计算机程序中会有很多数据，这些数据也需要一个容器将他们管理起来，这就是数据结构。常见的数据结构：数组（Array）、集合（Set）、列表（List）、队列（Queue）、链表（Linkedlist）、树（Tree）、堆（Heap）、栈（Stack）和字典（Dictionary）等结构。
Python中数据容器主要有：序列、集合和字典。
注意
Python中并没有数组结构，因为数组要求元素类型是一致的。而Python作为动态类型语言，不强制声明变量的数据类型，也不能强制检查元素的数据类型。所以Python中没有数组结构。
元组
元组（tuple）是一种序列（sequence）结构，下面先来介绍一些序列。
序列
序列（sequence）是一种可迭代的[1]，元素是有序的，可以重复出现的数据结构。序列可以通过索引访问元素。图9-1是一个班级序列，其中有一些学生，这些学生是有序的，顺序是他们被放到序列中的顺序，可以通过序号访问他们。这就像老师给进入班级的人分配学号，第一个报到的是“张三”，老师给他分配的是0，第二个报到的是“李四”，老师给他分配的是1，以此类推，最后一个序号应该是“学生人数-1”。
序列包括的结构有：列表（list）、字符串（str）、元组（tuple）、范围（range）、和字节序列（bytes）。序列可进行的操作有：索引、分片、加和乘。
- 索引操作
序列中第一个元素的索引是0，其他元素的索引是第一个元素的偏移量。可以有正偏移量，称为正值索引；也可以有负偏移量，称为负值索引。正值索引最后一个元素索引是“序列长度-1”，负值索引最后一个元素索引是“-1”。例如Hello字符串，它的正值索引如图9-2(a)所示，它的负值索引如图9-2(b)所示。
访问序列中的元素的通过索引下标访问的，即中括号[index]方式访问。在Python
Shell中运行示例如下：
>>> a = 'Hello'
>>> a[0]
'H'
>>> a[1]
'e'
>>> a[4]
'o'
>>> a[-1]
'o'
>>> a[-2]
'l'
>>> a[5]
Traceback (most recent call last):
File "<pyshell#2>", line 1, in <module>
a[5]
IndexError: string index out of range
>>> max(a)
'o'
>>> min(a)
'H'
>>> len(a)
5
a[0]是访问序列第一个元素，最后一个元素的索引可以是4或-1。但是索引超过范围，则会发生IndexError错误。另外，获取序列的长度使用函数len，类似的序列还有max和min函数，max函数返回最后一个元素，min函数返回第一个元素。
- 序列的加和乘
下面看看序列的加和乘，在前面第7章介绍+和*运算符时，提到过他们可以应用于序列。+运算符可以将两个序列连接起来，*运算符可以将重复多次。
在Python Shell中运行示例：
>>> a = 'Hello'
>>> a * 3
'HelloHelloHello'
>>> print(a)
Hello
>>> a += ' '
>>> a += 'World'
>>> print(a)
Hello World
- 序列分片
序列的分片（Slicing）就是从序列中切分出小的子序列。分片使用分片运算符，分片运算符有两种形式：
[start:end]。start是开始索引，end是结束索引。
[start:end:step]。start是开始索引，end是结束索引，step是步长，步长是在分片时获取元素的间隔。步长可以为正整数，也可为负整数。
注意
切下的分片包括start位置元素，但不包括end位置元素，start和end都可以省略。
在Python Shell中运行示例代码如下：
>>> a[1:3]
'el'
>>> a[:3]
'Hel'
>>> a[0:3]
'Hel'
>>> a[0:]
'Hello'
>>> a[0:5]
'Hello'
>>> a[:]
'Hello'
>>> a[1:-1]
'ell'
上述代码表达式a[1:3]是切出1~3之间的子字符串，注意不包括3，所以结果是el。表达式a[:3]省略了开始索引，默认开始索引是0，所以a[:3]与a[0:3]分片结果是一样的。表达式a[0:]省略了结束索引，默认结束索引是序列的长度，即5。所以a[0:]
与a[0:5]分片结果是一样的。表达式a[:]是省略了开始索引和结束索引，a[:]与a[0:5]结果一样。
另外，表达式a[1:-1]使用了负值索引，对照图9-1所示，不难计算出a[1:-1]结果是ell。
分片时使用[start:end:step]可以指定步长（step），步长与当次元素索引、下次元素索引之间的关系如下：
> 下次元素索引 = 当次元素索引 + 步长
在Python Shell中运行示例代码如下：
>>> a[1:5]
'ello'
>>> a[1:5:2]
'el'
>>> a[0:3]
'Hel'
>>> a[0:3:2]
'Hl'
>>> a[0:3:3]
'H'
>>> a[::-1]
'olleH'
表达式a[1:5]省略了步长参数，步长默认值是1。表达式a[1:5:2]是步长为2，结果是el。a[0:3]分片后的字符串是Hel。而a[0:3:3]是步长为3，分片结果H字符了。当步长为负数时比较麻烦，负数时是从右往左获取元素，所以表达式a[::-1]分片的结果是原始字符串的倒置。
创建元组
元组（tuple）是一种不可变序列，一旦创建就不能修改。创建元组可以使用tuple([iterable])函数或者直接用逗号（,）将元素分隔。
在Python Shell中运行示例代码如下：
>>> 21,32,43,45 ①
(21, 32, 43, 45)
>>> (21, 32, 43, 45) ②
(21, 32, 43, 45)
>>> a = (21,32,43,45)
>>> print(a)
(21, 32, 43, 45)
>>> ('Hello', 'World') ③
('Hello', 'World')
>>> ('Hello', 'World', 1,2,3)④
('Hello', 'World', 1, 2, 3)
>>> tuple([21,32,43,45]) ⑤
(21, 32, 43, 45)
代码第①行创建了一个有4个元素的元组，创建元组时使用小括号把元素包裹起来不是必须的。代码第②行使用括号将元素包裹起来，这只是为了提高程序的可读性。Python中没有强制声明数据类型，因此元组中的元素可以是任何数据类型，代码第③行创建是一个字符串元组，代码第④行是创建字符串和整数混合的元组。
另外，元组还有通过tuple([iterable])函数创建，参数iterable是任何可迭代对象。代码第⑤行是使用tuple()函数创建元组对象，实参[21,32,43,45]是一个列表，列表是可迭代对象，可以作为tuple()函数参数创建元组对象。
创建元组还需要注意如下极端情况：
>>> a = (21)
>>> type(a)
<class 'int'>
>>> a = (21,)
>>> type(a)
<class 'tuple'>
>>> a = ()
>>> type(a)
<class 'tuple'>
从上述代码可见，如果一个元组只有一个元素时，后面的逗号不能省略，即(21,)表示的是只有一个元素的元组，而(21)表示的是一个整数。另外，()可以创建空元组。
访问元组
元组做为序列可以通过下标索引访问元素，也可以对其进行分片。在Python
Shell中运行示例代码如下：
>>> a = ('Hello', 'World', 1,2,3) ①
>>> a[1]
'World'
>>> a[1:3]
('World', 1)
>>> a[2:]
(1, 2, 3)
>>> a[:2]
('Hello', 'World')
上述代码第①行是元组a，a[1]是访问元组第二个元素，表达式a[1:3]、a[2:]和a[:2]都是进行分片操作。
元组还可以进行拆包（Unpack）操作，就是将元组的元素取出赋值给不同变量。在Python Shell中运行示例代码如下：
>>> a = ('Hello', 'World', 1,2,3)
>>> str1, str2, n1,n2, n3 = a ①
>>> str1
'Hello'
>>> str2
'World'
>>> n1
1
>>> n2
2
>>> n3
3
>>> str1, str2, *n = a ②
>>> str1
'Hello'
>>> str2
'World'
>>> n
[1, 2, 3]
>>> str1,_,n1,n2,_ = a ③
上述代码第①行是将元组a进行拆包操作，接收拆包元素的变量个数应该等于元组个数相同。接收变量个数也可以少于元组个数，代码第②行接收变量个数只有3个，最后一个很特殊，变量n前面有星号，表示将剩下的元素作为一个列表赋值给变量n。另外，还可以使用下划线指定哪些元素不取值，代码第行是不取第二个和第五个元素。
遍历元组
遍历元组一般是使用for循环，示例代码如下：
# coding=utf-8
# 代码文件：chapter9/ch9.1.4.py
a = (21, 32, 43, 45)
for item in a: ①
print(item)
print('-----------')
for i, item in enumerate(a): ②
print('{0} - {1}'.format(i, item))
输出结果如下：
21
32
43
45
-----------
0 - 21
1 - 32
2 - 43
3 – 45
一般情况下遍历目的只是取出每一个元素值，见代码第①行的for循环。但有时需要在遍历过程中同时获取索引，则可以使用代码第②行的for循环，其中enumerate(a)函数可以获得元组对象，该元组对象有两个元素，第一个元素是索引，第二个元素是数值。所以i,
item是元组拆包过程，最后变量i是元组a的当前索引，item是元组a的当前元素值。
注意
本节虽然介绍的是元组的遍历，上述遍历方式适合于所有序列，如字符串、范围和列表等。
列表
列表（list）也是一种序列结构，与元组不同列表具有可变性，可以追加、插入、删除和替换列表中的元素。
列表创建
创建列表可以使用list([iterable])函数，或者用中括号[]将元素包裹，元素之间用逗号分隔。在Python Shell中运行示例代码如下：
>>> [20, 10, 50, 40, 30] ①
[20, 10, 50, 40, 30]
>>> []
[]
>>> ['Hello', 'World', 1, 2, 3] ②
['Hello', 'World', 1, 2, 3]
>>> a = [10] ③
>>> type(a)
<class 'list'>
>>> a = [10,] ④
>>> type(a)
<class 'list'>
>>> list((20, 10, 50, 40, 30)) ⑤
[20, 10, 50, 40, 30]
上述代码第①行创建一个有5个元素的列表，注意中括号不能省略，如果省略了中括号那就变成了元组了。创建空列表是[]表达式。列表中可以放入任何对象，代码第②行是创建一个字符串和整数混合的列表。代码第③行是创建只有一个元素的列表，中括号不能省略。另外，无论是元组还是列表，每一个元素后面都跟着一个逗号，只是最后一个元素的逗号经常是省略的，代码第④行最后一个元素没有省略逗号。
另外，列表还有通过list([iterable])函数创建，参数iterable是任何可迭代对象。代码第⑤行是使用list()函数创建列表对象，实参(20,
10, 50, 40,
30)是一个元组，元组是可迭代对象，可以作为list()函数参数创建列表对象。
追加元素
列表中追加单个元素可以使用append()方法追加单个元素。如果想追加另一列表，可以使用+运算符或extend()方法。
append()方法语法：
list.append(x)
其中x参数是要追加单个元素值。
extend()方法语法：
list.extend(t)
其中t参数是要追加的另外一个列表。
在Python Shell中运行示例代码如下：
>>> student_list = ['张三', '李四', '王五']
>>> student_list.append('董六') ①
>>> student_list
['张三', '李四', '王五', '董六']
>>> student_list += ['刘备', '关羽'] ②
>>> student_list
['张三', '李四', '王五', '董六', '刘备', '关羽']
>>> student_list.extend(['张飞', '赵云']) ③
>>> student_list
['张三', '李四', '王五', '董六', '刘备', '关羽', '张飞', '赵云']
上述代码中第①行使用了append方法，在列表后面追加一个元素，append()方法不能同时追加多个元素。代码第②行是利用+=运算符追加多个元素，能够支持+=运算是因为列表支持+运算。代码第③行是使用extend()方法追加多个元素。
插入元素
插入元素可以使用列表的insert()方法，该方法可以在指定索引位置，插入一个元素。insert()方法语法：
list.insert(i, x)
其中参数i是要插入的索引，参数x是要插入的元素数值。
在Python Shell中运行示例代码如下：
>>> student_list = ['张三', '李四', '王五']
>>> student_list.insert(2, '刘备')
>>> student_list
['张三', '李四', '刘备', '王五']
上述代码中student_list调用insert方法，在索引2位置插入一个元素，新元素的索引为2。
替换元素
列表具有可变性，其中的元素替换，替换元素很简单，通过列表下标索引元素放在赋值符号（=）左边，进行赋值即可替换。在Python
Shell中运行示例代码如下：
>>> student_list = ['张三', '李四', '王五']
>>> student_list[0] = "诸葛亮"
>>> student_list
['诸葛亮', '李四', '刘备', '王五']
其中student_list[0] = "诸葛亮"是替换列表student_list的第一个元素。
删除元素
列表中实现删除元素的方式有两种：一种是使用列表的remove()方法；另一种是使用列表的pop()方法。
- remove()方法
remove()方法从左往右查找列表中的元素，如果找到匹配元素则删除，注意如果找到多个匹配元素，只是删除第一个。如果没有找到则会抛出错误。
remove()方法语法：
list.remove(x)
其中x参数是要找到元素值。
使用remove()方法删除元素，示例代码如下：
>>> student_list = ['张三', '李四', '王五', '王五']
>> student_list.remove('王五')
>>> student_list
['张三', '李四', '王五']
>>> student_list.remove('王五')
>>> student_list
['张三', '李四']
- pop()方法
pop()方法也会删除列表中的元素，但它会将成功删除的元素返回。pop()方法语法如下：
item = list.pop([i])
参数i是指定删除元素的索引，i可以省略，表示删除最后一个元素。返回值item是删除的元素。
使用pop()方法删除元素示例代码如下：
>>> student_list = ['张三', '李四', '王五']
>>> student_list.pop()
'王五'
>>> student_list
['张三', '李四']
>>> student_list.pop(0)
'张三'
>>> student_list
['李四']
其他常用方法
前面介绍列表追加、插入和删除时，已经介绍了一些方法。事实上列表还有很多方法，本节再介绍几个常用的方法。包括：
reverse()。倒置列表。
copy()。复制列表。
clear()。清除列表中的所有元素。
index(x[, i[,
j]])。返回查找x第一次出现的索引，i是开始查找索引，j是结束查找索引。该方法继承自序列，元组和字符串也可以使用该方法。count(x)。返回x出现的次数。该方法继承自序列，元组和字符串也可以使用该方法。
在Python Shell中运行示例代码如下：
>>> a = [21, 32, 43, 45]
>>> a.reverse() ①
>>> a
[45, 43, 32, 21]
>>> b = a.copy() ②
>>> b
[45, 43, 32, 21]
>>> a.clear() ③
>>> a
[]
>>> b
[45, 43, 32, 21]
>>> a = [45, 43, 32, 21, 32]
>>> a.count(32) ④
2
>>> student_list = ['张三', '李四', '王五']
>>> student_list.index('王五') ⑤
2
>>> student_tuple = ('张三', '李四', '王五')
>>> student_tuple.index('王五') ⑥
2
>>> student_tuple.index('李四', 1 , 2)
1
上述代码中第①行是调用reverse()方法将列表a倒置。代码第②行是调用copy()方法复制a，并赋值给b。代码第③行是清除a中元素。代码第④行是返回a列表中32元素的个数。代码第⑤行是返回'王五'在student_list列表中的位置。代码第⑥行是返回'王五'在student_tuple元组中的位置。
列表推导式
Python中有一种特殊表达式——推导式，它可以将一种数据结构作为输入，经过过滤、计算等处理，最后输出另一种数据结构。根据数据结构的不同分为：列表推导式、集合推导式和字典推导式。本节先介绍列表推导式。
如果想获得0~9中偶数的平方数列，那么可以通过for循环实现，代码如下：
# coding=utf-8
# 代码文件：chapter9/ch9.2.7.py
n_list = []
for x in range(10):
if x % 2 == 0:
n_list.append(x ** 2)
print(n_list)
输出结构如下：
[0, 4, 16, 36, 64]
0~9中偶数的平方数列可以通过列表推导式实现，代码如下:
n_list = [x ** 2 for x in range(10) if x % 2 == 0] ①
print(n_list)
上述代码其中代码第行就是列表推导式，输出的结果与for循环是一样的。图9-3所示是列表推导式语法结构，其中in后面的表达式是“输入序列”；for前面的表达式是“输出表达式”它运算结果会保存一个新列表中；if条件语句是过滤输入序列，符合条件的才传递给输出表达式，“条件语句”是可以省略的，也是所有元素都传递给输出表达式。
条件语句可以包含多个条件，如果想找出0~99之间的偶数，而且可以被5整除数列，实现代码如下：
n_list = [x for x in range(100) if x % 2 == 0 if x % 5 == 0]
print(n_list)
列表推导式的条件语句有两个if x % 2 == 0和if x % 5 == 0，可见他们“与”的关系。
集合
集合（set）是一种可迭代的、无序的、不能包含重复元素的数据结构。图9-4是一个班级的集合，其中包含一些学生，这些学生是无序的，不能通过序号访问，而且不能有重复的同学。
提示
如果与序列比较，序列中的元素是有序的，可以重复出现，而集合中是无序的，不能重复的元素。序列强调的是有序，集合强调的是不重复。当不考虑顺序，而且没有重复的元素时，序列和集合可以互相替换。
集合又分为可变集合（set）和不可变集合（frozenset）。
创建可变集合
可变集合类型是set，创建可变集合可以使用set([iterable])函数，或者用大括号{}将元素包裹，元素之间用逗号分隔。在Python
Shell中运行示例代码如下：
>>> a = {'张三', '李四', '王五'} ①
>>> a
{'张三', '李四', '王五'}
>>> a = {'张三', '李四', '王五', '王五'}②
>>> len(a)
3
>>> a
{'张三', '李四', '王五'}
>>> set((20, 10, 50, 40, 30)) ③
{40, 10, 50, 20, 30}
>>> b = {} ④
>>> type(b)
<class 'dict'>
>>> b = set() ⑤
>>> type(b)
<class 'set'>
上述代码第①行是使用大括号创建集合，如果元素有重复的会怎样呢？代码第②行包含有重复的元素，创建时会剔除重复元素。代码第③行是使用set()函数创建集合对象。如果要创建一个空的集合不能使用{}表示，见代码第④行b并不是集合而是字典，而是使用空参数的set()函数，见代码第⑤行。
提示
要获得集合中元素的个数，可以使用len()函数，注意len()是函数不是方法，本例中len(a)表达式返回集合a的元素个数。
修改可变集合
可变集合类似于列表，可变集合内容可以被修改，可以插入和删除元素。修改可变集合几个常用的方法。包括：
add(elem)。添加元素，如果元素已经存在，则不能添加，不会抛出错误。
remove(elem)。删除元素，如果元素不存在，则抛出错误。
discard(elem)。删除元素，如果元素不存在，不会抛出错误。
pop()。删除返回集合中任意一个元素，返回值是删除的元素。
clear()。清除集合。
在Python Shell中运行示例代码如下：
>>> student_set = {'张三', '李四', '王五'}
>>> student_set.add('董六')
>>> student_set
{'张三', '董六', '李四', '王五'}
>>> student_set.remove('李四')
>>> student_set
{'张三', '董六', '王五'}
>>> student_set.remove('李四') ①
Traceback (most recent call last):
File "<pyshell#144>", line 1, in <module>
student_set.remove('李四')
KeyError: '李四'
>>> student_set.discard('李四') ②
>>> student_set
{'张三', '董六', '王五'}
>>> student_set.discard('王五')
>>> student_set
{'张三', '董六'}
>>> student_set.pop()
'张三'
>>> student_set
{'董六'}
>>> student_set.clear()
>>> student_set
set()
上述代码第①行使用remove()方法删除元素时，由于要删除的'李四'已经不在集合中，所以会抛出错误。而同样是删除集合中不存在的元素discard()方法不会抛出错误，见代码第②行。
遍历集合
集合是无序的，没有索引，不能通过下标访问单个元素。但可以遍历集合，访问集合每一个元素。
遍历集合一般是使用for循环，示例代码如下：
# coding=utf-8
# 代码文件：chapter9/ch9.3.3.py
student_set = {'张三', '李四', '王五'}
for item in student_set:
print(item)
print('-----------')
for i, item in enumerate(student_set): ①
print('{0} - {1}'.format(i, item))
输出结果如下：
张三
王五
李四
-----------
0 - 张三
1 - 王五
2 - 李四
上述中使用for循环遍历集合，代码第①行的for循环中使用了enumerate()函数，该还是在9.1.4节遍历元组时已经介绍过了，但是需要注意的是，此时变量i不是索引，只是遍历集合的次数。
不可变集合
不可变集合类型是frozenset，创建不可变集合使用frozenset([iterable])函数，不能使用大括号{}。在Python Shell中运行示例代码如下：
>>> student_set = frozenset({'张三', '李四', '王五'}) ①
>>> student_set
frozenset({'张三', '李四', '王五'})
>>> type(student_set)
<class 'frozenset'>
>>> student_set.add('董六') ②
Traceback (most recent call last):
File "<pyshell#168>", line 1, in <module>
student_set.add('董六')
AttributeError: 'frozenset' object has no attribute 'add'
>>> a = (21, 32, 43, 45)
>>> seta = frozenset(a) ③
>>> seta
frozenset({32, 45, 43, 21})
上述代码第①行是创建不可变集合，frozenset()的参数{'张三', '李四',
'王五'}是另一个集合对象，因为集合也是可迭代对象，可以作为frozenset()的参数。代码第③函数使用的了一个元组a作为frozenset()的参数。
由于创建的是不变集合，不能被修改，所以视图修改发生错误，见代码第②行，使用add()发生错误。
集合推导式
集合推导式与列表推断式类似，区别只是输出结构是集合。修改9.2.7节代码如下：
# coding=utf-8
# 代码文件：chapter9/ch9.3.5.py
n_list = {x for x in range(100) if x % 2 == 0 if x % 5 == 0}
print(n_list)
输出结构如下：
{0, 70, 40, 10, 80, 50, 20, 90, 60, 30}
由于集合是不能有重复元素的，集合推导式输出结果会过滤掉重复的元素，示例代码如下：
input_list = [2, 3, 2, 4, 5, 6, 6, 6]
n_list = [x ** 2 for x in input_list] ①
print(n_list)
n_set = {x ** 2 for x in input_list} ②
print(n_set)
输出结构如下：
[4, 9, 4, 16, 25, 36, 36, 36]
{4, 36, 9, 16, 25}
上述代码第①行是列表推导式。代码第②行是集合推导式，从结果可见没有重复的元素。
字典
字典（dict）是可迭代的、可变的数据结构，通过键来访问元素的数据结构。字典结构比较复杂，它是由两部分视图构成的：一个是键（key）视图；另一个是值（value）视图。键视图不能包含重复元素的，而值集合可以，键和值是成对出现的。
图9-5所示是字典结构的“国家代号”。键是国家代号，值是国家。
提示
字典更适合通过键快速访问值，就像查英文字典一样，键就是要查的英文单词，而值是英文单词的翻译和解释等内容。有的时候，一个英文单词会对应多个翻译和解释，这也是与字典集合特性对应的。
创建字典
字典类型是dict，创建字典可以使用dict()函数，或者用大括号{}将“键:值”对包裹，“键:值”对之间用逗号分隔。
在Python Shell中运行示例代码如下：
>>> dict1 = {102: '张三', 105: '李四', 109: '王五'} ①
>>> len(dict1)
3
>>> dict1
{102: '张三', 105: '李四', 109: '王五'}
>>> type(dict1)
<class 'dict'>
>>> dict1 = {}
>>> dict1
{}
>>> dict({102: '张三', 105: '李四', 109: '王五'}) ②
{102: '张三', 105: '李四', 109: '王五'}
>>> dict(((102, '张三'), (105, '李四'), (109, '王五'))) ③
{102: '张三', 105: '李四', 109: '王五'}
>>> dict([(102, '张三'), (105, '李四'), (109, '王五')]) ④
{102: '张三', 105: '李四', 109: '王五'}
>>> t1 = (102, '张三')
>>> t2 = (105, '李四')
>>> t3 = (109, '王五')
>>> t = (t1, t2, t3)
>>> dict(t) ⑤
{102: '张三', 105: '李四', 109: '王五'}
>>> list1 = [t1, t2, t3]
>>> dict(list1) ⑥
{102: '张三', 105: '李四', 109: '王五'}
>>> dict(zip([102, 105, 109], ['张三', '李四', '王五'])) ⑦
{102: '张三', 105: '李四', 109: '王五'}
上述代码第①行是使用大括号“键:值”对创建字典，这是最简单的创建字典方式了，那么创建一个空字典表达式是{}。获得字典长度（键值对个数）也是使用len()函数。
代码第②行、第③行、第④行、第⑤行和第⑥行都用dict()函数创建字典。代码第②行dict()函数参数是另外一个字典{102:
'张三', 105: '李四', 109: '王五'}，使用这种方式不如直接使用大括号“键:值”。
代码第③行和第⑤行参数是一个元组，这个元组中要包含三个只有两个元素的元组，创建过程参考如图9-6所示。代码第④行和第⑥行参数是一个列表，这个列表中包含三个只有两个元素的元组。
代码第⑦行是使用zip()函数，zip()函数将两个可迭代对象打包成元组，在创建字典时，可迭代对象元组，需要两个可迭代对象，第一个是键（[102,
105, 109]），第二个是值（['张三', '李四',
'王五']），他们包含的元素个数相同，并且一一对应。
注意 使用dict()函数创建字典还可以使用一种key=value形式参数，语法如下：
dict(key1=value1, key2=value2, key3=value3...)
key=value形式只能创建键是字符串类型的字典，使用时需要省略包裹字符串的引号（包括双引号或单引号）。在Python
Shell中运行示例代码如下：
>>> dict(102 = '张三', 105 = '李四', 109 = '王五') ①
SyntaxError: keyword can't be an expression
>>> dict('102' = '张三', '105' = '李四', '109' = '王五') ②
SyntaxError: keyword can't be an expression
>>> dict(S102 = '张三', S105 = '李四', S109 = '王五') ③
{'S102': '张三', 'S105': '李四', 'S109': '王五'}
代码第①行试图通过上述dict()函数创建键是整数类型的字典，结果会发生错误。代码第②行是试图使用字符串作为键创建字典，但是该dict()函数需要省略字符串键的引号，因此会发生错误。需要注意本例中键是由数字构成的字符串，他们很特殊如果省略包裹他们的引号，那么他们会表示为数字，使用该dict()函数是不允许的，所以此时的键不会识别字符串类型。代码第③行的键是在数字前面加S字母，这样不会识别为字符串类型。
修改字典
字典可以被修改，但都是针对键和值同时操作，修改字典包括添加、替换和删除“键:值”对。
在Python Shell中运行示例代码如下：
>>> dict1 = {102: '张三', 105: '李四', 109: '王五'}
>>> dict1[109] ①
'王五'
>>> dict1[110] = '董六' ②
>>> dict1
{102: '张三', 105: '李四', 109: '王五', 110: '董六'}
>>> dict1[109] = '张三' ③
>>> dict1
{102: '张三', 105: '李四', 109: '张三', 110: '董六'}
>>> del dict1[109] ④
>>> dict1
{102: '张三', 105: '李四', 110: '董六'}
>>> dict1.pop(105)
'李四'
>>> dict1
{102: '张三', 110: '董六'}
>>> dict1.pop(105, '董六') ⑤
'董六'
>>> dict1.popitem() ⑥
(110, '董六')
>>> dict1
{102: '张三'}
访问字典中元素可通过下标实现，下标参数是键，返回对应的值，代码第①行是dict1[109]是取出字典dict1中键为109的值。字典下标访问元素也可以在赋值符号（=）左边，代码第②行是字典110键赋值，注意此时字典dict1中没有110键，那么这样的操作会添加110:
'董六'键值对。如果键存在那么会替换对应的值，代码第③行会将键109对应的值替换为'张三'，虽然此时值视图中已经有'张三'了，但仍然可以添加，这说明值是可以重复的。
代码第④行是删除109键对应的值，注意del是语句不是函数。使用del语句删除键值对时，如果键不存在会抛出错误。
如果喜欢使用方法删除元素，可以使用字典的pop(key[,
default])和popitem()方法。pop(key[,
default])方法删除键值对，如果键不存在则返回默认值（default），见代码第⑤行是105键不存在返回默认值'董六'。popitem()方法删除任意键值对，返回删除的键值对，构成的元组，上述代码第⑥行删除了一个键值对，返回一个元组对象(110,
'董六')。
访问字典
字典还一些方法用来访问它的键或值，这些方法如下：
get(key[, default])。通过键返回值，如果键不存在返回默认值。
items()。返回字典的所有键值对。
keys()。返回字典键视图。
values()。返回字典值视图。
在Python Shell中运行示例代码如下：
>>> dict1 = {102: '张三', 105: '李四', 109: '王五'}
>>> dict1.get(105) ①
'李四'
>>> dict1.get(101) ②
>>> dict1.get(101, '董六') ③
'董六'
>>> dict1.items()
dict_items([(102, '张三'), (105, '李四'), (109, '王五')])
>>> dict1.keys()
dict_keys([102, 105, 109])
>>> dict1.values()
dict_values(['张三', '李四', '王五'])
上述代码第①行是通过get()方法返回105键对应的值，如果没有键对应的值，而且还没有为get()方法提供默认值，则不会有返回值，见代码第②行。代码第③行是提供了返回值。
在访问字典时，也可以使用in和not in运算符，但是需要注意的是in和not
in运算符只测试键视图中进行。在Python Shell中运行示例代码如下：
>>> student_dict = {'102': '张三', '105': '李四', '109': '王五'}
>>> 102 in dict1
True
>>> '李四' in dict1
False
遍历字典
字典遍历也是字典的重要操作。与集合不同，字典有两个视图，因此遍历过程可以只遍历值视图，也可以只遍历键视图，也可以同时遍历。这些遍历过程都是通过for循环实现的。
示例代码如下：
# coding=utf-8
# 代码文件：chapter9/ch9.4.4.py
student_dict = {102: '张三', 105: '李四', 109: '王五'}
print('---遍历键---')
for student_id in student_dict.keys(): ①
print('学号：' + str(student_id))
print('---遍历值---')
for student_name in student_dict.values(): ②
print('学生：' + student_name)
print('---遍历键:值---')
for student_id, student_name in student_dict.items(): ③
print('学号：{0} - 学生：{1}'.format(student_id, student_name))
输出结果如下：
---遍历键---
学号：102
学号：105
学号：109
---遍历值---
学生：张三
学生：李四
学生：王五
---遍历键:值---
学号：102 - 学生：张三
学号：105 - 学生：李四
学号：109 - 学生：王五
上述代码第③行遍历字典的键值对，items()方法返回是键值对元组序列，student_id,
student_name是从元组拆包出来的两个变量。
字典推导式
因为字典包含了键和值两个不同的结构，因此字典推导式结果可以非常灵活。字典推导示例代码如下：
# coding=utf-8
# 代码文件：chapter9/ch9.4.5.py
input_dict = {'one': 1, 'two': 2, 'three': 3, 'four': 4}
output_dict = {k: v for k, v in input_dict.items() if v % 2 == 0} ①
print(output_dict)
keys = [k for k, v in input_dict.items() if v % 2 == 0] ②
print(keys)
输出结构如下：
{'two': 2, 'four': 4}
['two', 'four']
上述代码第①行是字典推导式，注意输入结构不能直接使用字典，因为字典不是序列，可以通过字典的item()方法返回字典中键值对序列。代码第②行是字典推导式，但只返回键结构。
本章小结
本章介绍了Python中的几种数据结构。其中包括序列、元组、集合和字典，了解序列的特点，清楚序列包括哪些结构。然后详细介绍了元组、集合和字典。
配套视频
http://www.zhijieketang.com/classroom/10/courses
配套源代码
http://www.zhijieketang.com/group/8
纸质版电商
京东：https://item.jd.com/12468732.html
当当：http://product.dangdang.com/25574315.html
作者微博：@tony_关东升
邮箱：eorient@sina.com
智捷课堂微信公共号：zhijieketang
Python读者服务QQ群：565736812
-
可迭代（iterable），是指它的成员能返回一次的对象。 ↩
