上一节我们学习了列表的基本概念、索引、切片和元素修改。本节继续学习列表最常用的方法，重点掌握：
append()：在末尾添加一个元素。extend()：在末尾添加多个元素。insert()：在指定位置插入元素。remove()：删除指定值的第一个元素。pop()：删除并返回指定位置的元素。clear()：清空列表。sort()：直接修改原列表并进行排序。sorted()：返回一个新的排序列表，不修改原列表。reverse()：直接反转原列表。index()：查找元素第一次出现的位置。
**核心区别：**有些操作会直接修改原列表，有些操作则会创建并返回一个新的列表。初学阶段尤其要注意这一点。
什么是列表方法？
在 Python 中，列表不仅可以保存数据，还提供了很多可以直接使用的功能。
例如：
numbers = [1, 2, 3]
numbers.append(4)
print(numbers) # [1, 2, 3, 4]
这里的：
append()
就是一个列表方法（List Method）。
可以把方法简单理解成：
属于某个对象，并且可以通过
对象.方法()的形式调用的功能。
基本结构：
列表.方法()
例如：
numbers.append(4)
其中：
| 部分 | 含义 |
|---|---|
numbers |
列表对象 |
. |
访问对象中的成员 |
append |
方法名称 |
(4) |
传入的参数 |
append()：在列表末尾添加一个元素
append() 的作用是：
在列表的末尾添加一个元素。
例如：
numbers = [1, 2, 3, 4, 5]
numbers.append(6)
print(numbers) # [1, 2, 3, 4, 5, 6]
执行过程可以理解为：
原列表：
[1, 2, 3, 4, 5]
↓ append(6)
[1, 2, 3, 4, 5, 6]
append() 一次只能添加一个元素
这里需要特别注意：
numbers = [1, 2, 3]
numbers.append(4)
添加的是一个元素：
4
但是，如果传入一个列表：
numbers = [1, 2, 3]
other = [4, 5, 6]
numbers.append(other)
print(numbers) # [1, 2, 3, [4, 5, 6]]
整个 other 列表会被当成一个元素添加进去。
结果变成：
[
1,
2,
3,
[4, 5, 6]
]
也就是说：
append()不会自动拆开你传入的列表。
extend()：一次添加多个元素
如果希望把另一个列表中的元素逐个添加到当前列表，就可以使用：
extend()
例如：
numbers = [1, 2, 3]
other = [4, 5, 6]
numbers.extend(other)
print(numbers) # [1, 2, 3, 4, 5, 6]
可以理解成：
append():
[1, 2, 3] + [[4, 5, 6]]
结果：
[1, 2, 3, [4, 5, 6]]
而：
extend():
[1, 2, 3] + [4, 5, 6]
结果：
[1, 2, 3, 4, 5, 6]
append() 和 extend() 的区别
这是非常容易混淆的知识点。
| 方法 | 作用 | 示例结果 |
|---|---|---|
append() |
添加一个元素 | [1, 2, 3, [4, 5]] |
extend() |
添加多个元素 | [1, 2, 3, 4, 5] |
例如：
numbers = [1, 2, 3]
numbers.append([4, 5])
print(numbers) # [1, 2, 3, [4, 5]]
而：
numbers = [1, 2, 3]
numbers.extend([4, 5])
print(numbers) # [1, 2, 3, 4, 5]
记忆方法：
append：整个塞进去。
extend：拆开后逐个加入。
insert()：在指定位置插入元素
insert() 用于：
在列表指定的索引位置插入一个元素。
基本语法：
列表.insert(索引, 元素)
例如：
numbers = [1, 2, 3, 4, 5]
numbers.insert(2, 2.5)
print(numbers) # [1, 2, 2.5, 3, 4, 5]
原来的列表：
索引：
0 1 2 3 4
↓ ↓ ↓ ↓ ↓
[1, 2, 3, 4, 5]
执行：
numbers.insert(2, 2.5)
之后：
[1, 2, 2.5, 3, 4, 5]
原来索引 2 的元素 3 会向后移动。
remove()：按照元素的值删除
如果知道要删除的元素值，可以使用：
remove()
例如：
numbers = [10, 20, 30, 40, 50]
numbers.remove(30)
print(numbers) # [10, 20, 40, 50]
这里删除的是：
30
而不是索引 30。
remove() 只删除第一次出现的元素
例如：
numbers = [10, 20, 50, 30, 50, 50]
numbers.remove(50)
print(numbers) # [10, 20, 30, 50, 50]
虽然列表中有三个 50：
50
50
50
但 remove() 只删除第一次出现的 50。
remove() 找不到元素会报错
例如：
numbers = [1, 2, 3]
numbers.remove(10)
因为列表中不存在 10，所以会出现：
ValueError
因此：
使用
remove()前，如果不确定元素是否存在，可以先使用in检查。
例如：
numbers = [1, 2, 3]
if 10 in numbers:
numbers.remove(10)
pop()：删除并返回元素
pop() 和 remove() 都可以删除元素，但是它们的思维方式不同。
pop() 的特点是：
根据索引删除元素，并把被删除的元素返回出来。
例如：
numbers = [1, 2, 3, 4, 5]
result = numbers.pop(1)
print(result) # 2
print(numbers) # [1, 3, 4, 5]
执行：
numbers.pop(1)
删除的是索引 1 的元素：
索引：
0 1 2 3 4
↓ ↓ ↓ ↓ ↓
[1, 2, 3, 4, 5]
↑
删除
同时：
result = numbers.pop(1)
会把：
2
保存到：
result
中。
pop() 不指定索引
如果不传参数：
numbers = [1, 2, 3, 4, 5]
result = numbers.pop()
print(result) # 5
print(numbers) # [1, 2, 3, 4]
默认删除：
最后一个元素。
所以：
numbers.pop()
可以理解成：
numbers.pop(-1)
remove() 和 pop() 的区别
这是列表方法中另一个非常重要的区别。
| 方法 | 根据什么删除？ | 是否返回被删除元素？ |
|---|---|---|
remove() |
元素的值 | 否 |
pop() |
元素的索引 | 是 |
例如：
numbers = [10, 20, 30, 40]
numbers.remove(20)
意思是：
删除值为
20的元素。
而：
numbers = [10, 20, 30, 40]
numbers.pop(1)
意思是：
删除索引为
1的元素。
clear()：清空列表
如果想删除列表中的所有元素，可以使用：
clear()
例如：
numbers = [1, 2, 3, 4, 5]
numbers.clear()
print(numbers) # []
执行之后：
[1, 2, 3, 4, 5]
↓ clear()
[]
注意：
clear() 是清空列表中的元素，而不是删除变量本身。
例如：
numbers = [1, 2, 3]
numbers.clear()
print(numbers) # []
变量 numbers 仍然存在，只是里面没有元素了。
sort()：给列表排序
sort() 用于对列表进行排序。
例如：
numbers = [19, 2, 35, 1, 67, 41]
numbers.sort()
print(numbers) # [1, 2, 19, 35, 41, 67]
默认情况下：
按照升序排列。
也就是：
小 → 大
sort() 会修改原列表
这是 sort() 非常重要的特点。
例如：
numbers = [5, 2, 8, 1]
numbers.sort()
print(numbers) # [1, 2, 5, 8]
原来的：
[5, 2, 8, 1]
已经被修改成：
[1, 2, 5, 8]
因此：
sort()是一种原地操作（in-place operation）。
所谓“原地”，就是：
直接修改原来的对象，而不是创建一个新的列表。
sorted()：返回新的排序列表
除了 sort()，Python 还有一个：
sorted()
它不是列表方法，而是 Python 的内置函数（Built-in Function）。
例如：
numbers = [19, 2, 35, 1, 67, 41]
sorted_numbers = sorted(numbers)
print(numbers) # [19, 2, 35, 1, 67, 41]
print(sorted_numbers) # [1, 2, 19, 35, 41, 67]
可以看到：
原来的：
numbers
没有发生变化。
而：
sorted_numbers
是一个新的排序列表。
sort() 和 sorted() 的区别
| 特点 | sort() |
sorted() |
|---|---|---|
| 类型 | 列表方法 | 内置函数 |
| 是否修改原列表 | 是 | 否 |
| 是否返回新列表 | 否 | 是 |
| 使用方式 | numbers.sort() |
sorted(numbers) |
| 适用对象 | 列表 | 可迭代对象 |
例如：
numbers = [3, 1, 2]
numbers.sort()
print(numbers) # [1, 2, 3]
而：
numbers = [3, 1, 2]
result = sorted(numbers)
print(numbers) # [3, 1, 2]
print(result) # [1, 2, 3]
简单记忆：
sort()：自己排序自己。
sorted()：创建一个排好序的新列表。
reverse()：反转列表
reverse() 用于：
将列表中的元素顺序反过来。
例如：
numbers = [1, 2, 3, 4, 5]
numbers.reverse()
print(numbers) # [5, 4, 3, 2, 1]
原来：
1 → 2 → 3 → 4 → 5
反转之后：
5 → 4 → 3 → 2 → 1
reverse() 同样会直接修改原列表。
reverse() 不是排序
需要注意：
reverse()
只是：
反转原来的顺序。
它并不会进行大小排序。
例如：
numbers = [10, 2, 50, 1]
numbers.reverse()
print(numbers) # [1, 50, 2, 10]
它只是把：
10, 2, 50, 1
反过来：
1, 50, 2, 10
并没有按照数字大小排序。
index()：查找元素的索引
index() 用于：
查找某个元素第一次出现的位置。
例如：
programming_languages = ['Rust', 'Java', 'Python', 'C++']
result = programming_languages.index('Java')
print(result) # 1
列表：
索引：
0 1 2 3
↓ ↓ ↓ ↓
Rust Java Python C++
所以：
programming_languages.index('Java')
得到：
1
index() 只返回第一次出现的位置
例如：
numbers = [10, 20, 30, 20, 40]
print(numbers.index(20)) # 1
虽然 20 出现了两次：
[10, 20, 30, 20, 40]
↑ ↑
但 index() 返回的是：
1
也就是第一次出现的位置。
找不到元素会发生什么？
如果元素不存在：
programming_languages = ['Rust', 'Java', 'Python']
programming_languages.index('JavaScript')
Python 会抛出：
ValueError
因为：
'JavaScript'
不在列表中。
因此，如果不确定元素是否存在，可以先使用：
in
例如：
programming_languages = ['Rust', 'Java', 'Python']
if 'JavaScript' in programming_languages:
print(programming_languages.index('JavaScript'))
列表方法总结
目前学习到的这些方法可以分成几类。
添加元素
| 方法 | 作用 |
|---|---|
append() |
在末尾添加一个元素 |
extend() |
在末尾添加多个元素 |
insert() |
在指定位置插入一个元素 |
删除元素
| 方法 | 作用 |
|---|---|
remove() |
按照值删除第一个匹配的元素 |
pop() |
按照索引删除元素，并返回该元素 |
clear() |
清空整个列表 |
排序和调整顺序
| 方法/函数 | 作用 |
|---|---|
sort() |
原地排序，直接修改列表 |
sorted() |
返回新的排序列表 |
reverse() |
原地反转列表 |
查找
| 方法 | 作用 |
|---|---|
index() |
查找元素第一次出现的索引 |
in |
判断某个元素是否存在 |
最容易混淆的几个操作
append() vs extend()
numbers = [1, 2]
numbers.append([3, 4])
print(numbers) # [1, 2, [3, 4]]
而：
numbers = [1, 2]
numbers.extend([3, 4])
print(numbers) # [1, 2, 3, 4]
记住：
append → 添加一个整体
extend → 添加多个元素
remove() vs pop()
numbers = [10, 20, 30]
numbers.remove(20)
根据：
值 20
删除。
而：
numbers = [10, 20, 30]
numbers.pop(1)
根据：
索引 1
删除。
sort() vs sorted()
numbers = [3, 1, 2]
numbers.sort()
print(numbers) # [1, 2, 3]
修改原列表。
而：
numbers = [3, 1, 2]
new_numbers = sorted(numbers)
print(numbers) # [3, 1, 2]
print(new_numbers) # [1, 2, 3]
不会修改原列表。
一个完整示例
把几个常见操作放到一起：
numbers = [3, 1, 5]
# 添加元素
numbers.append(4)
print(numbers) # [3, 1, 5, 4]
# 插入元素
numbers.insert(1, 2)
print(numbers) # [3, 2, 1, 5, 4]
# 删除元素
numbers.remove(5)
print(numbers) # [3, 2, 1, 4]
# 排序
numbers.sort()
print(numbers) # [1, 2, 3, 4]
# 反转
numbers.reverse()
print(numbers) # [4, 3, 2, 1]
整个过程可以理解为：
[3, 1, 5]
↓ append(4)
[3, 1, 5, 4]
↓ insert(1, 2)
[3, 2, 1, 5, 4]
↓ remove(5)
[3, 2, 1, 4]
↓ sort()
[1, 2, 3, 4]
↓ reverse()
[4, 3, 2, 1]
一个非常重要的细节：这些方法通常返回 None
像：
append()
insert()
remove()
sort()
reverse()
clear()
这些方法主要作用是修改原列表，通常不会把修改后的列表返回给你。
例如：
numbers = [3, 2, 1]
result = numbers.sort()
print(numbers) # [1, 2, 3]
print(result) # None
所以不要写成：
numbers = numbers.sort()
这样会导致：
numbers
变成：
None
正确写法是：
numbers = [3, 2, 1]
numbers.sort()
print(numbers) # [1, 2, 3]
列表方法速查表
| 方法 / 函数 | 主要作用 | 修改原列表？ | 是否返回新列表？ |
|---|---|---|---|
append() |
末尾添加一个元素 | ✅ | ❌ |
extend() |
末尾添加多个元素 | ✅ | ❌ |
insert() |
指定位置插入元素 | ✅ | ❌ |
remove() |
按值删除第一个匹配元素 | ✅ | ❌ |
pop() |
按索引删除并返回元素 | ✅ | ❌ |
clear() |
清空列表 | ✅ | ❌ |
sort() |
原地排序 | ✅ | ❌ |
sorted() |
创建排序后的新列表 | ❌ | ✅ |
reverse() |
原地反转 | ✅ | ❌ |
index() |
查找元素第一次出现的索引 | ❌ | ❌ |
本节学习小结
本节主要学习了 Python 列表的常用方法：
append()：在列表末尾添加一个元素。extend()：把另一个可迭代对象中的元素逐个加入列表。insert()：在指定索引位置插入元素。remove()：按照元素值删除第一次出现的元素。pop()：按照索引删除元素，并返回被删除的元素；不指定索引时默认删除最后一个。clear()：清空列表。sort()：直接修改原列表并进行排序。sorted()：返回新的排序列表，不修改原列表。reverse()：直接反转列表中的元素顺序。index()：查找元素第一次出现的索引。
最值得记住的三组区别：
append() ↔ extend()
remove() ↔ pop()
sort() ↔ sorted()
如果把这些方法掌握好，就已经可以完成大量基础的列表操作了。