字典 — 按名字取值的映射表Copy Anchor Link

前三种容器按位置取元素,字典按键取名。 列表是储物柜 (按柜号取),字典是查号台(报上名字,直接查到你)。 它用哈希表实现,查找速度和集合一样快,但多了一样本事: 每个键背后挂着一个值——查「在不在」之外,还能问「是多少」。

1. 这一章在全书链条里的位置Copy Anchor Link

读法建议:字典章有一个「前松后紧」的节奏——前三节(映射、创建、 访问)都是铺垫,第四节「赋值的双重身份」开始才是它独有的功课; §9 的四容器总表是全书数据结构部分的收官,值得单独留一段 完整时间。如果前十三章学累了,可以先读 §9 拿全景,再回头 补细节——全景先行在这章是合法的读法。

四种容器排位的最后一席。书里给字典的定位是「mapping-based (基于映射的)结构」——与序列(列表、元组)和成员袋(集合) 并列的第三大类¹。它也是前十三章几乎所有伏笔的收束: 第 12 章说「元组能当字典键」,第 13 章说「空花括号是字典」, 第 11 章说「记录型数据最终投奔字典」——这一章全部兑现。 学完后,Python 的内建容器地图就完整了。

2. 顶层全景:一张映射表的三个动作Copy Anchor Link

  造     {'name': 'John', 'age': 30}       键:值 对,花括号装
  查     d['name'] → 'John'                 按键取值;键不存在报 KeyError
  遍历   for k, v in d.items():             三视角:keys() / values() / items()
  改     d['age'] = 31 / del d['city']      赋值即插入(键已存在则覆盖)

  图说:增、查、遍历、改——映射表的四个基本动作。

3. 核心原理一:映射与哈希表 — 字典为什么快Copy Anchor Link

书里给了本章唯一一段机制性解释,值得整段带走²:

• 字典的底层是哈希表(hash table):把键算成一个整数 (哈希值),由这个整数直接定位到存储位置;
• 增、查、删的平均代价是常数时间——数据从 10 条涨到 十万条,单次查找的耗时几乎不变;
• 这就是为什么键必须可哈希、且唯一(第 12 章的两道 门在这里第三次出现):哈希表靠键的哈希值定位, 两个键若相同,后者会覆盖前者。

五个真实场景书里列了五个³:数据库记录(键=字段名)、 软件配置(键=参数名)、缓存(键=输入,值=算过的结果)、 翻译系统(键=源语言词,值=译文)、通讯录(键=名字,值=联系方式)。 五例的共同点:「键有语义」——这正是字典对列表的终极优势: student['age'] 自解释,student[1] 靠猜。

4. 核心原理二:创建 — 三种原料一个壳Copy Anchor Link

创建三法里有一个「隐形的键名转换」值得点破:dict(name='Jane') 的键 name 没带引号——Python 把关键字参数的参数名自动 转成了字符串键。这是字典独有的便利(列表元组都没有对应物), 也是配置文件写法(dict(debug=True, port=8080))的地道形态⁴。

dict(name='Jane', age=25, city='Los Angeles')   # 关键字实参 → 键自动转成字符串
dict([('name', 'Alice'), ('age', 35)])           # 元组列表 → 一对一元组拆成键值
{'name': 'John', 'age': 30, 'city': 'New York'} # 花括号字面量(最常用)

len() 数的是键值对的个数:三个键值对的字典 len 是 3⁴。 练习区造了两张互逆的星期表(weekdays:数字→星期名; daysweek:星期名→数字)——同一个映射,方向反过来, 键和值的类型互换,都是合法字典⁵。映射没有「正向」「反向」 之分,只有「你要从哪边查」。

还有第三种摆法值得专门看——「列式」字典:

country_GDP_List = {'Name': ['United States', 'China', 'Germany', 'Japan', 'India'],
                    'GDP': [25462700, 17963171, 4072192, 4231141, 3385090]}

键是字段名,值是整列数据⁵。这是数据分析(pandas 的 前身形态)的标准摆法:一列一个键,所有列等长。对比「行式」 (一条记录一个字典,字典的列表),列式更适合「按字段整体运算」, 行式更适合「按记录整体处理」——第 15 章案例会两种都见到。

