Python 列表（List）核心知识点

Python 列表（List）是最常用的可变有序序列，支持存储任意类型数据（整数、字符串、对象等），核心特点是 “可修改、可索引、可迭代”。以下是列表的一些核心知识点：

一、列表的定义与基本特性

1. 定义方式

用方括号 [] 包裹元素，元素间用逗号分隔；也可通过 list() 函数转换其他可迭代对象（如字符串、元组）。

 

# 直接定义（元素类型可混合）
list1 = [1, "hello", True, [2, 3]]  # 支持嵌套（列表里套列表）
# 空列表
list2 = []  # 或 list2 = list()
# 转换其他对象
list3 = list("abc")  # 从字符串转：["a", "b", "c"]
list4 = list((1, 2, 3))  # 从元组转：[1, 2, 3]

 

2. 核心特性

• 可变：可直接修改元素（增、删、改），内存地址不变；
• 有序：元素按插入顺序排列，支持通过 “索引” 访问（从 0 开始）；
• 可重复：允许存储相同值的元素（如 [1, 1, 2]）；
• 元素类型无限制：可存储整数、字符串、列表、字典等任意类型。

二、列表的索引与切片（访问元素）

列表通过 “索引” 定位元素，通过 “切片” 获取子列表，是访问列表的核心方式。

1. 索引（Index）

• 正向索引：从左到右，第一个元素为 0，第二个为 1，以此类推；
• 反向索引：从右到左，最后一个元素为 -1，倒数第二个为 -2，以此类推。

 

lst = [10, 20, 30, 40]
print(lst[0])   # 正向：取第一个元素 → 10
print(lst[-1])  # 反向：取最后一个元素 → 40
print(lst[2])   # 正向：取第三个元素 → 30

 

2. 切片（Slice）

语法：lst[start:end:step]，返回新列表（不修改原列表），规则如下：

• start：切片起始位置（默认 0，可不写）；
• end：切片结束位置（不包含 end 本身，默认列表长度，可不写）；
• step：步长（每次跳过的元素数，默认 1，可正可负；负步长表示从右往左切）。

 

lst = [10, 20, 30, 40, 50]
# 1. 基本切片：取[start, end)的元素
print(lst[1:3])  # 从索引1到3（不含3）→ [20, 30]
# 2. 省略start/end：取到开头/结尾
print(lst[:3])   # 从开头到3 → [10, 20, 30]
print(lst[2:])   # 从2到结尾 → [30, 40, 50]
# 3. 步长控制：每隔step取一个
print(lst[::2])  # 步长2，取所有元素 → [10, 30, 50]
# 4. 反向切片（步长为负）
print(lst[::-1]) # 步长-1，反转列表 → [50, 40, 30, 20, 10]
print(lst[3:1:-1]) # 从3到1（不含1），反向取 → [40, 30]

 

三、列表的增删改操作（修改列表）

列表是可变序列，可直接修改元素，核心操作如下：

1. 增加元素（4 种常用方法）

方法	功能	示例
append(x)	在列表末尾添加一个元素 x	lst.append(60) → [10,20,30,40,50,60]
extend(iterable)	在列表末尾添加另一个可迭代对象的所有元素（如列表、元组）	lst.extend([60,70]) → [10,20,30,40,50,60,70]
insert(index, x)	在指定索引 index 处插入元素 x	lst.insert(2, 25) → [10,20,25,30,40,50]
切片赋值	用切片位置插入多个元素（替换原切片为空）	lst[1:1] = [15,18] → [10,15,18,20,30,40,50]

2. 删除元素（5 种常用方法）

方法	功能	示例
remove(x)	删除列表中第一个值为 x 的元素（若不存在则报错）	lst.remove(30) → [10,20,40,50]
pop(index)	删除指定索引 index 处的元素，并返回该元素（默认删最后一个，即 index=-1）	lst.pop(1) → 返回 20，列表变为 [10,30,40,50]
del lst[index]	关键字删除：删除指定索引的元素（支持切片删除）	del lst[2] → [10,20,40,50]；del lst[1:3] → [10,40,50]
clear()	清空列表所有元素，返回空列表	lst.clear() → []
切片赋值为空	用空列表替换切片，实现删除	lst[1:3] = [] → [10,40,50]

3. 修改元素

通过 “索引赋值” 直接修改指定位置的元素，或通过 “切片赋值” 修改多个元素。

 

 

