Python——列表的常见操作总结

Python 中的列表（List）是一种非常灵活的数据结构，用于存储序列化的数据集合。列表是可变的，意味着你可以在创建列表后添加、删除或修改其中的元素。列表中的元素可以是不同类型的数据，如整数、浮点数、字符串、甚至是另一个列表（即列表的嵌套）。

创建列表

列表使用方括号 [] 来定义，元素之间用逗号 , 分隔。

# 创建一个包含几个不同类型元素的列表  
my_list = [1, 2.5, "Hello", [3, 4, 5]]  
  
# 创建一个空列表  
empty_list = []

访问列表元素

你可以使用索引来访问列表中的元素。索引从 0 开始。

# 访问第一个元素  
print(my_list[0])  # 输出: 1  
  
# 访问最后一个元素（负索引）  
print(my_list[-1])  # 输出: [3, 4, 5]

列表的切片

列表支持切片操作，允许你访问列表中的一部分元素。

# 访问第一个到第四个元素  
print(my_list[0:4])  

# 访问第一个和第三个元素  （跨度为2）
print(my_list[0:4:2])  

# 倒序输出第一个到第四个元素  
print(my_list[0:4:-1])  

列表的加法和乘法

在Python中，列表（List）的加法和乘法操作有着特定的含义，它们与数值类型的加法和乘法有所不同。

列表加法

列表的加法操作实际上是列表的拼接（Concatenation），即将两个列表的元素按顺序合并成一个新的列表。

list1 = [1, 2, 3]  
list2 = [4, 5, 6]  
result = list1 + list2  
print(result)  # 输出: [1, 2, 3, 4, 5, 6]

在这个例子中，list1 和 list2 被加在一起，结果是一个新的列表 result，它包含了 list1 和 list2 的所有元素。

列表乘法

列表的乘法操作则是将列表中的元素重复指定的次数，生成一个新的列表。

list1 = [1, 2, 3]  
result = list1 * 3  
print(result)  # 输出: [1, 2, 3, 1, 2, 3, 1, 2, 3]

在这个例子中，list1 被乘以3，结果是一个新的列表 result，它包含了 list1 的元素重复三次。

注意事项

• 列表的加法和乘法操作不会修改原列表，而是返回一个新的列表。
• 列表的乘法操作是将列表中的每个元素都重复指定的次数，而不是将列表本身作为一个整体重复。
• 列表的加法和乘法操作只适用于列表类型，不能与其他类型（如整数、浮点数、字符串等）进行这些操作。如果尝试这样做，Python会抛出TypeError异常。

添加元素

在Python中，向列表添加元素有几种常用的方法。以下是几种主要的方式：

1. 使用 append() 方法

append() 方法用于在列表的末尾添加一个元素。这个元素可以是任何数据类型，包括另一个列表（实现列表的嵌套）。

my_list = [1, 2, 3]  
my_list.append(4)  # 向列表末尾添加元素4  
print(my_list)  # 输出: [1, 2, 3, 4]  
  
# 添加另一个列表作为元素（注意，这会嵌套列表）  
my_list.append([5, 6])  
print(my_list)  # 输出: [1, 2, 3, 4, [5, 6]]

2. 使用 extend() 方法

与 append() 不同，extend() 方法用于在列表的末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。

my_list = [1, 2, 3]  
my_list.extend([4, 5, 6])  # 向列表末尾添加多个元素  
print(my_list)  # 输出: [1, 2, 3, 4, 5, 6]  
  
# 注意，extend() 不会将列表作为单个元素添加

3. 使用 + 操作符

虽然这不是直接在原列表上添加元素，但你可以通过 + 操作符来合并两个列表，并将结果赋值给其中一个列表（或者一个新的列表变量）。

my_list = [1, 2, 3]  
another_list = [4, 5, 6]  
  
# 合并两个列表  
my_list = my_list + another_list  
print(my_list)  # 输出: [1, 2, 3, 4, 5, 6]  
  