5. 核心原理三:访问 — 三个视角的视图Copy Anchor Link

一个快速定位:这一节的关键词是「视角」——同一个字典, keys() 给你名单视角,values() 给你内容视角,items() 给你 对照视角。选哪个视角,取决于你要对「名单」「内容」还是 「对应关系」干活;选错视角就要绕路(比如用 keys() 再回头 取值,不如直接用 items())。

字典的访问比序列丰富:除了按键取值,还有三个视图(view) 方法,分别给你键、值、键值对⁶:

my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}

my_dict.keys()    # dict_keys(['name', 'age', 'city'])    所有键
my_dict.values()  # dict_values(['John', 30, 'New York'])  所有值
my_dict.items()  # dict_items([('name', 'John'), ...])     所有对——元组!

三个视图的名字(dict_keys 等)提示了一个性质:它们是 「动态视图」不是列表——字典改了,视图跟着变(通用知识, 不在书里)。要当列表用(索引、排序)得套 list(...)。

遍历的三种写法对应三个视角⁶:

for key in my_dict:                    # 直接遍历 = 遍历键(最简)
  print(key)

for key in my_dict:
  print(my_dict[key])                  # 键入手,取值

for key, value in my_dict.items():     # items() + 解包:键值同取(最常用)
  print(f'({key}: {value})')

第三种是黄金写法——items() 给出元组对,for k, v in ... 解包(第 12 章的解包在这里第三次上岗)。练习区走了一遍全组合: weekdays.items() 打印七对元组、weekdays[1] 取值、 GDP 字典加条件筛选(if v > 10000000 只留中美两国)⁷—— 字典遍历 + 分支筛选 = 一切「按条件查记录」的原型。

主线例子:GDP 字典的一生Copy Anchor Link

用练习区的国家 GDP 数据走完字典的一生(数字全部来自原书)⁵⁷⁸:

  ① 造    country_GDP = {'United States': 25462700, 'China': 17963171,
                        'Germany': 4072192, 'Japan': 4231141, 'India': 3385090}
          len = 5 —— 五对键值;键是国名(字符串),值是 GDP(百万美元)
  ② 查    country_GDP['United States'] → 25462700
          country_GDP['Mars'] → KeyError(查无此键)
  ③ 筛    for k, v in country_GDP.items():
            if v > 10000000: print(k, v)   → 只有美中印?不——输出两行:
                                             United States:25462700
                                             China:17963171(只有这两家过十万亿)
  ④ 增    country_GDP.update({'United Kingdom': 3070668, 'France': 2782905,
                               'Brazil': 1920096, 'Italy': 2010432,
                               'Canada': 2139840})      → len 变 10
  ⑤ 改    country_GDP['China'] = 新数字   → 覆盖旧值(赋值即覆盖)
  ⑥ 删    del country_GDP['France']       → 那一对键值一起消失

  图说:增(update/赋值)、查(键/index+条件)、改(赋值)、删(del)——
  数据库四操作的完整雏形。

6. 核心原理四:增删改 — 赋值的双重身份Copy Anchor Link

字典的「改」最简洁:d[key] = value 一个语法身兼两职⁹:

my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}

my_dict['ID'] = '0001'     # 键不存在 → 新增这一对
my_dict['name'] = 'Neo'    # 键已存在 → 覆盖旧值

书里专门警告了这个双重身份:先想清楚键在不在—— 不小心用了已存在的键,旧值被无声覆盖,和数据被改了一样难查 (第 11 章别名问题的字典版)。update() 是它的批量版, 原料可以是另一个字典,也可以是元组列表⁹:

my_dict.update({'email': 'a@b.com', 'major': 'English'})     # 并入字典
my_dict.update([('phone', '123-456-7890'), ('fax', '098-765-4321')])  # 并入元组对
del my_dict['fax']                                            # 按键删一对

练习区三连:weekdays 七个值整体改写成缩写(七次赋值, 覆盖不新增——键都是旧的);daysweek 删掉周末两个键; country_GDP update 进五国⁸。删除还有一个表里的方法 pop(key)——删的同时把值交回来(pop('a') 返回 1), 以及 popitem()(弹出一对)。del 与 pop 的分工: 不要那个值 → del;还要用那个值 → pop¹⁰。

