第五期 数据之美与数据结构

讲师：李浩然
（在本次课中，”项“和”元素“有着相同的意义）

1. 列表 (list)

1.1 列表的基本形式与创建

• 列表相比于普通变量而言，是多个元素相连的结构。所有的元素用方括号[]包含起来，每一个项之间用逗号分隔。
• 以下的代码是列表被创建的方式

students_all = [81, 94, 92, 71, 99, ……, 87]             # 可以都是整数
students_none = []                                      # 可以没有任何元素在内
student_names = [‘Edward’, ‘Ben’, ……, ‘Tom’]            # 可以都是字符串
student_heights = [1.75, 1.88, 1.62, ……, 1.73]          # 可以都是浮点数（小数）
student_info = [‘Edward’, 19, ‘University of Toronto’]  # 可以什么都有
student_combine = [[1, 2], 3]                           # 甚至可以将列表作为元素

1.2 索引 (index)

• 索引是指代某个元素在列表中的位置。
• 注意：在计算机中，计数从零开始。也就是说，在一个长度为 n 的列表里，第一个元素的索引是 0，最后一个元素的索引为 n - 1。
• 同时，列表也可以从尾部开始计数。列表的最后一个元素的索引可以为 -1 ，第一个元素的索引可以为 -n。

>>> ls = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> ls[0]                    # 打印字符串格式的元素
'foo'
>>> ls[0] == ‘foo’           # 比较元素和字符串
True
>>> ls[-6] == ls[0]          # 从尾部计数与从头部计数有相同意义
True
>>> ls[0] + ls[1]            # 列表里的字符串元素可以当做字符串变量来处理
‘foobar’
>>> ls_1 = [1, 2, 3, 4, 5]
>>> ls_1[0] + ls_1[1]        # 列表里的数字元素可以当做数字变量来处理
3
>>> ls_1[1] * ls_1[2]        # 列表里的数字元素可以当做数字变量来处理
6

小练习 1

>>> ls = [81, 94, 92, 71, 99, 87]
>>> print(’列表 ls 所有元素的平均数是多少？’)
列表 ls 所有元素的平均数是多少？
>>>

• Python 中，索引也可以设置为一个范围。
• 格式为变量名[开始的索引:结束的索引的后一个]
• 例如：ls[a:b] 指的是列表 ls 中的从第 a 项到第 b - 1 项。

>>> ls = [‘foo’, ‘bar’, ‘baz’, ‘qux’, ‘quux’, ‘corge’]
>>>
>>> ls[1:2]
['bar']
>>> ls[0:-3]                          # 从第 0 项到第 -4 项
[‘foo’, ‘bar’, ‘baz’]
>>> ls[-4:]                           # 从第 -4 项到列表末尾
[‘baz’, ‘qux’, ‘quux’, ‘corge’]
>>> ls[:]                             # 从列表开头到列表末尾
[‘foo’, ‘bar’, ‘baz’, ‘qux’, ‘quux’, ‘corge’]

小练习 2

>>> ls = [‘foo’, ‘bar’, ‘baz’, ‘qux’, ‘quux’, ‘corge’]
>>> ls[-5:4]
>>> ls[:-2]
>>> ls[5:2]

1.3 值的操作

>>> ls = [81, 94, 92, 71, 99, 87, 92]
>>> ls[0] = 90            # 列表中的项可以通过赋值号修改值
>>> ls
[90, 94, 92, 71, 99, 87, 92]
>>>
>>> 99 in ls              # 可以用关键字 'in' 来验证列表中是否包含某项
True
>>> 100 in ls
False

1.4 常用方法

1.4.1 len, min, max, sum

• 这四种方法可以说是 Python 中关于列表的最基础也是最常用的方法了。

>>> ls = [81, 94, 92, 71, 99, 87, 92]
>>> len(ls)    # 项的个数
7
>>> min(ls)    # 求最小值
71
>>> max(ls)    # 求最大值
99
>>> sum(ls)    # 求和
616

