Python字典(dict)完全指南

1. 字典的基本概念

字典(dict)是Python中的一种可变映射类型，它使用键值对(key-value pair)的形式来存储数据。字典的特点包括：

键(key)必须是不可变类型（如字符串、数字或元组）
值(value)可以是任意Python对象
键必须是唯一的
Python 3.7+版本中字典会保持插入顺序

2. 字典的创建方法

# 1. 使用花括号创建

# 最常用的创建方式，直观且灵活

# 可以在创建时直接初始化多个键值对

# 支持嵌套字典结构

student = {

    'name': '张三',  # 字符串类型的键值对

    'age': 20,      # 数字类型的值

    'scores': {'语文': 85, '数学': 92}  # 嵌套字典

}



# 2. 使用dict()构造函数

# 适用于键名符合变量命名规则的情况

# 代码更简洁，但不支持复杂的键名

info = dict(name='李四', age=22)  # 等同于 {'name': '李四', 'age': 22}



# 3. 使用字典推导式

# 适合批量创建有规律的键值对

# 代码简洁，可读性好

squares = {x: x**2for x in range(5)}  # 创建数字及其平方的映射



# 4. 使用dict.fromkeys()创建具有默认值的字典

# 适合初始化具有相同默认值的多个键

# 注意：所有键会共享同一个默认值对象

keys = ['a', 'b', 'c']

default_dict = dict.fromkeys(keys, 0)  # 创建所有键对应值为0的字典

3. 字典的基本操作

3.1 访问和修改元素

# 创建示例字典

user = {

    'name': '张三',

    'age': 25,

    'email': 'zhangsan@example.com'

}



# 1. 访问元素的多种方式

# 使用方括号访问 - 最直接的方式，但键不存在时会抛出KeyError

print(user['name'])  # 输出：张三



# 使用get()方法访问 - 推荐的安全访问方式

# 第一个参数是键名，第二个参数是键不存在时的默认值

age = user.get('age', 0)  # 如果'age'键不存在，返回默认值0

phone = user.get('phone', '未设置')  # 获取可能不存在的键



# 2. 修改元素

# 直接赋值修改已存在的键值对

user['age'] = 26# 修改已存在的键的值



# 3. 添加新元素

# 使用新键直接赋值

user['phone'] = '13800138000'# 添加新的键值对



# 4. 删除元素的多种方式

# 使用del语句 - 删除指定键值对，键不存在会抛出KeyError

del user['email']



# 使用pop()方法 - 删除并返回值，可以提供默认值

phone = user.pop('phone', None)  # 如果键不存在，返回None



# 使用popitem()方法 - 删除并返回最后一个键值对

last_item = user.popitem()  # 返回元组(key, value)

3.2 常用字典方法

# 1. 获取字典信息的方法

# keys() - 获取所有键

# 返回一个动态视图对象，会随字典变化而更新

keys = user.keys()  # 获取所有键的视图

key_list = list(keys)  # 转换为列表



# values() - 获取所有值

# 同样返回动态视图对象

values = user.values()  # 获取所有值的视图

value_list = list(values)  # 转换为列表



# items() - 获取所有键值对

# 返回(key, value)元组的视图对象

items = user.items()  # 获取所有键值对的视图

for key, value in items:  # 常用于遍历字典

    print(f"{key}: {value}")



# 2. 修改字典的方法

# update() - 批量更新字典

# 可以使用另一个字典或键值对序列更新

user.update({'city': '北京', 'age': 27})  # 使用字典更新

user.update(zip(['hobby', 'job'], ['读书', '程序员']))  # 使用键值对序列更新



# setdefault() - 设置默认值

# 如果键不存在，则设置默认值并返回

# 如果键存在，则返回现有值

email = user.setdefault('email', 'default@example.com')



# 3. 清理字典的方法

# clear() - 清空字典

# 删除所有键值对

user.clear()  # 字典变为空字典 {}



# copy() - 创建字典的浅拷贝

