本文目录导读：
批量替换键（Key）
创建新字典
# 原始字典
old_dict = {'name': '张三', 'age': 25, 'city': '北京'}
# 键映射关系
key_mapping = {
'name': 'username',
'age': 'age',
'city': 'address'
}
# 批量替换键
new_dict = {key_mapping.get(k, k): v for k, v in old_dict.items()}
print(new_dict) # {'username': '张三', 'age': 25, 'address': '北京'}
原地修改（in-place）
def replace_keys(dict_obj, key_mapping):
"""原地修改字典的键"""
for old_key, new_key in key_mapping.items():
if old_key in dict_obj:
dict_obj[new_key] = dict_obj.pop(old_key)
return dict_obj
# 使用示例
my_dict = {'a': 1, 'b': 2, 'c': 3}
key_map = {'a': 'x', 'b': 'y'}
replace_keys(my_dict, key_map)
print(my_dict) # {'x': 1, 'y': 2, 'c': 3}
批量替换值（Value）
使用列表生成式
# 原始字典
data = {'a': '苹果', 'b': '香蕉', 'c': '橘子', 'd': '苹果'}
# 值替换规则
value_mapping = {
'苹果': 'apple',
'香蕉': 'banana',
'橘子': 'orange'
}
# 批量替换值
new_data = {k: value_mapping.get(v, v) for k, v in data.items()}
print(new_data) # {'a': 'apple', 'b': 'banana', 'c': 'orange', 'd': 'apple'}
使用 map 函数
def replace_values(item):
k, v = item
replacements = {
'苹果': 'apple',
'香蕉': 'banana',
'橘子': 'orange'
}
return (k, replacements.get(v, v))
data = {'a': '苹果', 'b': '香蕉', 'c': '橘子'}
result = dict(map(replace_values, data.items()))
print(result) # {'a': 'apple', 'b': 'banana', 'c': 'orange'}
同时替换键和值
def batch_replace(dict_obj, key_map=None, value_map=None):
"""同时批量替换键和值"""
result = {}
for k, v in dict_obj.items():
# 替换键
new_key = key_map.get(k, k) if key_map else k
# 替换值
new_value = value_map.get(v, v) if value_map else v
result[new_key] = new_value
return result
# 使用示例
original = {'name': '张三', 'age': '25岁', 'city': '北京'}
key_map = {'name': 'username', 'city': 'location'}
value_map = {'张三': 'Zhang San', '25岁': '25', '北京': 'Beijing'}
result = batch_replace(original, key_map, value_map)
print(result) # {'username': 'Zhang San', 'age': '25', 'location': 'Beijing'}
复杂条件替换
def conditional_replace(data, conditions):
"""
根据条件批量替换
conditions: list of (key_pattern, value_transform_func)
"""
result = {}
for k, v in data.items():
new_key = k
new_value = v
for key_pattern, transform_func in conditions:
if key_pattern in k or key_pattern(k): # 支持字符串包含或函数判断
new_key = transform_func(k) if callable(transform_func) else transform_func
new_value = transform_func(v) if callable(transform_func) else v
break
result[new_key] = new_value
return result
# 示例：将所有包含"old"的键替换，并将数字值翻倍
data = {'old_name': '张三', 'old_age': 25, 'new_item': '测试'}
conditions = [
(lambda x: 'old_' in x, lambda x: x.replace('old_', 'new_') if isinstance(x, str) else x),
]
result = conditional_replace(data, conditions)
print(result) # {'new_name': '张三', 'new_age': 25, 'new_item': '测试'}
实用封装函数
class DictReplacer:
"""字典批量替换工具类"""
def __init__(self, key_rules=None, value_rules=None):
self.key_rules = key_rules or {}
self.value_rules = value_rules or {}
def add_key_rule(self, old_key, new_key):
self.key_rules[old_key] = new_key
def add_value_rule(self, old_value, new_value):
self.value_rules[old_value] = new_value
def replace(self, dict_obj, inplace=False):
"""执行替换"""
if inplace:
# 原地修改
for old_key, new_key in self.key_rules.items():
if old_key in dict_obj:
dict_obj[new_key] = dict_obj.pop(old_key)
for old_value, new_value in self.value_rules.items():
for k, v in list(dict_obj.items()):
if v == old_value:
dict_obj[k] = new_value
return dict_obj
else:
# 返回新字典
return {
self.key_rules.get(k, k):
self.value_rules.get(v, v)
for k, v in dict_obj.items()
}
# 使用示例
replacer = DictReplacer()
replacer.add_key_rule('name', 'username')
replacer.add_value_rule('苹果', 'apple')
data = {'name': '苹果', 'age': 25}
result = replacer.replace(data)
print(result) # {'username': 'apple', 'age': 25}
选择哪种方法取决于你的具体需求：
- 简单替换：使用字典推导式
- 需要原地修改：使用方法二
- 复杂条件：使用函数式方法
- 需要复用：封装成类
