流畅的Python(第2版)
Luciano Ramalho
安道 译
出版时间:2023年04月
页数:736
“一旦要深入了解和使用某个Python特性,我必先翻阅这本书。卢西亚诺的教学方式十分出色。本书是指导初学者修炼技能的上乘之作。”
——Carol Willing
Python指导委员会成员(2020—2021)
“这不是一本干讲编程技巧的书,其中还包含了大量经过测试的有用示例,且文风幽默。读完这本行文如流水的精彩之作,我和同事的Python编程水平都上了一个新台阶。”
——Maria McKinley
高级软件工程师

不要浪费时间让Python屈就你在其他语言中学到的模式。Python的简洁性有助于你迅速提升编程效率,但这通常意味着你并未使用它所提供的所有功能。《流畅的Python》是编程领域的实用经典参考书,第2版做了与时俱进的修订和升级,教你利用Python特性,写出高效且现代的Python 3代码。
打破旧有经验,探索并运用地道的Python 3特性。本书作者带你一览Python语言核心功能和库,教你编写更简洁、快速和易读的代码。
第2版分为如下五部分,每一部分均可单独成书。
● 数据结构:序列、字典、集合、Unicode和数据类。
● 函数即对象:一等函数、相关设计模式和函数声明中的类型提示。
● 类和协议:组合、继承、混入、接口、运算符重载、协议和更多静态类型。
● 控制流:上下文管理器、生成器、协程、async/await及线程和进程池。
● 元编程:特性、属性描述符、类装饰器,以及可取代或简化元类的类元编程新钩子。
  1. 【上册】
  2. 前言 
  3. 第一部分 数据结构
  4. 第1章 Python数据模型 
  5. 1.1 本章新增内容 
  6. 1.2 一摞Python风格的纸牌 
  7. 1.3 特殊方法是如何使用的 
  8. 1.3.1 模拟数值类型 
  9. 1.3.2 字符串表示形式 
  10. 1.3.3 自定义类型的布尔值 
  11. 1.3.4 容器API 
  12. 1.4 特殊方法概述 
  13. 1.5 len为什么不是方法 
  14. 1.6 本章小结 
  15. 1.7 延伸阅读 
  16. 第2章 丰富的序列 
  17. 2.1 本章新增内容 
  18. 2.2 内置序列类型概览 
  19. 2.3 列表推导式和生成器表达式 
  20. 2.3.1 列表推导式对可读性的影响 
  21. 2.3.2 列表推导式与map和filter比较 
  22. 2.3.3 笛卡儿积 
  23. 2.3.4 生成器表达式 
  24. 2.4 元组不仅仅是不可变列表 
  25. 2.4.1 用作记录 
  26. 2.4.2 用作不可变列表 
  27. 2.4.3 列表和元组方法的比较 
  28. 2.5 序列和可迭代对象拆包 
  29. 2.5.1 使用*获取余下的项 
  30. 2.5.2 在函数调用和序列字面量中使用*拆包 
  31. 2.5.3 嵌套拆包 
  32. 2.6 序列模式匹配 
  33. 2.7 切片 
  34. 2.7.1 为什么切片和区间排除最后一项 
  35. 2.7.2 切片对象 
  36. 2.7.3 多维切片和省略号 
  37. 2.7.4 为切片赋值 
  38. 2.8 使用+和*处理序列 
  39. 2.8.1 构建嵌套列表 
  40. 2.8.2 使用增量赋值运算符处理序列 
  41. 2.8.3 一个+=运算符赋值谜题 
  42. 2.9 list.sort与内置函数sorted 
  43. 2.10 当列表不适用时 
  44. 2.10.1 数组 
  45. 2.10.2 memoryview 
  46. 2.10.3 NumPy 
  47. 2.10.4 双端队列和其他队列 
  48. 2.11 本章小结 
  49. 2.12 延伸阅读 
  50. 第3章 字典和集合 
  51. 3.1 本章新增内容 
  52. 3.2 字典的现代句法
  53. 3.2.1 字典推导式 
  54. 3.2.2 映射拆包 
  55. 3.2.3 使用|合并映射 
  56. 3.3 使用模式匹配处理映射 
  57. 3.4 映射类型的标准API 
  58. 3.4.1 “可哈希”指什么 
  59. 3.4.2 常用映射方法概述 
  60. 3.4.3 插入或更新可变的值 
  61. 3.5 自动处理缺失的键 
  62. 3.5.1 defaultdict:处理缺失键的另一种选择 
  63. 3.5.2 __missing__方法 
  64. 3.5.3 标准库对__missing__方法的使用不一致 
  65. 3.6 dict的变体 
  66. 3.6.1 collections.OrderedDict 
  67. 3.6.2 collections.ChainMap 
  68. 3.6.3 collections.Counter 
  69. 3.6.4 shelve.Shelf 
  70. 3.6.5 子类应继承UserDict而不是dict 
  71. 3.7 不可变映射 
  72. 3.8 字典视图 
  73. 3.9 dict的实现方式对实践的影响 
  74. 3.10 集合论 
  75. 3.10.1 set字面量 
  76. 3.10.2 集合推导式 
  77. 3.11 集合的实现方式对实践的影响 
  78. 3.12 字典视图的集合运算 
  79. 3.13 本章小结 
  80. 3.14 延伸阅读 
  81. 第4章 Unicode文本和字节序列 
  82. 4.1 本章新增内容 
  83. 4.2 字符问题 
  84. 4.3 字节概要 
  85. 4.4 基本的编码解码器 
  86. 4.5 处理编码和解码问题 
  87. 4.5.1 处理UnicodeEncodeError 
  88. 4.5.2 处理UnicodeDecodeError 
  89. 4.5.3 加载模块时编码不符合预期抛出的SyntaxError 
  90. 4.5.4 如何找出字节序列的编码 
  91. 4.5.5 BOM:有用的鬼符 
  92. 4.6 处理文本文件 
  93. 4.7 为了正确比较而规范化Unicode字符串 
  94. 4.7.1 大小写同一化 
  95. 4.7.2 规范化文本匹配的实用函数 
  96. 4.7.3 极端“规范化”:去掉变音符 
  97. 4.8 Unicode文本排序 
  98. 4.9 Unicode数据库 
  99. 4.9.1 按名称查找字符 
  100. 4.9.2 字符的数值意义 
  101. 4.10 支持str和bytes的双模式API 
  102. 4.10.1 正则表达式中的str和bytes 
  103. 4.10.2 os函数中的str和bytes 
  104. 4.11 本章小结 
  105. 4.12 延伸阅读 
  106. 第5章 数据类构建器 
  107. 5.1 本章新增内容 
  108. 5.2 数据类构建器概述 
  109. 5.3 典型的具名元组 
  110. 5.4 带类型的具名元组 
  111. 5.5 类型提示入门 
  112. 5.5.1 运行时没有作用 
  113. 5.5.2 变量注解句法 
  114. 5.5.3 变量注解的意义 
  115. 5.6 @dataclass详解 
  116. 5.6.1 字段选项 
  117. 5.6.2 初始化后处理 
  118. 5.6.3 带类型的类属性 
  119. 5.6.4 初始化不作为字段的变量 
  120. 5.6.5 @dataclass示例:都柏林核心模式 
  121. 5.7 数据类导致代码异味 
  122. 5.7.1 把数据类用作脚手架 
  123. 5.7.2 把数据类用作中间表述 
  124. 5.8 模式匹配类实例 
  125. 5.8.1 简单类模式 
  126. 5.8.2 关键字类模式 
  127. 5.8.3 位置类模式 
  128. 5.9 本章小结 
  129. 5.10 延伸阅读 
  130. 第6章 对象引用、可变性和垃圾回收 
  131. 6.1 本章新增内容 
  132. 6.2 变量不是盒子 
  133. 6.3 同一性、相等性和别名 
  134. 6.3.1 在==和is之间选择 
  135. 6.3.2 元组的相对不可变性 
  136. 6.4 默认做浅拷贝 
  137. 6.5 函数的参数是引用时 
  138. 6.5.1 不要使用可变类型作为参数的默认值 
  139. 6.5.2 防御可变参数 
  140. 6.6 del和垃圾回收 
  141. 6.7 Python对不可变类型施加的把戏 
  142. 6.8 本章小结 
  143. 6.9 延伸阅读 
  144. 第二部分 函数即对象
  145. 第7章 函数是一等对象 
  146. 7.1 本章新增内容 
  147. 7.2 把函数视为对象 
  148. 7.3 高阶函数 
  149. 7.4 匿名函数 
  150. 7.5 9种可调用对象 
  151. 7.6 用户定义的可调用类型 
  152. 7.7 从位置参数到仅限关键字参数 
  153. 7.8 支持函数式编程的包 
  154. 7.8.1 operator模块 
  155. 7.8.2 使用functools.partial冻结参数 
  156. 7.9 本章小结 
  157. 7.10 延伸阅读 
  158. 第8章 函数中的类型提示 
  159. 8.1 本章新增内容 
  160. 8.2 关于渐进式类型 
  161. 8.3 渐进式类型实践 
  162. 8.3.1 Mypy初体验 
  163. 8.3.2 让Mypy严格要求 
  164. 8.3.3 参数的默认值 
  165. 8.3.4 使用None表示默认值 
  166. 8.4 类型由受支持的操作定义 
  167. 8.5 注解中可用的类型 
  168. 8.5.1 Any类型 
  169. 8.5.2 简单的类型和类 
  170. 8.5.3 Optional类型和Union类型 
  171. 8.5.4 泛化容器 
  172. 8.5.5 元组类型 
  173. 8.5.6 泛化映射 
  174. 8.5.7 抽象基类 
  175. 8.5.8 Iterable 
  176. 8.5.9 参数化泛型和TypeVar 
  177. 8.5.10 静态协议 
  178. 8.5.11 Callable 
  179. 8.5.12 NoReturn 
  180. 8.6 注解仅限位置参数和变长参数 
  181. 8.7 类型不完美,测试须全面 
  182. 8.8 本章小结 
  183. 8.9 延伸阅读 
  184. 第9章 装饰器和闭包 
  185. 9.1 本章新增内容 
  186. 9.2 装饰器基础知识 
  187. 9.3 Python何时执行装饰器 
  188. 9.4 注册装饰器 
  189. 9.5 变量作用域规则 
  190. 9.6 闭包 
  191. 9.7 nonlocal声明 
  192. 9.8 实现一个简单的装饰器 
  193. 9.9 标准库中的装饰器 
  194. 9.9.1 使用functools.cache做备忘 
  195. 9.9.2 使用lru_cache 
  196. 9.9.3 单分派泛化函数 
  197. 9.10 参数化装饰器 
  198. 9.10.1 一个参数化注册装饰器 
  199. 9.10.2 参数化clock装饰器 
  200. 9.10.3 基于类的clock装饰器 
  201. 9.11 本章小结 
  202. 9.12 延伸阅读 
  203. 第10章 使用一等函数实现设计模式 
  204. 10.1 本章新增内容 
  205. 10.2 案例分析:重构策略模式 
  206. 10.2.1 经典的策略模式 
  207. 10.2.2 使用函数实现策略模式 
  208. 10.2.3 选择最佳策略的简单方式 
  209. 10.2.4 找出一个模块中的全部策略 
  210. 10.3 使用装饰器改进策略模式 
  211. 10.4 命令模式 
  212. 10.5 本章小结 
  213. 10.6 延伸阅读 
  214. 第三部分 类和协议
  215. 第11章 符合Python风格的对象 
  216. 11.1 本章新增内容 
  217. 11.2 对象表示形式 
  218. 11.3 再谈向量类 
  219. 11.4 备选构造函数 
  220. 11.5 classmethod与staticmethod 
  221. 11.6 格式化显示 
  222. 11.7 可哈希的Vector2d 
  223. 11.8 支持位置模式匹配 
  224. 11.9 第3版Vector2d的完整代码 
  225. 11.10 Python私有属性和“受保护”的属性 
  226. 11.11 使用__slots__节省空间 
  227. 11.11.1 简单衡量__slot__节省的内存 
  228. 11.11.2 总结__slots__的问题 
  229. 11.12 覆盖类属性 
  230. 11.13 本章小结 
  231. 11.14 延伸阅读 
  232. 第12章 序列的特殊方法 
  233. 12.1 本章新增内容 
  234. 12.2 Vector类:用户定义的序列类型 
  235. 12.3 Vector类第1版:与Vector2d类兼容 
  236. 12.4 协议和鸭子类型 
  237. 12.5 Vector类第2版:可切片的序列 
  238. 12.5.1 切片原理 
  239. 12.5.2 能处理切片的__getitem__方法 
  240. 12.6 Vector类第3版:动态存取属性 
  241. 12.7 Vector类第4版:哈希和快速等值测试 
  242. 12.8 Vector类第5版:格式化 
  243. 12.9 本章小结 
  244. 12.10 延伸阅读 
  245. 第13章 接口、协议和抽象基类 
  246. 13.1 类型图 
  247. 13.2 本章新增内容 
  248. 13.3 两种协议 
  249. 13.4 利用鸭子类型编程 
  250. 13.4.1 Python喜欢序列 
  251. 13.4.2 使用猴子补丁在运行时实现协议 
  252. 13.4.3 防御性编程和“快速失败” 
  253. 13.5 大鹅类型 
  254. 13.5.1 子类化一个抽象基类 
  255. 13.5.2 标准库中的抽象基类 
  256. 13.5.3 定义并使用一个抽象基类 
  257. 13.5.4 抽象基类句法详解 
  258. 13.5.5 子类化抽象基类Tombola 
  259. 13.5.6 抽象基类的虚拟子类 
  260. 13.5.7 register的实际使用 
  261. 13.5.8 使用抽象基类实现结构类型 
  262. 13.6 静态协议 
  263. 13.6.1 为double函数添加类型提示 
  264. 13.6.2 运行时可检查的静态协议 
  265. 13.6.3 运行时协议检查的局限性 
  266. 13.6.4 支持静态协议 
  267. 13.6.5 设计一个静态协议 
  268. 13.6.6 协议设计最佳实践 
  269. 13.6.7 扩展一个协议 
  270. 13.6.8 numbers模块中的抽象基类和Numeric协议 
  271. 13.7 本章小结 
  272. 13.8 延伸阅读 
  273. 第14章 继承:瑕瑜互见 
  274. 14.1 本章新增内容 
  275. 14.2 super()函数 
  276. 14.3 子类化内置类型很麻烦 
  277. 14.4 多重继承和方法解析顺序 
  278. 14.5 混入类 
  279. 14.6 多重继承的实际运用 
  280. 14.6.1 抽象基类也是混入类 
  281. 14.6.2 ThreadingMixIn和ForkingMixIn 
  282. 14.6.3 Django泛化视图混入类 
  283. 14.6.4 Tkinter中的多重继承 
  284. 14.7 应对多重继承 
  285. 14.7.1 优先使用对象组合,而不是类继承 
  286. 14.7.2 理解不同情况下使用继承的原因 
  287. 14.7.3 使用抽象基类显式表示接口 
  288. 14.7.4 通过混入明确重用代码 
  289. 14.7.5 为用户提供聚合类 
  290. 14.7.6 仅子类化为子类化设计的类 
  291. 14.7.7 避免子类化具体类 
  292. 14.7.8 Tkinter的好、不好以及令人厌恶的方面 
  293. 14.8 本章小结 
  294. 14.9 延伸阅读 
  295. 第15章 类型提示进阶 
  296. 15.1 本章新增内容 
  297. 15.2 重载的签名 
  298. 15.2.1 重载max函数 
  299. 15.2.2 重载max函数的启示 
  300. 15.3 TypedDict 
  301. 15.4 类型校正 
  302. 15.5 在运行时读取类型提示 
  303. 15.5.1 注解在运行时的问题 
  304. 15.5.2 解决这个问题 
  305. 15.6 实现一个泛化类 
  306. 15.7 型变 
  307. 15.7.1 一个不变的自动售货机 
  308. 15.7.2 一个协变的自动售货机 
  309. 15.7.3 一个逆变的垃圾桶 
  310. 15.7.4 型变总结 
  311. 15.8 实现泛化静态协议 
  312. 15.9 本章小结 
  313. 15.10 延伸阅读 
  314. 第16章 运算符重载 
  315. 16.1 本章新增内容 
  316. 16.2 运算符重载入门 
  317. 16.3 一元运算符 
  318. 16.4 重载向量加法运算符+ 
  319. 16.5 重载标量乘法运算符* 
  320. 16.6 把@当作中缀运算符使用 
  321. 16.7 算术运算符总结 
  322. 16.8 众多比较运算符 
  323. 16.9 增量赋值运算符 
  324. 16.10 本章小结 
  325. 16.11 延伸阅读 
  326. 【下册】
  327. 第四部分 控制流
  328. 第17章 迭代器、生成器和经典协程 
  329. 17.1 本章新增内容 
  330. 17.2 单词序列 
  331. 17.3 序列可以迭代的原因:iter函数 
  332. 17.4 可迭代对象与迭代器 
  333. 17.5 为Sentence类实现__iter__方法 
  334. 17.5.1 Sentence类第2版:经典迭代器 
  335. 17.5.2 不要把可迭代对象变成迭代器 
  336. 17.5.3 Sentence类第3版:生成器函数 
  337. 17.5.4 生成器的工作原理 
  338. 17.6 惰性实现版本 
  339. 17.6.1 Sentence类第4版:惰性生成器 
  340. 17.6.2 Sentence类第5版:惰性生成器表达式 
  341. 17.7 何时使用生成器表达式 
  342. 17.8 一个等差数列生成器 
  343. 17.9 标准库中的生成器函数 
  344. 17.10 可迭代的归约函数 
  345. 17.11 yield from:从子生成器中产出 
  346. 17.11.1 重新实现chain 
  347. 17.11.2 遍历树状结构 
  348. 17.12 泛化可迭代类型 
  349. 17.13 经典协程 
  350. 17.13.1 示例:使用协程计算累计平均值 
  351. 17.13.2 让协程返回一个值 
  352. 17.13.3 经典协程的泛化类型提示 
  353. 17.14 本章小结 
  354. 17.15 延伸阅读 
  355. 第18章 with、match和else块 
  356. 18.1 本章新增内容 
  357. 18.2 上下文管理器和with块 
  358. 18.2.1 contextlib包中的实用工具 
  359. 18.2.2 使用@contextmanager 
  360. 18.3 案例分析:lis.py中的模式匹配 
  361. 18.3.1 Scheme句法 
  362. 18.3.2 导入和类型 
  363. 18.3.3 解析器 
  364. 18.3.4 环境 
  365. 18.3.5 REPL 
  366. 18.3.6 求值函数 
  367. 18.3.7 实现闭包的Procedure类
  368. 18.3.8 使用OR模式 
  369. 18.4 先做这个,再做那个:if语句之外的else块 
  370. 18.5 本章小结 
  371. 18.6 延伸阅读 
  372. 第19章 Python并发模型 
  373. 19.1 本章新增内容 
  374. 19.2 全景概览 
  375. 19.3 术语定义 
  376. 19.4 一个演示并发的“Hello World”示例 
  377. 19.4.1 使用线程实现旋转指针 
  378. 19.4.2 使用进程实现旋转指针 
  379. 19.4.3 使用协程实现旋转指针 
  380. 19.4.4 对比几版supervisor函数 
  381. 19.5 GIL真正的影响 
  382. 19.6 自建进程池 
  383. 19.6.1 基于进程的方案 
  384. 19.6.2 理解用时 
  385. 19.6.3 利用多核进行素数检测的程序代码 
  386. 19.6.4 实验:进程数多一些或少一些 
  387. 19.6.5 基于线程的方案并不可靠 
  388. 19.7 多核世界中的Python 
  389. 19.7.1 系统管理 
  390. 19.7.2 数据科学 
  391. 19.7.3 服务器端Web和移动开发 
  392. 19.7.4 WSGI应用程序服务器 
  393. 19.7.5 分布式任务队列 
  394. 19.8 本章小结 
  395. 19.9 延伸阅读 
  396. 19.9.1 使用线程和进程实现并发 
  397. 19.9.2 GIL 
  398. 19.9.3 标准库之外的并发世界 
  399. 19.9.4 Python之外的并发和伸缩世界 
  400. 第20章 并发执行器 
  401. 20.1 本章新增内容 
  402. 20.2 并发网络下载 
  403. 20.2.1 依序下载的脚本 
  404. 20.2.2 使用concurrent.futures模块下载 
  405. 20.2.3 future对象在哪里 
  406. 20.3 使用concurrent.futures启动进程 
  407. 20.4 实验Executor.map方法 
  408. 20.5 显示下载进度并处理错误 
  409. 20.5.1 flags2系列示例处理错误的方式 
  410. 20.5.2 使用futures.as_completed函数 
  411. 20.6 本章小结 
  412. 20.7 延伸阅读 
  413. 第21章 异步编程 
  414. 21.1 本章新增内容 
  415. 21.2 一些定义 
  416. 21.3 一个asyncio示例:探测域名 
  417. 21.4 新概念:可异步调用对象 
  418. 21.5 使用asyncio和HTTPX下载 
  419. 21.5.1 原生协程的秘密:默默无闻的生成器 
  420. 21.5.2 “不成功便成仁”问题 
  421. 21.6 异步上下文管理器 
  422. 21.7 增强asyncio版下载脚本的功能 
  423. 21.7.1 使用asyncio.as_completed和一个线程 
  424. 21.7.2 使用信号量限制请求 
  425. 21.7.3 每次下载发起多个请求 
  426. 21.8 把任务委托给执行器 
  427. 21.9 使用asyncio编写服务器 
  428. 21.9.1 一个FastAPI Web服务 
  429. 21.9.2 一个使用asyncio编写的TCP服务器 
  430. 21.10 异步迭代和异步可迭代对象 
  431. 21.10.1 异步生成器函数 
  432. 21.10.2 异步生成器表达式和异步推导式 
  433. 21.11 asyncio之外的异步世界:Curio 
  434. 21.12 异步对象的类型提示 
  435. 21.13 异步原理与陷阱 
  436. 21.13.1 阻塞型调用导致漫长等待 
  437. 21.13.2 I/O密集型系统的误区 
  438. 21.13.3 绕开CPU密集型陷阱 
  439. 21.14 本章小结 
  440. 21.15 延伸阅读 
  441. 第五部分 元编程
  442. 第22章 动态属性和特性 
  443. 22.1 本章新增内容 
  444. 22.2 使用动态属性转换数据 
  445. 22.2.1 使用动态属性访问JSON类数据 
  446. 22.2.2 处理无效属性名 
  447. 22.2.3 使用__new__方法灵活创建对象 
  448. 22.3 计算特性 
  449. 22.3.1 第1步:数据驱动属性创建 
  450. 22.3.2 第2步:通过特性获取链接的记录 
  451. 22.3.3 第3步:用特性覆盖现有属性 
  452. 22.3.4 第4步:自己实现特性缓存 
  453. 22.3.5 第5步:使用functools缓存特性 
  454. 22.4 使用特性验证属性 
  455. 22.4.1 LineItem类第1版:表示订单中商品的类 
  456. 22.4.2 LineItem类第2版:能验证值的特性 
  457. 22.5 特性全解析 
  458. 22.5.1 特性覆盖实例属性 
  459. 22.5.2 特性的文档 
  460. 22.6 定义一个特性工厂函数 
  461. 22.7 处理属性删除操作 
  462. 22.8 处理属性的重要属性和函数 
  463. 22.8.1 影响属性处理方式的特殊属性 
  464. 22.8.2 处理属性的内置函数 
  465. 22.8.3 处理属性的特殊方法 
  466. 22.9 本章小结 
  467. 22.10 延伸阅读 
  468. 第23章 属性描述符 
  469. 23.1 本章新增内容 
  470. 23.2 描述符示例:属性验证 
  471. 23.2.1 LineItem类第3版:一个简单的描述符 
  472. 23.2.2 LineItem类第4版:为储存属性自动命名 
  473. 23.2.3 LineItem类第5版:一种新型描述符 
  474. 23.3 覆盖型描述符与非覆盖型描述符对比 
  475. 23.3.1 覆盖型描述符 
  476. 23.3.2 没有__get__方法的覆盖型描述符 
  477. 23.3.3 非覆盖型描述符 
  478. 23.3.4 覆盖类中的描述符 
  479. 23.4 方法是描述符 
  480. 23.5 描述符用法建议 
  481. 23.6 描述符的文档字符串和覆盖删除操作 
  482. 23.7 本章小结 
  483. 23.8 延伸阅读 
  484. 第24章 类元编程 
  485. 24.1 本章新增内容
  486. 24.2 身为对象的类 
  487. 24.3 type:内置的类工厂函数 
  488. 24.4 类工厂函数 
  489. 24.5 引出__init_subclass__ 
  490. 24.6 使用类装饰器增强类的功能 
  491. 24.7 导入时和运行时比较 
  492. 24.8 元类入门 
  493. 24.8.1 元类如何定制类 
  494. 24.8.2 一个友好的元类示例 
  495. 24.8.3 元类求解时间实验 
  496. 24.9 使用元类实现Checked类 
  497. 24.10 元类的实际运用 
  498. 24.10.1 可简化或代替元类的现代功能 
  499. 24.10.2 元类是稳定的语言功能 
  500. 24.10.3 一个类只能有一个元类 
  501. 24.10.4 元类应作为实现细节 
  502. 24.11 使用元类的__prepare__方法实现新颖的构思 
  503. 24.12 小结 
  504. 24.13 本章小结 
  505. 24.14 延伸阅读 
  506. 结语 
书名:流畅的Python(第2版)
作者:Luciano Ramalho
译者:安道 译
国内出版社:人民邮电出版社
出版时间:2023年04月
页数:736
书号:978-7-115-61236-6
原版书书名:Fluent Python, Second Edition
原版书出版商:O'Reilly Media
Luciano Ramalho
 
卢西亚诺·拉马略(Luciano Ramalho)是Thoughtworks首席咨询师、Python软件基金会成员、巴西知名Python语言学习社区Python Brasil联合创始人。拥有25年Python编程经验,著有编程领域经典作品《流畅的Python》。
 
 
购买选项
定价:199.80元
书号:978-7-115-61236-6
出版社:人民邮电出版社