列表(list)篇（一）

2.1 创建列表

在Python中，列表（list）是一种基础的数据结构，可以包含不同类型的元素，并且这些元素是有序排列的。列表的元素可以是整数、浮点数、字符串、布尔值，甚至是其他列表（嵌套列表）等。

要定义一个列表，你可以使用方括号 []，并在其中放置用逗号分隔的元素。下面是一些示例：

# 定义一个空列表
empty_list = []

# 定义一个包含整数的列表
integer_list = [1, 2, 3, 4, 5]

# 定义一个包含不同类型元素的列表
mixed_list = [1, "hello", 3.14, True]

# 定义一个包含嵌套列表的列表
nested_list = [1, [2, 3], [4, [5, 6]]]

# 使用列表推导式定义一个列表，包含0到9的平方
squared_list = [x**2 for x in range(10)]

# 输出列表
print(empty_list)
print(integer_list)
print(mixed_list)
print(nested_list)
print(squared_list)

当你运行这些代码时，你将看到如下输出：

[]
[1, 2, 3, 4, 5]
[1, 'hello', 3.14, True]
[1, [2, 3], [4, [5, 6]]]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

列表提供了许多内置的方法和操作，例如 append() 来添加元素，remove() 来删除元素，pop() 来移除并返回列表的最后一个元素，index() 来查找元素的索引等。这些方法和操作使得列表成为Python中非常灵活和有用的数据结构。

2.2 append()函数

在Python中，list 是一种数据结构，用于存储一系列有序的元素。append() 是 list 类型的一个方法，用于在列表的末尾添加一个新元素。

以下是 append() 方法的基本用法：

# 创建一个空列表
my_list = []

# 使用append()方法向列表中添加元素
my_list.append(1)  # 列表变为 [1]
my_list.append(2)  # 列表变为 [1, 2]
my_list.append(3)  # 列表变为 [1, 2, 3]

# 打印列表以查看结果
print(my_list)  # 输出: [1, 2, 3]

append() 方法只接受一个参数，即要添加到列表末尾的元素。它不会返回新的列表，而是直接修改原始列表。

需要注意的是，append() 是在列表的末尾添加元素，而不是在指定索引位置。如果你需要在特定索引位置插入元素，应使用 insert() 方法：

# 在索引1的位置插入元素'b'
my_list.insert(1, 'b')  # 列表变为 [1, 'b', 2, 3]

print(my_list)  # 输出: [1, 'b', 2, 3]

在这个例子中，‘b’ 被插入到 my_list 的第二个位置（索引为1，因为索引是从0开始的）。

2.3 clear()函数

在Python中，list 类型有一个 clear() 方法，用于移除列表中的所有元素，将其变为一个空列表。这个方法不接受任何参数，并且没有返回值。调用 clear() 之后，原来的列表将不再包含任何元素。

下面是一个使用 clear() 方法的例子：

# 创建一个包含元素的列表
my_list = [1, 2, 3, 4, 5]

# 打印原始列表
print("Original list:", my_list)  # 输出: Original list: [1, 2, 3, 4, 5]

# 使用clear()方法清空列表
my_list.clear()

# 打印清空后的列表
print("Cleared list:", my_list)  # 输出: Cleared list: []

在这个例子中，my_list 初始时包含5个元素。调用 my_list.clear() 之后，列表中的所有元素都被移除了，my_list 变成了一个空列表。

需要注意的是，clear() 方法直接修改了原始列表，而不是创建一个新的空列表。因此，调用 clear() 之后，原来指向该列表的所有变量和引用都将反映出列表已被清空的状态。

与 clear() 方法类似，但效果不同的是 del 语句。使用 del 语句可以删除整个列表对象：

# 删除整个列表对象
del my_list

# 尝试访问已删除的列表会引发错误
# print(my_list)  # NameError: name 'my_list' is not defined

在这种情况下，my_list 这个变量名将不再存在，而不是仅仅其引用的列表内容被清空。如果尝试访问已删除的变量，将会引发 NameError。

2.4 copy()函数

在Python中，list的copy()方法用于创建列表的一个浅拷贝（shallow copy）。这意味着新列表是原始列表的一个新实例，但它包含的元素仍然是原始列表中元素的引用，而不是新创建的对象。

这里是如何使用copy()方法的示例：

# 创建一个原始列表
original_list = [1, 2, 3, [4, 5]]

# 使用copy()方法创建列表的拷贝
copied_list = original_list.copy()

# 打印原始列表和拷贝的列表
print("Original list:", original_list)
print("Copied list:", copied_list)

# 修改原始列表中的一个元素
original_list[0] = 100