# 或者创建一个新列表  
combined_list = my_list + another_list  
print(combined_list)  # 输出: [1, 2, 3, 4, 5, 6]

4. 使用 insert() 方法

insert() 方法允许你在列表的指定位置插入一个元素。你需要指定插入位置的索引以及要插入的元素。

my_list = [1, 2, 4, 5]  
my_list.insert(2, 3)  # 在索引2的位置插入元素3  
print(my_list)  # 输出: [1, 2, 3, 4, 5]

5.使用切片的方法

my_list = [1, 2, 3]  
  
# 在列表末尾添加一个元素  
my_list[len(my_list ):] = 4  
print(my_list)  # 输出: [1, 2, 3, 4]  
  
# 在列表末尾添加多个元素  
my_list[len(my_list ):] = [4, 5, 6]  
print(my_list )  # 输出: [1, 2, 3, 4, 5, 6]

删除元素

在Python中，删除列表中的元素可以通过几种不同的方法来实现。以下是几种常用的方法：

1. 使用 remove() 方法

remove() 方法用于移除列表中第一个匹配指定值的元素。如果找不到该元素，则抛出 ValueError 异常。

my_list = [1, 2, 3, 4, 5, 4]  
my_list.remove(4)  # 移除第一个出现的4  
print(my_list)  # 输出: [1, 2, 3, 5, 4]  
  
# 如果尝试移除不存在的元素  
# my_list.remove(6)  # 这会抛出 ValueError

注意：如果列表中存在多个匹配的元素，只会删除第一个匹配的元素。

2. 使用 pop() 方法

pop() 方法用于移除列表中的一个元素（默认是最后一个元素），并返回该元素的值。你也可以指定要移除元素的索引。

my_list = [1, 2, 3, 4, 5]  
last_element = my_list.pop()  # 移除并返回最后一个元素  
print(last_element)  # 输出: 5  
print(my_list)  # 输出: [1, 2, 3, 4]  
  
# 移除指定索引的元素  
second_element = my_list.pop(1)  # 移除索引为1的元素（即2）  
print(second_element)  # 输出: 2  
print(my_list)  # 输出: [1, 3, 4]

3. 使用 clear() 方法

在Python中，clear() 方法是列表（List）的一个内置方法，用于清空列表中的所有元素。当调用此方法后，列表中的所有元素将被删除，但列表本身仍然存在，即列表对象并没有被删除，只是其内部不再包含任何元素。

my_list = [1, 2, 3, 4, 5]  
my_list.clear()  
print(my_list)  # 输出: []

从上面的示例可以看出，调用 clear() 方法后，列表 my_list 中的所有元素都被删除了，但 my_list 仍然是一个有效的空列表。

4. 使用 del 语句

del 语句可以用于删除列表中的元素，你可以通过索引来指定要删除的元素，或者通过切片来删除一段元素。

my_list = [1, 2, 3, 4, 5]  
del my_list[2]  # 删除索引为2的元素（即3）  
print(my_list)  # 输出: [1, 2, 4, 5]  
  
# 删除一段元素  
del my_list[1:3]  # 删除索引从1到2的元素（即2和4）  
print(my_list)  # 输出: [1, 5]  
  
# 注意：使用del删除元素后，该元素及其后的元素索引都会发生变化

列表排序

在Python中，列表（List）支持多种排序方式。以下是一些常用的列表排序元素的方法：

1. 使用 sort() 方法

sort() 方法用于对列表进行就地排序，即直接修改原列表，不返回任何值（返回 None）。你可以通过指定 reverse 参数来控制排序是升序还是降序（默认为升序）。

my_list = [3, 1, 4, 1, 5, 9, 2]  
my_list.sort()  # 升序排序  
print(my_list)  # 输出: [1, 1, 2, 3, 4, 5, 9]  
  
my_list.sort(reverse=True)  # 降序排序  
print(my_list)  # 输出: [9, 5, 4, 3, 2, 1, 1]

