Python字典与列表操作代码汇总：增删改查常用方法

概览图：Python 列表与字典增删改查核心特性与容器形态速览

一、列表与字典的底层存储与寻址模型差异

要熟练且不出错地使用列表和字典，首先需要理解两者在底层数据结构上的根本差异。许多初学者在编写代码时经常困惑于“为什么在大列表中使用 in 检查元素会变慢，而在字典中检查键却几乎不受数据规模影响”，这本质上是由它们的内存组织形式决定的。

Python 的列表底层基于连续动态数组实现。列表内保存的是指向具体对象的指针，这些指针在物理内存中依次紧密排列。当通过索引访问元素时（如 lst[0] 或 lst[5]），解释器直接使用首地址加上固定步长的物理偏移量，一步命中目标位置，因此按索引读取的时间复杂度为常数级 O(1)。然而，当在列表头部或中间插入/删除元素时，为了保持连续性，后续的所有指针都必须集体向后或向前搬移一位，时间复杂度退化为 O(n)。

相比之下，Python 字典底层基于散列表（Hash Table）与紧凑键值数组。当存入一个键值对时，Python 首先调用内置函数 hash(key) 计算键的哈希值，然后根据哈希值映射到具体的索引桶中。这种机制允许字典在查找、增加和删除键值对时直接完成散列定位，平均时间复杂度均为 O(1)。代价是字典的键必须是可哈希（不可变）的对象，且哈希机制需要预留一定冗余内存以避免碰撞。

图 1：列表（连续内存数组）与字典（哈希散列表）底层存储与寻址模型

二、列表（List）常用操作：增删改查代码汇总

1. 增加元素（Create）

列表提供了多种增加元素的方法，针对单个追加、批量拼接与指定位置插入有着明确的方法分工：

• append(x)：将元素 x 追加到列表末尾。这是最常用的操作，平摊时间复杂度为 O(1)。该方法是原地修改，返回值为 None。
• extend(iterable)：接收一个可迭代对象，解包并将其中的每个元素依次追加到末尾。等价于原地 += 运算。
• insert(index, x)：在指定索引 index 前插入元素 x。由于需要移动插入点之后的所有元素，时间复杂度为 O(n)。
• 加号拼接（+）：连接两个列表，返回一个全新的列表对象，原列表保持不变。

# 基础列表初始化
fruits = ['apple', 'banana']

# 1. append 追加单个元素（注意返回值为 None）
fruits.append('orange')

# 2. extend 批量追加列表内容
fruits.extend(['grape', 'melon'])

# 3. insert 在指定索引处插入
fruits.insert(1, 'cherry')

# 4. 加号拼接产生新列表
combined = fruits + ['mango']

2. 删除元素（Delete）

删除操作依据“按索引下标删除”还是“按具体匹配值删除”分为两大阵营：

• pop([index])：移除并返回指定索引处的元素。若未传入参数，默认弹出最后一个元素（index=-1）。若索引越界会触发 IndexError。
• del lst[index]：Python 关键字语句，按索引删除元素，支持切片删除（如 del lst[1:3]）。无返回值。
• remove(value)：从左到右查找并移除首个匹配项 value。若列表中不存在该值，会抛出 ValueError。
• clear()：清空列表内的全部元素，列表长度变为 0。

nums = [10, 20, 30, 40, 20, 50]

# 1. pop 弹出末尾元素并接收返回值
last_item = nums.pop()       # 弹出 50

# 2. pop 弹出指定下标元素
second_item = nums.pop(1)    # 弹出下标 1 的 20

# 3. remove 移除首个值为 20 的项（建议配合 in 检查）
if 20 in nums:
    nums.remove(20)

# 4. del 按索引删除
del nums[0]                  # 删掉此时下标 0 的 10

3. 修改元素（Update）

列表属于可变数据类型（Mutable），支持直接通过下标或切片对指定区间进行内容覆盖与重构：

• 单索引赋值：lst[index] = new_value，直接覆写指定位置的对象指针。
• 切片赋值：lst[start:stop] = iterable，可替换一段连续区间，替换长度可以与原区间长度不一致。
• 原地重排：sort() 实现升序或自定义关键字排序，reverse() 实现元素首尾颠倒。两者均为原位修改，返回 None。

items = ['a', 'b', 'c', 'd', 'e']

# 1. 索引单值修改
items[0] = 'alpha'

# 2. 切片区间替换（将下标 1 到 2 替换为三个新项）
items[1:3] = ['beta', 'gamma', 'delta']

# 3. 原地排序与倒序
num_list = [5, 2, 9, 1]
num_list.sort()              # 变为 [1, 2, 5, 9]
num_list.reverse()           # 变为 [9, 5, 2, 1]

4. 查询与检索（Retrieve）

列表提供了从正向/反向索引、切片截取到成员包含判断与频次统计的全套查询方案：

• 下标读取：lst[i] 支持正向索引（从 0 开始）与负向索引（-1 代表最后一项）。
• 切片读取：lst[start:stop:step]，提取子列表，产生新对象。
• 成员检测：x in lst，按顺序遍历比对，时间复杂度 O(n)。
• 索引查找：lst.index(x, [start, stop])，查找首个匹配项索引，查无时抛出 ValueError。
• 频次统计：lst.count(x)，统计 x 在列表中出现的完整次数。

letters = ['a', 'b', 'c', 'b', 'd']

# 1. 下标访问与切片
first = letters[0]           # 'a'
last = letters[-1]           # 'd'
sub = letters[1:4]           # ['b', 'c', 'b']

