1. 列表在Python里的地位，为什么内置方法值得系统过一遍
先说说我自己的经历。几年前我第一次用Python写数据处理脚本时，面对列表只知道往里面塞数据然后for循环遍历，直到有一天需要从列表里“按值删除一个元素”却突然卡住，才意识到自己对列表内置方法的了解有多碎片化。后来系统性捋了一遍，发现很多写法能简化到让人拍大腿的程度，代码阅读性和运行效率都上了一个台阶。
列表（list）在Python里是最灵活、最常用的容器类型，没有之一。无论是写爬虫时暂存抓到的URL，做数据分析时收集处理后的结果，还是算法题里维护一个动态序列，几乎离不开列表。它本质上是动态数组：支持任意类型混存、支持索引访问、支持切片，而且容量可以自动扩展。这套“开箱即用”的能力，很大程度上来自它内置的那十几个方法。
你可能会问：这些方法我一个个查文档不就行了？话是这么说，但实际项目里真正容易出问题的恰恰是方法之间的细微差别。比如append和extend都能“往里加东西”，但加进去的结构完全不同；remove和pop都能“删”，但一个按值删、一个按下标删、返回结果也完全不同；sort和sorted从名字到效果都很像，但一个是原地修改、一个是返回新列表。这些细节如果不搞清楚，往往写到第50行代码时突然出现诡异的结果。
所以这篇笔记不是单纯罗列方法名，而是按使用场景把列表的内置方法梳理成几条主线，配合实际代码演示每个方法的效果和边界。整篇文章围绕这个分类展开：
- 增加元素：
append、extend、insert - 删除元素：
remove、pop、clear - 查找与统计：
index、count - 排序与反转：
sort、reverse、sorted、reversed - 拷贝与生成：
copy、list()构造函数
最后我会单独讲几个我在实际开发中踩过的坑，尤其是循环中删除元素、浅拷贝陷阱、以及pop(0)的性能问题。这些都是文档里不会明说、但上线后一定会遇到的细节。
我默认你已经了解列表的基本定义方式，比如nums = [1, 2, 3]这种。如果你是完全零基础，建议先掌握for循环和函数的概念再来看这篇，会更顺畅一些。
2. 增加元素的三板斧：append、extend、insert的适用与混淆
2.1 append是“整个塞进去”，extend是“拆开逐个放进去”
append和extend是初学者最容易搞混的一对，原因很简单：表面上看，它们都能把一个列表加到另一个列表后面。但结果差别很大。
a = [1, 2, 3] a.append([4, 5, 6]) print(a) # [1, 2, 3, [4, 5, 6]] b = [1, 2, 3] b.extend([4, 5, 6]) print(b) # [1, 2, 3, 4, 5, 6]注意到区别了吗？append把参数当成一个完整的对象塞进列表末尾，哪怕参数本身是一个列表，它也只占一个位置；extend则会把参数里每个元素拆出来，依次追加到末尾。用生活类比来说：append像是把一个外卖盒原封不动放进冰箱，extend则像是把外卖盒里的菜一道道端出来摆到冰箱隔层里。
这个区别在写数据处理逻辑时至关重要。比如你有一个列表存储所有学生的成绩，现在来了一个新学生，他的各科成绩是一个列表，你应该用append把整份成绩单作为一个条目存进去；但如果你有一批新成绩需要合到总表里，就应该用extend把它们逐条合并。
还有一个隐藏细节：如果extend传进去的是一个字符串，它会按字符拆开。这提醒我们，extend的参数必须是一个可迭代对象，字符串、元组、集合都可以，但单个整数不行，会直接抛TypeError。所以在调用前最好确认一下参数的类型。
2.2 insert：指定位置的“插队”
append和extend都只能在末尾操作，但有时候我们需要在列表中间某个位置插入元素，这时就用insert。
tasks = ["写周报", "开会", "下班"] tasks.insert(1, "回复邮件") print(tasks) # ['写周报', '回复邮件', '开会', '下班']insert的第一个参数是索引位置，第二个参数是要插入的值。插入后，原位置及之后的元素都会自动后移一位。这里有几个边界情况值得记住：
- 如果索引是负数，比如
-1，表示在倒数第一个元素之前插入，结果等价于插入到末尾前一个位置。 - 如果索引大于列表长度，Python不会报错，而是直接把元素追加到末尾，行为等同于
append。 - 如果索引小于负的列表长度，元素会被插入到列表头部。
nums = [10, 20, 30] nums.insert(-1, 25) print(nums) # [10, 20, 25, 30] nums = [10, 20, 30] nums.insert(100, 40) print(nums) # [10, 20, 30, 40]有一点要注意：insert在列表中间插入元素时，后续元素整体平移，这是一个O(n)操作。如果你需要频繁在头部或中间插入，列表并不是合适的数据结构，后面我会专门聊性能问题。
2.3 三种方式的选型建议
总结一下我的使用经验。绝大部分场景下，append是首选，因为它语义最清晰、性能是O(1)；extend用在两个列表合并的场景；insert尽量少用，除非你确定插入位置不会频繁变动。如果一段代码里需要多次在头部插入元素，我会停下来想一想是不是该换collections.deque了。
还有一个容易忽略的操作：直接用加法合并列表。a + b生成一个新列表，a.extend(b)修改原列表。如果你的业务逻辑希望保留原列表不变，选加法；希望原列表直接扩展，用extend。从内存效率看，extend因为复用原列表的存储空间，通常比创建新列表更省。
3. 删除与清空：remove、pop、clear各自解决了什么问题
3.1 remove：按值删除，但只删第一个匹配项
remove的作用是按值删除元素。你告诉它“把这个值删掉”，它会从索引0开始向后查找第一个匹配的元素并删除。
colors = ["red", "green", "blue", "green"] colors.remove("green") print(colors) # ['red', 'blue', 'green']注意，它只删第一个匹配项。列表里还有一个"green"，如果没有后续再次调用remove，它就会一直留在列表里。这个行为在数据清洗时很常见：你想把所有等于某个值的元素都删掉，循环里反复调用remove，但这样容易踩坑，我在第6节详细展开。
还有一个非常关键的边界：如果值不存在，remove会抛出ValueError。这个异常信息是list.remove(x): x not in list。实际开发中，删除前最好先用in判断一下，或者用try/except包住：
if "purple" in colors: colors.remove("purple")这样做的好处是避免程序因为一个不存在的值直接崩溃。
3.2 pop：按下标删除，并且返回被删除的值
pop和remove不一样，它按索引位置删除，而且会返回被删除的这个值。如果不传参数，默认删除最后一个元素：
stack = [1, 2, 3, 4] last = stack.pop() print(stack) # [1, 2, 3] print(last) # 4 stack.pop(0) print(stack) # [2, 3]这个“删除后返回被删值”的特点让pop非常适合实现一些需要“取出来”的场景。比如任务队列处理：你有一个待处理URL列表，每次从末尾取一个URL出来请求，处理完就丢弃，天然用pop()实现。再比如撤销功能：每次操作后把状态压栈，需要撤销时用pop弹出来。
pop结合append使用，可以轻松实现栈（后进先出）和队列（先进先出）。
# 栈：后进先出 stack = [] stack.append("A") stack.append("B") stack.append("C") while stack: print(stack.pop()) # C B A # 队列：先进先出，注意用pop(0)性能较差 queue = [] queue.append("A") queue.append("B") while queue: print(queue.pop(0)) # A B从性能角度说，pop()在末尾删除是O(1)，非常快；pop(0)在头部删除是O(n)，因为后续元素都要前移。如果你需要频繁从头部弹出元素，建议用collections.deque，它的popleft()是O(1)。
3.3 clear：一键清空列表
clear方法的作用是移除列表中所有元素，让列表变成空列表[]。注意，它是原地操作，不返回新列表，也没有返回值。
nums = [1, 2, 3] nums.clear() print(nums) # []有人可能会问：nums = []和nums.clear()有什么区别？区别在于是否修改原对象。nums = []是重新绑定一个新列表对象，如果其他变量还引用着原列表，它们仍然指向旧列表；而nums.clear()直接清空原列表的内容，所有引用这个列表的变量看到的都是空列表。这个区别在函数传参时尤其容易出问题：
def reset(lst): lst.clear() data = [1, 2, 3] reset(data) print(data) # []如果函数里写成lst = []，外部变量data并不会变成空列表。所以在设计“清空某个列表”的操作时，clear更符合直觉。
3.4 del语句与删除方法的配合
除了三个内置方法，还有一个del语句也常用于删除。del的灵活性很高，可以按索引删除单个元素，可以按切片删除一段元素，甚至可以删除整个变量。
nums = [10, 20, 30, 40, 50] del nums[1] # 删除索引1的元素 print(nums) # [10, 30, 40, 50] del nums[1:3] # 删除索引1到2的元素 print(nums) # [10, 50] del nums # 删除整个变量del和pop最大的区别是：del不返回值，你没有机会拿到被删除的元素。所以如果你需要“把元素取出来再用”，用pop；如果只是单纯删除，del或remove都可以。另外del对切片的高效操作是列表方法里做不到的，比如一次性删除前100个元素，del lst[:100]就干净利落。
4. 查找与统计：index、count和in操作符的正确搭配
4.1 index：查找元素位置，注意异常处理
index(value)方法返回列表中第一个值为value的索引位置。它和remove一样能接收一个可选的范围参数：index(value, start, end)，只在指定区间内查找。
nums = [5, 3, 8, 3, 9, 3] print(nums.index(3)) # 1 print(nums.index(3, 2)) # 3，从索引2开始找 print(nums.index(3, 4, 6)) # 5，在索引4到5之间找使用index最常见的坑是元素不存在时会抛ValueError。所以一个稳健的写法是：
if 3 in nums: pos = nums.index(3)这种写法其实做了两次查找，第一次是in，第二次是index，性能略差。如果你追求效率，可以用try/except：
try: pos = nums.index(3) except ValueError: print("元素不存在")如果涉及到查找大量元素的位置，另一种思路是使用enumerate构建一个“值到索引”的字典，把查找复杂度从O(n)降到O(1)。当然，前提是列表中没有重复元素，或者你能接受后者覆盖前者。
4.2 count：统计出现次数
count(value)返回指定值在列表中出现的次数。如果元素不存在，返回0，不会抛异常。
grades = ["优", "良", "中", "优", "优"] print(grades.count("优")) # 3 print(grades.count("差")) # 0count在数据清洗、分析文本中某个词出现频率时非常实用。比如统计一篇英文文章里每个单词出现的次数，可以先split成列表，再对每个目标词count。要统计全部元素的频次时，更推荐用collections.Counter，它一次性统计所有元素，性能更好，代码也更简洁。
一个组合技巧：nums.index(nums.max())配合count可以快速找到最大值的位置；如果最大有多个，可以先count再结合循环找所有位置。
4.3 in操作符：最常用的存在性判断
严格来说in不是列表的内置方法，而是Python成员运算符，但它在查找场景里实在太常用了，值得放在一起说。in判断一个值是否在列表里，返回True或False。
if "python" in skills: print("会用Python")从时间复杂度看，in对列表是O(n)线性扫描。如果列表长度很大（几万、几十万），频繁使用in会明显拖慢速度。这种场景建议把列表转成集合（set），集合的成员判断是O(1)：
skills_set = set(skills) if "python" in skills_set: print("会用Python")4.4 切片：列表最强大的特性，与index/count结合
切片（slice）允许你快速截取列表的一部分，语法是lst[start:end:step]，规则是左闭右开。它不是方法，而是语法糖，但在理解和处理列表时是不可或缺的。
nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] print(nums[2:5]) # [2, 3, 4] print(nums[:4]) # [0, 1, 2, 3] print(nums[6:]) # [6, 7, 8, 9] print(nums[::2]) # [0, 2, 4, 6, 8] print(nums[::-1]) # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]切片返回的是一个新的列表，不修改原列表。但如果用lst[:] = new_list这种形式，可以原地替换切片的元素：
nums[2:5] = [20, 30] print(nums) # [0, 1, 20, 30, 5, 6, 7, 8, 9]注意，nums[::-1]虽然能实现反转，但它生成一个新列表，如果你只想要反转后的结果并且不关心内存，可以使用；如果希望原地反转，应该用reverse()方法。
切片在数据处理中经常配合index和count使用。比如你找到了某个元素的索引位置，然后想提取它前后的元素序列，切片就是最自然的操作。再比如你要把列表按固定窗口切块分析，lst[offset:offset+window]这种写法非常典型。
5. 排序与反转：sort、sorted、reverse、reversed的适用场景
5.1 sort：原地排序，内存友好
sort是列表专属的排序方法，它直接修改原列表，不返回新列表。默认按升序排列，支持reverse=True参数切换到降序，更强大的是支持key参数指定排序依据。
nums = [3, 1, 4, 1, 5, 9, 2, 6] nums.sort() print(nums) # [1, 1, 2, 3, 4, 5, 6, 9] words = ["banana", "apple", "cherry", "date"] words.sort(key=len) print(words) # ['date', 'apple', 'banana', 'cherry'] words.sort(key=len, reverse=True) print(words) # ['banana', 'cherry', 'apple', 'date']key参数是sort的灵魂。你可以传一个函数，让排序基于这个函数的返回值。比如按字符串长度、按元组某个元素、按对象的某个属性排序。这正是热词里“多维列表排序某一个位置的值”的核心解法。
假设有一个学生列表，每个学生是(姓名, 成绩)元组，你想按成绩降序排序：
students = [ ("张三", 89), ("李四", 76), ("王五", 93), ] students.sort(key=lambda x: x[1], reverse=True) print(students) # [('王五', 93), ('张三', 89), ('李四', 76)]这里lambda x: x[1]的意思是“取每个元素（元组）的第二个分量作为排序依据”。你完全可以根据需求换成x[0]按姓名排序，或换成其他维度。
如果你的数据是多维列表，比如每行代表一条记录，每列代表一个字段，想按某列排序，一样的思路：
data = [ [3, 9], [1, 7], [2, 5], ] data.sort(key=lambda row: row[1]) print(data) # [[2, 5], [1, 7], [3, 9]]sort是稳定排序，意思是值相同的元素会保持原来的相对顺序。这在多级排序场景中很有用：先按成绩排序，再按姓名排序，只需连续调用两次sort，第二次的key优先级更高。
5.2 sorted：返回新列表，不修改原数据
sorted是一个内置函数，接收任意可迭代对象，返回一个排好序的新列表，原数据保持不变。
nums = [3, 1, 4, 1, 5] sorted_nums = sorted(nums) print(nums) # [3, 1, 4, 1, 5] print(sorted_nums) # [1, 1, 3, 4, 5]sorted同样支持key和reverse参数。它比sort更通用，可以对字典（按键排序）、集合（转成列表排序）等不可变序列使用。
选择sort还是sorted的场景很明确：如果我需要保留原列表不变，或者排序对象本身不是列表，用sorted；如果数据结构是列表，且确定原列表的引用需要被其他代码继续使用、不介意顺序被改变，用sort，因为sort不需要创建新列表，内存占用更小，大数据量时优势明显。
5.3 reverse和reversed：原地反转与新列表
reverse()是列表方法，原地反向排列元素，不返回新列表：
nums = [1, 2, 3, 4, 5] nums.reverse() print(nums) # [5, 4, 3, 2, 1]reversed是内置函数，返回一个反向迭代器，需要用list()包装才能得到列表，或者直接用for循环遍历：
nums = [1, 2, 3, 4, 5] for x in reversed(nums): print(x) # 5 4 3 2 1 rev_list = list(reversed(nums)) print(rev_list) # [5, 4, 3, 2, 1]reversed不修改原列表，也不生成完整的副本，内存友好。如果你只想做一次反向遍历，reversed是最佳选择；如果你要得到一个反转后的列表副本，list(reversed(lst))或者lst[::-1]都可以；如果你要原地反转并让其他引用也看到变化，用reverse()。
5.4 一个综合案例：按多维度排序成绩单
这里我写一个实际项目里可能会遇到的综合示例。假设有一个学生成绩表，每行包含姓名、数学成绩、语文成绩，需求是先按数学成绩降序，数学相同再按语文成绩降序。
scores = [ ("张三", 90, 80), ("李四", 90, 95), ("王五", 88, 92), ("赵六", 90, 88), ] # 方案一：key函数返回元组，先比较第一个元素，相同再比较第二个 scores.sort(key=lambda x: (x[1], x[2]), reverse=True) for s in scores: print(s) # ('李四', 90, 95) # ('张三', 90, 80) # ('赵六', 90, 88) # 呃，这里其实不对，继续看 # ('王五', 88, 92) # 方案一输出的顺序是：按数学降序，数学相同时按语文降序 # 正确的完整顺序应该是： # ('李四', 90, 95) # ('赵六', 90, 88) # ('张三', 90, 80) # ('王五', 88, 92)等等，我上面这个代码里的输出注释写得有问题。如果用reverse=True，它会把整个元组都按逆序比较，数学相同的情况下，语文成绩变成降序，数学不同时数学是降序。所以正确顺序是李四(90,95)、赵六(90,88)、张三(90,80)、王五(88,92)。我刚在注释里写的顺序才是对的，但第一段输出里的顺序是错的，这里重新整理一下避免误导。
scores.sort(key=lambda x: (x[1], x[2]), reverse=True) for s in scores: print(s) # ('李四', 90, 95) # ('赵六', 90, 88) # ('张三', 90, 80) # ('王五', 88, 92)这个技巧非常实用，特别是处理表格类数据时。如果你需要让某个维度升序、另一个维度降序，就不能直接reverse=True了，因为reverse对所有维度都生效。你可以对数值字段取负值来实现混合方向排序：
# 数学降序，语文升序 scores.sort(key=lambda x: (-x[1], x[2]))这类写法在炒股、比赛排名、报表排序等场景里特别常见。
6. 拷贝列表：copy方法与浅拷贝的陷阱
6.1 copy()：表面拷贝背后的引用共享
copy()方法返回列表的浅拷贝，意思是最外层列表是新的，但列表里的元素如果是可变对象（比如嵌套列表、字典），这些内部对象仍然是原对象的引用。
a = [1, 2, 3] b = a.copy() b.append(4) print(a) # [1, 2, 3] print(b) # [1, 2, 3, 4]单层列表的拷贝看起来一切正常。但一旦列表里装了嵌套列表，问题就来了：
a = [[1, 2], [3, 4]] b = a.copy() b[0][0] = 99 print(a) # [[99, 2], [3, 4]] print(b) # [[99, 2], [3, 4]]我只改了b里的元素，a却跟着变了。原因就是copy()只复制了外层列表，内层[1, 2]这个子列表还是同一个对象，a和b共享它。
6.2 deepcopy：彻底复制嵌套结构
如果你需要完全独立的副本，包括所有嵌套对象，必须用copy模块的deepcopy：
import copy a = [[1, 2], [3, 4]] b = copy.deepcopy(a) b[0][0] = 99 print(a) # [[1, 2], [3, 4]] print(b) # [[99, 2], [3, 4]]deepcopy会递归复制所有层级的对象，内存消耗更大，但保证独立性。在数据处理、爬虫、配置管理等场景里，如果你要把一份列表作为模板反复加工，务必考虑是否需要deepcopy。
6.3 简单赋值、切片拷贝、list()之间的区别
除了copy()，还有几种方式也能产生新列表：
a = [1, 2, 3] b = a # 简单赋值，b和a指向同一个列表 c = a[:] # 切片拷贝，浅拷贝 d = list(a) # 构造函数，浅拷贝 e = a.copy() # copy方法，浅拷贝 a.append(4) print(b) # [1, 2, 3, 4] b受到a影响 print(c) # [1, 2, 3] c不受影响 print(d) # [1, 2, 3] print(e) # [1, 2, 3]关键是区分“简单赋值”和“拷贝”。b = a不是拷贝，它只是让b和a指向同一个对象，任何一方修改都会影响另一方；c = a[:]、d = list(a)、e = a.copy()都是浅拷贝，外层独立，内层共享。很多坑就是从这个区别开始的。
6.4 拷贝的实际应用与内存注意
实际开发中，使用拷贝最常见的场景是函数参数。Python函数参数是按引用传递的，你在函数内修改列表，外部变量也会变。如果不希望外部数据被修改，可以在函数内先copy一份再操作：
def process(data): data = data.copy() # 保护外部数据 data.append("processed") return data还有一个高频场景：需要基于一个列表生成多个不同的排序或筛选结果，这时候原列表不能动，所有结果都要从拷贝派生。我记得有一次写报表脚本，对一份原始数据先按销售额排序、再按销量筛选，如果直接操作原列表，后面所有计算全乱了，后来用copy加sorted才理顺。
关于内存：deepcopy很耗资源，能用浅拷贝就不用深拷贝。在调试时可以通过id()函数确认两个变量是否指向同一个对象。掌握这几个拷贝方法，能帮你避免大量“改了A却影响了B”的诡异问题。
7. 列表方法之外的进阶玩法：推导式与in-place操作
7.1 列表推导式：一行代码替代循环+append
列表推导式不是“内置方法”，但它和列表搭配起来非常顺手，以至于很多Python教程会把它们放在一起讲。推导式的基本语法是[表达式 for 变量 in 可迭代对象 if 条件]。
nums = [1, 2, 3, 4, 5, 6] squares = [n * n for n in nums] even_squares = [n * n for n in nums if n % 2 == 0] print(squares) # [1, 4, 9, 16, 25, 36] print(even_squares) # [4, 16, 36]这个写法和下面的循环完全等价，但更简洁：
squares = [] for n in nums: squares.append(n * n)我实际写代码时，如果只是简单的映射或过滤，几乎都直接用推导式，因为它可读性好，执行速度也比for循环加append略快。不过如果逻辑复杂到超过两三层嵌套，推导式反而难读懂，我会回到普通循环。
7.2 推导式与内置方法的组合
推导式可以和前面讲到的内置方法组合出很多巧妙的写法。比如统计成绩大于90的人数：
count = len([s for s in scores if s[1] > 90])快速把二维列表“拍平”成一位列表：
matrix = [[1, 2], [3, 4], [5, 6]] flat = [x for row in matrix for x in row] print(flat) # [1, 2, 3, 4, 5, 6]对列表去重并保持顺序：
nums = [1, 3, 2, 1, 3, 4, 2] seen = set() unique = [x for x in nums if not (x in seen or seen.add(x))] print(unique) # [1, 3, 2, 4]这几种写法在实际项目中能大大精简代码量。当然，去重也可以用list(set(nums))，但那样会丢失顺序，所以推导式在“保持顺序去重”的场景里是更优解。
7.3 原地修改与返回新对象的思维习惯
Python中有一个重要的区分：某些方法修改原对象（原地操作），某些方法返回新对象。列表内置方法里，append、extend、insert、remove、pop、clear、sort、reverse都是原地操作，返回None；而copy()、list()、切片、sorted()返回新对象。
这个区别虽然基础，但我在写代码时经常看到“重新发明轮子”的写法：
# 错误示例：sort后还想用返回值 lst = [3, 1, 2] new_lst = lst.sort() # new_lst是None！正确写法应该是lst.sort()后再使用lst，或者用sorted(lst)得到新列表。养成“先判断这个方法返回什么”的习惯，能帮你节省大量调试时间。
7.4 enumerate与zip：遍历时的黄金搭档
严格说enumerate和zip也是内置函数而非列表方法，但它们和列表的配合无处不在。遍历列表时既需要索引又需要值，用enumerate：
names = ["张三", "李四", "王五"] for i, name in enumerate(names): print(i, name) # 0 张三 # 1 李四 # 2 王五并行遍历两个列表，用zip：
names = ["张三", "李四"] scores = [89, 76] for name, score in zip(names, scores): print(name, score) # 张三 89 # 李四 76这些组合虽然不是“内置方法”本身，但在处理列表时几乎形影不离。把它们也纳入你的列表工具箱，会顺手很多。
8. 实测翻车现场：循环删除、pop(0)性能与可变默认参数
8.1 循环中删除元素的经典翻车
先说一个高频错误：在for循环遍历列表时，直接用remove或pop删除元素。这段代码很多人写过：
nums = [1, 2, 3, 4, 5, 6] for n in nums: if n % 2 == 0: nums.remove(n) print(nums) # [1, 3, 5] 看着没问题？看起来结果对了，但如果换成不同的数据，问题就暴露了：
nums = [1, 2, 2, 3, 4] for n in nums: if n == 2: nums.remove(n) print(nums) # [1, 2, 3, 4] 期望是[1, 3, 4]，但2没删干净为什么？因为for循环是按索引递增遍历的。当你在遍历过程中删除元素，列表长度变化、所有后续元素索引前移，循环会跳过紧跟在被删元素后面的那个元素。[1, 2, 2, 3, 4]第一次删除索引1的2后，原索引2的2变成了索引1，但循环已经走到索引2，于是这个2被跳过。
解决这个问题有三种常见方案：
方案一：遍历副本，删除原列表
nums = [1, 2, 2, 3, 4] for n in nums.copy(): if n == 2: nums.remove(n) print(nums) # [1, 3, 4]方案二：倒序遍历
nums = [1, 2, 2, 3, 4] for i in range(len(nums) - 1, -1, -1): if nums[i] == 2: nums.pop(i) print(nums) # [1, 3, 4]方案三：用列表推导式创建新列表（推荐）
nums = [1, 2, 2, 3, 4] nums = [n for n in nums if n != 2] print(nums) # [1, 3, 4]我自己的习惯是，能不用循环删除尽量不用；如果数据量不大，最推荐推导式，因为它没有副作用，可读性也最好。
8.2 pop(0)的性能陷阱与deque替代方案
另一个容易忽略的性能问题是从列表头部频繁删除或插入。我已经在前面提过pop(0)是O(n)，insert(0, x)也是O(n)。如果数据量小无所谓；数据量上来后（比如几万、几十万元素），这个差异会非常明显。
我做过一个简单测试，对一个10万元素的列表，反复从头部pop和从尾部pop，耗时差距可以达到几百倍。原因就是列表是连续内存结构，头部操作需要整体搬迁。
如果业务逻辑需要频繁从两端操作，推荐用collections.deque：
from collections import deque dq = deque([1, 2, 3, 4]) dq.appendleft(0) # 头部插入，O(1) left = dq.popleft() # 头部弹出，O(1) dq.append(5) # 尾部插入，O(1) right = dq.pop() # 尾部弹出，O(1)deque支持下标访问，但不支持切片、sort等列表方法。所以在需要切片和排序时还是要转回列表。实际项目中我的经验是：队列、双端队列场景用deque，普通数据操作场景用list，不要为了一个pop(0)去牺牲列表的其他便利性。
8.3 可变默认参数：列表做函数默认值的大坑
这也是一个和列表相关的经典坑，虽然不是内置方法，但和列表作为可变对象息息相关。
def add_task(task, task_list=[]): task_list.append(task) return task_list print(add_task("写代码")) # ['写代码'] print(add_task("写文档")) # ['写代码', '写文档']第二次调用时，task_list默认值仍然是第一次调用时的同一个列表，所以"写文档"被加进去了。这个问题的根源在于：默认参数在函数定义时只评估一次，并且默认值是一个可变对象。
正确做法是使用不可变默认值，在函数内部初始化：
def add_task(task, task_list=None): if task_list is None: task_list = [] task_list.append(task) return task_list这个问题在日常开发中非常隐蔽，尤其是调试的时候，你可能完全想不到上次调用的数据会影响下一次。类似的还有把列表作为class属性、作为全局变量等，都要格外小心。
8.4 列表的内存占用与预分配注意事项
列表是动态数组，当append导致容量不足时，Python会申请更大的内存空间，并把原数据复制过去。这个过程是自动的，但频繁扩容会带来性能损耗。好在Python的列表扩容策略比较聪明，是按比例增长的，所以多数场景下你不需要手动优化。
但如果你知道列表最终会是一个很大的规模，可以提前用列表乘法或者推导式预分配空间，减少扩容次数：
# 预分配固定长度的占位列表 n = 10000 data = [0] * n # 或者用推导式初始化 data = [i * i for i in range(n)]不过，预分配也可能造成内存浪费，如果实际存不满，先占的内存不会自动释放。所以我的建议是：数据规模不确定时正常append就好，别过度优化；只有在明确知道规模、且需要极限性能时，才考虑预分配。
8.5 疑似“改了原列表”的各种操作排查
最后整理一个我工作中排查列表问题的清单：
- 如果发现变量A改了之后B也变了，先检查是否用了
b = a简单赋值。 - 如果列表里装了列表或字典，copy之后修改嵌套对象仍然影响原列表，需要deepcopy。
- 如果sort后想要新列表却得到了None，检查是不是把sort当作sorted用了。
- 如果循环删除后还剩元素，检查遍历过程中列表是否位移了。
- 如果函数默认参数是列表，多次调用结果互相污染，检查默认值是否该为None。
这个清单能解决大部分实际遇到的列表相关问题。排查顺序建议是：先看数据是不是同一个对象（用id()），再看是否涉及嵌套可变对象，最后看遍历过程中是否有增删操作。
9. 从“会用列表”到“用好列表”：我的整体建议
列表的内置方法不多，十几个，但组合起来能覆盖几乎所有日常数据处理需求。写这篇文章的过程里，我自己也重新梳理了一遍：方法本身很简单，难的是在合适的场景做出合适的选择。
我给你的建议是分三步走。
第一步，先把增删改查四个基本操作背熟。append、extend、insert负责增；remove、pop、clear负责删；index、count、in负责查；直接索引赋值负责改。这一层能覆盖90%的日常代码。
第二步，掌握排序和拷贝。sort和sorted要分清原地修改与返回新列表；reverse和reversed同理；copy和deepcopy要理解浅拷贝与深拷贝的边界。这些方法的区别是面试题的高频考点，更是实际开发中容易踩坑的地方。
第三步，把切片、列表推导式、enumerate、zip这些“类方法”的能力也纳入工具箱。它们虽然不叫内置方法，但会让你的代码从“能跑”变成“优雅”。尤其是在数据清洗和分析场景里，一个切片加一个推导式往往能替代十几行循环。
列表这东西，你不要觉得会append就会了。我见过很多写了几年Python的老手，还在为sort返回值是None而发懵，也见过不少因为浅拷贝导致数据被污染的线上事故。掌握了方法之后，更重要的是理解Python的对象模型：哪些操作修改原对象，哪些操作返回新对象，哪些拷贝是浅的、哪些是深的。把这些想通了，很多问题不用查文档也能猜出七八分。
最后留一个小练习：试着用列表内置方法和推导式，把一段英文文本按单词出现频率降序排列，并输出频次最高的前10个单词。做完这个练习，你对列表方法、排序、字典互相配合的理解，应该能再扎实不少。
