1. 创建列表
使用方括号
[]来创建列表，英文逗号分隔元素。列表是一种有序、可变的数据结构，可以存储多个元素，并且每个元素可以是不同的数据类型，如整数、浮点数、字符串等。# 创建一个整数列表 numbers = [1, 2, 3, 4, 5] # 创建一个字符串列表 fruits = ["apple", "banana", "orange"] # 创建一个混合类型的列表 mixed = [1, "hello", 3.14, True] # 创建一个空列表 empty = []
列表是有序的，元素的顺序在列表中是有意义的。可以使用索引来访问列表中的元素，索引从0开始，表示第一个元素；最后一个元素的下标是-1。
fruits = ["apple", "banana", "orange"] print(fruits[0]) # 输出：apple
2. 列表切片
列表切片是一种用于从列表中提取子列表的操作。通过切片，可以选择性地获取列表中的一部分元素，而不影响原始列表。列表切片的语法是通过使用索引来指定切片的起始位置、结束位置和步长。
切片的语法如下：
my_list[start:end:step]
其中，
start表示切片的起始位置（包含在切片中），end表示切片的结束位置（不包含在切片中），step表示切片的步长（用于指定每隔多少个元素取一个元素，默认为1）。下面是一些使用列表切片的示例：numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] # 提取从索引2到索引5之间的元素（不包含索引5） slice1 = numbers[2:5] print(slice1) # 输出：[3, 4, 5] # 提取从索引3到末尾的元素 slice2 = numbers[3:] print(slice2) # 输出：[4, 5, 6, 7, 8, 9, 10] # 提取从开头到索引6之间，每隔一个元素取一个 slice3 = numbers[:6:2] print(slice3) # 输出：[1, 3, 5] # 提取整个列表的副本 slice4 = numbers[:] print(slice4) # 输出：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
需要注意的是，切片操作不会修改原始列表，而是返回一个新的列表。这使得切片非常灵活，可以方便地对列表进行子集操作。
此外，切片还支持负索引，负索引表示从列表末尾开始计数。例如，
my_list[-1]表示列表中的最后一个元素。numbers = [1, 2, 3, 4, 5] last_element = numbers[-1] print(last_element) # 输出：5
3. 列表的添加
要向列表中添加元素，有几种常用的方法。
- 使用
append()方法：append()方法用于在列表末尾添加一个元素。
my_list = [1, 2, 3] my_list.append(4) print(my_list) # 输出：[1, 2, 3, 4]
- 使用
insert()方法：insert()方法用于在指定位置插入一个元素。需要提供插入位置的索引和要插入的元素。
my_list = [1, 2, 3] my_list.insert(1, 4) # 在索引1的位置插入元素4 print(my_list) # 输出：[1, 4, 2, 3]
- 使用
extend()方法或+运算符：extend()方法用于将另一个可迭代对象的元素添加到列表末尾，而+运算符可以用于连接两个列表。
my_list = [1, 2, 3] my_list.extend([4, 5]) # 添加另一个列表的元素 print(my_list) # 输出：[1, 2, 3, 4, 5] my_list = [1, 2, 3] new_list = my_list + [4, 5] # 连接两个列表 print(new_list) # 输出：[1, 2, 3, 4, 5]
需要注意的是，
append()方法会将整个对象作为一个元素添加到列表末尾，而extend()方法和+运算符会将可迭代对象中的每个元素都添加到列表中。可迭代对象是指可以被迭代遍历的对象，例如列表、元组、字符串等。当使用
extend()方法或+运算符将可迭代对象添加到列表中时，它们会遍历可迭代对象，并将其中的每个元素添加到列表的末尾。例如：
my_list = [1, 2, 3] my_list.extend([4, 5]) # 使用extend()方法添加另一个列表的元素 print(my_list) # 输出：[1, 2, 3, 4, 5] my_list = [1, 2, 3] new_list = my_list + [4, 5] # 使用+运算符连接两个列表 print(new_list) # 输出：[1, 2, 3, 4, 5] my_string = "Hello" my_list.extend(my_string) # 将字符串的每个字符添加到列表中 print(my_list) # 输出：[1, 2, 3, 'H', 'e', 'l', 'l', 'o']
4. 列表的删除
- 使用
del语句：del语句可以用于删除列表中的一个或多个元素，甚至可以删除整个列表。例如：
my_list = [1, 2, 3, 4, 5] del my_list[2] # 删除索引为2的元素 print(my_list) # 输出：[1, 2, 4, 5] del my_list[1:3] # 删除索引为1和2的元素 print(my_list) # 输出：[1, 5] del my_list # 删除整个列表
- 使用
remove()方法：remove()方法用于删除列表中的指定元素。如果列表中有多个相同的元素，它只会删除第一个遇到的元素。例如：
my_list = [1, 2, 3, 4, 5] my_list.remove(3) # 删除值为3的元素 print(my_list) # 输出：[1, 2, 4, 5]
- 使用
pop()方法：pop()方法用于删除列表中指定索引位置的元素，并返回被删除的元素的值。如果不指定索引，默认会删除并返回列表中的最后一个元素。例如：
my_list = [1, 2, 3, 4, 5] removed_element = my_list.pop(2) # 删除索引为2的元素，并返回被删除的元素的值 print(my_list) # 输出：[1, 2, 4, 5] print(removed_element) # 输出：3 last_element = my_list.pop() # 删除并返回列表中的最后一个元素 print(my_list) # 输出：[1, 2, 4] print(last_element) # 输出：5
clear()方法，可以用于清空列表，即删除列表中的所有元素。调用clear()方法后，列表将变为空列表。以下是使用clear()方法清空列表的示例：
my_list = [1, 2, 3, 4, 5] my_list.clear() # 清空列表 print(my_list) # 输出：[]
调用
clear() 方法后，my_list 变成了一个空列表。请注意，
clear() 方法只是清空列表中的元素，并没有删除列表对象本身。如果之后仍然需要使用这个列表对象，可以继续对其进行操作，添加新的元素等。5. 队列的修改
当使用列表实现队列时，可以利用列表的一些方法和操作来进行排序、反转、计数、索引、复制以及进行加法和乘法操作。
- 排序（sort）：使用
sort()方法对队列中的元素进行排序。 - 示例：
queue.sort()
- 反转（reverse）：使用
reverse()方法将队列中的元素反转顺序。 - 示例：
queue.reverse()
- 计数（count）：使用
count()方法统计队列中指定元素的出现次数。 - 示例：
count = queue.count(element)
- 索引（index）：使用
index()方法查找指定元素在队列中的索引位置。 - 示例：
index = queue.index(element)
- 复制（copy）：使用
copy()方法创建队列的副本。 - 示例：
new_queue = queue.copy()
- 加法（加法运算符）：使用加法运算符
+将两个队列合并。 - 示例：
combined_queue = queue1 + queue2
- 乘法（乘法运算符）：使用乘法运算符
将队列重复多次。 - 示例：
repeated_queue = queue * n
下面是一些示例代码，演示了这些队列操作的用法：
# 创建一个队列 queue = [3, 1, 4, 1, 5, 9] # 排序操作 queue.sort() print(queue) # 输出：[1, 1, 3, 4, 5, 9] # 反转操作 queue.reverse() print(queue) # 输出：[9, 5, 4, 3, 1, 1] # 计数操作 count = queue.count(1) print(count) # 输出：2 # 索引操作 index = queue.index(4) print(index) # 输出：2 # 复制操作 new_queue = queue.copy() print(new_queue) # 输出：[9, 5, 4, 3, 1, 1] # 加法操作 queue1 = [1, 2, 3] queue2 = [4, 5, 6] combined_queue = queue1 + queue2 print(combined_queue) # 输出：[1, 2, 3, 4, 5, 6] # 乘法操作 repeated_queue = queue * 3 print(repeated_queue) # 输出：[9, 5, 4, 3, 1, 1, 9, 5, 4, 3, 1, 1, 9, 5, 4, 3, 1, 1]
6. 列表嵌套
列表嵌套是指在一个列表中包含另一个列表作为元素。这种嵌套结构可以创建多维列表或列表的列表，提供了一种灵活的方式来组织和表示复杂的数据。
嵌套列表可以包含任意数量的子列表，并且每个子列表可以具有不同的长度。这使得列表嵌套成为一种非常强大的数据结构，可以表示各种复杂的数据关系。
下面是一个示例，展示了如何创建和访问嵌套列表：
# 创建一个嵌套列表 nested_list = [[1, 2, 3], [4, 5], [6, 7, 8, 9]] # 访问嵌套列表的元素 print(nested_list[0]) # 输出：[1, 2, 3] print(nested_list[1][1]) # 输出：5 print(nested_list[2][2:]) # 输出：[8, 9] # 修改嵌套列表的元素 nested_list[1].append(6) print(nested_list) # 输出：[[1, 2, 3], [4, 5, 6], [6, 7, 8, 9]]
在上述示例中，我们创建了一个嵌套列表
nested_list，其中包含三个子列表。可以使用索引访问嵌套列表的元素，例如 nested_list[0] 返回第一个子列表 [1, 2, 3]。通过使用双重索引，我们可以访问嵌套列表中更深层次的元素，例如 nested_list[1][1] 返回第二个子列表的第二个元素 5。还可以使用切片操作来访问子列表的部分元素，例如 nested_list[2][2:] 返回第三个子列表的后两个元素 [8, 9]。嵌套列表的元素可以通过索引、切片和列表的方法进行修改。例如，我们可以使用
append() 方法向第二个子列表中添加一个新元素 6。使用列表嵌套可以实现更复杂的数据结构和数据关系，例如二维数组、矩阵、树等。它为处理和组织复杂数据提供了灵活性和可扩展性。
要访问嵌套列表中的元素，可以使用索引操作和切片操作。通过指定索引值或切片范围，可以获取嵌套列表中的特定元素或子列表。
下面是一些常用的方法来访问嵌套列表的元素：
- 使用索引操作：可以使用方括号
[]和索引值来访问嵌套列表中的元素。索引从0开始，表示第一个元素。如果嵌套列表是多维的，可以使用多个索引值来访问深层的元素。
nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] print(nested_list[0]) # 输出：[1, 2, 3] print(nested_list[1][2]) # 输出：6
- 使用切片操作：可以使用冒号
:来指定切片范围，以获取嵌套列表中的一部分元素。切片操作返回一个新的列表。
nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] print(nested_list[1:]) # 输出：[[4, 5, 6], [7, 8, 9]] print(nested_list[0][1:]) # 输出：[2, 3]
- 使用循环遍历：可以使用循环结构（如
for循环）来遍历嵌套列表中的所有元素。
nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] for sublist in nested_list: for item in sublist: print(item)
深拷贝（Deep Copy）是指创建一个新的对象，该对象与原始对象具有相同的值，但是在内存中拥有不同的地址。深拷贝会递归地复制对象及其所有嵌套对象，确保每个对象都是独立的，互不影响。
简单来说，深拷贝创建了原始对象的完全独立副本，而不仅仅是对原始对象的引用。这意味着对深拷贝的副本进行修改不会影响原始对象。
在Python中，可以使用
copy模块中的deepcopy()函数来执行深拷贝操作。下面是一个示例：import copy original_list = [1, 2, [3, 4]] copied_list = copy.deepcopy(original_list) # 修改深拷贝的副本 copied_list[2][0] = 5 print(original_list) # 输出：[1, 2, [3, 4]] print(copied_list) # 输出：[1, 2, [5, 4]]
在上述示例中，我们使用
deepcopy()函数创建了original_list的深拷贝副本copied_list。然后，我们修改了copied_list中嵌套列表的元素，但这并不会影响到original_list。打印两个列表的结果可以看到它们的值是不同的。深拷贝适用于需要完全独立的副本的情况，尤其是当原始对象包含嵌套对象时。相比之下，浅拷贝（Shallow Copy）只复制最外层对象的引用，而不会递归地复制嵌套对象。因此，浅拷贝的副本与原始对象共享内部对象，对副本的修改可能会影响到原始对象。
7. 列表推导式
列表推导式（List Comprehension）是一种简洁而强大的语法结构，用于创建新的列表。它允许在一行代码中使用简洁的语法来生成列表，而无需编写显式的循环语句。
列表推导式的一般语法形式如下：
new_list = [expression for item in iterable if condition]
其中，
expression是一个表达式，用于生成新列表中的元素。item是从iterable中取出的每个元素，可以在expression中使用。iterable是一个可迭代对象（如列表、元组、字符串等），提供了要遍历的元素。condition是一个可选的条件表达式，用于过滤元素。下面是一些示例来说明列表推导式的用法：
- 生成一个由平方数组成的列表：
squares = [x**2 for x in range(1, 6)] # 输出：[1, 4, 9, 16, 25]
- 过滤出偶数的列表：
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] even_numbers = [x for x in numbers if x % 2 == 0] # 输出：[2, 4, 6, 8, 10]
- 使用条件表达式修改元素：
numbers = [1, 2, 3, 4, 5] modified_numbers = [x if x % 2 == 0 else x * 2 for x in numbers] # 输出：[2, 2, 6, 4, 10]
- 嵌套列表推导式：
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] flattened_matrix = [num for row in matrix for num in row] # 输出：[1, 2, 3, 4, 5, 6, 7, 8, 9]
numbers = [1, 2, 3, 4, 5] pairs = [(x, y) for x in numbers for y in numbers if x != y] # 输出：[(1, 2), (1, 3), (1, 4), (1, 5), (2, 1), (2, 3), (2, 4), (2, 5), (3, 1), (3, 2), (3, 4), (3, 5), (4, 1), (4, 2), (4, 3), (4, 5), (5, 1), (5, 2), (5, 3), (5, 4)]
在上述示例中，我们使用两个嵌套的for循环来迭代
numbers列表中的元素，并使用if语句来排除相等的元素。最终，我们生成了一个包含所有不相等数对的列表。列表推导式可以大大简化代码，使生成新列表的过程更加清晰和高效。它具有灵活性和表达能力，可以根据需要进行条件过滤、元素变换和嵌套操作。然而，对于复杂的逻辑和较长的推导式，适度的使用和良好的可读性仍然是值得注意的。