# 2. 存在性与频次
has_c = 'c' in letters       # True
b_count = letters.count('b') # 2
b_idx = letters.index('b')   # 1

三、字典（Dict）常用操作：增删改查代码汇总

1. 增加与修改（Create / Update）

在 Python 字典中，“新增键值对”与“修改已有键值”在基础语法上高度统一：

• 直接下标赋值 d[key] = value：若 key 尚不存在，则新增该条目；若 key 已存在，则无条件覆盖其旧值。
• update([other])：接收另一个字典或键值对迭代器，批量合并至当前字典。重复键将被覆盖。
• setdefault(key, default)：若 key 存在，则直接返回其当前值且不作修改；若不存在，则将 key: default 写入字典并返回 default。常用于分组累加初始化。
• 字典合并运算符（Python 3.9+）：d1 | d2 生成新字典，d1 |= d2 原地就地合并更新。

user = {'id': 101, 'name': 'Alice'}

# 1. 下标赋值：增加新键与修改已有键
user['role'] = 'admin'       # 键不存在 -> 新增
user['name'] = 'Alice W.'    # 键已存在 -> 修改更新

# 2. update 批量合并
user.update({'city': 'Beijing', 'status': 'active'})

# 3. setdefault 安全初始化（若已存在则不动）
user.setdefault('status', 'offline') # 依然保持 'active'
user.setdefault('tags', []).append('developer') # 初始化列表并追加

2. 删除条目（Delete）

字典提供了对条目的精准提取、批量剔除与清空机制：

• del d[key]：直接删除指定键及其对应的值。若 key 不存在，抛出 KeyError。
• pop(key[, default])：删除 key 并返回对应的值。若提供 default 参数，当键缺失时不报错而是返回该默认值；若未提供且键不存在，抛出 KeyError。
• popitem()：按照后进先出（LIFO）顺序移除并返回最后一个插入的 (key, value) 元组。字典为空时调用抛出 KeyError。
• clear()：清空字典所有键值对。

session = {'sid': 'abc-123', 'auth': True, 'exp': 3600, 'temp': 99}

# 1. pop 弹出并提取值（带默认值防止异常）
exp_time = session.pop('exp', None)     # 返回 3600
missing = session.pop('token', 'EMPTY') # 键不存在，返回 'EMPTY'

# 2. popitem 弹出最后插入的一项
last_entry = session.popitem()          # 返回 ('temp', 99)

# 3. del 删除指定键
del session['sid']

3. 查询与检索（Retrieve）

字典在日常业务代码中查询频次极高，必须熟练掌握安全取值与各类遍历视图：

• 下标读取 d[key]：速度最快，但在键不存在时会直接抛出 KeyError 中断程序。
• get(key, default=None)：安全取值方法。若键存在返回其值；若键不存在则返回传入的 default，程序不会崩溃。
• 键存在性测试 key in d：检查 key 是否存在于字典中，时间复杂度为 O(1)。注意：in 仅比对键，不比对值。
• 视图对象：keys()（所有键）、values()（所有值）、items()（键值对元组），支持动态视图迭代。

config = {'host': '127.0.0.1', 'port': 8080}

# 1. 安全取值与契约取值
host = config['host']                   # 业务强制要求的键直接取
timeout = config.get('timeout', 30)     # 可选配置优雅兜底

# 2. 键存在判断
if 'port' in config:
    print(f"Port is active: {config['port']}")

# 3. 遍历键值对视图
for k, v in config.items():
    print(f"{k} -> {v}")

四、常用操作场景选择与代码避坑决策流

虽然增删改查的基础语法简洁明了，但在具体业务逻辑组合使用时，若忽视边界条件极易埋下难以定位的隐蔽 Bug。下图梳理了在列表元素删除和字典取值查询时的高频决策路径：

图 2：常用场景操作选择与异常避坑代码决策流程

五、核心方法的原位修改机制与返回值规则

在增删改查的操作中，另一个最容易导致初学者产生困惑的问题是：操作完成后，变量接收到的到底是什么？

Python 中对于容器修改主要遵循三大设计原则：
1. 原地修改并返回 None（如 append(), sort(), update()）：设计者故意让其返回 None，以强提醒开发者“当前操作直接改变了原对象，不需要重新赋值”。若误写 lst = lst.append(5)，lst 变量会立刻变为 None。
2. 原地修改并返回被剔除项（如 pop(), popitem()）：在改变原容器的同时，将被移除的数据作为结果交出，方便实现栈或消费队列。
3. 不修改原容器并返回全新实例（如切片 lst[:], sorted(), d1 | d2）：原对象不受任何影响，调用方必须使用变量接收返回的新容器。

图 3：核心操作的原位修改（In-Place）与返回值机制对照解析

六、字典与列表“增删改查”核心方法全景对照总结

为了便于日常编码快速查阅与选型，下表将列表与字典在增删改查四个维度的代表方法、时间复杂度、原位修改特性与常见报错风险进行了系统横向对比：

图 4：Python 列表与字典“增删改查”核心方法全景速查矩阵

在实际工程开发中，应根据数据特性与访问频次合理选型：凡涉及高频按标识符随机读取、排重关联的场景，优先采用字典；凡重视相对顺序、频繁截取切片或进行队列进出的场景，优先采用列表。掌握增删改查的底层时间复杂度与返回值特性，能够从根源上写出兼具可读性、高性能与健壮性的 Python 代码。