Python字典dict创建方法详解与哈希表底层原理实战

脚本专家

Python 的字典（dict）是开发中最常用的映射类型数据结构，基于哈希表实现，提供 O(1) 平均时间复杂度的键值存取。本文从八种创建方式入手，深入哈希表底层原理，讲解键的哈希性要求、Python 3.6+ 优化、性能对比以及实战中的构建模式，帮助你彻底掌握 dict 的正确用法。

一、什么是字典
字典是一种键值对存储结构，每个键映射到一个值。键必须是可哈希（不可变）类型，如字符串、整数、元组（元素全不可变）。Python 3.7+ 官方保证字典保持插入顺序。通过键直接访问值，速度极快。

2. person = {
3. 'name': '小明',
4. 'age': 25,
5. 'city': '北京',
6. 'job': '工程师',
7. }
8. print(person['name']) # 小明

复制代码

二、字典的八种创建方式

1. 花括号字面量（最常用）

2. empty = {}
3. person = {'name': '小明', 'age': 25, 'city': '北京'}
4. # 嵌套字典
5. config = {
6. 'database': {'host': 'localhost', 'port': 5432},
7. 'cache': {'host': 'redis://localhost', 'port': 6379},
8. }

复制代码

2. dict() 构造函数

2. # 关键字参数：键必须是合法标识符
3. d1 = dict(name='小明', age=25, city='北京')
4. # 可迭代对象（每个元素是元组）
5. d2 = dict([('name', '小明'), ('age', 25), ('city', '北京')])
6. # zip 组合两个列表
7. keys = ['name', 'age', 'city']
8. values = ['小明', 25, '北京']
9. d3 = dict(zip(keys, values))
10. # 混合使用
11. d4 = dict(name='小明', age=25)
12. d4.update({'city': '北京'})

复制代码

3. 字典推导式

2. squares = {x: x ** 2 for x in range(6)}
3. # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
4. # 带条件
5. even_squares = {x: x ** 2 for x in range(10) if x % 2 == 0}
6. # {0: 0, 2: 4, 4: 16, 6: 36, 8: 64}
7. # 反转键值
8. original = {'a': 1, 'b': 2, 'c': 3}
9. reversed_dict = {v: k for k, v in original.items()}
10. # 过滤
11. scores = {'小明': 85, '小红': 92, '小刚': 78, '小李': 95}
12. passing = {name: score for name, score in scores.items() if score >= 90}

复制代码

4. fromkeys()

2. keys = ['a', 'b', 'c', 'd']
3. d = dict.fromkeys(keys, 0)  # {'a': 0, 'b': 0, 'c': 0, 'd': 0}
4. d2 = dict.fromkeys(['x', 'y', 'z'])  # 值默认为 None

复制代码

注意：fromkeys 使用可变默认值（如空列表）时会导致所有键共享同一对象，应改用推导式。

2. # 正确用法：每个键独立列表
3. d3 = {k: [] for k in ['a', 'b']}
4. d3['a'].append(1)
5. print(d3)  # {'a': [1], 'b': []}

复制代码

5. 从 Counter 创建

2. from collections import Counter
3. words = ['apple', 'banana', 'apple', 'cherry', 'banana', 'apple']
4. counter = Counter(words)
5. print(dict(counter))  # {'apple': 3, 'banana': 2, 'cherry': 1}

复制代码

6. 从 JSON 字符串创建

2. import json
3. json_str = '{"name": "小明", "age": 25, "scores": [85, 92, 78]}'
4. data = json.loads(json_str)

复制代码

三、底层原理：哈希表
字典的底层是哈希表：通过 hash() 函数将键转为整数，再映射到内部数组的索引。这是 O(1) 查找的根本原因。

2. print(hash('hello'))   # 整数（每次运行可能不同）
3. print(hash(42))        # 42
4. print(hash((1,2,3)))   # 整数

复制代码

哈希冲突：不同键可能映射到同一索引，Python 使用开放寻址法解决。正常场景下不影响性能，极端情况（所有键哈希值相同）退化为 O(n)。

键的哈希性要求：键必须实现 __hash__ 和 __eq__。字符串、数字、布尔值、全不可变元组、None、frozenset 可哈希；列表、字典、集合不可哈希。自定义对象默认可哈希（基于 id），一旦定义 __eq__ 必须同时定义 __hash__。

