详细介绍一下Python中列表的常用操作

原创

小焱写作

发布于 2025-11-14 08:54:37

1350

文章被收录于专栏：javajava

Python 列表（List）是最常用的核心数据结构之一，支持丰富的操作方法，涵盖 创建、访问、增删改查、排序、切片、遍历 等场景。以下从实战角度出发，详细拆解列表的常用操作，搭配代码示例和场景说明，方便直接复用。

一、列表的创建与初始化

1. 直接创建（最常用）

用方括号 [] 包裹元素，元素间用逗号分隔，支持异构元素（不同类型）：

# 普通列表
nums = [1, 2, 3, 4, 5]
fruits = ["苹果", "香蕉", "橙子"]

# 异构列表（允许不同类型元素）
mixed = [10, "Python", True, 3.14, [6, 7]]  # 包含列表嵌套

2. 空列表创建

# 方法1：空方括号（推荐）
empty_list = []

# 方法2：list() 函数
empty_list2 = list()

3. 用 `list()` 函数转换创建

可将字符串、元组、集合等可迭代对象转为列表：

# 字符串转列表（按字符拆分）
str_to_list = list("hello")  # 输出：['h', 'e', 'l', 'l', 'o']

# 元组转列表
tuple_to_list = list((1, 2, 3))  # 输出：[1, 2, 3]

# 集合转列表（无序，去重）
set_to_list = list({2, 2, 3, 4})  # 输出：[2, 3, 4]（顺序不确定）

4. 用 `range()` 生成有序列表

range(start, end, step) 生成连续整数，需配合 list() 转为列表：

# 0~4（步长默认1）
nums1 = list(range(5))  # 输出：[0, 1, 2, 3, 4]

# 2~8（步长2）
nums2 = list(range(2, 9, 2))  # 输出：[2, 4, 6, 8]

二、列表的访问与切片（核心操作）

列表是有序结构，支持通过 索引访问单个元素 和 切片截取子列表。

1. 索引访问（下标访问）

索引从 0 开始（正向索引），最后一个元素索引为 len(list)-1；
支持反向索引（从 -1 开始，-1 表示最后一个元素，-2 表示倒数第二个）。

fruits = ["苹果", "香蕉", "橙子", "葡萄"]

# 正向索引
print(fruits[0])  # 第一个元素：苹果
print(fruits[2])  # 第三个元素：橙子

# 反向索引
print(fruits[-1])  # 最后一个元素：葡萄
print(fruits[-3])  # 倒数第三个元素：香蕉

# 索引越界会报错（避免！）
# print(fruits[4])  # IndexError: list index out of range

2. 切片操作（截取子列表）

语法：list[start:end:step]

start：起始索引（默认0，包含该元素）；
end：结束索引（默认len(list)，不包含该元素）；
step：步长（默认1，负数表示反向切片）；
切片返回新列表，不修改原列表。

nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 1. 截取索引1~4（含1不含5）
print(nums[1:5])  # 输出：[1, 2, 3, 4]

# 2. 省略start（从开头截取到end-1）
print(nums[:3])  # 输出：[0, 1, 2]

# 3. 省略end（从start截取到末尾）
print(nums[6:])  # 输出：[6, 7, 8, 9]

# 4. 步长为2（每隔1个元素取1个）
print(nums[0:8:2])  # 输出：[0, 2, 4, 6]

# 5. 反向切片（步长为-1，反转列表）
print(nums[::-1])  # 输出：[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

# 6. 截取倒数3个元素
print(nums[-3:])  # 输出：[7, 8, 9]

三、列表的增删改操作（可变特性核心）

列表是可变结构，可动态添加、删除、修改元素，以下是高频操作：

1. 添加元素

方法	代码示例	功能说明	适用场景
append(x)	fruits.append("芒果")	在列表末尾添加1个元素	单个元素添加（最常用）
extend(iterable)	fruits.extend(["草莓", "荔枝"])	批量添加可迭代对象（列表、元组等）的元素	多个元素批量添加
insert(index, x)	fruits.insert(1, "梨")	在指定索引位置插入1个元素	插入到指定位置

fruits = ["苹果", "香蕉"]

# append：末尾加单个元素
fruits.append("橙子")
print(fruits)  # 输出：['苹果', '香蕉', '橙子']

