【Python入门】6.2数据容器--列表（list）

Python 列表（List）系统学习指南

列表（List）是 Python 中最基础、最常用的可变序列类型，支持增删改查、嵌套、推导式等强大功能，是数据处理和日常开发的核心工具。以下从「基础定义→核心操作→进阶用法→实战场景→注意事项」全方位梳理列表知识：

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

1. 定义

• 列表是有序、可变的元素集合，元素可以是任意数据类型（整数、字符串、列表、字典等），且允许重复。
• 语法：用方括号 [] 包裹元素，元素之间用逗号 , 分隔。

2. 核心特性

3. 空列表与创建方式

二、列表的核心操作（增删改查）

1. 查：访问列表元素

列表通过「索引（Index）」访问元素，索引从 0 开始（正向索引），也支持负索引（从末尾倒数，-1 表示最后一个元素）。

（1）单个元素访问

nums = [10, 20, 30, 40, 50]
print(nums[0])   # 输出 10（正向索引 0：第一个元素）
print(nums[-1])  # 输出 50（负索引 -1：最后一个元素）
print(nums[2])   # 输出 30（正向索引 2：第三个元素）
print(nums[-3])  # 输出 30（负索引 -3：倒数第三个元素）

• 注意：索引越界会报错 IndexError: list index out of range（如访问 nums[5] 或 nums[-6]）。

（2）切片（访问多个元素）

语法：list[start:end:step]，返回新列表（不修改原列表）

• start：起始索引（默认 0，包含）
• end：结束索引（默认列表长度，不包含）
• step：步长（默认 1，可正可负，负步长表示反向切片）

示例：

nums = [10, 20, 30, 40, 50]
print(nums[1:4])    # [20, 30, 40]（索引1到3，不包含4）
print(nums[:3])     # [10, 20, 30]（从开头到索引2）
print(nums[2:])     # [30, 40, 50]（从索引2到末尾）
print(nums[::2])    # [10, 30, 50]（步长2，隔一个取一个）
print(nums[::-1])   # [50, 40, 30, 20, 10]（步长-1，反转列表）
print(nums[3:1:-1]) # [40, 30]（反向切片：索引3到2，不包含1）

（3）其他查询操作

2. 改：修改列表元素

直接通过「索引/切片」赋值修改，支持单个元素或多个元素批量修改。

（1）修改单个元素

nums = [10, 20, 30, 40, 50]
nums[2] = 300  # 索引2的元素改为300
print(nums)    # 输出 [10, 20, 300, 40, 50]
nums[-1] = 500 # 最后一个元素改为500
print(nums)    # 输出 [10, 20, 300, 40, 500]

（2）切片批量修改

nums = [10, 20, 30, 40, 50]
nums[1:3] = [200, 300]  # 索引1-2（不包含3）替换为[200,300]
print(nums)             # [10, 200, 300, 40, 50]
nums[3:] = [400, 500, 600]  # 索引3到末尾替换为3个元素（列表长度改变）
print(nums)             # [10, 200, 300, 400, 500, 600]
nums[:2] = []           # 切片赋值为空列表 → 删除对应元素
print(nums)             # [300, 400, 500, 600]

3. 增：向列表添加元素

列表是可变的，添加元素不会创建新列表，常用方法有 append()、extend()、insert()，以及 + 运算符。

示例：

nums = [10, 20, 30]
nums.append(40)          # [10,20,30,40]
nums.extend((50, 60))    # [10,20,30,40,50,60]（元组转元素添加）
nums.extend("ab")        # [10,20,30,40,50,60,'a','b']（字符串转字符添加）
nums.insert(1, 15)       # [10,15,20,30,40,50,60,'a','b']
new_nums = nums + [70,80]# 原nums不变，new_nums是拼接结果

4. 删：删除列表元素

常用方法有 del 语句、remove()、pop()、clear()，功能和使用场景不同：

示例：

nums = [10, 20, 30, 20, 40]
del nums[1]          # [10, 30, 20, 40]（删除索引1的20）
del nums[2:]         # [10, 30]（删除索引2及以后的元素）
nums.remove(30)      # [10]（删除值为30的元素）
num = nums.pop()     # num=10，nums变为[]
nums = [10,20,30]
nums.clear()         # nums变为[]

三、列表的常用方法（内置函数）