7. 核心原理五:字典推导式 — 第四种壳Copy Anchor Link

壳的终章:花括号里带冒号的推导式¹¹:

squares_dict = {x: x ** 2 for x in range(1, 6)}
# {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

word_lengths = {word: len(word) for word in ['apple', 'banana', 'cherry']}
# {'apple': 5, 'banana': 6, 'cherry': 6}

combined = {keys[i]: values[i] for i in range(len(keys))}   # 两列表合成字典
# {'a': 1, 'b': 2, 'c': 3}

even_degree = {x: [x*2, x**2] for x in range(10) if x % 2 == 0}
# {0: [0, 0], 2: [4, 4], 4: [8, 16], 6: [12, 36], 8: [16, 64]}

与另外三种壳的对比一眼可见:字典推导式冒号前是键表达式、 冒号后是值表达式,for/if 照旧¹¹。{x: x**2 ...} 的键是 x、 值是 x²;{word: len(word) ...} 的键是词、值是长度—— 键和值可以是完全不同的表达式,这是映射型推导独有的自由度。

练习区的句子题是综合应用:{word: len(word) for word in sentence.split()},输入 'Python is a useful language',输出 {'Python': 6, 'is': 2, 'a': 1, 'useful': 6, 'language': 8}—— split 切词(第 05 章)、len 量长、推导式收进字典,三章工具一行合流。 加 if len(word) > 3 后,is 和 a 被筛掉¹²。

还有一条「索引配对」的捷径要会:dict(zip(keys, values)) (通用知识,不在书里)与 {k: v for k, v in zip(keys, values)} 等效——zip 按位配对,dict 直接收成字典,比 range+索引 更地道。

9. 四种容器总表:全书数据结构部分的收官Copy Anchor Link

四种容器全部登场,把分散在第 11–14 章的选择判据汇成一张总表—— 这是全书后半部最值得打印的一页:

选型决策树(从上往下走,第一个命中的就是答案):

  需要按「名字/标识」取值吗?      是 → 字典
  需要数学集合运算(交并差)吗?    是 → 集合
  造好之后会被改吗?              不会 → 元组
  以上都不是                     → 列表(默认答案)

  图说:字典最特化(映射),集合次之(运算),元组是纪律(只读),
  列表是兜底——拿不准就用列表,错不了太远。

这张表也是「编程语言与系统研究」视角下的一个观察样本: 四种容器不是四个孤立工具,而是**「序列性、可变性、键语义」 三个维度的组合设计**——删掉任何一个维度,就得到另一种容器。 理解这个设计空间,比记住四种容器的 API(每个容器自带的命令清单)更有迁移价值 (换新语言时,你会先找它的 dict 和 list,而不是先背语法)。

10. get() 与计数模式:正文留白的主修补Copy Anchor Link

d[key] 的 KeyError 是字典第一课,但正文没给安全查法—— 补上,并给出它最重要的应用场景:计数器¹³:

# 安全取值:查无此键时给默认值,不报错
gdp = country_GDP.get('France', 0)      # 有 → 返回值;无 → 返回 0
d.get('Mars')                            # 无默认时,查无此键返回 None

# 计数模式:数一批东西里每种出现几次
words = ['apple', 'banana', 'apple', 'cherry', 'banana', 'apple']
counts = {}
for w in words:
  counts[w] = counts.get(w, 0) + 1       # 没有就当 0,数过就加一
# {'apple': 3, 'banana': 2, 'cherry': 1}

计数模式逐行走一遍:counts.get(w, 0) 第一次遇到 'apple' 时返回 0(默认),加一存回;第二次遇到,get 拿到 1,加一存 2…… 「get 带默认 + 加一存回」是字典最经典的一行,它的变体 (累加、收集、标记)撑起了数据清洗的半壁江山。 第 16 章的 Counter 就是把这个模式做成了官方工具。

11. 练习走查:GDP 数据的完整数据工程Copy Anchor Link