# extend：批量加多个元素
fruits.extend(("葡萄", "芒果"))  # 元组作为可迭代对象
print(fruits)  # 输出：['苹果', '香蕉', '橙子', '葡萄', '芒果']

# insert：指定位置插入（索引1处）
fruits.insert(1, "梨")
print(fruits)  # 输出：['苹果', '梨', '香蕉', '橙子', '葡萄', '芒果']

2. 删除元素

方法/语法	代码示例	功能说明	适用场景
del list[index]	del fruits[2]	按索引删除元素	知道元素索引时
remove(x)	fruits.remove("香蕉")	按值删除（删除第一个匹配项）	知道元素值，且元素存在时
pop(index)	fruits.pop() / fruits.pop(1)	按索引删除（默认删除最后一个），返回删除值	需要获取删除的元素时
clear()	fruits.clear()	清空列表所有元素（保留列表对象）	需重置列表时

fruits = ["苹果", "梨", "香蕉", "橙子", "葡萄", "芒果"]

# del：按索引删除（删除索引2的"香蕉"）
del fruits[2]
print(fruits)  # 输出：['苹果', '梨', '橙子', '葡萄', '芒果']

# remove：按值删除（删除第一个"葡萄"）
fruits.remove("葡萄")
print(fruits)  # 输出：['苹果', '梨', '橙子', '芒果']

# pop：删除最后一个元素，返回删除值
last_fruit = fruits.pop()
print(last_fruit)  # 输出：芒果
print(fruits)  # 输出：['苹果', '梨', '橙子']

# pop：按索引删除（删除索引1的"梨"）
pop_fruit = fruits.pop(1)
print(pop_fruit)  # 输出：梨
print(fruits)  # 输出：['苹果', '橙子']

# clear：清空列表
fruits.clear()
print(fruits)  # 输出：[]

3. 修改元素

直接通过 索引赋值 修改单个元素，或通过 切片赋值 批量修改：

nums = [1, 2, 3, 4, 5]

# 1. 单个元素修改（索引2处改为30）
nums[2] = 30
print(nums)  # 输出：[1, 2, 30, 4, 5]

# 2. 切片批量修改（索引1~3改为 [20, 30, 40]）
nums[1:4] = [20, 30, 40]
print(nums)  # 输出：[1, 20, 30, 40, 5]

# 3. 切片批量替换（长度可不一致，会自动调整列表长度）
nums[3:] = [400, 500, 600]
print(nums)  # 输出：[1, 20, 30, 400, 500, 600]

四、列表的查询与统计操作

1. 判断元素是否存在（`in` / `not in`）

fruits = ["苹果", "香蕉", "橙子"]

print("香蕉" in fruits)  # 输出：True（存在）
print("芒果" not in fruits)  # 输出：True（不存在）

2. 查找元素索引（`index()`）

查找元素的 第一个匹配项 的索引；
元素不存在会报错，建议先通过 in 判断。

fruits = ["苹果", "香蕉", "橙子", "香蕉"]

# 查找"香蕉"的第一个索引
print(fruits.index("香蕉"))  # 输出：1

# 查找索引2之后的"香蕉"（start参数）
print(fruits.index("香蕉", 2))  # 输出：3

# 元素不存在报错，避免方式：
if "芒果" in fruits:
    print(fruits.index("芒果"))
else:
    print("元素不存在")

3. 统计元素出现次数（`count()`）

nums = [1, 2, 2, 3, 3, 3, 4]

print(nums.count(2))  # 输出：2（2出现2次）
print(nums.count(3))  # 输出：3（3出现3次）
print(nums.count(5))  # 输出：0（元素不存在，返回0）

4. 获取列表长度（`len()`）

fruits = ["苹果", "香蕉", "橙子"]
print(len(fruits))  # 输出：3

五、列表的排序与反转

1. 排序（`sort()` / `sorted()`）

list.sort()：原地排序（修改原列表），无返回值；
sorted(list)：生成新列表（不修改原列表），返回排序后的新列表；
支持 reverse=True 降序排序，默认升序。

nums = [3, 1, 4, 1, 5, 9, 2]

# 1. sort()：原地升序排序（原列表改变）
nums.sort()
print(nums)  # 输出：[1, 1, 2, 3, 4, 5, 9]