Python 3.6+ 优化：采用紧凑存储（稠密表+索引表），内存减少 20-25%，并且 Python 3.7+ 官方保证保持插入顺序。

四、键类型深入与缺失键处理
90% 的字典键为字符串，便于序列化和配置。

常见错误：访问不存在的键引发 KeyError。四种处理方式：

2. d = {'name': '小明', 'age': 25}
3. # 1. get() 返回默认值
4. city = d.get('city', '未知')  # '未知'
5. # 2. in 检查
6. if 'city' in d: city = d['city']
7. # 3. setdefault() 获取并设置默认值
8. city = d.setdefault('city', '北京')  # 返回 '北京'，并写入 d
9. # 4. collections.defaultdict
10. from collections import defaultdict
11. words = ['apple', 'banana', 'apricot']
12. by_first = defaultdict(list)
13. for w in words:
14. by_first[w[0]].append(w)
15. print(dict(by_first))  # {'a': ['apple', 'apricot'], 'b': ['banana']}

复制代码

五、性能特征
常用操作时间复杂度：
- d[key]、d[key]=value、del d[key]、key in d 均为 O(1)
- 遍历、copy、clear 为 O(n)
- len(d) 是 O(1)（字典维护计数）

对比列表 in 查找：

2. import time
3. n = 10000
4. lst = list(range(n))
5. d = {i: True for i in range(n)}
6. start = time.perf_counter()
7. for _ in range(10000):
8. _ = 9999 in lst
9. t_list = time.perf_counter() - start
10. start = time.perf_counter()
11. for _ in range(10000):
12. _ = 9999 in d
13. t_dict = time.perf_counter() - start
14. print(f'列表查找: {t_list:.4f}s，字典查找: {t_dict:.4f}s，快 {t_list/t_dict:.0f} 倍')

复制代码

随 n 增大，字典优势更加明显。

六、字典视图：keys()、values()、items()
视图是动态的，反映字典的实时变化。

2. d = {'name': '小明', 'age': 25, 'city': '北京'}
3. keys = d.keys()
4. d['job'] = '工程师'
5. print(keys)  # 自动包含 'job'

复制代码

视图支持集合操作（keys 和 items）：交集（&）、并集（|）、差集（-）、对称差（^）。values 通常不支持，因为值可能重复或不可哈希。

七、实战构建模式

查找表替代 if-elif 链

2. def get_status_text(code):
3. status = {
4. 200: '成功', 301: '永久重定向', 404: '未找到',
5. 500: '服务器错误', 502: '网关错误', 503: '服务不可用',
6. }
7. return status.get(code, '未知状态')

复制代码

函数调度表

2. def add(a,b): return a+b
3. def sub(a,b): return a-b
4. ops = {'+': add, '-': sub, '*': lambda a,b: a*b, '/': lambda a,b: a/b if b else None}
5. def calculate(op, a, b):
6. func = ops.get(op)
7. if func: return func(a, b)
8. raise ValueError(f'不支持运算符: {op}')

复制代码

缓存装饰器

2. def memoize(func):
3. cache = {}
4. def wrapper(*args):
5. if args not in cache:
6. cache[args] = func(*args)
7. return cache[args]
8. return wrapper
10. @memoize
11. def fibonacci(n):
12. if n < 2: return n
13. return fibonacci(n-1) + fibonacci(n-2)
15. print(fibonacci(40))  # 102334155，秒出

复制代码

八、小结
字典是 Python 开发中不可或缺的工具。掌握花括号、dict()、推导式、fromkeys、JSON 等创建方式，理解哈希表底层原理，正确处理缺失键，利用视图和集合操作，能够极大提升代码效率。下一篇将重点讲解字典的增删改查操作。

热心网友7

感谢楼主的详尽讲解！八种创建方式总结得很全面，特别是字典推导式的几种变体以及 `fromkeys` 的坑点提醒，非常实用。底层原理部分也讲得很清晰，紧凑存储和顺序保证确实是 Python 3.6+ 的重大改进。另外想反馈一个小细节：第五部分“性能特征”好像只写了“常用操作”四个字就截断了，是内容还没写完吗？期待后续补充，谢谢！