14.2.2 的 GDP 练习是全书最接近真实数据工作的一段,值得按 「数据工程」的眼光重走一遍⁵⁸:

  第 1 步 采集   造 country_GDP(行式):五国 GDP,单位百万美元
  第 2 步 摆形   再造 country_GDP_List(列式):同样的数据,键是字段名,
                 值是整列——同一个世界的两张表
  第 3 步 查询   country_GDP['United States'] → 25462700
                 for k, v in ...items() if v > 10000000 → 美中两国
  第 4 步 扩展   update 进第 6–10 名五国 → len 5 变 10
  第 5 步 加列   country_GDP_List['Population'] = [...] → 列式加新字段,
                 一次赋值长出一列

  图说:采集 → 摆形 → 查询 → 扩展 → 加列——真实数据分析项目
  的五个阶段,一个练习全走了。第 5 步「加列」尤其有 pandas 味道:
  列式数据加字段,就是 dict 加键。

「行式加记录 vs 列式加字段」的不对称值得记住:行式数据加一条 记录是 append 一条字典;列式加一条记录要给每个键都 append ——反过来,列式加字段是一步赋值,行式加字段要遍历每条记录改。 加记录选行式,加字段选列式,这个判据会在你下一次设计 数据结构时自动生效。

练习走查二:一对互逆的字典(weekdays 与 daysweek)Copy Anchor Link

14.2.2 的另一组练习造了一对方向相反的星期字典,看似重复, 其实藏着字典作为「映射」的本义¹⁴:

weekdays  = {1: 'Monday', 2: 'Tuesday', …, 7: 'Sunday'}   # 数字 → 英文名
daysweek  = {'Monday': 1, 'Tuesday': 2, …, 'Sunday': 7}   # 英文名 → 数字

第一个字典回答「第几天是星期几」:weekdays[1] → 'Monday'。 第二个回答反向的问题:「Tuesday 是一周第几天」:daysweek['Tuesday'] → 2。 同一个世界,两个查询方向,就要两张映射表——这是字典和列表 的根本分野:列表天生只会「第几个」,字典让你自己定义「按什么查」。

这一组练习还演示了字典内容的两类典型维护。改值:把 7 个全称换成 缩写('M'、'Tu'、'W'……),七次 weekdays[1] = 'M' 式的赋值, 键不动、值全换¹⁴。删键:del daysweek['Saturday']、del daysweek['Sunday'], 直接把周末从表里划掉,剩 5 个工作日¹⁴。 改值是覆盖,删键是消失——赋值的双重身份(新键则建、旧键则盖) 在这里各演了一遍。

访问这一侧,练习又示范了字典的三种看法:直接按键查(weekdays[1] → 'Monday';daysweek['Monday'] → 1)、items() 遍历打印每一对 (('Monday', 1) 这样的小元组一行一对)、以及条件筛选—— 「GDP 超过一千万(单位:百万)的国家」用 if v > 10000000 从 country_GDP 里滤出美、中两国¹⁵。 三种看法正好对应字典数据的三种典型用法:点名、过花名册、按条件圈人。 这组小练习合起来的信息量是:字典的全部本事,就是「按你定义的键查、 按你定义的条件筛」——键是什么、值是什么,完全由你的问题决定; 同一个星期,既能以「第几天」为键,也能以「英文名」为键。

12. 字典与 JSON:通往世界的格式Copy Anchor Link

字典还有一层本书未展开的身份:它是 JSON 的原生对应物。 JSON(一种数据交换格式,网络上 API 传数据的通用语言)的 对象结构 {"name": "John", "age": 30},和 Python 字典 几乎逐字符相同。标准库的 json 模块两个函数打通两个世界 (通用知识,不在书里)¹⁶:

import json

json.dumps({'name': 'John', 'age': 30})   # 字典 → JSON 文本
json.loads('{"name": "John", "age": 30}') # JSON 文本 → 字典

这意味着:学会字典,你就同时学会了「读网络上的数据」的一半 ——抓个 API 返回,json.loads 之后就是一个嵌套字典, 本章的全部操作(按键取值、items 遍历、条件筛选)直接上岗。 第 15 章案例之后的任何真实项目,字典都是数据的默认形态; JSON 则是数据出远门时的默认行李。

13. 作者的判断与证据Copy Anchor Link