lst = [10, 20, 30, 40]
# 1. 索引修改：改单个元素
lst[1] = 25  # → [10, 25, 30, 40]
# 2. 切片修改：改多个元素（新列表长度可与原切片不同）
lst[2:] = [35, 45, 55]  # → [10, 25, 35, 45, 55]

 

四、列表的常用内置函数与方法

1. 内置函数（直接作用于列表）

函数	功能	示例（lst = [10,20,30]）
len(lst)	求列表长度（元素个数）	len(lst) → 3
max(lst)	求列表中元素的最大值（元素需可比较）	max(lst) → 30
min(lst)	求列表中元素的最小值（元素需可比较）	min(lst) → 10
sum(lst)	求列表中所有数值元素的和（元素需为数值）	sum(lst) → 60
sorted(lst, reverse=False)	对列表元素排序，返回新列表（原列表不变；reverse=True 表示降序）	sorted(lst, reverse=True) → [30,20,10]
list(iterable)	将可迭代对象转为列表	list((1,2)) → [1,2]

2. 列表对象方法（lst.方法名()）

除了增删改方法，列表还有以下常用方法：

方法	功能	示例（lst = [20,10,30,10]）
count(x)	统计元素 x 在列表中出现的次数	lst.count(10) → 2
index(x, start=0, end=len(lst))	查找元素 x 在列表中第一个出现的索引（可指定查找范围 [start, end)，不存在则报错）	lst.index(10) → 1
reverse()	反转列表（修改原列表，无返回值）	lst.reverse() → [10,30,10,20]
sort(key=None, reverse=False)	对列表排序（修改原列表，无返回值；key 可指定排序依据，如 key=str）	lst.sort() → [10,10,20,30]；lst.sort(reverse=True) → [30,20,10,10]
copy()	复制列表，返回新列表（浅复制）	new_lst = lst.copy() → [20,10,30,10]

五、列表的进阶特性

1. 列表推导式（快速创建列表）

用简洁语法生成列表，格式：[表达式 for 变量 in 可迭代对象 if 条件]，比 for 循环更高效。

 

# 示例1：生成1-5的平方列表
squares = [x**2 for x in range(1,6)]  # → [1,4,9,16,25]
# 示例2：生成偶数列表（加条件过滤）
evens = [x for x in range(10) if x % 2 == 0]  # → [0,2,4,6,8]
# 示例3：嵌套推导式（处理二维列表）
matrix = [[1,2],[3,4]]
flatten = [num for row in matrix for num in row]  # → [1,2,3,4]

 

2. 列表的浅复制与深复制

• 浅复制：只复制列表的 “外层结构”，内层嵌套的可变对象（如子列表）仍共享内存（修改子列表会影响原列表）。
  实现方式：lst.copy()、lst[:]、list(lst)。
• 深复制：完全复制列表的所有层级（包括内层嵌套对象），新列表与原列表完全独立（修改不互相影响）。
  需导入 copy 模块，用 copy.deepcopy(lst)。

 

import copy
# 原列表（含嵌套子列表）
lst = [1, [2, 3]]

# 浅复制
shallow = lst.copy()
shallow[1][0] = 20  # 修改子列表
print(lst)  # → [1, [20, 3]]（原列表子列表也被改）

# 深复制
deep = copy.deepcopy(lst)
deep[1][0] = 30  # 修改子列表
print(lst)  # → [1, [20, 3]]（原列表不受影响）

 

3. 列表的遍历方式

• for 循环直接遍历元素（最常用）：

  lst = [10,20,30]
  for num in lst:
      print(num)  # 依次输出10、20、30
  

   
• for 循环 + 索引遍历（需同时用索引和元素时）：

  for i in range(len(lst)):
      print(f"索引{i}：{lst[i]}")  # 输出“索引0：10”等
  

   
• enumerate () 遍历（同时获索引和元素）（更高效）：

  for i, num in enumerate(lst):
      print(f"索引{i}：{num}")  # 同上，代码更简洁
  

   

六、列表的注意事项

1. 索引越界报错：访问不存在的索引（如 lst[10] 当 len(lst)=3 时），会抛出 IndexError；
2. 可变与不可变的区别：列表是可变的，修改时内存地址不变；而字符串、元组是不可变的，修改会生成新对象；
3. sort() 与 sorted() 的区别：lst.sort() 直接修改原列表，无返回值；sorted(lst) 返回新列表，原列表不变；
4. 列表与元组的区别：列表用 []，可变；元组用 ()，不可变（适合存储不修改的数据，如坐标 (x,y)）。