# 创建新字典，但嵌套的可变对象仍然共享引用

user_copy = user.copy()

4. 字典的高级应用

4.1 嵌套字典

# 复杂的嵌套字典示例

# 展示了多层嵌套的数据结构

# 适用于表示层级关系的数据

school = {

    'class_1': {

        'teacher': '王老师',

        'students': {

            '001': {

                'name': '张三',

                'scores': {'语文': 85, '数学': 92}

            },

            '002': {

                'name': '李四',

                'scores': {'语文': 89, '数学': 94}

            }

        }

    }

}



# 访问嵌套数据的方法

# 1. 使用多级键访问

print(school['class_1']['students']['001']['scores']['语文'])  # 输出：85



# 2. 使用get()方法的安全访问

# 避免键不存在时的异常

score = school.get('class_1', {}).get('students', {}).get('001', {}).get('scores', {}).get('语文', 0)



# 3. 修改嵌套数据

# 逐层创建或修改数据

school['class_2'] = {}  # 创建新的班级

school['class_2']['teacher'] = '李老师'# 添加教师信息

school['class_2']['students'] = {}  # 初始化学生字典

4.2 字典推导式高级用法

# 1. 条件字典推导式

# 根据条件筛选键值对

scores = {'张三': 85, '李四': 92, '王五': 78, '赵六': 95}

# 筛选成绩大于等于85分的学生

pass_students = {name: score for name, score in scores.items() if score >= 85}



# 2. 转换值的字典推导式

# 对原字典的值进行转换

grades = {name: 'A'if score >= 90else'B'if score >= 80else'C'

         for name, score in scores.items()}



# 3. 嵌套字典推导式

# 创建复杂的嵌套字典结构

# 生成乘法表字典

matrix = {i: {j: i*j for j in range(3)} for i in range(3)}

# 结果示例：{0: {0: 0, 1: 0, 2: 0}, 1: {0: 0, 1: 1, 2: 2}, 2: {0: 0, 1: 2, 2: 4}}

5. 使用字典格式化字符串

5.1 基本格式化

# 1. 使用%操作符（旧式格式化）

# 语法简单，但功能有限

info = {'name': '张三', 'age': 25}

print('%(name)s is %(age)d years old' % info)



# 2. 使用str.format()方法

# 更灵活，支持更多格式化选项

print('{name} is {age} years old'.format(**info))



# 3. 使用f-string（推荐，Python 3.6+）

# 最简洁、直观的方式

# 支持直接使用表达式

print(f"{info['name']} is {info['age']} years old")

5.2 高级格式化技巧

# 1. 对齐和填充

data = {'name': '张三', 'score': 95.5}

# 左对齐，宽度10

# 右对齐，宽度8，保留2位小数

print(f"{data['name']:<10}|{data['score']:>8.2f}")



# 2. 使用字典进行复杂模板格式化

# 适用于生成报告、配置文件等

template = '''

学生信息：

姓名：{name}

年龄：{age}

成绩：{score:.1f}

'''



student = {

    'name': '张三',

    'age': 18,

    'score': 95.6

}



print(template.format(**student))

6. 字典性能优化建议

6.1 字典创建优化

# 1. 预分配空间

# 当知道字典大小时，使用dict.fromkeys()预分配空间

# 避免频繁的内存重新分配

keys = range(10000)

optimized_dict = dict.fromkeys(keys)  # 预分配10000个空间



# 对比：动态增长的字典

unoptimized_dict = {}

for i in range(10000):

    unoptimized_dict[i] = None# 会导致多次内存重新分配



# 2. 使用字典推导式替代循环

# 字典推导式通常比循环创建字典更快

squares_comprehension = {x: x**2for x in range(1000)}  # 更快



squares_loop = {}

for x in range(1000):  # 更慢

    squares_loop[x] = x**2

6.2 访问优化

# 1. 使用get()方法的最佳实践

# 当确定键存在时，使用方括号访问更快