# 2. sort(reverse=True)：原地降序排序
nums.sort(reverse=True)
print(nums)  # 输出：[9, 5, 4, 3, 2, 1, 1]

# 3. sorted()：生成新列表（原列表不变）
nums2 = [3, 1, 4]
new_nums = sorted(nums2, reverse=True)
print(new_nums)  # 输出：[4, 3, 1]
print(nums2)     # 输出：[3, 1, 4]（原列表未变）

# 4. 字符串列表排序（按字母顺序）
fruits = ["banana", "apple", "orange"]
fruits.sort()
print(fruits)  # 输出：['apple', 'banana', 'orange']

2. 反转列表（`reverse()`）

原地反转（修改原列表），无返回值：

nums = [1, 2, 3, 4, 5]
nums.reverse()
print(nums)  # 输出：[5, 4, 3, 2, 1]

# 若需保留原列表，用切片反转（生成新列表）
nums2 = [1, 2, 3]
reversed_nums2 = nums2[::-1]
print(reversed_nums2)  # 输出：[3, 2, 1]
print(nums2)           # 输出：[1, 2, 3]（原列表未变）

六、列表的遍历（循环操作）

1. 直接遍历元素（最常用）

fruits = ["苹果", "香蕉", "橙子"]
for fruit in fruits:
    print(fruit)  # 依次输出：苹果、香蕉、橙子

2. 遍历索引和元素（`enumerate()`）

enumerate(list, start=0) 返回 (索引, 元素) 元组，start 可指定起始索引：

fruits = ["苹果", "香蕉", "橙子"]
for idx, fruit in enumerate(fruits, start=1):  # start=1，索引从1开始
    print(f"第{idx}个水果：{fruit}")
# 输出：
# 第1个水果：苹果
# 第2个水果：香蕉
# 第3个水果：橙子

3. 遍历多个列表（`zip()`）

zip(list1, list2) 按索引配对，返回 (list1[i], list2[i]) 元组：

fruits = ["苹果", "香蕉", "橙子"]
prices = [5.9, 3.5, 4.2]

for fruit, price in zip(fruits, prices):
    print(f"{fruit}：{price}元")
# 输出：
# 苹果：5.9元
# 香蕉：3.5元
# 橙子：4.2元

七、列表的其他实用操作

1. 列表拼接（`+`）

生成新列表，不修改原列表：

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

2. 列表重复（`*`）

生成新列表，元素重复指定次数：

nums = [1, 2]
new_nums = nums * 3
print(new_nums)  # 输出：[1, 2, 1, 2, 1, 2]

3. 列表推导式（快速生成列表）

简化列表创建逻辑，语法：[表达式 for 变量 in 可迭代对象 if 条件]

# 1. 生成1~10的平方列表
squares = [x*x for x in range(1, 11)]
print(squares)  # 输出：[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# 2. 筛选偶数（条件判断）
evens = [x for x in range(1, 11) if x % 2 == 0]
print(evens)  # 输出：[2, 4, 6, 8, 10]

# 3. 处理字符串列表（转大写）
fruits = ["apple", "banana"]
upper_fruits = [fruit.upper() for fruit in fruits]
print(upper_fruits)  # 输出：['APPLE', 'BANANA']

八、列表操作的注意事项

索引越界：访问索引超过 len(list)-1 会报错，需先判断长度或用 try-except 捕获；
remove() 只删第一个匹配项：若列表有重复元素，需循环删除或用列表推导式；
sort() 原地修改：若需保留原列表，用 sorted()；
列表是可变类型：作为函数参数时，修改会影响原列表（传引用）；
嵌套列表操作：修改嵌套列表的元素需访问到内层列表，例如：

nested = [[1, 2], [3, 4]]
nested[0][1] = 20  # 修改内层列表的元素
print(nested)  # 输出：[[1, 20], [3, 4]]

总结

列表的常用操作可归纳为 “创建-访问-增删改-统计-排序-遍历” 七大场景，核心重点：

索引和切片是访问列表的基础；
append()/extend()/insert() 用于添加元素；
del/remove()/pop() 用于删除元素；
sort()/reverse() 用于排序反转；
列表推导式是高效生成列表的技巧。

掌握这些操作，就能应对 Python 中 90% 以上的列表使用场景，也是后续学习数据处理、算法的基础。

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

python

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

python

登录后参与评论

0 条评论

热度