2. 使用 sorted() 函数

与 sort() 方法不同，sorted() 函数会对列表进行排序，但它会返回一个新的列表，而不是修改原列表。这在你需要保留原列表顺序时非常有用。sorted() 函数同样接受一个 reverse 参数来控制排序顺序。

my_list = [3, 1, 4, 1, 5, 9, 2]  
sorted_list = sorted(my_list)  # 升序排序  
print(sorted_list)  # 输出: [1, 1, 2, 3, 4, 5, 9]  
  
sorted_list_desc = sorted(my_list, reverse=True)  # 降序排序  
print(sorted_list_desc)  # 输出: [9, 5, 4, 3, 2, 1, 1]  
  
# 注意：原列表my_list没有被修改  
print(my_list)  # 输出: [3, 1, 4, 1, 5, 9, 2]

3. 使用 lambda 函数进行复杂排序

当需要根据列表中元素的某个属性或通过复杂逻辑进行排序时，可以使用 lambda 函数作为 sort() 方法或 sorted() 函数的 key 参数。

# 假设我们有一个包含元组的列表，每个元组包含姓名和年龄  
people = [('John', 45), ('Diana', 35), ('Mike', 29)]  
  
# 按年龄升序排序  
people.sort(key=lambda x: x[1])  
print(people)  # 输出: [('Mike', 29), ('Diana', 35), ('John', 45)]  
  
# 按年龄降序排序  
sorted_people = sorted(people, key=lambda x: x[1], reverse=True)  
print(sorted_people)  # 输出: [('John', 45), ('Diana', 35), ('Mike', 29)]

4. 使用 operator 模块进行排序

对于简单的属性排序（如列表中的整数或字符串），直接使用 sort() 或 sorted() 的 key 参数配合 lambda 函数通常是足够的。但对于更复杂的对象或需要更高效的排序，可以使用 operator 模块中的函数作为 key 参数。

import operator  
  
# 使用operator.itemgetter进行复杂对象的排序  
people = [('John', 45), ('Diana', 35), ('Mike', 29)]  
sorted_people = sorted(people, key=operator.itemgetter(1))  
print(sorted_people)  # 输出: [('Mike', 29), ('Diana', 35), ('John', 45)]

元素查找

在Python中，查找列表中的元素通常可以通过几种不同的方法来实现，每种方法适用于不同的场景和需求。以下是一些常用的查找列表元素的方法：

1. 使用 in 关键字

in 关键字用于检查某个值是否存在于列表中，它会返回一个布尔值（True 或 False）。

my_list = [1, 2, 3, 4, 5]  
if 3 in my_list:  
    print("元素存在")  
else:  
    print("元素不存在")

2. 使用 index() 方法

index() 方法用于查找列表中某个值的索引位置。如果找到了该值，则返回其索引（索引从0开始）；如果未找到，则抛出 ValueError 异常。

my_list = [1, 2, 3, 4, 5]  
index = my_list.index(3)  
print(f"元素3的索引是: {index}")  
# 如果元素不存在，会抛出ValueError  

my_list.undex(3,1,7)
#在第二个和第八个元素之间查找3

同样如果列表中存在多个被查找的元素，只会返回第一个的下标值。

3. 使用 count() 方法

使用列表的count()方法会返回指定元素在列表中出现的次数。

my_list = [1, 2, 2, 3, 4, 4, 4, 5]  
  
# 查找元素2出现的次数  
count_of_two = my_list.count(2)  
print(f"元素2出现的次数是: {count_of_two}")  # 输出: 元素2出现的次数是: 2  
  
# 查找元素4出现的次数  
count_of_four = my_list.count(4)  
print(f"元素4出现的次数是: {count_of_four}")  # 输出: 元素4出现的次数是: 3  
  
# 查找一个不存在的元素（比如6）出现的次数  
count_of_six = my_list.count(6)  
print(f"元素6出现的次数是: {count_of_six}")  # 输出: 元素6出现的次数是: 0