除了增删改查，列表还有多个实用内置方法，整理如下（按常用程度排序）：

关键方法详解

1. sort() 与 sorted() 的区别

• list.sort()：原地排序，修改原列表，无返回值（返回 None）
• sorted(list)：返回新排序列表，原列表不变（支持所有可迭代对象）

nums = [3,1,4,2]
nums.sort()          # 原列表变为 [1,2,3,4]，返回 None
new_nums = sorted(nums)  # new_nums = [1,2,3,4]，原nums不变
# 按元素长度排序（字符串列表）
words = ["apple", "banana", "cherry"]
words.sort(key=len)  # ["apple", "cherry", "banana"]（按长度升序）
# 降序排序
nums.sort(reverse=True)  # [4,3,2,1]

2. 浅拷贝（copy()）与深拷贝

• 浅拷贝：仅复制列表的「第一层元素」，如果列表包含嵌套对象（如子列表、字典），则复制的是嵌套对象的引用（修改子对象会影响原列表）
• 深拷贝：需导入 copy 模块的 deepcopy()，完全复制所有层级的对象（修改子对象不影响原列表）

# 浅拷贝示例
list1 = [1, [2, 3], 4]
list2 = list1.copy()  # 或 list2 = list1[:]
list2[0] = 100        # 修改第一层元素，原列表不受影响
list2[1][0] = 200     # 修改嵌套子列表，原列表同步改变
print(list1)          # [1, [200, 3], 4]

# 深拷贝示例
import copy
list3 = copy.deepcopy(list1)
list3[1][0] = 300     # 修改嵌套子列表，原列表不受影响
print(list1)          # [1, [200, 3], 4]
print(list3)          # [1, [300, 3], 4]

四、列表的进阶用法

1. 列表推导式（List Comprehension）

列表推导式是 Python 特有的简洁语法，用于快速创建列表，效率高于 for 循环 + append()，语法：

# 基础格式：[表达式 for 变量 in 可迭代对象]
new_list = [x*2 for x in range(5)]  # [0, 2, 4, 6, 8]

# 带条件筛选：[表达式 for 变量 in 可迭代对象 if 条件]
even_nums = [x for x in range(10) if x % 2 == 0]  # [0,2,4,6,8]

# 嵌套推导式（多维列表）
matrix = [[i*j for j in range(3)] for i in range(2)]  # [[0,0,0], [0,1,2]]

# 复杂表达式
words = ["apple", "banana", "cherry"]
upper_words = [word.upper() for word in words if len(word) > 5]  # ["BANANA", "CHERRY"]

2. 嵌套列表（多维列表）

列表中包含其他列表，称为嵌套列表（常用作二维/三维数据，如矩阵、表格）。

（1）创建与访问

# 创建二维列表（3行2列）
matrix = [
    [1, 2],
    [3, 4],
    [5, 6]
]

# 访问元素：先访问行索引，再访问列索引
print(matrix[0][1])  # 2（第0行第1列）
print(matrix[2][0])  # 5（第2行第0列）

# 遍历二维列表
for row in matrix:
    for num in row:
        print(num, end=" ")  # 输出 1 2 3 4 5 6

（2）注意：避免用乘法创建嵌套列表

# 错误示例：乘法创建的是同一子列表的引用
bad_matrix = [[0]*2]*3  # 3个[0,0]指向同一个列表
bad_matrix[0][0] = 1    # 修改一个子列表，所有子列表同步改变
print(bad_matrix)       # [[1,0], [1,0], [1,0]]

# 正确示例：用列表推导式创建
good_matrix = [[0]*2 for _ in range(3)]
good_matrix[0][0] = 1
print(good_matrix)      # [[1,0], [0,0], [0,0]]

3. 列表的迭代与遍历

（1）普通 for 循环遍历

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

（2）获取索引+元素（enumerate()）

nums = [10, 20, 30]
for index, num in enumerate(nums):
    print(f"索引{index}：{num}")  # 索引0：10；索引1：20；索引2：30
# 指定起始索引
for index, num in enumerate(nums, start=1):
    print(f"序号{index}：{num}")  # 序号1：10；序号2：20；序号3：30

（3）并行遍历多个列表（zip()）

names = ["Alice", "Bob", "Charlie"]
ages = [25, 30, 35]
for name, age in zip(names, ages):
    print(f"{name} 今年 {age} 岁")  # Alice 今年25岁；Bob 今年30岁；Charlie 今年35岁