• 「哈希表实现、平均常数时间」是本书对数据结构机制讲得最深的 一段²——前面三种容器都没给过内部实现的说明, 可见作者认为字典的「快」值得解释,也值得读者记住。
• 五个真实场景的选择(记录/配置/缓存/翻译/通讯录)覆盖了 字典的全部经典用途³;「缓存」一例是性能意识的体现—— 字典当备忘录,是编程里性价比最高的优化之一。
• 「行式 vs 列式」的对比没有点破,但两种摆法在练习里并排出现 (country_GDP 与 country_GDP_List)⁵——第 15 章案例的 数据形态在这里提前彩排。
• 总结表(Table 14.1)补了正文没讲的 pop/popitem,并标注了 d[key] 的 KeyError——表比正文宽的老传统,最后一章 依然如故¹⁰。

14. 边界与局限Copy Anchor Link

一分钟自查先放前面:能否不看资料写出——建一个空字典、 安全地查一个可能不存在的键、遍历键值对、用推导式造 「词→词长」的字典?四问全对,本章毕业。

判断(我们的,不是书里的): 字典是四种容器里「新手收益最高」 的一种——因为「按键取名」是人和数据最自然的对话方式。 学生记录、商品目录、配置项、通讯录,现实世界全是键值对; 学会字典,等于学会了用代码复刻世界的基本数据结构。 如果只能精通一种容器,选字典;如果只能背一张表,背 §9 的 决策树。 如果错,会错在: 对纯数值计算(数组、矩阵)的场景, 字典的收益骤降——那是 numpy 数组的领地;「收益最高」的判断 针对的是通用编程与数据处理,不是数值计算。

• d[key] 对缺失键报 KeyError——而 get() 是正文缺席的解法。 d.get('Mars') 返回 None(不报错),d.get('Mars', 0) 可以 指定「查无此键时的默认值」——计数、累加场景(第 15 章案例的 counts[word] = counts.get(word, 0) + 1)全靠它。正文只字未提, 这是本章最大的留白,必须补¹³。
• 键必须可哈希且唯一,值随意。 列表、字典、集合不能当键 (元组可以——元素全不可变时);值可以是任何东西, 包括列表和另一个字典(嵌套字典,JSON 的原型)。
• 字典保插入序(Python 3.7+ 的语言保证):遍历 items() 按插入顺序走——这是「有序」和「序列」的区别: 有序(遍历顺序固定)不等于有索引(不能 d[0])。
• 「行式 vs 列式」的取舍:字段固定、按记录处理 → 行式 (列表套字典);字段成组运算、数据量大 → 列式(字典套列表, pandas 的雏形)。第 15 章四个案例会各用一种,看完回头这里就通了。
• 没有讲字典的嵌套访问(d['a']['b'],JSON 数据的日常)、 setdefault、collections 里的 defaultdict 和 Counter—— 第 16 章的三件套正好补上后两个(原书把 collections 单独成章, 是完整设计)。嵌套访问的要点:外层键取到内层容器, 再对内层照常操作,一级一级往下走即可。

15. 可带走的Copy Anchor Link

1. 字典 = 键值映射;哈希表实现,增查删平均 O(1)¹²。
2. 键必须可哈希且唯一;值任意;重复键后者覆盖前者²。
3. 创建三法:dict(关键字)、dict(元组对列表)、花括号字面量⁴。
4. d[key] 取值,缺失报 KeyError;d.get(key, 默认) 才是安全查法¹³。
5. 三视图:keys()、values()、items();遍历黄金写法 for k, v in d.items()⁶。
6. d[k] = v 双重身份:新键插入、旧键覆盖;update() 批量并入⁹。
7. 删除:del(不要值)、pop(要值);表里的 popitem 弹一对¹⁰。
8. 字典推导式 = {键表达式: 值表达式 for ... if ...}¹¹。
9. 行式 vs 列式:按记录处理 vs 按字段运算,第 15 章见真章。
10. 同一批数据可以造互逆的两张字典(数字 → 星期、星期 → 数字):查询方向不同, 映射表就不同——「按什么查」永远由你的问题决定,这是字典和列表的根本分野¹⁴¹⁵。

这一章是四种结构的最后一章单讲;它的练习量(造表、查表、改表、删表)也是 全书最大的——把这一章的练习都做顺,数据篇的地基就算打完了。

16. 原文地图Copy Anchor Link