《Python从小白到大牛》第9章数据结构

作者: tony关东升 | 来源:发表于2018-08-21 11:11 被阅读41次

当你有很多书时，你会考虑买一个书柜，将你的书分门别类摆放进入。使用了书柜不仅仅使房间变得整洁，也便于以后使用书时方便查找。在计算机程序中会有很多数据，这些数据也需要一个容器将他们管理起来，这就是数据结构。常见的数据结构：数组（Array）、集合（Set）、列表（List）、队列（Queue）、链表（Linkedlist）、树（Tree）、堆（Heap）、栈（Stack）和字典（Dictionary）等结构。

Python中数据容器主要有：序列、集合和字典。

注意
Python中并没有数组结构，因为数组要求元素类型是一致的。而Python作为动态类型语言，不强制声明变量的数据类型，也不能强制检查元素的数据类型。所以Python中没有数组结构。

元组

元组（tuple）是一种序列（sequence）结构，下面先来介绍一些序列。

序列

序列（sequence）是一种可迭代的^[1]，元素是有序的，可以重复出现的数据结构。序列可以通过索引访问元素。图9-1是一个班级序列，其中有一些学生，这些学生是有序的，顺序是他们被放到序列中的顺序，可以通过序号访问他们。这就像老师给进入班级的人分配学号，第一个报到的是“张三”，老师给他分配的是0，第二个报到的是“李四”，老师给他分配的是1，以此类推，最后一个序号应该是“学生人数-1”。

图9-1　序列

序列包括的结构有：列表（list）、字符串（str）、元组（tuple）、范围（range）、和字节序列（bytes）。序列可进行的操作有：索引、分片、加和乘。

索引操作

序列中第一个元素的索引是0，其他元素的索引是第一个元素的偏移量。可以有正偏移量，称为正值索引；也可以有负偏移量，称为负值索引。正值索引最后一个元素索引是“序列长度-1”，负值索引最后一个元素索引是“-1”。例如Hello字符串，它的正值索引如图9-2(a)所示，它的负值索引如图9-2(b)所示。

图9‑2 索引

访问序列中的元素的通过索引下标访问的，即中括号[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条件语句是过滤输入序列，符合条件的才传递给输出表达式，“条件语句”是可以省略的，也是所有元素都传递给输出表达式。

图9‑3 索引

条件语句可以包含多个条件，如果想找出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是一个班级的集合，其中包含一些学生，这些学生是无序的，不能通过序号访问，而且不能有重复的同学。

图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所示是字典结构的“国家代号”。键是国家代号，值是国家。

图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所示。代码第④行和第⑥行参数是一个列表，这个列表中包含三个只有两个元素的元组。

图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），是指它的成员能返回一次的对象。 ↩

《Python从小白到大牛》第9章数据结构

元组

序列

创建元组

访问元组

遍历元组

列表

列表创建

追加元素

插入元素

替换元素

删除元素

其他常用方法

列表推导式

集合

创建可变集合

修改可变集合

遍历集合

不可变集合

集合推导式

字典

创建字典

修改字典

访问字典

遍历字典

字典推导式

本章小结

配套视频

配套源代码

纸质版电商

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读