# 打印修改后的原始列表和拷贝的列表
print("Modified original list:", original_list)
print("Copied list after modification of original:", copied_list)

# 修改原始列表中的一个嵌套列表
original_list[3][0] = 400

# 打印修改后的原始列表和拷贝的列表
print("Modified original list with nested list change:", original_list)
print("Copied list after modification of nested list in original:", copied_list)

输出结果将会显示，尽管我们修改了原始列表中的元素和嵌套列表，但拷贝的列表并没有受到这些修改的影响。这是因为copy()创建了原始列表的一个新实例，但内部元素仍然是原始元素的引用。

需要注意的是，如果列表包含可变对象（如列表、字典等），那么对原始列表中的这些对象的修改也会反映在拷贝的列表中，因为拷贝的列表包含的是对这些对象的引用，而不是对象的新副本。这被称为浅拷贝。如果你希望创建一个完全独立的副本，包括内部对象的新副本，那么你需要使用深拷贝（deep copy），可以使用copy模块的deepcopy()函数来实现。

import copy

# 创建一个原始列表
original_list = [1, 2, 3, [4, 5]]

# 使用deepcopy()方法创建列表的深拷贝
deep_copied_list = copy.deepcopy(original_list)

# 修改原始列表中的嵌套列表
original_list[3][0] = 400

# 打印原始列表和深拷贝的列表
print("Original list with nested list change:", original_list)
print("Deep copied list after modification of nested list in original:", deep_copied_list)

在这个例子中，即使我们修改了原始列表中的嵌套列表，深拷贝的列表也没有受到影响，因为它包含了原始内部对象的新副本。

2.5 count()函数

在Python中，list 类型有一个 count() 方法，用于统计列表中某个元素出现的次数。这个方法接受一个参数，即要统计的元素，并返回该元素在列表中出现的次数。

下面是一个使用 count() 方法的例子：

# 创建一个包含元素的列表
my_list = [1, 2, 3, 2, 2, 4, 5, 2]

# 统计元素2在列表中出现的次数
count_of_two = my_list.count(2)

# 打印结果
print("The count of 2 in the list is:", count_of_two)  # 输出: The count of 2 in the list is: 4

在这个例子中，my_list 包含8个元素，其中元素2出现了4次。调用 my_list.count(2) 返回了4，即元素2在列表中出现的次数。

count() 方法只会统计列表中直接包含的元素，不会递归地检查嵌套的对象（如列表中的列表）。如果列表中包含嵌套列表，并且你想要统计某个元素在整个嵌套列表结构中出现的次数，你需要实现一个递归函数来遍历所有嵌套列表。

需要注意的是，count() 方法对于列表中的元素进行直接比较，因此如果列表中的元素是不可哈希的类型（如列表或字典），那么它们不能被用作 count() 方法的参数，因为这样的元素不能出现在哈希表中，而 count() 方法需要利用哈希表来快速查找元素。

此外，count() 方法的时间复杂度通常是O(n)，其中n是列表的长度，因为它需要遍历整个列表来统计元素的出现次数。

2.6 del

在Python中，del语句可以用来删除列表中的元素或整个列表。当你想删除列表中的某个元素时，你可以使用del语句并指定该元素的索引。如果你想删除整个列表，你可以使用del语句并指定列表的变量名。

下面是使用del语句删除列表元素的例子：

# 创建一个包含元素的列表
my_list = [1, 2, 3, 4, 5]

# 打印原始列表
print("Original list:", my_list)  # 输出: Original list: [1, 2, 3, 4, 5]

# 使用del语句删除索引为2的元素（即数字3）
del my_list[2]

# 打印删除元素后的列表
print("List after deleting element at index 2:", my_list)  # 输出: List after deleting element at index 2: [1, 2, 4, 5]

在这个例子中，del my_list[2]删除了my_list中索引为2的元素，即数字3。

如果你想删除整个列表，可以这样做：

# 创建一个包含元素的列表
my_list = [1, 2, 3, 4, 5]

# 打印原始列表
print("Original list:", my_list)  # 输出: Original list: [1, 2, 3, 4, 5]

# 使用del语句删除整个列表
del my_list

# 尝试访问已删除的列表会引发错误
# print(my_list)  # NameError: name 'my_list' is not defined

在这个例子中，del my_list删除了整个列表对象，包括其变量名my_list。此后，尝试访问my_list将会导致NameError，因为该变量已经不存在了。

请注意，使用del语句删除列表元素或整个列表时，必须确保你正在删除的是正确的元素或列表，因为删除操作是不可逆的。如果你想保留原始列表并创建一个没有特定元素的新列表，你应该使用list.remove(element)方法（用于删除第一个匹配的元素）或list.copy()与列表推导式（用于创建新列表，不包含某些元素）。

