278 lines
11 KiB
Markdown
278 lines
11 KiB
Markdown
## 第011课：常用数据结构之元组和列表
|
||
|
||
在开始本节课的内容之前，我们先给大家一个编程任务，将一颗色子掷6000次，统计每个点数出现的次数。这个任务对大家来说应该是非常简单的，我们可以用1到6均匀分布的随机数来模拟掷色子，然后用6个变量分别记录每个点数出现的次数，相信大家都能写出下面的代码。
|
||
|
||
```Python
|
||
import random
|
||
|
||
f1 = 0
|
||
f2 = 0
|
||
f3 = 0
|
||
f4 = 0
|
||
f5 = 0
|
||
f6 = 0
|
||
for _ in range(6000):
|
||
face = random.randint(1, 6)
|
||
if face == 1:
|
||
f1 += 1
|
||
elif face == 2:
|
||
f2 += 1
|
||
elif face == 3:
|
||
f3 += 1
|
||
elif face == 4:
|
||
f4 += 1
|
||
elif face == 5:
|
||
f5 += 1
|
||
else:
|
||
f6 += 1
|
||
print(f'1点出现了{f1}次')
|
||
print(f'2点出现了{f2}次')
|
||
print(f'3点出现了{f3}次')
|
||
print(f'4点出现了{f4}次')
|
||
print(f'5点出现了{f5}次')
|
||
print(f'6点出现了{f6}次')
|
||
```
|
||
|
||
看看上面的代码，相信大家一定觉得它非常的“笨重”和“丑陋”，更可怕的是，如果要统计掷2颗或者更多的色子统计每个点数出现的次数，那就需要定义更多的变量，写更多的分支结构。讲到这里，相信大家一定想问：有没有办法用一个变量来保存多个数据，有没有办法用统一的代码对多个数据进行操作？答案是肯定的，在Python中我们可以通过容器类型的变量来保存和操作多个数据，我们首先为大家介绍列表（list）这种新的数据类型。
|
||
|
||
### 定义和使用列表
|
||
|
||
在Python中，**列表是由一系元素按特定顺序构成的数据序列**，这样就意味着定义一个列表类型的变量，**可以保存多个数据**，而且**允许有重复的数据**。跟上一课我们讲到的字符串类型一样，列表也是一种结构化的、非标量类型，操作一个列表类型的变量，除了可以使用运算符还可以使用它的方法。
|
||
|
||
在Python中，可以使用`[]`字面量语法来定义列表，列表中的多个元素用逗号进行分隔，代码如下所示。
|
||
|
||
```Python
|
||
items1 = [35, 12, 99, 68, 55, 87]
|
||
items2 = ['Python', 'Java', 'Go', 'Kotlin']
|
||
```
|
||
|
||
需要说明的是，列表是一种可变数据类型，也就是说列表可以添加元素、删除元素、更新元素，这一点跟我们上一课讲到的字符串有着鲜明的差别。字符串是一种不可变数据类型，也就是说对字符串做拼接、重复、转换大小写、修剪空格等操作的时候会产生新的字符串，原来的字符串并没有发生任何改变。
|
||
|
||
#### 列表的运算符
|
||
|
||
和字符串类型一样，列表也支持拼接、重复、成员运算、索引和切片，对此我们不再进行赘述，请大家参考下面的代码。
|
||
|
||
```Python
|
||
items1 = [35, 12, 99, 68, 55, 87]
|
||
items2 = [45, 8, 29]
|
||
|
||
# 列表的拼接
|
||
items3 = items1 + items2
|
||
print(items3) # [35, 12, 99, 68, 55, 87, 45, 8, 29]
|
||
|
||
# 列表的重复
|
||
items4 = ['hello'] * 3
|
||
print(items4) # ['hello', 'hello', 'hello']
|
||
|
||
# 列表的成员运算
|
||
print(100 in items3) # False
|
||
print('hello' in items4) # True
|
||
|
||
# 获取列表的长度(元素个数)
|
||
size = len(items3)
|
||
print(size) # 9
|
||
|
||
# 列表的索引
|
||
print(items3[0], items3[-size]) # 35 35
|
||
items3[-1] = 100
|
||
print(items3[size - 1], items3[-1]) # 100 100
|
||
|
||
# 列表的切片
|
||
print(items3[:5]) # [35, 12, 99, 68, 55]
|
||
print(items3[4:]) # [55, 87, 45, 8, 100]
|
||
print(items3[-5:-7:-1]) # [55, 68]
|
||
print(items3[::-2]) # [100, 45, 55, 99, 35]
|
||
```
|
||
|
||
值得一提的是，由于列表是可变类型，所以通过索引操作既可以获取列表中的元素，也可以更新列表中的元素。对列表做索引操作一样要注意索引越界的问题，对于有`N`个元素的列表，正向索引的范围是`0`到`N-1`，负向索引的范围是`-1`到`-N`，如果超出这个范围，将引发`IndexError`异常，错误信息为：`list index out of range`。
|
||
|
||
#### 列表元素的遍历
|
||
|
||
如果想逐个取出列表中的元素，可以使用`for`循环的，有以下两种做法。
|
||
|
||
方法一：
|
||
|
||
```Python
|
||
items = ['Python', 'Java', 'Go', 'Kotlin']
|
||
|
||
for index in range(len(items)):
|
||
print(items[index])
|
||
```
|
||
|
||
方法二：
|
||
|
||
```Python
|
||
items = ['Python', 'Java', 'Go', 'Kotlin']
|
||
|
||
for item in items:
|
||
print(item)
|
||
```
|
||
|
||
讲到这里，我们可以用列表的知识来重构上面“掷色子统计每个点数出现次数”的代码。
|
||
|
||
```Python
|
||
import random
|
||
|
||
counters = [0] * 6
|
||
for _ in range(6000):
|
||
face = random.randint(1, 6)
|
||
counters[face - 1] += 1
|
||
for face in range(1, 7):
|
||
print(f'{face}点出现了{counters[face - 1]}次')
|
||
```
|
||
|
||
上面的代码中，我们用`counters`列表中的六个元素分别表示1到6的点数出现的次数，最开始的时候六个元素的值都是`0`。接下来用随机数模拟掷色子，如果摇出1点`counters[0]`的值加`1`，如果摇出2点`counters[1]`的值加`1`，以此类推。大家感受一下，这段代码是不是比之前的代码要简单优雅很多。
|
||
|
||
### 列表的方法
|
||
|
||
和字符串一样，列表类型的方法也很多，下面为大家讲解比较重要的方法。
|
||
|
||
#### 添加和删除元素
|
||
|
||
```Python
|
||
items = ['Python', 'Java', 'Go', 'Kotlin']
|
||
|
||
# 使用append方法在列表尾部添加元素
|
||
items.append('Swift')
|
||
print(items) # ['Python', 'Java', 'Go', 'Kotlin', 'Swift']
|
||
# 使用insert方法在列表指定索引位置插入元素
|
||
items.insert(2, 'SQL')
|
||
print(items) # ['Python', 'Java', 'SQL', 'Go', 'Kotlin', 'Swift']
|
||
|
||
# 删除指定的元素
|
||
items.remove('Java')
|
||
print(items) # ['Python', 'SQL', 'Go', 'Kotlin', 'Swift']
|
||
# 删除指定索引位置的元素
|
||
items.pop(0)
|
||
items.pop(len(items) - 1)
|
||
print(items) # ['SQL', 'Go', 'Kotlin']
|
||
|
||
# 清空列表中的元素
|
||
items.clear()
|
||
print(items) # []
|
||
```
|
||
|
||
需要提醒大家，在使用`remove`方法删除元素时，如果要删除的元素并不在列表中，会引发`ValueError`异常，错误消息是：`list.remove(x): x not in list`。在使用`pop`方法删除元素时，如果索引的值超出了范围，会引发`IndexError`异常，错误消息是：`pop index out of range`。
|
||
|
||
#### 元素位置和次数
|
||
|
||
列表类型的`index`方法可以查找某个元素在列表中的索引位置；因为列表中允许有重复的元素，所以列表类型提供了`count`方法来统计一个元素在列表中出现的次数。请看下面的代码。
|
||
|
||
```Python
|
||
items = ['Python', 'Java', 'Java', 'Go', 'Kotlin', 'Python']
|
||
|
||
# 查找元素的索引位置
|
||
print(items.index('Python')) # 0
|
||
print(items.index('Python', 2)) # 5
|
||
# 注意：虽然列表中有'Java'，但是从索引为3这个位置开始后面是没有'Java'的
|
||
print(items.index('Java', 3)) # ValueError: 'Java' is not in list
|
||
```
|
||
|
||
再来看看下面这段代码。
|
||
|
||
```Python
|
||
items = ['Python', 'Java', 'Java', 'Go', 'Kotlin', 'Python']
|
||
|
||
# 查找元素出现的次数
|
||
print(items.count('Python')) # 2
|
||
print(items.count('Go')) # 1
|
||
print(items.count('Swfit')) # 0
|
||
```
|
||
|
||
#### 元素排序和反转
|
||
|
||
列表的`sort`操作可以实现列表元素的排序，而`reverse`操作可以实现元素的反转，代码如下所示。
|
||
|
||
```Python
|
||
items = ['Python', 'Java', 'Go', 'Kotlin', 'Python']
|
||
|
||
# 排序
|
||
items.sort()
|
||
print(items) # ['Go', 'Java', 'Kotlin', 'Python', 'Python']
|
||
# 反转
|
||
items.reverse()
|
||
print(items) # ['Python', 'Python', 'Kotlin', 'Java', 'Go']
|
||
```
|
||
|
||
### 列表的生成式
|
||
|
||
在Python中，列表还可以通过一种特殊的字面量语法来创建，这种语法叫做生成式。我们给出两段代码，大家可以做一个对比，看看哪一种方式更加简单优雅。
|
||
|
||
通过`for`循环为空列表添加元素。
|
||
|
||
```Python
|
||
# 创建一个由1到9的数字构成的列表
|
||
items1 = []
|
||
for x in range(1, 10):
|
||
items1.append(x)
|
||
print(items1)
|
||
|
||
# 创建一个由'hello world'中除空格和元音字母外的字符构成的列表
|
||
items2 = []
|
||
for x in 'hello world':
|
||
if x not in ' aeiou':
|
||
items2.append(x)
|
||
print(items2)
|
||
|
||
# 创建一个由个两个字符串中字符的笛卡尔积构成的列表
|
||
items3 = []
|
||
for x in 'ABC':
|
||
for y in '12':
|
||
items3.append(x + y)
|
||
print(items3)
|
||
```
|
||
|
||
通过生成式创建列表。
|
||
|
||
```Python
|
||
# 创建一个由1到9的数字构成的列表
|
||
items1 = [x for x in range(1, 10)]
|
||
print(items1) # [1, 2, 3, 4, 5, 6, 7, 8, 9]
|
||
|
||
# 创建一个由'hello world'中除空格和元音字母外的字符构成的列表
|
||
items2 = [x for x in 'hello world' if x not in ' aeiou']
|
||
print(items2) # ['h', 'l', 'l', 'w', 'r', 'l', 'd']
|
||
|
||
# 创建一个由个两个字符串中字符的笛卡尔积构成的列表
|
||
items3 = [x + y for x in 'ABC' for y in '12']
|
||
print(items3) # ['A1', 'A2', 'B1', 'B2', 'C1', 'C2']
|
||
```
|
||
|
||
下面这种方式不仅代码简单优雅，而且性能也优于上面使用`for`循环和`append`方法向空列表中追加元素的方式。可以简单跟大家交待下为什么生成式拥有更好的性能，那是因为Python解释器的字节码指令中有专门针对生成式的指令（`LIST_APPEND`指令）；而`for`循环是通过方法调用（`LOAD_METHOD`和`CALL_METHOD`指令）的方式为列表添加元素，方法调用本身就是一个相对耗时的操作。对这一点不理解也没有关系，记住“**强烈建议用生成式语法来创建列表**”这个结论就可以了。
|
||
|
||
### 嵌套的列表
|
||
|
||
Python语言没有限定列表中的元素必须是相同的数据类型，也就是说一个列表中的元素可以任意的数据类型，当然也包括列表。如果列表中的元素又是列表，那么我们可以称之为嵌套的列表。嵌套的列表可以用来表示表格或数学上的矩阵，例如：我们想保存5个学生3门课程的成绩，可以定义一个保存5个元素的列表保存5个学生的信息，而每个列表元素又是3个元素构成的列表，分别代表3门课程的成绩。但是，一定要注意下面的代码是有问题的。
|
||
|
||
```Python
|
||
scores = [[0] * 3] * 5
|
||
print(scores) # [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
|
||
```
|
||
|
||
看上去我们好像创建了一个`5 * 3`的嵌套列表，但实际上当我们录入第一个学生的第一门成绩后，你就会发现问题来了，我们看看下面代码的输出。
|
||
|
||
```Python
|
||
# 嵌套的列表需要多次索引操作才能获取元素
|
||
scores[0][0] = 95
|
||
print(scores) # [[95, 0, 0], [95, 0, 0], [95, 0, 0], [95, 0, 0], [95, 0, 0]]
|
||
```
|
||
|
||
我们不去过多的解释为什么会出现这样的问题，如果想深入研究这个问题，可以通过[Python Tutor](<http://www.pythontutor.com/visualize.html>)网站的可视化代码执行功能，看看创建列表时计算机内存中发生了怎样的变化，下面的图就是在这个网站上生成的。建议大家不去纠结这个问题，现阶段只需要记住不能用`[[0] * 3] * 5]`这种方式来创建嵌套列表就行了。那么创建嵌套列表的正确做法是什么呢，下面的代码会给你答案。
|
||
|
||
```Python
|
||
scores = [[0] * 3 for _ in range(5)]
|
||
scores[0][0] = 95
|
||
print(scores) # [[95, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
|
||
```
|
||
|
||
|
||
|
||
在讲完下节课的知识点后，我们会把这个案例写得更为完整一些，实现录入5个学生3门课程的成绩，统计出每个学生和每门课程的平均分。
|
||
|
||
### 简单的总结
|
||
|
||
这节课我们先不做总结，等学完下节课的元组之后，我们对列表和元组的使用做一个简单的总结。
|
||
|
||
> **温馨提示**：学习中如果遇到困难，可以加**QQ交流群**询问，群号：**789050736**。
|
||
|