Python(二十) 中的列表
一、什么是列表
列表，英文叫 list。
在 Python 中，列表是一种可以保存多个数据的容器。
通俗地说：
如果一个变量只能装一个数据，那么列表就像一个盒子，可以装很多数据。
例如，保存一个学生姓名：
name = "小明"
如果要保存多个学生姓名，可以使用列表：
students = ["小明", "小红", "小刚"]
这里的 students 就是一个列表。
列表中的每一个数据，叫做元素。
"小明" 是一个元素
"小红" 是一个元素
"小刚" 是一个元素
列表适合用来保存一组相关数据，例如：
学生名单
考试成绩
商品列表
城市列表
任务清单
二、列表的基本特点
Python 列表有几个重要特点：
1. 列表可以保存多个数据
2. 列表中的元素是有顺序的
3. 列表可以通过索引访问元素
4. 列表可以修改
5. 列表中可以保存不同类型的数据
示例：
data = ["小明", 18, 95.5, True]
print(data)
输出结果：
['小明', 18, 95.5, True]
虽然列表可以保存不同类型的数据，但教学时建议告诉学生：
实际开发中，一个列表通常保存同一类数据，这样更清楚。
例如：
scores = [90, 85, 76, 100]
names = ["小明", "小红", "小刚"]
三、创建列表
1. 创建普通列表
students = ["小明", "小红", "小刚"]
print(students)
输出结果：
['小明', '小红', '小刚']
2. 创建数字列表
scores = [90, 85, 76, 100]
print(scores)
3. 创建空列表
空列表表示列表中暂时没有任何元素。
students = []
print(students)
输出结果：
[]
空列表常用于后面逐步添加数据。
4. 使用 list() 创建列表
可以使用 list() 把某些数据转换成列表。
示例：
text = "Python"
letters = list(text)
print(letters)
输出结果：
['P', 'y', 't', 'h', 'o', 'n']
四、列表索引
列表中的每个元素都有位置编号，这个编号叫索引。
Python 中索引从 0 开始。
示例：
students = ["小明", "小红", "小刚"]
对应关系：
元素： 小明 小红 小刚
索引： 0 1 2
获取列表中的元素：
students = ["小明", "小红", "小刚"]
print(students[0])
print(students[1])
print(students[2])
输出结果：
小明
小红
小刚
教学重点：
第一个元素的索引是 0，不是 1。
五、负数索引
列表也支持负数索引。
负数索引从右往左数。
示例：
students = ["小明", "小红", "小刚"]
对应关系：
元素： 小明 小红 小刚
正索引： 0 1 2
负索引： -3 -2 -1
示例：
students = ["小明", "小红", "小刚"]
print(students[-1])
print(students[-2])
输出结果：
小刚
小红
可以这样记：
列表[-1] 表示最后一个元素。
六、索引越界
如果访问不存在的位置，会报错。
示例：
students = ["小明", "小红", "小刚"]
print(students[5])
会报错：
IndexError: list index out of range
原因：
列表只有 3 个元素，最大索引是 2。
students[5] 超出了范围。
避免方式：
students = ["小明", "小红", "小刚"]
index = 5
if index < len(students):
print(students[index])
else:
print("索引超出范围")
七、查询列表元素
查询列表常见方式有：
1. 使用索引获取元素
2. 使用 in 判断元素是否存在
3. 使用 index() 查找元素位置
4. 使用 count() 统计元素出现次数
1. 使用索引查询
students = ["小明", "小红", "小刚"]
print(students[0])
输出结果：
小明
2. 使用 in 判断是否存在
students = ["小明", "小红", "小刚"]
if "小红" in students:
print("小红在列表中")
else:
print("小红不在列表中")
3. 使用 not in 判断是否不存在
students = ["小明", "小红", "小刚"]
if "小李" not in students:
print("小李不在列表中")
4. 使用 index() 查找位置
students = ["小明", "小红", "小刚"]
position = students.index("小红")
print(position)
输出结果：
1
注意：
如果 index() 查找的元素不存在，会报错。
安全写法：
students = ["小明", "小红", "小刚"]
if "小李" in students:
print(students.index("小李"))
else:
print("没有找到小李")
5. 使用 count() 统计次数
numbers = [1, 2, 3, 2, 4, 2]
print(numbers.count(2))
输出结果：
3
八、修改列表元素
列表是可变对象，可以修改里面的元素。
格式：
列表[索引] = 新值
示例：
students = ["小明", "小红", "小刚"]
students[1] = "小李"
print(students)
输出结果：
['小明', '小李', '小刚']
解释：
students[1] 原来是 "小红"。
修改后变成了 "小李"。
也可以修改最后一个元素：
students = ["小明", "小红", "小刚"]
students[-1] = "小王"
print(students)
输出结果：
['小明', '小红', '小王']
九、增加列表元素
列表中增加元素的常用方法有：
append() 在末尾添加一个元素
insert() 在指定位置插入一个元素
extend() 一次添加多个元素
十、append() 在末尾添加
append() 用于在列表末尾添加一个元素。
示例：
students = ["小明", "小红"]
students.append("小刚")
print(students)
输出结果：
['小明', '小红', '小刚']
注意：
append() 每次添加的是一个整体。
示例：
numbers = [1, 2, 3]
numbers.append([4, 5])
print(numbers)
输出结果：
[1, 2, 3, [4, 5]]
这里 [4, 5] 被当成一个元素添加进去了。
十一、insert() 指定位置插入
insert() 用于在指定位置插入元素。
格式：
列表.insert(索引, 元素)
示例：
students = ["小明", "小刚"]
students.insert(1, "小红")
print(students)
输出结果：
['小明', '小红', '小刚']
解释：
在索引 1 的位置插入 "小红"。
原来索引 1 以及后面的元素会往后移动。
十二、extend() 一次添加多个元素
extend() 用于把另一个可迭代对象中的元素逐个添加到列表末尾。
示例：
students = ["小明", "小红"]
students.extend(["小刚", "小李"])
print(students)
输出结果：
['小明', '小红', '小刚', '小李']
append() 和 extend() 的区别：
numbers = [1, 2, 3]
numbers.append([4, 5])
print(numbers)
输出：
[1, 2, 3, [4, 5]]
numbers = [1, 2, 3]
numbers.extend([4, 5])
print(numbers)
输出：
[1, 2, 3, 4, 5]
简单记忆：
append 是把一个东西整体放进去。
extend 是把一组东西拆开后逐个放进去。
十三、删除列表元素
删除列表元素常用方式有：
remove() 按值删除
pop() 按索引删除，并返回被删除的元素
del 删除指定位置或切片
clear() 清空列表
十四、remove() 按值删除
remove() 会删除列表中第一个匹配的元素。
示例：
students = ["小明", "小红", "小刚"]
students.remove("小红")
print(students)
输出结果：
['小明', '小刚']
注意：
如果要删除的元素不存在，remove() 会报错。
安全写法：
students = ["小明", "小红", "小刚"]
name = "小李"
if name in students:
students.remove(name)
else:
print("列表中没有这个学生")
如果列表中有多个相同元素：
numbers = [1, 2, 3, 2, 4]
numbers.remove(2)
print(numbers)
输出结果：
[1, 3, 2, 4]
只删除第一个 2。
十五、pop() 按索引删除
pop() 用于删除指定索引位置的元素，并返回被删除的元素。
示例：
students = ["小明", "小红", "小刚"]
name = students.pop(1)
print(name)
print(students)
输出结果：
小红
['小明', '小刚']
如果不写索引，默认删除最后一个元素：
students = ["小明", "小红", "小刚"]
last_student = students.pop()
print(last_student)
print(students)
输出结果：
小刚
['小明', '小红']
pop() 常用于：
删除最后一个元素
取出并移除某个元素
模拟栈结构
十六、del 删除元素
del 可以删除指定位置的元素。
示例：
students = ["小明", "小红", "小刚"]
del students[1]
print(students)
输出结果：
['小明', '小刚']
del 也可以删除一段切片：
numbers = [1, 2, 3, 4, 5]
del numbers[1:4]
print(numbers)
输出结果：
[1, 5]
十七、clear() 清空列表
clear() 用于删除列表中所有元素。
示例：
students = ["小明", "小红", "小刚"]
students.clear()
print(students)
输出结果：
[]
注意：
clear() 是清空列表内容，列表变量本身还存在。
十八、列表长度 len()
len() 可以获取列表中元素的个数。
示例：
students = ["小明", "小红", "小刚"]
print(len(students))
输出结果：
3
常见使用场景：
students = ["小明", "小红", "小刚"]
if len(students) == 0:
print("列表为空")
else:
print("列表中有", len(students), "个学生")
更简洁的判断空列表：
students = []
if students:
print("列表不是空的")
else:
print("列表是空的")
空列表 [] 在条件判断中会被当作 False。
十九、遍历列表
遍历列表就是把列表中的元素一个一个取出来处理。
最常用的是 for 循环。
示例：
students = ["小明", "小红", "小刚"]
for student in students:
print(student)
输出结果：
小明
小红
小刚
这里的 student 每次循环会保存列表中的一个元素。
教学时可以这样讲：
for 循环像是从列表中一个一个拿东西。
二十、同时获取索引和值 enumerate()
有时候遍历列表时，不只想要元素，还想要元素的索引。
可以使用 enumerate()。
示例：
students = ["小明", "小红", "小刚"]
for index, student in enumerate(students):
print(index, student)
输出结果：
0 小明
1 小红
2 小刚
如果希望编号从 1 开始：
students = ["小明", "小红", "小刚"]
for index, student in enumerate(students, start=1):
print(index, student)
输出结果：
1 小明
2 小红
3 小刚
enumerate() 适合课堂中讲“序号 + 内容”的输出。
二十一、列表切片
切片用于获取列表中的一部分元素。
基本格式：
列表[开始位置:结束位置]
注意：
包含开始位置。
不包含结束位置。
示例：
numbers = [0, 1, 2, 3, 4, 5]
print(numbers[1:4])
输出结果：
[1, 2, 3]
解释：
从索引 1 开始，到索引 4 之前结束。
取到索引 1、2、3 的元素。
可以这样记：
左闭右开：包含左边，不包含右边。
二十二、切片省略写法
1. 省略开始位置
numbers = [0, 1, 2, 3, 4, 5]
print(numbers[:3])
输出结果：
[0, 1, 2]
表示从开头取到索引 3 之前。
2. 省略结束位置
numbers = [0, 1, 2, 3, 4, 5]
print(numbers[3:])
输出结果：
[3, 4, 5]
表示从索引 3 取到最后。
3. 全部省略
numbers = [0, 1, 2, 3, 4, 5]
print(numbers[:])
输出结果：
[0, 1, 2, 3, 4, 5]
numbers[:] 可以得到一个新列表，里面的元素和原列表一样。
二十三、带步长的切片
格式：
列表[开始位置:结束位置:步长]
示例：
numbers = [0, 1, 2, 3, 4, 5, 6]
print(numbers[0:7:2])
输出结果：
[0, 2, 4, 6]
也可以省略开始和结束：
numbers = [0, 1, 2, 3, 4, 5, 6]
print(numbers[::2])
输出结果：
[0, 2, 4, 6]
二十四、使用切片反转列表
步长可以是负数。
使用 [::-1] 可以反转列表。
示例：
numbers = [1, 2, 3, 4, 5]
new_numbers = numbers[::-1]
print(new_numbers)
输出结果：
[5, 4, 3, 2, 1]
注意：
numbers[::-1] 会得到一个新列表。
原列表不变。
二十五、使用切片修改列表
列表的切片不仅可以查询，还可以修改。
示例：
numbers = [1, 2, 3, 4, 5]
numbers[1:4] = [20, 30, 40]
print(numbers)
输出结果：
[1, 20, 30, 40, 5]
也可以替换成不同数量的元素：
numbers = [1, 2, 3, 4, 5]
numbers[1:4] = [99]
print(numbers)
输出结果：
[1, 99, 5]
教学提醒：
切片赋值很灵活，但初学阶段不要写得太复杂。
二十六、列表排序 sort()
sort() 用于对列表本身进行排序。
示例：
numbers = [5, 2, 9, 1]
numbers.sort()
print(numbers)
输出结果：
[1, 2, 5, 9]
注意：
sort() 会修改原列表。
降序排序：
numbers = [5, 2, 9, 1]
numbers.sort(reverse=True)
print(numbers)
输出结果：
[9, 5, 2, 1]
二十七、使用 sorted() 排序
sorted() 也可以排序，但它不会修改原列表，而是返回一个新列表。
示例：
numbers = [5, 2, 9, 1]
new_numbers = sorted(numbers)
print(numbers)
print(new_numbers)
输出结果：
[5, 2, 9, 1]
[1, 2, 5, 9]
降序排序：
numbers = [5, 2, 9, 1]
new_numbers = sorted(numbers, reverse=True)
print(new_numbers)
输出结果：
[9, 5, 2, 1]
sort() 和 sorted() 的区别：
sort()：修改原列表，没有返回新列表
sorted()：不修改原列表，返回新列表
二十八、按规则排序 key
排序时可以使用 key 指定排序规则。
示例：按字符串长度排序。
words = ["python", "java", "c", "javascript"]
words.sort(key=len)
print(words)
输出结果：
['c', 'java', 'python', 'javascript']
解释：
key=len 表示按照每个字符串的长度排序。
按学生成绩排序：
students = [
{"name": "小明", "score": 85},
{"name": "小红", "score": 92},
{"name": "小刚", "score": 78}
]
students.sort(key=lambda student: student["score"])
print(students)
如果想从高到低：
students.sort(key=lambda student: student["score"], reverse=True)
教学提醒：
key 可以理解为“按照什么来排”。
二十九、反转列表 reverse()
reverse() 用于把原列表顺序反过来。
示例：
numbers = [1, 2, 3, 4, 5]
numbers.reverse()
print(numbers)
输出结果：
[5, 4, 3, 2, 1]
注意：
reverse() 会修改原列表。
对比切片反转：
numbers = [1, 2, 3, 4, 5]
new_numbers = numbers[::-1]
print(numbers)
print(new_numbers)
输出结果：
[1, 2, 3, 4, 5]
[5, 4, 3, 2, 1]
区别：
reverse() 修改原列表。
[::-1] 返回新列表。
三十、列表中的最大值、最小值、求和
如果列表中都是数字，可以使用：
max() 最大值
min() 最小值
sum() 求和
示例：
scores = [90, 85, 76, 100]
print(max(scores))
print(min(scores))
print(sum(scores))
输出结果：
100
76
351
计算平均分：
scores = [90, 85, 76, 100]
average = sum(scores) / len(scores)
print(average)
输出结果：
87.75
注意：
sum() 只能用于可以相加的元素。
如果列表里有字符串，可能会报错。
三十一、列表推导式
列表推导式可以用简洁方式生成列表。
普通写法：
numbers = []
for i in range(1, 6):
numbers.append(i)
print(numbers)
输出结果：
[1, 2, 3, 4, 5]
列表推导式写法：
numbers = [i for i in range(1, 6)]
print(numbers)
输出结果一样：
[1, 2, 3, 4, 5]
生成平方列表：
squares = [i * i for i in range(1, 6)]
print(squares)
输出结果：
[1, 4, 9, 16, 25]
筛选偶数：
numbers = [1, 2, 3, 4, 5, 6]
evens = [num for num in numbers if num % 2 == 0]
print(evens)
输出结果：
[2, 4, 6]
教学建议：
初学者先掌握 for 循环和 append()，再学习列表推导式。
三十二、列表复制
列表复制是一个很容易出错的地方。
先看一个例子：
a = [1, 2, 3]
b = a
b.append(4)
print(a)
print(b)
输出结果：
[1, 2, 3, 4]
[1, 2, 3, 4]
很多初学者会以为只有 b 变化。
实际原因：
b = a 不是复制一个新列表。
它只是让 b 和 a 指向同一个列表。
如果想复制出一个新列表，可以使用：
a = [1, 2, 3]
b = a.copy()
b.append(4)
print(a)
print(b)
输出结果：
[1, 2, 3]
[1, 2, 3, 4]
也可以使用切片复制：
b = a[:]
注意：
copy() 和切片复制是浅拷贝。
如果列表里面还有列表，情况会更复杂。
初学阶段先掌握：
b = a 不是复制新列表。
b = a.copy() 才是复制一份新的普通列表。
三十三、嵌套列表
列表中还可以放列表，这叫嵌套列表。
示例：
matrix = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
print(matrix)
可以把它看作一个表格：
1 2 3
4 5 6
7 8 9
访问嵌套列表中的元素：
matrix = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
print(matrix[0])
print(matrix[0][1])
输出结果：
[1, 2, 3]
2
解释：
matrix[0] 表示第一行。
matrix[0][1] 表示第一行中的第二个元素。
修改嵌套列表：
matrix[1][2] = 60
print(matrix)
输出结果：
[[1, 2, 3], [4, 5, 60], [7, 8, 9]]
三十四、遍历嵌套列表
可以使用两层 for 循环遍历嵌套列表。
示例：
matrix = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
for row in matrix:
for num in row:
print(num)
解释：
外层循环一次取出一行。
内层循环取出这一行中的每个数字。
如果想按表格形式输出：
matrix = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
for row in matrix:
for num in row:
print(num, end=" ")
print()
输出结果：
1 2 3
4 5 6
7 8 9
三十五、列表和字符串的关系
列表和字符串都属于序列类型，所以它们都支持：
索引
切片
len()
for 遍历
in 判断
例如：
text = "Python"
students = ["小明", "小红", "小刚"]
print(text[0])
print(students[0])
区别：
字符串不可变，不能直接修改某个字符。
列表可变，可以修改、添加、删除元素。
示例：
students = ["小明", "小红"]
students[0] = "小李"
print(students)
列表可以修改。
但字符串不能这样写：
text = "Python"
text[0] = "J"
三十六、常见注意事项
1. 列表使用方括号 []
正确写法：
students = ["小明", "小红"]
不要和元组的小括号混淆：
students = ("小明", "小红")
这不是列表，而是元组。
2. 索引从 0 开始
students = ["小明", "小红", "小刚"]
print(students[0])
输出：
小明
3. 访问索引要避免越界
students = ["小明", "小红"]
print(students[5])
会报错。
4. append() 和 extend() 不一样
numbers = [1, 2]
numbers.append([3, 4])
print(numbers)
输出：
[1, 2, [3, 4]]
numbers = [1, 2]
numbers.extend([3, 4])
print(numbers)
输出：
[1, 2, 3, 4]
5. remove() 删除不存在的元素会报错
安全写法：
students = ["小明", "小红"]
if "小李" in students:
students.remove("小李")
else:
print("没有这个元素")
6. sort() 会修改原列表
numbers = [3, 1, 2]
numbers.sort()
print(numbers)
输出：
[1, 2, 3]
如果不想修改原列表，使用 sorted()：
numbers = [3, 1, 2]
new_numbers = sorted(numbers)
print(numbers)
print(new_numbers)
7. b = a 不是复制新列表
a = [1, 2, 3]
b = a
b.append(4)
print(a)
输出：
[1, 2, 3, 4]
如果要复制新列表：
b = a.copy()
或者：
b = a[:]
8. 不要一边遍历列表，一边随意删除元素
不推荐：
numbers = [1, 2, 3, 4, 5, 6]
for num in numbers:
if num % 2 == 0:
numbers.remove(num)
这可能导致结果不符合预期。
更推荐创建新列表：
numbers = [1, 2, 3, 4, 5, 6]
new_numbers = []
for num in numbers:
if num % 2 != 0:
new_numbers.append(num)
print(new_numbers)
或者使用列表推导式：
numbers = [1, 2, 3, 4, 5, 6]
new_numbers = [num for num in numbers if num % 2 != 0]
print(new_numbers)
9. 空列表在条件判断中是 False
students = []
if students:
print("有学生")
else:
print("没有学生")
输出：
没有学生
10. 列表方法很多会直接修改原列表
例如：
append()
insert()
extend()
remove()
pop()
clear()
sort()
reverse()
这些方法通常会改变原列表。
教学时可以提醒学生：
调用列表方法后，要观察原列表是否发生变化。
三十七、课堂示例
示例 1：学生名单管理
students = []
students.append("小明")
students.append("小红")
students.append("小刚")
print(students)
讲解重点：
空列表可以后续添加数据。
append() 用于在末尾添加元素。
示例 2：修改学生姓名
students = ["小明", "小红", "小刚"]
students[1] = "小李"
print(students)
讲解重点：
列表可以通过索引修改元素。
示例 3：删除学生
students = ["小明", "小红", "小刚"]
name = "小红"
if name in students:
students.remove(name)
print("删除成功")
else:
print("没有这个学生")
print(students)
讲解重点：
remove() 按值删除。
删除前最好先判断元素是否存在。
示例 4：输出成绩统计
scores = [90, 85, 76, 100]
print("最高分：", max(scores))
print("最低分：", min(scores))
print("总分：", sum(scores))
print("平均分：", sum(scores) / len(scores))
讲解重点：
数字列表可以使用 max、min、sum。
平均分 = 总分 / 人数。
示例 5：成绩从高到低排序
scores = [90, 85, 76, 100]
scores.sort(reverse=True)
print(scores)
输出结果：
[100, 90, 85, 76]
示例 6：筛选及格成绩
scores = [45, 80, 59, 90, 100]
passed_scores = []
for score in scores:
if score >= 60:
passed_scores.append(score)
print(passed_scores)
输出结果：
[80, 90, 100]
也可以使用列表推导式：
passed_scores = [score for score in scores if score >= 60]
示例 7：按学生成绩排序
students = [
{"name": "小明", "score": 85},
{"name": "小红", "score": 92},
{"name": "小刚", "score": 78}
]
students.sort(key=lambda student: student["score"], reverse=True)
print(students)
讲解重点：
key 指定排序依据。
lambda student: student["score"] 表示按成绩排序。
三十八、课堂练习
练习 1：创建列表并输出
要求：创建一个保存 3 个城市名的列表，并输出。
参考代码：
cities = ["北京", "上海", "广州"]
print(cities)
练习 2：访问第一个和最后一个元素
要求：输出列表中的第一个和最后一个城市。
参考代码：
cities = ["北京", "上海", "广州"]
print(cities[0])
print(cities[-1])
练习 3：添加一个元素
要求：向学生列表中添加一个新学生。
参考代码：
students = ["小明", "小红"]
students.append("小刚")
print(students)
练习 4：删除一个元素
要求：从学生列表中删除 "小红"。
参考代码：
students = ["小明", "小红", "小刚"]
students.remove("小红")
print(students)
练习 5：修改一个元素
要求：把列表中的 "小红" 修改为 "小李"。
参考代码：
students = ["小明", "小红", "小刚"]
students[1] = "小李"
print(students)
练习 6：输出所有学生
要求：使用 for 循环输出每个学生姓名。
参考代码：
students = ["小明", "小红", "小刚"]
for student in students:
print(student)
练习 7：成绩排序
要求：将成绩从高到低排序。
参考代码：
scores = [90, 75, 88, 100]
scores.sort(reverse=True)
print(scores)
练习 8：筛选偶数
要求：从列表中筛选偶数。
参考代码：
numbers = [1, 2, 3, 4, 5, 6]
evens = []
for num in numbers:
if num % 2 == 0:
evens.append(num)
print(evens)
练习 9：使用切片获取前三个元素
参考代码：
numbers = [10, 20, 30, 40, 50]
print(numbers[:3])
练习 10：反转列表
参考代码：
numbers = [1, 2, 3, 4, 5]
print(numbers[::-1])
三十九、教学建议
讲解列表时，可以按照下面顺序：
1. 先说明列表是保存多个数据的容器
2. 讲列表的创建
3. 讲索引和负数索引
4. 讲查询元素
5. 讲修改元素
6. 讲 append、insert、extend 添加元素
7. 讲 remove、pop、del、clear 删除元素
8. 讲 for 循环遍历列表
9. 讲切片
10. 讲 sort 和 sorted 排序
11. 讲列表复制和嵌套列表
12. 最后用学生名单、成绩统计等例子练习
可以用下面的问题引导学生：
如果要保存全班学生姓名，只用一个变量够不够？
为什么第一个元素的索引是 0？
append 和 extend 有什么区别？
sort 和 sorted 有什么区别？
b = a 到底有没有复制出新列表？
删除列表元素前，为什么最好先判断是否存在？
教学重点建议放在：
索引
增删改查
遍历
切片
排序
append 和 extend 的区别
sort 和 sorted 的区别
列表可变性
列表推导式、嵌套列表、按 key 排序可以作为拓展内容。
四十、总结
列表是 Python 中非常常用的数据结构，用来保存一组有顺序的数据。
可以这样记：
列表：用 [] 表示，可以保存多个元素
索引：根据位置获取元素
切片：获取列表中的一部分
增：append、insert、extend
删：remove、pop、del、clear
改：列表[索引] = 新值
查：索引、in、index、count
排序：sort、sorted
常用操作：
students = ["小明", "小红", "小刚"]
students.append("小李")
students[0] = "小王"
students.remove("小红")
print(students[0])
print(students[:2])
最重要的注意事项：
1. 列表索引从 0 开始
2. 负数索引从右往左数
3. 访问索引不能越界
4. append 和 extend 不一样
5. remove 删除不存在元素会报错
6. sort 会修改原列表，sorted 返回新列表
7. b = a 不是复制新列表
8. 不要一边遍历列表，一边随意删除元素
一句话总结：
列表让我们可以把一组数据放在一起管理，是 Python 中进行数据存储、遍历、修改和排序的基础工具。
