列表
简单数据类型
- 整型
<class 'int'> - 浮点型
<class 'float' - 布尔型
<class 'bool'>
容器数据类型
- 列表
<class 'list'> - 元组
<class 'tuple'> - 字典
<class 'dict'> - 集合
<class 'set'> - 字符串
<class 'str'>
一、 列表的定义
列表是有序集合，没有固定大小，能够保存任意数量任意类型的 Python 对象，语法为 [元素1, 元素2, ..., 元素n]。
- 关键点是
中括号 []和逗号 , - 中括号 把所有元素绑在一起
- 逗号 将每个元素一一分开
二、 列表的创建
- 创建一个普通列表
【例子】
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(x, type(x))
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday'] <class 'list'>
x = [2, 3, 4, 5, 6, 7]
print(x, type(x))
# [2, 3, 4, 5, 6, 7] <class 'list'>
这段代码继续演示了列表的使用。它创建了两个不同的列表，并打印出它们的内容和类型。让我解释一下它的执行流程：
首先，代码创建了一个名为
x的列表，其中包含了字符串元素'Monday','Tuesday','Wednesday','Thursday','Friday'。然后，使用
print()函数将列表x和它的类型打印出来。type(x)返回x的类型。接下来，代码重新赋值给变量
x，使其成为一个包含整数元素的列表[2, 3, 4, 5, 6, 7]。再次使用
print()函数将新的列表x和它的类型打印出来。最终，在控制台上会输出两个列表的内容和它们的类型。例如：
['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday'] <class 'list'>
[2, 3, 4, 5, 6, 7] <class 'list'>
总结起来，这段代码创建了两个不同的列表，并分别打印出它们的内容和类型。第一个列表包含字符串元素，第二个列表包含整数元素。
- 利用range()创建列表
【例子】
x = list(range(10))
print(x, type(x))
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] <class 'list'>
x = list(range(1, 11, 2))
print(x, type(x))
# [1, 3, 5, 7, 9] <class 'list'>
x = list(range(10, 1, -2))
print(x, type(x))
# [10, 8, 6, 4, 2] <class 'list'>
这段代码展示了如何使用 range() 函数来创建列表。让我解释一下它的执行流程：
首先，代码使用
range()函数创建了一个包含从 0 到 9 的整数序列的列表。range(10)生成一个序列，包含了从 0 开始（包括 0）到 10 结束（不包括 10）的整数。然后通过list()函数将该序列转换为列表。接着，使用
print()函数分别打印出列表x的内容和它的类型。然后，代码重新赋值给变量
x，使用range()函数创建了一个包含从 1 到 10 的奇数的列表。range(1, 11, 2)生成一个序列，包含了从 1 开始（包括 1）到 11 结束（不包括 11），步长为 2 的整数。同样地，通过list()函数将该序列转换为列表。再次使用
print()函数打印出新的列表x的内容和它的类型。最后，代码再次赋值给变量
x，使用range()函数创建了一个包含从 10 到 1 的偶数的列表。range(10, 1, -2)生成一个序列，包含了从 10 开始（包括 10）到 1 结束（不包括 1），步长为 -2 的整数。同样地，通过list()函数将该序列转换为列表。最终，在控制台上会输出三个列表的内容和它们的类型。例如：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] <class 'list'>
[1, 3, 5, 7, 9] <class 'list'>
[10, 8, 6, 4, 2] <class 'list'>
总结起来，这段代码展示了如何使用 range() 函数来创建不同规律的整数序列，并将它们转换成列表进行操作。
- 利用推导式创建列表
【例子】
x = [0] * 5
print(x, type(x))
# [0, 0, 0, 0, 0] <class 'list'>
x = [0 for i in range(5)]
print(x, type(x))
# [0, 0, 0, 0, 0] <class 'list'>
x = [i for i in range(10)]
print(x, type(x))
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] <class 'list'>
x = [i for i in range(1, 10, 2)]
print(x, type(x))
# [1, 3, 5, 7, 9] <class 'list'>
x = [i for i in range(10, 1, -2)]
print(x, type(x))
# [10, 8, 6, 4, 2] <class 'list'>
x = [i ** 2 for i in range(1, 10)]
print(x, type(x))
# [1, 4, 9, 16, 25, 36, 49, 64, 81] <class 'list'>
x = [i for i in range(100) if (i % 2) != 0 and (i % 3) == 0]
print(x, type(x))
# [3, 9, 15, 21, 27, 33, 39,
这段代码展示了列表推导式的用法。让我逐个解释一下每个例子的执行过程：
在第一个例子中，代码使用
[0] * 5创建一个包含五个元素的列表，每个元素都是 0。第二个例子使用列表推导式
[0 for i in range(5)]创建了与前一个例子相同的列表。接下来，使用列表推导式
[i for i in range(10)]创建了一个包含从 0 到 9 的整数序列的列表。在第四个例子中，使用列表推导式
[i for i in range(1, 10, 2)]创建了包含从 1 到 9 的奇数的列表。下一个例子使用列表推导式
[i for i in range(10, 1, -2)]创建了包含从 10 到 2 的偶数的列表。在第六个例子中，使用列表推导式
[i ** 2 for i in range(1, 10)]创建了一个包含从 1 到 9 的平方数的列表。最后一个例子使用列表推导式
[i for i in range(100) if (i % 2) != 0 and (i % 3) == 0]创建了一个包含从 0 到 99 中满足条件的整数的列表。条件是该整数除以 2 的余数不等于 0，并且除以 3 的余数等于 0。
总的来说，列表推导式是一种简洁的方式来创建新的列表，并可以根据需要添加条件或对元素进行转换。
注意：
由于list的元素可以是任何对象，因此列表中所保存的是对象的指针。即使保存一个简单的[1,2,3]，也有3个指针和3个整数对象。
x = [a] * 4操作中，只是创建4个指向list的引用，所以一旦a改变，x中4个a也会随之改变。
【例子】
x = [[0] * 3] * 4
print(x, type(x))
# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] <class 'list'>
x[0][0] = 1
print(x, type(x))
# [[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]] <class 'list'>
a = [0] * 3
x = [a] * 4
print(x, type(x))
# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] <class 'list'>
x[0][0] = 1
print(x, type(x))
# [[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]] <class 'list'>
这段代码展示了在创建二维列表时可能遇到的一个陷阱。让我来解释一下发生了什么：
在第一个例子中，使用 [0] * 3 创建一个包含三个整数 0 的列表。然后，使用 [[0] * 3] * 4 创建一个包含 [0] * 3 列表的复制的列表 x。由于 x 中的每个元素都是引用到同一个 [0] * 3 列表，所以当修改 [0] * 3 列表的元素时，x 中对应位置的元素也会被修改。
在第一个打印语句中，打印了 x 和 x 的类型。输出结果为 [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] <class 'list'>，即一个包含四个具有相同值的列表的列表。
然后，通过 x[0][0] = 1 将 x 中第一个列表的第一个元素修改为 1。再次打印 x 和 x 的类型，输出结果为 [[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]] <class 'list'>。可以看到，由于 x 中的每个元素都引用到同一个 a 列表，所以修改 a 列表的元素会影响到 x 中所有对应位置的元素。
在第二个例子中，先使用 [0] * 3 创建一个包含三个整数 0 的列表 a。然后，使用列表复制 [a] * 4 创建一个新的列表 x。由于 x 中的每个元素都是引用到同一个 [0] * 3 列表，所以当修改 [0] * 3 列表的元素时，x 中对应位置的元素也会被修改。
打印第二个 x 和 x 的类型，输出结果为 [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] <class 'list'>，即一个包含四个具有相同值的列表的列表。
然后，通过 x[0][0] = 1 将 x 中第一个列表的第一个元素修改为 1。再次打印 x 和 x 的类型，输出结果为 [[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]] <class 'list'>。可以看到，由于 x 中的每个元素都引用到同一个 a 列表，所以修改 a 列表的元素会影响到 x 中所有对应位置的元素。
因此，要避免这个陷阱，我们应该确保在使用 * 运算符复制列表时，创建的是独立的副本而不是引用。可以使用列表推导式或循环来创建独立的副本，如以下示例所示：
x = [[0] * 3 for i in range(4)]
# 或
a = [0] * 3
x = []
for i in range(4):
x.append(a.copy())
这样，每个子列表都是独立的，修改其中一个子列表不会影响到其他子列表。
总结起来，当你想创建一个二维列表时，如果希望每个内部列表都是独立的，应该使用列表复制；而如果想让所有内部列表共享同一个引用，可以使用复制的方式创建外部列表。
- 创建一个混合列表
【例子】
mix = [1, 'lsgo', 3.14, [1, 2, 3]]
print(mix, type(mix))
# [1, 'lsgo', 3.14, [1, 2, 3]] <class 'list'>
这段代码创建了一个名为 mix 的列表，其中包含了不同类型的元素，包括整数、字符串、浮点数和另一个嵌套列表。
print(mix, type(mix)) 语句用于打印列表 mix 的内容和类型。在这种情况下，输出如下：
[1, 'lsgo', 3.14, [1, 2, 3]] <class 'list'>
列表 mix 包含四个元素，分别是整数 1、字符串 'lsgo'、浮点数 3.14 和另一个嵌套列表 [1, 2, 3]。整个列表的类型是 list。
这个示例展示了列表可以容纳不同类型的元素。列表是一种有序、可变的数据类型，可以存储多个值，并且可以根据需要进行修改。
- 创建一个空列表
【例子】
empty = []
print(empty, type(empty))
# [] <class 'list'>
这段代码创建了一个名为 empty 的空列表，并使用 print() 函数将其内容和类型打印出来。
在这个例子中，输出如下：
[] <class 'list'>
这表示 empty 列表是一个空列表，因为它没有任何元素。列表的类型是 list，这是 Python 中用于表示列表的内置类。
空列表是一个没有任何元素的列表。它可以作为一个容器，可以随时添加、删除或修改元素。您可以通过使用 append() 方法或直接赋值的方式向空列表中添加元素。
例如：
empty.append(1) # 向空列表中添加一个整数元素1
empty.append('hello') # 向空列表中添加一个字符串元素'hello'
这样，empty 列表将变为 [1, 'hello']。
空列表在编程中非常常见，它提供了一种灵活的数据结构，可以根据需要动态地存储和处理数据。
列表不像元组，列表内容可更改 (mutable)，因此附加 (append, extend)、插入 (insert)、删除 (remove, pop) 这些操作都可以用在它身上。
三、 向列表中添加元素
- list.append(obj) 在列表末尾添加新的对象，只接受一个参数，参数可以是任何数据类型，被追加的元素在 list 中保持着原结构类型。
【例子】
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.append('Thursday')
print(x)
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Thursday']
print(len(x)) # 6
这段代码创建了一个名为 x 的列表，并使用 append() 方法将字符串 'Thursday' 添加到列表的末尾。然后，使用 print() 函数打印了列表 x 和 len() 函数获取列表的长度。
输出如下所示：
['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Thursday']
6
在列表 x 中，我们最初有五个元素：'Monday'、'Tuesday'、'Wednesday'、'Thursday' 和 'Friday'。然后，我们使用 append() 方法将字符串 'Thursday' 添加到列表的末尾。因此，现在列表 x 包含六个元素，其中两个元素是 'Thursday'。
在 Python 列表中，可以包含重复的元素。通过调用 append() 方法，我们可以将一个元素添加到列表的末尾，即使它已经存在于列表中。列表的长度可以通过 len() 函数获取，这里返回的值是 6，表示列表中有 6 个元素。
这种特性使得列表在许多情况下非常灵活，您可以根据需要添加、删除或修改列表中的元素。
- list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
【例子】
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.extend(['Thursday', 'Sunday'])
print(x)
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Thursday', 'Sunday']
print(len(x))
# 7
这段代码创建了一个名为 x 的列表，并使用 extend() 方法将另一个列表 ['Thursday', 'Sunday'] 添加到列表 x 的末尾。然后，使用 print() 函数打印了列表 x 和 len() 函数获取列表的长度。
输出如下所示：
['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Thursday', 'Sunday']
7
在列表 x 中，我们最初有五个元素：'Monday'、'Tuesday'、'Wednesday'、'Thursday' 和 'Friday'。然后，我们使用 extend() 方法将另一个列表 ['Thursday', 'Sunday'] 添加到列表 x 的末尾。extend() 方法会将新列表中的每个元素添加到原始列表中，因此现在列表 x 包含了七个元素。
与 append() 方法不同，extend() 方法可以添加多个元素到列表中，而不仅仅是一个元素。这使得在列表中添加多个元素变得非常方便。
通过调用 len() 函数，我们可以获取列表的长度，这里返回的值是 7，表示列表中有 7 个元素。
使用 append() 方法和 extend() 方法可以根据需要灵活地添加元素到列表中，具体取决于您的需求。
严格来说 append 是追加，把一个东西整体添加在列表后，而 extend 是扩展，把一个东西里的所有元素添加在列表后。
- list.insert(index, obj) 在编号 index 位置插入 obj。
【例子】
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.insert(2, 'Sunday')
print(x)
# ['Monday', 'Tuesday', 'Sunday', 'Wednesday', 'Thursday', 'Friday']
print(len(x)) # 6
这段代码创建了一个名为 x 的列表，并使用 insert() 方法将字符串 'Sunday' 插入到列表 x 的索引位置为 2 的位置上。然后，使用 print() 函数打印了列表 x 和 len() 函数获取列表的长度。
输出如下所示：
['Monday', 'Tuesday', 'Sunday', 'Wednesday', 'Thursday', 'Friday']
6
在列表 x 中，我们最初有五个元素：'Monday'、'Tuesday'、'Wednesday'、'Thursday' 和 'Friday'。然后，我们使用 insert() 方法将字符串 'Sunday' 插入到索引位置 2，即在 'Tuesday' 之前。因此，现在列表 x 包含了六个元素。
insert() 方法需要两个参数：要插入的元素的索引位置和要插入的元素本身。通过调用 insert() 方法，我们可以将新元素插入到列表的任意位置，而不仅仅是在末尾或开头。
通过调用 len() 函数，我们可以获取列表的长度，这里返回的值是 6，表示列表中有 6 个元素。
使用 insert() 方法可以根据需要在列表中的指定位置插入元素，可以灵活地更改列表的内容和结构。
四、 删除列表中的元素
- list.remove(obj) 移除列表中某个值的第一个匹配项
【例子】
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.remove('Monday')
print(x) # ['Tuesday', 'Wednesday', 'Thursday', 'Friday']
这段代码创建了一个名为 x 的列表，并使用 remove() 方法从列表 x 中删除了字符串 'Monday'。然后，使用 print() 函数打印了修改后的列表 x。
输出如下所示：
['Tuesday', 'Wednesday', 'Thursday', 'Friday']
在列表 x 中，我们最初有五个元素：'Monday'、'Tuesday'、'Wednesday'、'Thursday' 和 'Friday'。然后，我们使用 remove() 方法根据指定的值 'Monday' 从列表中删除了该元素。此时，列表 x 中不再包含字符串 'Monday'。
remove() 方法会找到列表中首次出现的指定值，并将其从列表中删除。如果指定的值在列表中多次出现，只有第一个匹配项会被删除。如果指定的值不存在于列表中，会引发 ValueError 异常。
通过调用 print() 函数，我们可以查看修改后的列表 x，现在列表中的第一个元素是 'Tuesday' 而不是 'Monday'。
使用 remove() 方法可以根据指定的值从列表中删除元素，使得列表中只保留需要的内容。
- list.pop([index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
【例子】
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
y = x.pop()
print(y) # Friday
y = x.pop(0)
print(y) # Monday
y = x.pop(-2)
print(y) # Wednesday
print(x) # ['Tuesday', 'Thursday']
这段代码创建了一个名为 x 的列表，并使用 pop() 方法从列表 x 中删除指定位置的元素，并将被删除的元素赋值给变量 y。然后，使用 print() 函数打印了变量 y 和修改后的列表 x。
输出如下所示：
Friday
Monday
Wednesday
['Tuesday', 'Thursday']
首先，我们使用 pop() 方法没有传递参数时，它会默认删除列表的最后一个元素。因此，第一次调用 pop() 方法将删除列表 x 的最后一个元素 'Friday'，并将其赋值给变量 y。
接着，我们使用 pop(0) 方法将列表 x 的索引位置为 0 的元素删除，即删除了列表的第一个元素 'Monday'，并将其赋值给变量 y。
随后，我们使用 pop(-2) 方法将列表 x 的倒数第二个元素删除，即删除了列表中的 'Wednesday'，并将其赋值给变量 y。
最后，我们使用 print() 函数分别打印了变量 y 和修改后的列表 x。现在，列表 x 中只剩下 'Tuesday' 和 'Thursday' 两个元素。
通过使用 pop() 方法，我们可以删除列表中指定位置的元素，并且还可以获取到被删除的元素的值。这使得我们可以根据需要删除和处理列表中的元素。
remove 和 pop 都可以删除元素，前者是指定具体要删除的元素，后者是指定一个索引。
- del var1[, var2 ……] 删除单个或多个对象。
【例子】
如果知道要删除的元素在列表中的位置，可使用del语句。
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
del x[0:2]
print(x) # ['Wednesday', 'Thursday', 'Friday']
这段代码创建了一个名为 x 的列表，并使用 del 语句删除了列表 x 中索引位置为 0 到 1 的元素。然后，使用 print() 函数打印了修改后的列表 x。
输出如下所示：
['Wednesday', 'Thursday', 'Friday']
通过 del 语句，我们可以删除列表中指定范围的元素。在这种情况下，我们使用 del x[0:2] 删除了列表 x 中索引位置从 0 到 1 的元素（包括索引位置 0 和 1）。也就是将列表中的 'Monday' 和 'Tuesday' 这两个元素删除。
删除后，列表 x 中只剩下 'Wednesday'、'Thursday' 和 'Friday' 三个元素。
使用 del 语句可以直接在原地删除列表中的元素，而不会返回被删除的元素。这使得我们能够根据需要快速删除列表中的一部分元素。
如果你要从列表中删除一个元素，且不再以任何方式使用它，就使用del语句；如果你要在删除元素后还能继续使用它，就使用方法pop()。
五、 获取列表中的元素
- 通过元素的索引值，从列表获取单个元素，注意，列表索引值是从0开始的。
- 通过将索引指定为-1，可让Python返回最后一个列表元素，索引 -2 返回倒数第二个列表元素，以此类推。
【例子】
x = ['Monday', 'Tuesday', 'Wednesday', ['Thursday', 'Friday']]
print(x[0], type(x[0])) # Monday <class 'str'>
print(x[-1], type(x[-1])) # ['Thursday', 'Friday'] <class 'list'>
print(x[-2], type(x[-2])) # Wednesday <class 'str'>
这段代码创建了一个名为 x 的列表，其中包含了不同类型的元素。然后，使用索引方式访问并打印了列表中的元素以及它们的类型。
输出如下所示：
Monday <class 'str'>
['Thursday', 'Friday'] <class 'list'>
Wednesday <class 'str'>
首先，我们通过索引 0 访问了列表 x 中的第一个元素 'Monday'，并使用 type() 函数确认它的类型是字符串 (<class 'str'>)。
接着，我们通过索引 -1 访问了列表 x 中的最后一个元素 ['Thursday', 'Friday']，它是一个嵌套的列表，并使用 type() 函数确认它的类型是列表 (<class 'list'>)。
最后，我们通过索引 -2 访问了列表 x 中的倒数第二个元素 'Wednesday'，并使用 type() 函数确认它的类型是字符串 (<class 'str'>)。
可以看到，列表 x 中的元素可以是不同的数据类型，包括字符串和列表等。在访问和操作列表时，我们可以根据索引来获取特定位置的元素，并通过 type() 函数来确定元素的类型。
切片的通用写法是 start : stop : step
- 情况 1 - "start :"
- 以 step 为 1 (默认) 从编号 start 往列表尾部切片。
【例子】
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(x[3:]) # ['Thursday', 'Friday']
print(x[-3:]) # ['Wednesday', 'Thursday', 'Friday']
这段代码创建了一个名为 x 的列表，并使用切片操作符 : 打印了列表中特定范围的元素。
输出如下所示：
['Thursday', 'Friday']
['Wednesday', 'Thursday', 'Friday']
首先，使用切片 x[3:] 获取了列表 x 中从索引位置 3（包括索引位置 3）到列表末尾的所有元素。因此，打印结果为 ['Thursday', 'Friday']，即从星期四开始到星期五的所有元素。
接着，使用切片 x[-3:] 获取了列表 x 中倒数第三个元素（索引位置 -3）到列表末尾的所有元素。因此，打印结果为 ['Wednesday', 'Thursday', 'Friday']，即从星期三开始到星期五的所有元素。
切片操作允许我们根据索引范围获取列表中的一部分元素。在切片操作中，左边界是包含的，而右边界则是不包含的。如果省略左边界或右边界，则会默认选择列表的开始或结束位置作为边界。
- 情况 2 - ": stop"
- 以 step 为 1 (默认) 从列表头部往编号 stop 切片。
【例子】
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[:3]) # ['Monday', 'Tuesday', 'Wednesday']
print(week[:-3]) # ['Monday', 'Tuesday']
- 情况 3 - "start : stop"
- 以 step 为 1 (默认) 从编号 start 往编号 stop 切片。
【例子】
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[1:3]) # ['Tuesday', 'Wednesday']
print(week[-3:-1]) # ['Wednesday', 'Thursday']
- 情况 4 - "start : stop : step"
- 以具体的 step 从编号 start 往编号 stop 切片。注意最后把 step 设为 -1，相当于将列表反向排列。
【例子】
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[1:4:2]) # ['Tuesday', 'Thursday']
print(week[:4:2]) # ['Monday', 'Wednesday']
print(week[1::2]) # ['Tuesday', 'Thursday']
print(week[::-1])
# ['Friday', 'Thursday', 'Wednesday', 'Tuesday', 'Monday']
- 情况 5 - " : "
- 复制列表中的所有元素（浅拷贝）。
【例子】
eek = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[:])
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
【例子】浅拷贝与深拷贝
list1 = [123, 456, 789, 213]
list2 = list1
list3 = list1[:]
print(list2) # [123, 456, 789, 213]
print(list3) # [123, 456, 789, 213]
list1.sort()
print(list2) # [123, 213, 456, 789]
print(list3) # [123, 456, 789, 213]
list1 = [[123, 456], [789, 213]]
list2 = list1
list3 = list1[:]
print(list2) # [[123, 456], [789, 213]]
print(list3) # [[123, 456], [789, 213]]
list1[0][0] = 111
print(list2) # [[111, 456], [789, 213]]
print(list3) # [[111, 456], [789, 213]]
这段代码展示了关于列表的一些特性。
首先，创建了一个名为 list1 的列表 [123, 456, 789, 213]。然后，使用 list2 = list1 将 list2 关联到 list1。接着，通过使用切片操作符 [:] 创建了一个新的列表 list3，它包含了 list1 中的所有元素。
然后，分别打印了 list2 和 list3 的内容，结果如下：
[123, 456, 789, 213]
[123, 456, 789, 213]
此时，list2 和 list3 的内容与 list1 完全相同。
接下来，对 list1 进行排序操作 list1.sort()。然后，再次打印了 list2 和 list3 的内容，结果如下：
[123, 213, 456, 789]
[123, 456, 789, 213]
可以看到，由于 list2 和 list3 都是通过引用 list1 创建的，它们与 list1 共享相同的列表对象。因此，对 list1 的排序操作也会影响到 list2，但不会影响到 list3。这是因为切片操作 list1[:] 创建了一个新的列表对象，与原始列表对象完全独立。
接着，重新给 list1 赋值了一个新的列表 [[123, 456], [789, 213]]。然后，再次使用 list2 = list1 关联了 list2 到 list1，同时使用切片操作 list3 = list1[:] 创建了一个新的列表对象。
再次打印了 list2 和 list3 的内容，结果如下：
[[123, 456], [789, 213]]
[[123, 456], [789, 213]]
此时，list2 和 list3 的内容与 list1 完全相同。
最后，修改了 list1 中的元素 list1[0][0] = 111。然后，再次打印了 list2 和 list3 的内容，结果如下：
[[111, 456], [789, 213]]
[[111, 456], [789, 213]]
可以看到，由于 list2 和 list3 与 list1 共享相同的列表对象，对 list1 中嵌套列表的修改也会影响到 list2 和 list3。
这些例子展示了列表的引用和复制行为。赋值操作（=）只是创建了一个指向列表对象的引用，而不是创建了一个新的独立列表对象。如果需要创建一个新的独立列表对象，可以使用切片操作符来复制列表。
六、 列表的常用操作符
- 等号操作符：
== - 连接操作符
+ - 重复操作符
* - 成员关系操作符
in、not in
「等号 ==」，只有成员、成员位置都相同时才返回True。
列表拼接有两种方式，用「加号 +」和「乘号 *」，前者首尾拼接，后者复制拼接。
【例子】
list1 = [123, 456]
list2 = [456, 123]
list3 = [123, 456]
print(list1 == list2) # False
print(list1 == list3) # True
list4 = list1 + list2 # extend()
print(list4) # [123, 456, 456, 123]
list5 = list3 * 3
print(list5) # [123, 456, 123, 456, 123, 456]
list3 *= 3
print(list3) # [123, 456, 123, 456, 123, 456]
print(123 in list3) # True
print(456 not in list3) # False
代码中给出了关于列表的一些操作和结果。
首先，创建了三个列表 list1 = [123, 456]，list2 = [456, 123]，list3 = [123, 456]。
接下来，使用 == 进行比较操作，list1 == list2 返回 False，因为 list1 和 list2 元素的顺序不同，而 list1 == list3 返回 True，因为它们包含相同的元素。
然后，通过 + 操作符将 list1 和 list2 进行连接，赋值给 list4。list4 的结果是 [123, 456, 456, 123]，即将 list2 的元素添加到了 list1 后面。
接着，使用 * 操作符将 list3 重复三次，赋值给 list5。list5 的结果是 [123, 456, 123, 456, 123, 456]，即 list3 的元素被重复了三次。
然后，使用 *= 3 将 list3 重复三次，结果仍然赋值给 list3。list3 的结果与 list5 相同，都是 [123, 456, 123, 456, 123, 456]，即 list3 的元素被重复了三次。
接下来，使用 in 和 not in 运算符判断元素是否存在于列表中。123 in list3 返回 True，因为 123 存在于 list3 中。456 not in list3 返回 False，因为 456 存在于 list3 中。
这些例子展示了列表的比较操作、连接操作、重复操作和成员运算符的用法和结果。
前面三种方法（append, extend, insert）可对列表增加元素，它们没有返回值，是直接修改了原数据对象。
而将两个list相加，需要创建新的 list 对象，从而需要消耗额外的内存，特别是当 list 较大时，尽量不要使用 “+” 来添加list。
七、 列表的其它方法
list.count(obj) 统计某个元素在列表中出现的次数
【例子】
list1 = [123, 456] * 3
print(list1) # [123, 456, 123, 456, 123, 456]
num = list1.count(123)
print(num) # 3
代码中创建了一个列表 list1 = [123, 456]，然后使用 * 操作符将其重复了三次，赋值给 list1。所以 list1 的结果是 [123, 456, 123, 456, 123, 456]，即 list1 中的元素 [123, 456] 被重复了三次。
接下来，使用 count() 方法统计 123 在 list1 中出现的次数，并将结果赋值给变量 num。list1.count(123) 返回 3，表示 123 在 list1 中出现了三次。
因此，打印 num 的结果是 3。这表示元素 123 在列表 list1 中出现了三次。
list.index(x[, start[, end]]) 从列表中找出某个值第一个匹配项的索引位置
【例子】
list1 = [123, 456] * 5
print(list1.index(123)) # 0
print(list1.index(123, 1)) # 2
print(list1.index(123, 3, 7)) # 4
代码中创建了一个列表 list1 = [123, 456]，然后使用 * 操作符将其重复了五次，赋值给 list1。所以 list1 的结果是 [123, 456, 123, 456, 123, 456, 123, 456, 123, 456]，即 list1 中的元素 [123, 456] 被重复了五次。
接下来，使用 index() 方法来查找元素在列表中的索引位置。
list1.index(123)返回0，这表示元素123在list1中的第一个位置上，即索引0。list1.index(123, 1)返回2，这表示从索引1开始往后查找元素123在list1中的位置，即索引2。list1.index(123, 3, 7)返回4，这表示从索引3到索引6的范围内查找元素123在list1中的位置，即索引4。
因此，打印出的结果分别是 0，2 和 4。
list.reverse() 反向列表中元素
【例子】
x = [123, 456, 789]
x.reverse()
print(x) # [789, 456, 123]
代码中创建了一个列表 x = [123, 456, 789]，然后使用 reverse() 方法来反转列表中的元素顺序。所以 x.reverse() 操作会将列表 x 中的元素顺序进行反转。
最后，打印列表 x 的结果是 [789, 456, 123]，即原来的列表 [123, 456, 789] 中的元素顺序被反转为 [789, 456, 123]。
因此，打印出的结果是 [789, 456, 123]。表示列表 x 的元素顺序已被成功反转。
list.sort(key=None, reverse=False) 对原列表进行排序。
-
key-- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。 -
reverse-- 排序规则，reverse = True降序，reverse = False升序（默认）。 - 该方法没有返回值，但是会对列表的对象进行排序。
【例子】
x = [123, 456, 789, 213]
x.sort()
print(x)
# [123, 213, 456, 789]
x.sort(reverse=True)
print(x)
# [789, 456, 213, 123]
# 获取列表的第二个元素
def takeSecond(elem):
return elem[1]
x = [(2, 2), (3, 4), (4, 1), (1, 3)]
x.sort(key=takeSecond)
print(x)
# [(4, 1), (2, 2), (1, 3), (3, 4)]
x.sort(key=lambda a: a[0])
print(x)
# [(1, 3), (2, 2), (3, 4), (4, 1)]
代码中首先创建了一个列表 x = [123, 456, 789, 213]，然后使用 sort() 方法对列表进行排序。
-
x.sort()对列表进行升序排序，结果为[123, 213, 456, 789]，即从小到大排列的列表。
接下来，使用 sort() 方法进行更多的排序示例。
-
x.sort(reverse=True)对列表进行降序排序，结果为[789, 456, 213, 123]，即从大到小排列的列表。
接下来，定义了一个名为 takeSecond 的函数，该函数用于获取列表中元组的第二个元素。
然后，将列表 x 定义为包含一系列元组 (2, 2), (3, 4), (4, 1), (1, 3)。接着使用 sort(key=takeSecond) 方法将列表按照元组的第二个元素进行排序。
-
[(4, 1), (2, 2), (1, 3), (3, 4)]是按照元组的第二个元素从小到大排列的结果。
lambda a: a[0] 是一个匿名函数（lambda 函数），它接受一个参数 a 并返回 a 的第一个元素 a[0]。
在代码中，这个 lambda 函数被用作 sort() 方法的 key 参数，用于指定排序列表时所使用的键。具体而言，它指定以每个元组的第一个元素为键进行排序。
在使用 sort(key=lambda a: a[0]) 对列表进行排序时，列表中的元组将按照它们的第一个元素从小到大进行排序。
-
[(1, 3), (2, 2), (3, 4), (4, 1)]是按照元组的第一个元素从小到大排列的结果。