小练习 3

• 这道练习在前面已经出现过了，在这里希望大家可以用上面的方法来求出结果。

>>> ls = [81, 94, 92, 71, 99, 87]
>>> print(’列表 ls 所有元素的平均数是多少？’)
列表 ls 所有元素的平均数是多少？
>>> 

1.4.2 append, remove

• 除了列表在创建时存在的项，我们也可以通过 append 方法和 remove 方法改变项的个数。

>>> ls = [81, 94, 92, 71, 99, 87, 92]
>>> ls.append(92)                # 在列表末尾添加一个项
>>> ls
[81, 94, 92, 71, 99, 87, 92, 92]
>>> ls.remove(92)                # 删去第一个出现的匹配项
>>> ls
[81, 94, 71, 99, 87, 92, 92]
>>> ls.remove(100)               # 删去一个不存在的值会得到错误
Error!

1.4.3 index, count, reverse

>>> ls = [81, 94, 92, 71, 99, 87, 92]
>>> ls.index(92)          # 显示第一个匹配的项的索引
2
>>> ls.index(100)         # 查找一个不存在的值会得到错误
Error!
>>> ls.count(92)          # 数一数这个值在列表里出现了几次
2
>>> ls.reverse()          # 将列表反转
>>> ls
[92, 87, 99, 71, 92, 94, 81]

2. 元组 (tuple)

• 元组和列表是非常相像的，最主要的不同是元组是不可改变的。也就是说，元组在创建之后，里面每个项的值不能被改变，不能添加新的项，也不能删除已经存在的项。除此之外，元组和列表基本相同，上面提到的列表的性质在元组上都有体现。

2.1 元组的形式与创建

• 与列表不同，元组是用圆括号来创建的。

>>> seq_1 = (81, 94, 92, 71, 99, 87, 92)   # 元组的项可以为数字
>>> seq_2 = ()                             # 元组可以为空
>>> seq_3 = ('Edward', 'is', 'handsome')   # 元组的项可以为字符串
>>> seq_4 = ((0, 0), (1, 1))               # 元组的项可以为元组
>>> seq_5 = ([1, 2], 3)                    # 元组的项可以为列表

课外内容（不懂没关系）：在元组内的列表的值是可以进行修改的。这是因为在元组中，列表的储存形式为内存地址，并非真正的值。在改变元组中的列表的值的时候，并没有改变在元组中的内存地址，从而使元组中的值依然是未改变的。（如果想明白的更透彻一点可以来找我）

2.2 元组的非法用法

>>> seq.append(92)     # 不可以添加项
Error!
>>> seq.remove(92)     # 不可以删除项
Error!
>>> seq[0] = 100       # 不可以修改值
Error!

2.3 元组的意义

• 因为其不可变性，元组常常用来保存一些长时间不变的量，比如说银行卡号、身份证号、邮箱账号等。这样一来，这些量就不会被意外改掉了。

3. 字典 (dictionary)

• 字典是一个用来记录配对信息的数据类型。每一个项在字典里有两部分，键（key）和值（value）。
• 不同于列表和元组的是，字典中没有索引。在字典中，我们使用它的键来找寻它的值。

3.1 字典的形式与创建

• 字典的项是用花括号{}包含起来的，每一个项之间用逗号分隔，每一个项内用冒号:来分隔键和值。

>>> dic_1 = { 882673: 100, 882674: 82, 882675: 93 }
>>> dic_2 = { ‘Edward’: 100, ‘Shawn’: 49 }
>>> dic_3 = { ‘Edward’: ‘University of Toronto’,
                ‘Shawn’: ‘Western University’,
                ‘Kate’: ‘Peking University’ }

注意：对于字典，我们需要注意的是，它的每一个项的键都是不可更改的。也就是说，当一个键一旦声明，就不可以再改变。若想改变，只能删除再添加。

