前言

如果说字符串是文本处理一把手，那列表list绝对是Python万能容器。存数字、存文字、存嵌套数组、爬虫存数据、算法存中间结果，写代码三天两头就要和列表打交道。很多新手分不清append/extend，分不清sort和sorted，删除元素疯狂踩索引移位的坑，还搞不懂列表可变和字符串不可变的巨大差别。今天一次性把列表定义、索引、切片、遍历、全部内置方法讲透，搭配可直接运行的案例，逻辑严谨、语言轻松，新手老手都能收藏备查！

一、列表基础：列表是什么（重点：列表是可变序列）

1. 定义方式

列表使用方括号[]包裹，内部元素用逗号分隔，支持存放任意类型数据：数字、字符串、布尔值、嵌套列表全都能塞。

# 空列表
lst1 = []
基础单类型列表
lst2 = [10, 20, 30, 40]
混合类型列表
lst3 = ["张三", 18, True, 3.14]
二维嵌套列表（矩阵常用）
lst4 = [[1,2], [3,4], [5,6]]

核心特性：列表是可变序列（和字符串形成鲜明对比）

这是列表和字符串最本质的区别：字符串创建后不能修改单个字符；列表支持原地增、删、改，所有操作直接修改原列表，不用接收返回值。

lst = [10, 20, 30]
直接通过索引修改元素，合法操作
lst[0] = 999
print(lst)  # [999, 20, 30]

后面所有插入、删除、排序、反转方法，几乎都是原地修改，不用赋值接收，牢记这个底层逻辑。

二、索引：精准取出/修改单个元素

列表和字符串共享同一套索引规则：

1. 正向索引：从左往右，从0开始递增
2. 反向索引：从右往左，从-1开始递减
3. 支持读取 + 修改元素（可变特性专属）
4. 索引超出列表长度，直接抛出IndexError报错

lst = ["x", "b", "a", "a"]
print(lst[0])   # x
print(lst[-1])  # a
修改指定位置元素
lst[1] = 666
print(lst)

三、切片：截取一段子列表

切片语法和字符串完全一致：lst[start:end:step]

• start：起始下标（包含），默认0
• end：终止下标（不包含），默认列表末尾
• step：步长，负数可实现倒序截取

切片会生成全新列表，不会改动原列表；就算下标越界也不会报错，自动截断边界。

lst = [1,2,3,4,5,6,7]
print(lst[1:4])     # [2,3,4]
print(lst[::-1])    # 列表整体反转切片
print(lst[:3])      # 取前3个元素

四、遍历列表，两种主流写法

日常循环处理列表元素分两种场景，按需选用：

1. 只取元素（最简单）

lst = [10, 20, 30]
for item in lst:
    print(item)

2. 同时获取下标+元素（修改、定位必备）

lst = ["a", "b", "c"]
for index in range(len(lst)):
    print(index, lst[index])

拓展案例：遍历二维嵌套列表

datas = [
    [1, 5, 2],
    [5, 9, 3],
    [2, 8, 7]
]
双层循环遍历二维列表所有数字
max_value = datas[0][0]
for row in datas:
for col in row:
if col > max_value:
max_value = col
print("二维列表最大值：", max_value)

五、列表全套内置常用方法（全文核心，分类讲解）

所有方法分为五大类：查找统计、插入新增、删除清除、反转排序、拷贝，附带踩坑说明与完整代码示例。

5.1 查找与统计：index() / count()

index(目标元素)

返回列表中第一个匹配元素的索引；列表不存在该元素直接报错，稳妥使用前建议用in判断。

lst = ["x", "b", "a", "a"]
print(lst.index("a"))  # 输出2，第一个a的下标
规避报错写法
if "z" in lst:
print(lst.index("z"))
else:
print("列表无该元素")

count(目标元素)

统计元素在列表中出现的总次数，不存在返回0，不会报错。

lst = ["a", "b", "a", "a"]
print(lst.count("a"))  # 3
print(lst.count("z"))  # 0

5.2 插入元素三大方法：append / insert / extend

三者功能天差地别，新手最容易混淆，对比记忆：

1. append(obj)：在列表末尾整体追加一个元素，不管传入数字、字符串、列表，统一当成单个内容塞进尾部
2. insert(index, obj)：在指定下标位置插入元素，原位置及后面所有元素整体后移
3. extend(可迭代对象)：把字符串、列表等可迭代对象拆分单个元素，依次追加到列表尾部

datas = [1, 2, 3]
datas.append(4)          # 末尾加数字4
datas.insert(0, "a")    # 下标0插入字符串a
datas.insert(3, 2.5)    # 下标3插入浮点数
datas.extend([5, 6, 7]) # 拆分列表逐个添加
datas.extend("xyz")     # 拆分字符串x y z依次添加
print(datas)

5.3 删除与清空：pop / remove / clear

pop()

不传参数：删除列表最后一个元素，并且返回被删掉的值

传索引pop(index)：删除指定下标元素，返回删除内容

datas = [1, 2, 3, 4]
res = datas.pop()
print("删除的末尾元素：", res, "剩余列表：", datas)
res = datas.pop(0)
print("删除首位元素：", res, "剩余列表：", datas)

remove(值)

根据元素内容删除第一个匹配项；列表无该元素直接报错，建议搭配in判断使用。

if 25 in datas:
    datas.remove(25)
print(datas)

clear()

一键清空列表内所有元素，最终得到空列表[]

# datas.clear()
# print(datas)

5.4 反转与排序：reverse() / sort()

两个方法均为原地修改列表，无返回值

1. reverse()：直接颠倒列表元素顺序，不做大小比较，单纯反转
2. sort()：对列表元素升序排序；传入reverse=True变为降序排序

datas = [1, 5, 2, 9, 5, 6, 4]
datas.reverse()
print("反转后：", datas)
datas.sort()
print("升序排序：", datas)
datas.sort(reverse=True)
print("降序排序：", datas)

5.5 浅拷贝 copy()

列表是可变对象，直接赋值只会创建引用，修改一个另一个同步变化；copy()生成一份全新列表，互不干扰。

old_lst = [10, 20, 30]
new_lst = old_lst.copy()
old_lst[0] = 999
print(old_lst)  # [999,20,30]
print(new_lst)  # [10,20,30] 拷贝不受原列表修改影响

六、实战小案例（巩固列表操作）

案例1：手动求列表最大、最小值

不用内置max()/min()，纯循环实现，理解遍历逻辑

datas = [50, 40, 80, 60, 10, 30]
max_value = min_value = datas[0]
for num in datas[1:]:
if num > max_value:
max_value = num
if num < min_value:
min_value = num
print("最大值：", max_value, "最小值：", min_value)

案例2：原地反转列表（不使用reverse方法）

利用下标对称交换，底层理解反转原理

datas = [10, 50, 20, 60, 80, 20, 90]
for i in range(len(datas) // 2):
# 首尾对称交换
datas[i], datas[len(datas)-1-i] = datas[len(datas)-1-i], datas[i]
print("手动反转结果：", datas)

七、文末总结

1. 核心区分：列表是可变序列，支持原地增删改；字符串不可变，所有操作生成新对象；
2. 索引切片规则和字符串通用，但列表索引支持赋值修改元素；
3. 插入三兄弟分清：append整体追加、insert定点插入、extend拆分追加；
4. 删除分两种逻辑：pop按下标删、remove按值删；
5. reverse单纯颠倒顺序，sort做大小排序，均原地修改无需接收返回值；
6. 多列表共存记得用copy()拷贝，避免引用同步修改的坑。