五、列表的特性与注意事项

1. 列表 vs 元组（Tuple）：核心区别

2. 列表的时间复杂度（效率）

→ 优化建议：若需频繁在开头插入/删除，优先使用 collections.deque（双端队列，O(1) 首尾操作）。

3. 常见坑与避坑指南

（1）索引越界错误

nums = [1,2,3]
print(nums[3])  # 报错 IndexError：索引3超出范围（最大索引2）
# 避坑：访问前判断索引是否在 [0, len(list)-1] 范围内
if 3 < len(nums):
    print(nums[3])

（2）append 与 extend 混淆

nums = [1,2,3]
nums.append([4,5])  # 错误：添加的是子列表，结果 [1,2,3,[4,5]]
nums.extend([4,5])  # 正确：添加元素4、5，结果 [1,2,3,4,5]

（3）列表作为函数参数的「引用传递」

列表是可变对象，作为函数参数时，函数内修改列表会影响原列表：

def modify_list(lst):
    lst.append(100)  # 修改的是原列表的引用

nums = [1,2,3]
modify_list(nums)
print(nums)  # [1,2,3,100]（原列表被修改）

# 避坑：传递列表副本（浅拷贝）
modify_list(nums.copy())  # 或 modify_list(nums[:])

（4）列表推导式的变量泄露（Python 2）

Python 2 中列表推导式的变量会泄露到全局作用域，Python 3 已修复：

# Python 2（错误）
x = 10
lst = [x*2 for x in range(3)]
print(x)  # 输出 2（变量x被覆盖）

# Python 3（正确）
x = 10
lst = [x*2 for x in range(3)]
print(x)  # 输出 10（变量x未泄露）

六、实战场景示例

1. 数据筛选与转换（列表推导式）

# 筛选1-100中的偶数，并平方
even_squares = [x*x for x in range(1, 101) if x % 2 == 0]
print(even_squares[:5])  # [4, 16, 36, 64, 100]

# 转换字符串列表为小写
words = ["APPLE", "BANANA", "CHERRY"]
lower_words = [word.lower() for word in words]
print(lower_words)  # ["apple", "banana", "cherry"]

2. 嵌套列表处理（矩阵转置）

# 二维列表（矩阵）转置
matrix = [[1,2,3], [4,5,6], [7,8,9]]
transposed = [[row[i] for row in matrix] for i in range(3)]
print(transposed)  # [[1,4,7], [2,5,8], [3,6,9]]

3. 列表去重（保留顺序）

nums = [2, 1, 3, 2, 4, 1]
# 方法1：利用字典（Python 3.7+ 字典有序）
unique_nums = list(dict.fromkeys(nums))  # [2,1,3,4]
# 方法2：列表推导式（保留首次出现）
unique_nums = []
[unique_nums.append(x) for x in nums if x not in unique_nums]
print(unique_nums)  # [2,1,3,4]

4. 栈与队列实现（列表特性）

• 栈（LIFO，后进先出）：用 append()（入栈）和 pop()（出栈）
• 队列（FIFO，先进先出）：用 append()（入队）和 pop(0)（出队），但 pop(0) 效率低，推荐用 collections.deque

# 栈实现
stack = []
stack.append(1)  # 入栈：[1]
stack.append(2)  # 入栈：[1,2]
stack.pop()      # 出栈：返回2，stack变为[1]

# 队列实现（高效版）
from collections import deque
queue = deque([1,2,3])
queue.append(4)  # 入队：deque([1,2,3,4])
queue.popleft()  # 出队：返回1，queue变为deque([2,3,4])

总结

列表是 Python 中最灵活、最常用的数据结构，核心要点可概括为：

1. 基础：有序、可变、支持任意元素和嵌套；
2. 核心操作：索引/切片访问、增（append/extend）删（del/pop/remove）改（索引赋值）查（in/count/index）；
3. 进阶：列表推导式（简洁高效创建列表）、嵌套列表（多维数据处理）、浅拷贝/深拷贝（避免引用问题）；
4. 避坑：注意索引越界、append 与 extend 区别、可变对象的引用传递。

掌握列表的所有用法后，可应对大部分 Python 数据处理场景，后续学习字典、集合、 pandas 等工具时也能更轻松衔接。