0.特别说明
- 文章内容参考B站视频：2w多的Python教程
1.为什么需要列表？
- 变量可以存储一个元素，而列表是一个大容器，可以储存N多个元素，程序可以方便地对这些数据进行整体操作
a = 10
lst = ["hello", 711, "world"]
- 列表相当于其他语言中的数组
- 列表示意图
| 索引 | -7 | -6 | -5 | -4 | -3 | -2 | -1 |
|---|---|---|---|---|---|---|---|
| 数据 | “hello” | 98 | 711 | 86.7 | “world” | “瑶瑶啊哟” | True |
| 索引 | 0 | 1 | 2 | 3 | 4 | 5 | 6 |
- 内存示意图
2.列表的创建
- 列表需要使用中括号 []，元素之间使用英文的逗号进行分隔
- 列表的创建方式
- 使用中括号
- 使用内置函数list()
# 使用中括号创建列表
lst1 = ["hello", "world", 998]
# 使用list()创建对象
lst2 = list(["niu", "niu", 711])
print(id(lst1), type(lst1), lst1)
print(id(lst2), type(lst2), lst2)
运行结果：
2518027416832 <class ‘list’> [‘hello’, ‘world’, 998]
2518027746560 <class ‘list’> [‘niu’, ‘niu’, 711]
3.列表的特点
（1）列表元素按顺序有序排列
- 即输出时的顺序为创建时的顺序
（2）索引映射唯一一个数据
| 索引 | -3 | -2 | -1 |
|---|---|---|---|
| 数据 | “hello” | “world” | 998 |
| 索引 | 0 | 1 | 2 |
lst1 = ["hello", "world", 998]
print(lst1[2], lst1[-3])
运行结果：
998 hello
0代表第一个元素，1代表第二个元素……以此类推，这是顺序索引值，而逆序索引值从-1开始代表最后一个数，依次向前推
（3）列表可以存储重复数据
- lst = ["a ", "a ", "a "] 是合法的
（4）任意数据类型可以混合存储
- lst2 = [1, "aa ", 98.2, True] 也是合法的
（5）根据需要动态分配内存和回收内存
- 永远不用担心列表所分配的内存是否会小于自己的需要的内存，也不用担心造成内存浪费
4.列表元素的查询操作
（1）获取列表中指定元素的索引
- 使用index() 方法
① 查询列表中存在的N个相同元素时，只返回相同元素中第一个元素的索引
lst = ["hello", "world", 998, "world"]
print(lst.index("world"))
运行结果：
1
这里有两个相同元素 world 但是只返回了第一个 world 的索引值
??② 如果查询的元素在列表中不存在，则会抛出ValueError
lst = ["hello", "world", 998, "world"]
print(lst.index("python"))
运行结果：
抛出异常
ValueError: ‘python’ is not in list
??③ 可以在指定的a和b之间查找元素（查找范围是索引值左闭右开区间[a,b)）
lst = ["hello", "world", "python", 998, "world"]
print(lst.index("world", 2, 5))
运行结果：
4
（2）获取列表中的单个元素
- 正向索引从0 到N-1 ，例如lst[2]
- 逆向索引从**-N** 到**-1** ，例如lst[-1]
- 指定索引不存在，抛出异常IndexError: list index out of range
（3）获取列表中的多个元素
- 语法格式：列表名 [start : stop : step] （称为切片操作）
- 切片的结果：原列表片段的拷贝（是一个新的列表对象）
- 切片的范围：左闭右开区间 [start,stop)
- step的取值：
①step为正数：[: stop : step] 默认切片从列表的第一个元素（索引是0）开始，[start : : step] 默认切片到列表最后一个元素结束，这两个都是从start开始往后计算切片
②step是负数：[: stop : step] 默认切片从列表的最后一个元素开始，[start : : step] 默认切片到列表第一个元素（索引是0）结束，这两个都是从start开始往前计算切片
③不取值，默认为1，简写为**[start : stop]**
lst1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# 切片的结果是一个新的列表
lst2 = lst1[2:6]
print("原列表：", id(lst1))
print("现列表：", id(lst2))
# step为正数
print(lst1[1:6:2])
print(lst1[:4:1]) # 索引范围[0,4)
print(lst1[5::1]) # 索引范围[5,9)
# step为负数
print(lst1[:4:-1]) # 索引范围[8,4)
print(lst1[5::-1]) # 索引范围[5,0]
运行结果：
原列表： 2645048440064
现列表： 2645048442432
[2, 4, 6]
[1, 2, 3, 4]
[6, 7, 8, 9]
[9, 8, 7, 6]
[6, 5, 4, 3, 2, 1]
（4）判断元素是否存在
- 语法格式：元素 in 列表名?或者?元素 not in 列表名
lst1 = [1, 2, "hello", "world"]
# 判断元素是否在列表存在
print("a" in lst1)
print(1 in lst1)
print(2 not in lst1)
运行结果：
False
True
False
（5）列表元素的遍历
- 语法格式：for 迭代变量 in 列表名：
lst1 = [1, 2, 3.2, "hello", "world"]
for var in lst1:
print(var, type(var))
运行结果：
1 <class ‘int’>
2 <class ‘int’>
3.2 <class ‘float’>
hello <class ‘str’>
world <class ‘str’>
5.列表元素的增加操作
| 方法 | 操作描述 |
|---|---|
| append() | 在列表的末尾添加一个元素 |
| extend() | 在列表的末尾至少添加一个元素 |
| insert() | 在列表的任意一个位置添加元素 |
| 切片 | 在列表的任意一个位置至少添加一个元素 |
（1）append()方法
lst1 = [0, 1, 2, 3]
print(lst1, id(lst1))
lst1.append(6)
print(lst1, id(lst1))
运行结果：
[0, 1, 2, 3] 2837448439040
[0, 1, 2, 3, 6] 2837448439040
可以看到增加前后列表的 id不变，说明在增加操作时并没有产生新的列表
（2）extend()方法
lst1 = [0, 1, 2, 3]
lst2 = [4, 5]
# append()方法
lst1.append(lst2)
print(lst1)
# extend()方法
lst1.extend(lst2)
print(lst1)
运行结果：
[0, 1, 2, 3, [4, 5]]
[0, 1, 2, 3, [4, 5], 4, 5]
在使用append()方法时，增加的只是一个元素，即使增加的是一个列表，也会把这个列表看做是一个元素（参照集合），而extend()方法则会将列表中的元素取出来逐一增加到原列表的末尾
（3）insert()方法
- 语法格式：列表名 . insert( a, b)，a为想要插入的索引值，b为想要插入的值
lst1 = [0, 1, 2, 3]
lst1.insert(2, 10)
print(lst1)
运行结果：
[0, 1, 10, 2, 3]
（4）切片
- 语法格式：列表名 [start : stop : step] = 可迭代对象
其中，[start,stop)中的元素会被可迭代对象替换，即使用新的元素代替旧的元素
特别地： 当设置了步长时，序列中元素的个数必须和切片中元素的个数一致，否则会报错：ValueError: attempt to assign sequence of size 3 to extended slice of size 2
# 将索引为2之后的元素全都替换成10,11,12
lst1 = [0, 1, 2, 3]
lst1[2:] = range(10, 13)
print(lst1)
# 将索引范围是[2,4)的元素替换成 h e l l o
lst2 = [0, 1, 2, 3, 4, 5, 6]
lst2[2:4] = "hello"
print(lst2)
# 步长不为1时，插入与删除的元素个数要对应
lst3 = [0, 2, 4, 6, 8]
lst4 = [1, 3]
lst3[:4:2] = lst4
print(lst3)
运行结果：
[0, 1, 10, 11, 12]
[0, 1, ‘h’, ‘e’, ‘l’, ‘l’, ‘o’, 4, 5, 6]
[1, 2, 3, 6, 8]
注意：lst[2:4] = 1 是不被允许的，会报错：TypeError: can only assign an iterable，这是因为整型1，不具有迭代能力（其他int和float类型的值也一样），它就是一个值。未达到目的，但可以写成List[0:2] = (1,）
6.列表元素的删除操作
| 方法 | 操作描述 |
|---|---|
| remove() | 一次删除一个元素，有重复元素时只删除第一个 |
| pop() | 删除一个指定索引位置上的元素，不指定索引时删除列表最后一个元素 |
| clear() | 清空列表 |
| del | 删除列表（也可对具体的元素进行删除） |
| 切片 | 一次至少删除一个元素 |
（1）remove()方法
lst = [10, 20, 30, 40, 50, 60, 30]
lst.remove(30)
print(lst)
运行结果：
[10, 20, 40, 50, 60, 30]
注意： 若要删除的元素不在列表内，则抛出异常：ValueError: list.remove(x): x not in list
（2）pop()方法
lst = [10, 20, 30, 40, 50, 60, 30]
lst.pop(1)
print(lst)
lst.pop()
print(lst)
运行结果：
[10, 30, 40, 50, 60, 30]
[10, 30, 40, 50, 60]
注意： 若指定索引不存在，则抛出异常：IndexError: pop index out of range
（3）clear()方法
lst = [10, 20, 30, 40, 50, 60, 30]
lst.clear()
print(lst)
运行结果：
[]
（4）del
- 对整个列表对象的删除
lst = [10, 20, 30, 40, 50, 60, 30]
del lst
print(lst)
异常：
NameError: name ‘lst’ is not defined
- 对具体元素的删除
lst = [10, 20, 30, 40, 50, 60, 30]
del lst[3]
print(lst)
运行结果：
[10, 20, 30, 50, 60, 30]
[10, 20, 60, 30]
（5）切片
- 可理解为对列表元素的增加操作，只不过这个“增加”，“增加”的是一个空列表
lst = [10, 20, 30, 40, 50, 60, 30]
lst[2:4] = []
print(lst)
运行结果：
[10, 20, 50, 60, 30]
切片操作会产生一个新的列表对象，但对其进行的赋值操作，是对原有列表的操作，赋值操作完成后仍是原列表而不是新列表
更新中…