同时，虽说字典的项的值可以是任何形式，但是字典的项的键却不可是列表，因为列表是可以被更改的。比如说：dic = { [ 1, 2, 3 ]: ‘Edward’}是非法的。

假若在创造一个字典的时候，相同的键出现了两次，那只有最后一次是有效的。

3.2 值的操作

>>> dic = { ‘a’: 1, ‘b’: 2, ‘c’: 3, ‘d’: 4 }
>>> dic[‘a’]                # 访问字典里的值
1
>>> dic[‘a’] = 2            # 修改字典里的值
>>> dic
{ ‘a’: 2, ‘b’: 2, ‘c’: 3, ‘d’: 4 }
>>> del dic[‘b’]            # 删除字典里的值
>>> dic
{ ‘a’: 2, ‘c’: 3, ‘d’: 4 }

小练习 4

将如下表格以字典的形式表达出来。提示：列表也可以作为字典的值

>>>

小练习 5

将如下字典中的 Shawn 项的第二个成绩改为 98，然后将 Kate 项删除。

>>> dic = { ‘Edward’: [ 100, 97, 97 ],
        ‘Shawn’: [ 100, 100, 98 ],
        ‘Kate’: [ 97, 95, 92 ]}

4. 复合结构

• 在所有的上述的数据结构中，他们够可以相互包含，从而时间更为复杂的功能。

4.1 复合结构的形式与创建

>>> ls = [ { ‘a’: 1 }, ( 2, 3 ) ]                   # 列表中包含字典和元组
>>> seq = ( [ 1, 2, 3 ], { ‘a’: 1 } )               # 元组中包含列表和字典
>>> dic = { ‘a’: [ 1, 2, 3 ], ‘b’: ( 1, 2 ) }
                                            # 字典的值中包含列表和元组。
                                            # 注意，字典的键不允许有字典和列表出现。

4.2 值的操作

• 通过使用多重下标，我们可以完成对复合结构的操作。

>>> ls = [ { ‘a’: 1 }, ( 2, 3 ) ]
>>> ls[0][‘a’]
1
>>> ls[1][5]
3
>>> dic = { ‘a’: [ 1, 2, 3 ], ‘b’: ( 1, 2 ) }
>>> dic[‘a’][0] = 2
>>> dic
{ ‘a’: [ 2, 2, 3 ], ‘b’: ( 1, 2 ) }

4.3 数据结构的转换

• 将列表或元组转换为字符串用 join() 方法。
• 将列表转换为元组用 tuple() 方法。
• 将元组转换为列表用 list() 方法。

示例：

>>> ls = [ 1, 2, 3 ]
>>> seq = ( 4, 5, 6 )
>>> str = ‘789’
>>> str_ls = ”“.join(ls)    # 将列表转换为字符串
‘123’
>>> ls_str = list(str)      # 将字符串转换为列表
[’7’, ’8’, ‘9’ ]
>>> seq_ls = tuple(ls)      # 将列表转换为元组
( 1, 2, 3 )
>>> ls_seq = list(seq)      # 将元组转换为列表

5. 课后作业

在数据库中，学生的名字与期末成绩以如下格式保存着：

{ ...,
    学生 ID: [学生姓名, 语文成绩, 数学成绩, 英语成绩],
    学生 ID: [学生姓名, 语文成绩, 数学成绩, 英语成绩],
    学生 ID: [学生姓名, 语文成绩, 数学成绩, 英语成绩],
  ... }

例如：

{   ...
    30: ['Shawn Pang', 78, 98, 94],
    31: ['Edward Li', 100, 100, 100],
    32: ['Imogene Liu', (80, 95, 92)],
    ...
}

像这样的学生数据，在数据库中有 100 条。同时，学生的学生 ID 是从 0 开始到 99 结束，且一直保持连续。

请写出一个 Python 程序，将所有平均成绩高于 90 分的学生的名字以一个列表的形式打印出来。