2.7 enumerate()函数

在Python中，enumerate()是一个内置函数，它用于遍历一个可迭代对象（如列表、元组或字符串）的元素，并同时返回每个元素的索引和值。这对于在循环中同时需要索引和元素值的情况非常有用。

enumerate()函数的基本语法是：

enumerate(iterable, start=0)

其中，iterable是一个可迭代对象，start是一个可选参数，表示计数开始的索引值，默认为0。

下面是一个使用enumerate()函数的例子，它遍历一个列表并打印出每个元素的索引和值：

# 创建一个列表
my_list = ['apple', 'banana', 'cherry']

# 使用enumerate()遍历列表
for index, value in enumerate(my_list):
    print(f"Index: {index}, Value: {value}")

输出结果将会是：

Index: 0, Value: apple
Index: 1, Value: banana
Index: 2, Value: cherry

在上面的例子中，enumerate(my_list)返回一个枚举对象，该对象在每次迭代时产生一个包含索引和值的元组。for循环则解包这个元组，将索引赋值给index变量，将值赋值给value变量。

通过enumerate()函数，你可以方便地在循环中同时获取到元素的索引和值，而不需要使用额外的计数器或索引变量。

2.8 extend()函数

在Python中，list.extend()是一个方法，用于将一个可迭代对象（如列表、元组或字符串）的元素添加到现有列表的末尾。与list.append()方法不同，extend()会将可迭代对象中的每个元素单独添加到列表中，而不是将整个可迭代对象作为单个元素添加。

以下是list.extend()方法的语法：

list.extend(iterable)

其中，iterable是一个可迭代对象，可以是列表、元组、字符串等。

下面是一个使用extend()方法的例子：

# 创建一个列表
my_list = [1, 2, 3]

# 创建另一个可迭代对象
another_list = [4, 5, 6]

# 使用extend()将another_list的元素添加到my_list中
my_list.extend(another_list)

# 打印修改后的列表
print(my_list)  # 输出: [1, 2, 3, 4, 5, 6]

在这个例子中，extend()方法将another_list中的每个元素（4、5、6）添加到my_list的末尾。

如果尝试使用append()方法将another_list添加到my_list，结果将会有所不同：

# 使用append()将another_list作为一个元素添加到my_list中
my_list.append(another_list)

# 打印修改后的列表
print(my_list)  # 输出: [1, 2, 3, [4, 5, 6]]

在这个例子中，append()方法将整个another_list作为一个元素添加到了my_list的末尾，而不是将another_list中的元素添加到my_list中。

extend()方法在处理列表合并时非常有用，因为它可以简洁地将多个列表的元素合并到一个列表中。

2.9 index()函数

在Python中，list.index()是一个列表方法，用于查找列表中某个元素的第一个匹配项的索引。如果元素存在于列表中，index()方法返回该元素的最低索引（即它首次出现的位置）。如果元素不在列表中，index()方法将引发一个ValueError异常。

以下是list.index()方法的基本语法：

list.index(value, [start, [stop]])

• value：需要查找的元素值。
• start（可选）：开始搜索的索引位置。如果指定了该参数，搜索将从该索引开始，直到列表的末尾。
• stop（可选）：停止搜索的索引位置。搜索将在该索引之前结束。

下面是一个使用index()方法的例子：

# 创建一个列表
my_list = ['apple', 'banana', 'cherry', 'date', 'elderberry']

# 使用index()查找'cherry'的索引
cherry_index = my_list.index('cherry')

# 打印结果
print(f"The index of 'cherry' is: {cherry_index}")  # 输出: The index of 'cherry' is: 2

# 尝试查找不存在的元素
try:
    nonexistent_index = my_list.index('fig')
except ValueError as e:
    print(f"An error occurred: {e}")  # 输出: An error occurred: 'fig' is not in list

在上面的例子中，my_list.index(‘cherry’)返回2，因为’cherry’是列表中第三个元素（索引从0开始）。当我们尝试查找一个不存在的元素（如’fig’）时，index()方法会抛出一个ValueError异常，因此我们需要使用try和except块来捕获并处理这个异常。

如果你想从列表的特定部分开始搜索，你可以使用start和stop参数。例如，要查找从索引1开始到索引4（不包括4）的元素’banana’的索引，你可以这样做：

banana_index = my_list.index('banana', 1, 4)
print(f"The index of 'banana' between indices 1 and 4 (exclusive) is: {banana_index}")  # 输出: The index of 'banana' between indices 1 and 4 (exclusive) is: 1

在这个例子中，尽管’banana’实际上在索引0的位置，但由于我们指定了搜索范围，所以返回的是在该范围内的第一个匹配项的索引。