user = {'name': '张三', 'age': 25}



# 快：确定键存在时使用方括号

name = user['name']



# 慢：不必要的get()调用

name = user.get('name')



# 正确使用场景：键可能不存在时使用get()

phone = user.get('phone', '未设置')



# 2. 避免重复访问

# 对频繁访问的值进行本地缓存

def process_user_slow(user):

    # 差：重复访问字典

    print(f"姓名：{user['name']}")

    print(f"年龄：{user['age']}")

    if user['age'] > 18:

        print(f"{user['name']}是成年人")



def process_user_fast(user):

    # 好：将频繁使用的值缓存到局部变量

    name = user['name']

    age = user['age']

    print(f"姓名：{name}")

    print(f"年龄：{age}")

    if age > 18:

        print(f"{name}是成年人")

6.3 更新优化

# 1. 批量更新优化

# 使用update()方法进行批量更新，而不是多次单独更新

user = {'name': '张三'}



# 差：多次单独更新

user['age'] = 25

user['city'] = '北京'

user['email'] = 'zhangsan@example.com'



# 好：使用update()批量更新

user.update({

    'age': 25,

    'city': '北京',

    'email': 'zhangsan@example.com'

})



# 2. 避免频繁的增删操作

# 如果需要频繁增删，考虑使用collections.defaultdict或set

from collections import defaultdict



# 统计单词频率的例子

# 使用defaultdict避免键检查

word_counts = defaultdict(int)

text = "the quick brown fox jumps over the lazy dog"

for word in text.split():

    word_counts[word] += 1# 无需检查键是否存在

6.4 内存优化

# 1. 使用__slots__优化类字典

# 当类属性固定时，使用__slots__可以显著减少内存使用

class UserNormal:

    def __init__(self, name, age):

        self.name = name

        self.age = age



class UserOptimized:

    __slots__ = ['name', 'age']  # 显著减少内存使用

    def __init__(self, name, age):

        self.name = name

        self.age = age



# 2. 及时清理不需要的数据

# 使用clear()方法而不是重新赋值

large_dict = {i: i**2for i in range(10000)}



# 差：直接赋值新字典

large_dict = {}  # 旧字典仍在内存中，等待垃圾回收



# 好：使用clear()清理

large_dict.clear()  # 立即释放内存



# 3. 使用弱引用字典

# 当需要缓存对象但不阻止它们被垃圾回收时

from weakref import WeakKeyDictionary



class Cache:

    def __init__(self):

        # 当键对象没有其他引用时，自动从字典中删除

        self.data = WeakKeyDictionary()

6.5 性能测试示例

import timeit

import sys



# 1. 字典创建性能对比

def test_dict_creation():

    # 测试不同创建方法的性能

    setup = """size = 1000"""

    

    test1 = """dict_comp = {x: x**2 for x in range(size)}"""

    test2 = """dict_loop = {}

for x in range(size):

    dict_loop[x] = x**2"""

    

    time1 = timeit.timeit(test1, setup, number=1000)

    time2 = timeit.timeit(test2, setup, number=1000)

    

    print(f"字典推导式: {time1:.4f}秒")

    print(f"循环创建: {time2:.4f}秒")



# 2. 内存使用对比

def compare_memory_usage():

    # 测试普通类和使用__slots__的类的内存占用

    normal_users = [UserNormal(f"user{i}", i) for i in range(1000)]

    optimized_users = [UserOptimized(f"user{i}", i) for i in range(1000)]

    

    normal_size = sys.getsizeof(normal_users[0]) * len(normal_users)

    optimized_size = sys.getsizeof(optimized_users[0]) * len(optimized_users)

    

    print(f"普通类对象占用内存: {normal_size/1024:.2f}KB")

    print(f"优化类对象占用内存: {optimized_size/1024:.2f}KB")



if __name__ == '__main__':

    print("性能测试结果：")

    test_dict_creation()

    print("\n内存使用对比：")

    compare_memory_usage()