来源书籍

Python学习手册(原书第4版)

Skill 版本:v24 编程语言类 经典原理(高浓度 + 高稳定性) 572 张卡片

Mark Lutz · 李军、刘红伟等 译 · 机械工业出版社(电子版:华章分社〔北京华章图文信息有限公司〕) · 2011 · 第4版 · ISBN 978-7-111-32653-3

类别清单覆盖

8/9

已覆盖 8 补充生成 0 未覆盖 1

全书导读

本书把Python当作由少量通用机制组合而成的语言来教:名称指向对象,容器保存引用,函数和类也是对象,模块组织可复用命名空间。读者先学会运行程序和操作数据,再理解函数如何接收数据、模块如何共享定义、对象如何响应协议,最后才进入管理这些行为的工具。

这是2011年中文第4版,原书围绕Python 2.6与3.0写作。语言模型可以帮助理解后续代码,但旧语法、接口、安装路径与计时数字有自己的时代条件。遇到版本比较时,先分清它说明的是历史迁移问题、稳定机制还是特定实现的观察,不能把同一个“Python”名称当作兼容性证明。

全书主线

全书首先回答程序在哪里运行、值以什么对象表示。赋值把名称连到对象,修改则发生在可变对象内部;分清这两件事,才能解释列表共享、函数参数、模块变量和类实例状态。数值、字符串与容器提供不同能力,表达式及协议决定哪些组合可用。

语句让计算沿条件与循环推进,迭代协议进一步把“如何取得下一项”与“如何处理这一项”分开。函数把计算边界和参数契约显式化,模块让这些定义在文件之间复用;由此,名称解析、导入缓存与生命周期开始影响结果。类再把状态和操作结合,继承、组合及运算符协议分别处理复用、协作与接口适配。

异常把失败从普通返回结果中分离,并要求调用者安排恢复与清理。高级部分沿着同一方向扩展:编码管理文本与字节的边界,描述符管理属性边界,装饰器管理定义与调用的边界,元类管理类创建边界。这些机制可以组合,但各自运行时机和状态归属不同;知道边界,比记住一组语法形状更能解释程序。

译者序

译者序定位本书为核心语言教程,解释其从培训课程发展而来的组织方式。

前言

语言基础与应用专题分书讲解,入门教程也连接补充参考。

关于第4版

版本分支让源码与工具的兼容性成为迁移前提。

版本变化需核对源码契约

语言版本变化可能同时改变语法、标准库和返回对象,既有代码即使只出现一个常用语句的改动也会大范围受影响。迁移应先明确源版本、目标版本及依赖,而不能由语言同名推断源码可直接运行。原书Python2/3并行支持的判断属于2009年的背景,不当当前支持策略。

版本变化需核对源码契约保存独立卡片。

原书依据 · 3 处

覆盖Python 3.0和Python 2.6

同一本书区分两条版本线,并说明新增语法受具体版本限制。

版本变化需核对源码契约关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处

新增章

新增章节安排类实例、文本编码和属性/装饰器/元类,属于课程组织而非新机制说明。

已有内容的修改

主题之间有知识依赖,线性章节顺序也可能需要回查前置内容。

语言学习需识别前置依赖

某个接口的语法常依赖另一机制:print和格式化可能用关键字参数,字典视图要结合迭代理解,执行代码又涉及文件对象。阅读顺序只提供主线,遇到前置概念应回查实际定义,而不是只背当前语法形式。

语言学习需识别前置依赖保存独立卡片。

原书依据 · 2 处

Python 2.6和Python 3.0中的特定语言扩展

扩展表把新增语法映射到后续实质章节,是版本导航索引。

Python 3.0中特定的语言删除

删除替代表与自动迁移工具只能提供线索,不保证语义等价。

自动迁移不保证行为相同

语法转换可减少机械修改,但不能自动验证数据、依赖或业务结果仍相同。原书也承认转换工具不能处理所有情况;历史2to3建议需带版本背景,官方已在Python3.13移除2to3和lib2to3,不能当当前默认迁移命令。

自动迁移不保证行为相同保存独立卡片。

原书依据 · 1 处
键存在不能由非空值代替

检测字典键是否存在,应按键成员关系判断。表0-2把D.has_key(K)列为可用D.get(key)!=None替代,但若键存在且值为None,后者会返回假,语义并不相同。迁移需区分键缺失与合法空值,不能只凭替换表标题宣称等价。

key in d检查键存在,d[key]的值可合法是None、0或空容器;旧has_key已不用于Python3,不能改成“取到非空值”替代。

has_key迁移应优先key in d;原图d.get(key)!=None会漏掉存在且值为None的键,不是等价存在性测试。

键存在不能由非空值代替保存独立卡片。

原书依据 · 3 处

关于本书

范围说明提醒读者教程有明确学习目标。

事前准备

本书假定读者会基本计算机操作,而不是预先掌握其他语言。

本书的范围和其他书籍

核心教程、应用教程和参考资料各提供不同阅读深度。

本书的风格和结构

教程按类型、语句、函数、模块与类逐层组织,练习和解答补充主线。

语言学习需识别前置依赖关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处

书籍更新

勘误和补充可能随时间变化,原书给出服务入口。

关于本书的程序

原示例有明确版本基础,其他实现与后续版本仍需核对。

版本变化需核对源码契约关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处

使用代码示例

示例使用条款与归属信息给出作者、原版ISBN和许可范围。

体例

排版区分输入、输出、占位与注释,提示符不是程序源码。

提示符不属于输入源码

教程命令行的%或交互解释器的>>>、…通常是环境提示符;复制示例时应输入其后的代码,并区分程序输出、可替换占位与注释。把排版标记一并当源码执行会造成误解,尤其多行交互与系统命令不是同一环境。

提示符不属于输入源码保存独立卡片。

原书依据 · 1 处

联系我们

联系信息与勘误入口为出版服务背景。

致谢

致谢交代课程反馈与多版图书的形成历程,末尾署名确认作者。

第一部分 使用入门

第一部分开始介绍语言定位和程序运行方式。

第1章 问答环节

语言选择需要同时看开发投入、运行成本、移植要求和可用组件。Python的动态对象与库支持能减少某些手工工作,但并不证明任何程序都运行更快或无需处理依赖。本章先建立这些评价维度,后面才用实际语法和对象机制解释它们来自哪里。

首章以新手问答交代语言选择与用途。

人们为何使用Python

语言选择同时涉及质量、开发时间、移植、库与组件集成,评价维度不能互换。

开发效率不同于执行速度

开发效率关注编写、调试和维护所需投入,运行速度关注程序执行成本。简洁表达、内置结构和库复用可能减少手写代码,却不自动加快每一步运行;应按实际任务分别评价,原书数倍效率和代码比例是经验概括,不当保证。

开发效率不同于执行速度保存独立卡片。

原书依据 · 4 处
可移植性依赖完整环境

语言和标准接口可减少跨平台改写,但能否直接复制运行还取决于依赖、系统服务、路径与实现版本。核心语法可用不等于所有应用组件均可用,不能把“多数代码无需改动”扩成任意平台无差异。

可移植性依赖完整环境保存独立卡片。

原书依据 · 3 处
语言生态扩展应用能力

语言核心提供表达和执行规则,标准库及第三方库再提供文件、网络、数值等领域能力。选择语言时应核对实际任务依赖,而不是仅比较语法。库存在也不证明每个版本和平台都有相同支持。

786及02148将对象类型、函数、异常、模块、属性和外部工具列为不同能力入口,并对内置工具、自写扩展、编译扩展三层作解释。列表只是能力地图:NumPy/SWIG/Jython/IronPython/Django等各自职责、运行环境不同,不能以同列就当可替代或当前兼容承诺;模块可用性依具体安装与版本。

语言生态扩展应用能力保存独立卡片。

原书依据 · 5 处
集成可以双向组织组件

Python既可调用其他语言组件,也可嵌入宿主应用供其调用。两种方向分别解决复用已有能力与暴露可定制行为的问题;“黏合语言”描述组织角色,不等于所有跨语言对象或错误语义天然相同。

集成可以双向组织组件保存独立卡片。

原书依据 · 6 处
软件质量

一致和显式的表达有助于理解代码,复用工具再支持组织。

显式表达减少理解歧义

当多种写法都能完成任务时,选择清楚、一致且能看出意图的表达,可降低读者推断隐藏行为的负担。语言风格提供方向,模块与类提供组织工具,但不能保证任何Python代码自动可维护;简短与清楚也不是同一标准。

显式表达减少理解歧义保存独立卡片。

原书依据 · 3 处
开发效率

动态表达和库工具可以缩短开发周期,但效率倍数依场景而定。

开发效率不同于执行速度关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
Python是“脚本语言”吗

脚本一词可指Shell任务、控制层或快速开发风格,不能限制语言应用规模。

集成可以双向组织组件关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
脚本是角色而非能力上限

脚本可指从命令行执行的系统任务、连接组件的控制层,或快速迭代的开发方式。Python可扮演这些角色,也可组织多文件应用;仅凭脚本标签不能推断程序只能很小、无需设计或不能长期维护。

脚本是角色而非能力上限保存独立卡片。

原书依据 · 1 处

好吧,Python的缺点是什么呢

执行模型与真正瓶颈决定性能取舍,混合实现可分离重计算。

开发效率不同于执行速度关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
字节码是实现层而非语言定义

原书标准实现先将源码编译为字节码再由解释器执行,说明“无需用户编译步骤”不等于实现内部没有编译。执行模型属于具体实现,不能因此断言所有Python实现都只解释同一字节码,或所有任务都按同一倍率慢于C。

字节码是实现层而非语言定义保存独立卡片。

原书依据 · 3 处
混合实现先分离性能核心

可把需要加速的部分交给编译扩展,保留Python组织逻辑,从而分别照顾开发效率与计算成本。收益依赖工作量与跨层开销,调用C库不意味着整个程序每部分都达到C实现速度,也不是不测瓶颈就全量重写的理由。

混合实现先分离性能核心保存独立卡片。

原书依据 · 4 处

如今谁在使用Python

历史用户规模与公司案例说明应用广度,但开源分发难以直接数独立用户。

下载量不等于独立用户数

开放分发没有统一注册人数,下载、调查与预装都只反映使用的一部分。一次用户可多次下载,预装又可能没有单独下载记录,因此应说明估计口径和误差,不能把下载计数直接写成独立使用人数。

下载量不等于独立用户数保存独立卡片。

原书依据 · 1 处

使用Python可以做些什么

应用角色概览连接后续各领域工具,但没有展开具体接口。

系统编程

系统接口可统一常见操作,平台相关服务仍需识别。

可移植性依赖完整环境关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
用户图形接口

GUI工具包通过不同宿主绑定提供界面,跨平台目标与具体依赖须分别看。

语言生态扩展应用能力关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
Internet脚本

网络能力来自协议模块与更高层框架,不同层次工具承担不同职责。

语言生态扩展应用能力关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
组件集成

扩展与嵌入分别从Python与宿主角度组织可定制组件。

集成可以双向组织组件关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
数据库编程

统一数据库API减少调用差异,对象持久化又解决不同表示需求。

统一数据库API不等于同库语义

统一连接、执行和结果访问的调用外观可减少更换数据库时的适配工作,但SQL方言、事务和驱动行为仍可能不同,不能仅替换接口包就保证应用原样运行。对象保存与关系查询也是不同需求,先明确数据表示和访问目标。

统一数据库API不等于同库语义保存独立卡片。

原书依据 · 1 处
对象持久化与数据库查询分工

pickle将对象保存到文件并恢复,关系数据库接口提供按数据库规则查询,面向对象数据库又有自己的存储机制。能保存一个对象不等于已经具备并发事务、索引和多条件查询;应按需要选择持久化层,而不是把都能保存数据理解为可互换。

把字段保存到实例只在对象及进程存活期间保有状态;要跨程序运行重建,需要明确外部存储和重建机制。本节才进入pickle/shelve持久化阶段,前面的实例属性赋值本身不代表已经建立持久数据库或跨进程共享。

本例将pickle对象序列化、dbm持久键值存储与shelve的映射式对象访问分层说明。shelve可让脚本按字符串键存取可pickle的值,但不是完整关系数据库,没有因此自动具备SQL查询或事务保障;映射外观也不意味着与普通内存字典所有行为完全相同。

对象持久化与数据库查询分工保存独立卡片。

原书依据 · 3 处
快速原型

通过稳定组件边界可以保留原型的其余部分,仅替换需优化的实现。

混合实现先分离性能核心关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
数值计算和科学计算编程

数值工具用编译例程承担计算,让Python组织问题。

混合实现先分离性能核心关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
游戏、图像、人工智能、XML、机器人等

多领域工具再次体现通用语言与专用组件结合。

集成可以双向组织组件关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处

Python如何获得支持

用户规模扩大后,变更需要更明确的协作与回归验证流程。

规模扩大需明确变更流程

当一个工具被更多人依赖,修改影响会扩大;用公开协作、方案讨论与回归验证组织变更,比只由个人私下决定更可追踪。原书用Python社区历史说明这一演变,不意味着每个小改动都必须单独写PEP,或原书组织与会议数据仍是现状。

规模扩大需明确变更流程保存独立卡片。

原书依据 · 1 处

Python有哪些技术上的优点

技术特点小节引出对象、实现和工具等方面,供后续逐项解释。

面向对象

面向对象是组织方式之一,Python同时支持过程式代码。

面向对象可选而非强制写类

Python提供类和继承等代码组织工具,也允许以函数和过程式语句解决问题。使用对象与必须自行设计类是不同要求;应按数据、职责与复用需要选择结构,不能仅因语言支持OOP就把所有脚本改成类。

Python可用函数、模块和脚本完成许多任务,类适合需要实例状态和相应行为等结构的情境。面向对象设计也不要求每个对象必须处于复杂自定义继承层次,不能把继承当是否面向对象的唯一判据。

面向对象可选而非强制写类保存独立卡片。

原书依据 · 3 处
免费

开源使实现可检查和修改,但用户支持与变更治理仍是独立问题。

源码可见不等于支持承诺

开放实现使有需要的开发者能检查、研究和修改底层机制,减少完全依赖封闭厂商解释的限制。但源码可读不自动提供响应时限或适合每个用户的维护能力;社区协作与具体项目支持应分别了解。

源码可见不等于支持承诺保存独立卡片。

原书依据 · 1 处
可移植

解释器、字节码兼容与外围依赖共同决定平台可移植范围。

可移植性依赖完整环境关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
功能强大

动态对象、内存管理和模块化工具共同支撑复杂程序,不是没有类型或不需资源管理。

语言生态扩展应用能力关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
动态类型

动态类型指运行时根据实际对象确定类型与可用操作,名称不必预先固定绑定某一种对象类型。它不表示对象没有类型或任意对象都可互换;需要的操作仍须由传入对象支持,错误也可能在实际执行该路径时才暴露。

无需像某些静态语言先声明变量固定类型,不意味着操作没有类型限制;对象保有类型,名称指向当前绑定对象。

“对象有类型、名字引用对象”是理解动态类型的核心;对象缓存可能复用不可变值,不保证每次表达式都分配全新对象。对象头的具体布局与引用计数为实现说明。

a先引用整数、再引用字符串、再引用浮点数,改变的是名字的目标对象;原对象并未随重绑定转换类型。典型程序仍应保持可理解的变量职责。

动态类型允许普通名称重绑定到不同对象,变量不等于C++ const对象声明;具体语法仍禁止给True/False/None等关键字赋值,并非字面任何名称都能改绑。

动态类型保存独立卡片。

原书依据 · 5 处
自动内存管理不包办资源生命周期

运行时负责对象内存的分配与回收,减少手动管理底层存储的工作。但不能据此假定对象在某一精确时刻立即销毁,或文件、连接等外部资源无需明确关闭;对象内存和外部资源有不同生命周期。

CPython引用计数支持及时回收部分不再引用对象,循环引用却可能需要另行检测;缓存也可延长寿命。不把立即回收说成所有Python实现承诺,也不据此省去文件等外部资源显式关闭。

文件应在明确范围关闭,优先with或可靠finally,不能依赖何时垃圾收集。关闭处理资源和缓冲,仍不等于所有写入都具备业务原子性或崩溃后持久性。

自动内存管理不包办资源生命周期保存独立卡片。

原书依据 · 4 处
程序组织工具承担不同职责

模块组织可复用组件,类帮助组织对象行为,异常表达和处理失败;它们从不同角度管理复杂性,不是必须依次套用的同一工具。拥有这些能力也不能自动使大型程序有清晰边界,应按实际责任组合。

表中global/nonlocal、import/from、def/class及异常资源语句只是本部分后续导航;nonlocal对应Python3作用域工具,不把Python2替代方案当同一关键字。

程序组织工具承担不同职责保存独立卡片。

原书依据 · 2 处
可混合

Python前端和编译组件可按不同阶段的需求逐步调整。

集成可以双向组织组件关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
简单易用

短编辑运行周期支持交互迭代,但没有显式编译步骤不等于没有编译。

开发效率不同于执行速度关联本项背景,实质主要讲解在对应位置。

字节码是实现层而非语言定义关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处
简单易学

核心较易入门是教学定位,掌握复杂功能仍需实际背景与学习。

Python和其他语言比较起来怎么样

语言比较反映作者重视可读性和角色取舍,不能把偏好当普遍排名。

显式表达减少理解歧义关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处

本章小结

首章收束语言选择,下一章转向实际解释器和运行方式。

本章习题

五题回顾选择因素、使用范围、性能和设计理念。

习题解答

答案回顾后比较表达自由与工程维护,强调未来读者的理解成本。

显式表达减少理解歧义关联本项背景,实质主要讲解在对应位置。

混合实现先分离性能核心关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处
代码还要服务未来维护者

代码既供机器执行,也供后续维护和复用的人理解。表达越依赖个人技巧与隐藏上下文,修改者越难判断意图;一致、可预测的写法有助于长期维护。并不因此禁止所有多样性或创造性,应按实际可读性判断,而不是用语言名称替代评估。

代码还要服务未来维护者保存独立卡片。

原书依据 · 1 处

第2章 Python如何运行程序

源码是保存语句的文本,解释器负责把它纳入执行过程。以CPython为背景的字节码说明了源码与运行之间还有实现步骤;缓存可复用编译结果,却不是程序行为本身。其他实现、冻结交付和混合语言方案各有分工,因此文件扩展名、打包方式与执行实现应分开理解。

运行章先确定解释器与平台,让读者能理解后续示例如何启动。

Python解释器简介

语言是一组规则,实现则是读取并执行程序的软件,可独立启动或嵌入宿主。

语言与解释器实现要分清

Python既指语言,也常指执行该语言的软件实现。解释器读取和执行代码,可作为可执行程序或嵌入宿主的库;实现使用C、Java等技术,不改变读者写的是Python源码。确认语言语法之外,还要确认实际实现及其库环境。

语言与解释器实现要分清保存独立卡片。

原书依据 · 3 处

程序执行

程序员看到源码与启动,解释器内部处理则是另一个观察层次。

程序员的视角

源码文件保存语句,启动方式决定解释器怎样读取并执行它。

源码文件与运行入口分开

简单脚本可由普通文本文件保存语句,再交给解释器执行;命令行或IDE是不同启动入口。扩展名有助于识别和常规模块导入,但文本内容、解释器与启动参数仍需匹配;不能仅由文件叫.py就判断它已经执行或执行成功。

源码文件与运行入口分开保存独立卡片。

原书依据 · 6 处
Python的视角

传统CPython分编译与执行,缓存服务加载且有适用范围,运行时仍能构造程序。

字节码是实现层而非语言定义关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
字节码缓存服务加载阶段

缓存编译结果可在后续加载时省去重新编译,不能据此推断主体代码每次运行更快。原书脚注限定常规保存发生在模块导入,顶层脚本与交互代码不同;当前缓存位置常为pycache,不把旧相邻.pyc路径当通用布局。

源码缓存有效时可复用已编译字节码,但缓存判定不是简单只比pyc时间新旧;版本与校验形式都需匹配。直接脚本通常不留同样导入缓存,不意味着不编译;仅字节码发行也不能保证任意布局和解释器版本都可加载。

.pyo是旧版优化字节码形式,Python3.5起改为带优化级别标记的.pyc;不能按旧扩展名或5%说法推断现代任意程序加速。缓存与执行语义需分别核对,不把旧Psyco介绍当当前选型建议。

字节码缓存服务加载阶段保存独立卡片。

原书依据 · 4 处
缓存写入失败不等于不能执行

不能写入字节码缓存时,编译结果仍可在内存中用于本次执行;缓存持久化与能否读取并执行源码是不同条件。它不免除源码、依赖和其他操作所需权限,不能据一条缓存失败就断定所有运行失败或所有权限无关。

缓存写入失败不等于不能执行保存独立卡片。

原书依据 · 1 处
运行时可以建立并执行代码

函数与类定义、模块导入以及动态编译执行可以在运行过程中发生。编译能力是运行系统的一部分,所以没有显式构建步骤不等于没有编译阶段。eval/exec是执行接口而非两个内置模块,动态执行需明确可信输入和环境,不能把任意字符串当普通数据处理。

运行时可以建立并执行代码保存独立卡片。

原书依据 · 1 处

执行模块的变体

标准实现的执行流程不构成所有实现必须遵循的语言规则。

语言与解释器实现要分清关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
Python实现的替代者

CPython、Jython和IronPython分别连接不同宿主运行环境。

实现选择连接不同宿主

原书CPython以C实现语言运行,Jython把Python代码接入Java运行环境,IronPython面向.NET集成。它们解决的宿主组件复用需求不同,不能把CPython字节码直接当Java或.NET字节码。语言版本、扩展和接口可用范围还须按具体实现确认,原书速度与健壮性排名不是当前通用结论。

实现选择连接不同宿主保存独立卡片。

原书依据 · 1 处
执行优化工具

优化既可运行时特化,也可转换到另一语言,二者有不同约束。

即时编译可按实际类型特化

原书Psyco示例在运行时观察类型信息,为实际出现的类型组合生成机器代码并替代部分字节码执行。这样减少通用解释工作,但收益取决于可优化代码与实现约束,不能把宣传倍数当每个程序结果;这里描述历史机制而非建议安装该项目。

即时编译可按实际类型特化保存独立卡片。

原书依据 · 1 处
源码转换需核对语言子集

原书Shedskin把Python源码转换为C++再交给编译器,采用的静态约束意味着支持范围未必等于任意Python程序。生成可编译代码和保持原有动态行为是不同目标,应先确认可接受输入,再讨论速度或平台。

源码转换需核对语言子集保存独立卡片。

原书依据 · 1 处
冻结二进制文件

冻结将解释器与应用依赖打包,解决分发而不必改变执行模型。

打包独立程序不等于编译加速

冻结把字节码、解释器及支持文件组合为便于分发的程序,使接收环境可不单独安装Python。它仍可能通过解释器运行原有字节码,不能由.exe外观推断主体已原生编译或性能必然提高;目标平台依赖与资源完整性也需确认。

787发布选项把解释器/字节码捆绑与源代码/字节码分发对照;独立可执行文件不表示主体原生编译。distutils/eggs是历史打包选项,不能按本书旧版安装指引直接使用;官方记录distutils已于Python3.12从标准库移除。

打包独立程序不等于编译加速保存独立卡片。

原书依据 · 3 处
隐藏源文件不等于保密保证

打包后用户可能看不到原来的.py文件,这只描述分发形式,不能据此证明逻辑不可检查或机密可安全内嵌。应区分没有直接提供源码与有可验证的保密措施,不能把冻结当安全边界。

787的分发隐藏源码说法仅是文件呈现,不是可验证的逻辑保密/抗逆向保证,不能把密钥或重要秘密依赖冻结保护。

隐藏源文件不等于保密保证保存独立卡片。

原书依据 · 2 处
其他执行选项

运行实现可改变状态管理,混合语言又可添加类型以便生成扩展。

协程状态管理取决于实现

原书Stackless以改变执行状态与C栈的关系说明运行实现可提供不同的调度条件。它不是把普通函数语法换名就自动并行,也不能把协程等同多个CPU同时执行;具体栈约束与调度方式须看所用实现版本。

协程状态管理取决于实现保存独立卡片。

原书依据 · 1 处
混合语言可生成扩展绑定

Cython可结合Python风格代码与C类型、函数接口,再生成使用Python/C API的C代码并编译。它适合包装外部库或特定性能需求,但支持的语法和运行行为需按其契约理解,不能把所有输入都视作未经修改的标准Python。

混合语言可生成扩展绑定保存独立卡片。

原书依据 · 1 处
未来的可能性

未来实现可能改变执行方式,语言规则不应与某一虚拟机永久绑定。

语言与解释器实现要分清关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处

本章小结

运行章回顾执行模型与变体,接下来进入启动方式。

本章习题

六道习题检查解释器、源码、字节码及实现区别。

习题解答

答案回顾解释器、源码、字节码和不同宿主实现。

字节码缓存服务加载阶段关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处

第3章 如何运行程序

交互提示适合观察短表达式,源码文件适合保存和复用程序。命令行、IDE、导入、图标和系统脚本入口都能触发执行,但启动环境、工作目录和参数可能不同。诊断“同一文件为何行为不同”时,先确认真正运行的解释器和入口,再检查输入与路径。

启动章覆盖交互、脚本、导入与IDE,读者需区分其行为。

交互提示模式下编写代码

从系统启动解释器时,可执行程序路径与会话内代码属于不同层。

启动解释器需定位正确程序

在系统终端启动Python,需要系统找到所需解释器;PATH搜索、显式可执行路径与切换目录是不同的定位办法。多个版本并存时不能仅凭命令名判断目标,启动后的版本信息也应与任务匹配。原书C:\Python30等路径只是示例,不是所有机器固定安装位置。

启动解释器需定位正确程序保存独立卡片。

原书依据 · 3 处
交互地运行代码

交互会话执行输入并自动显示表达式结果,与脚本显式输出不同。

交互回显不同于显式输出

交互会话会显示某些表达式的求值结果,脚本里的裸表达式通常不会自动显示;若程序需要输出,应显式使用相应输出接口。赋值保存对象与回显展示也不是同一操作,不能把交互屏幕中的结果直接当脚本已有打印语句。

交互回显不同于显式输出保存独立卡片。

原书依据 · 3 处
为什么使用交互提示模式

交互反馈便于探索和组件检查,但会话并非自动安全沙箱或持久程序。

源码文件与运行入口分开关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
交互试验仍需限定副作用

交互解释器执行的仍是真实代码,不能因尚未显式导入模块就保证没有文件写入、资源耗尽或其他副作用。对明确、有限且可信的表达式,及时反馈有助理解;对未知输入或会修改状态的操作应先核对边界,不把交互模式当安全隔离。

交互试验仍需限定副作用保存独立卡片。

原书依据 · 1 处
错误消息定位不等于确定根因

交互错误通常提供异常类别、出错位置及上下文,可帮助发现未绑定名称等问题,并可继续会话。但指出发生错误的行不等于已解释最初原因,先前状态仍可能影响结果;应结合实际调用与对象分析,不把一条消息当完整诊断。

723及02027-02030用同一fetcher对照索引成功/越界,默认报告包含异常类型和活动调用路径;命令行与IDLE的文件名、行显示可不同,交互输入的行号未必有脚本意义。栈追踪给发生位置和调用上下文,并不能仅凭最后一行断定完整根因;交互会话继续与外部脚本未捕获异常后终止须区分。

735的02056-02057逐层列出模块gosouth(1)、gosouth内gobad(x,0)、gobad的return x/y,最后ZeroDivisionError。调用路径能显示传零来源的一部分,定位仍要结合参数与意图;不把源行提示当全部程序错误都可由解释器判定,也不把Python3.0的消息字面当当前恒定格式。

错误消息定位不等于确定根因保存独立卡片。

原书依据 · 5 处
使用交互提示模式

输入环境、缩进与复合语句提交规则决定交互文本怎样被解析。

交互回显不同于显式输出关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
系统命令与语言输入要分开

Python提示符接受Python代码,系统终端按其shell规则解释命令。启动Python的命令不能直接当Python语句输入;即使语言中另有调用系统命令的接口,也需明确那是另一层操作。提示符可帮助识别环境,但自定义界面仍须确认实际解释者。

系统命令与语言输入要分开保存独立卡片。

原书依据 · 1 处
交互复合语句有提交边界

原书经典交互会话以缩进建立复合语句,并用空行提交整个代码块;文件中不依赖同样的空行提交。粘贴多块代码前需确认所用REPL规则,否则还未结束上一块就输入下一句会引发语法错误。该历史交互规则不推广为所有现代粘贴模式完全一致。

交互复合语句有提交边界保存独立卡片。

原书依据 · 1 处

系统命令行和文件

文件保留可重用源码,脚本与模块称谓取决于使用角色。

源码文件与运行入口分开关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
第一段脚本

第一个文件用导入、变量和注释组合简单输出,源码需独立保存。

源码文件与运行入口分开关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
注释与字符串内容要区分

代码语法上下文中的#可开始行注释,供人解释意图,不作为执行语句;但字符串里的同一字符仍可属于数据。保存源码时需保留真实语句和必要说明,不能把所有带#的文本一律删除。

三引号内容仍是字符串表达式;在模块/类/函数等规定位置可作文档字符串,不因包住代码就变成真正注释。用它临时屏蔽代码还可能遇到内部三引号或转义问题,应区分注释语法与文本数据。

docstring在模块/类/函数等规定位置可作为文档元数据保存,不等同#注释;普通三引号文本不在任何位置都会自动成为文档字符串。

注释与字符串内容要区分保存独立卡片。

原书依据 · 3 处
使用命令行运行文件

解释器与脚本路径分别定位,shell还可重定向输出。

启动解释器需定位正确程序关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
解释器路径和脚本路径分开

系统先找到解释器,再由它读取指定脚本;两者路径与当前工作目录可各不相同。明确两条路径可减少定位歧义,不能因能找到Python就断言能找到脚本,或因能双击.py就知道使用了哪个解释器。

解释器路径和脚本路径分开保存独立卡片。

原书依据 · 1 处
流重定向属于启动环境

shell可把脚本标准输出导向文件而不显示在终端,这改变输出去向,不改变脚本是否显式生成了该输出。它是shell功能而非Python特有语句;目标路径、覆盖与其他输出流应按所用shell规则确认,不把原书一条示例当所有环境共同语法。

流重定向属于启动环境保存独立卡片。

原书依据 · 2 处
使用命令行和文件

源码真实格式、命令行文件路径与导入模块名不能混用。

交互回显不同于显式输出关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
源码应保存为真正的文本文件

源码需要符合语言语法的文本,富文本文件或隐藏的额外.txt后缀会使启动、识别或导入出现问题。应核对实际文件名和格式,而不是只看显示图标;编辑器自动加扩展名的行为随配置而变。

源码应保存为真正的文本文件保存独立卡片。

原书依据 · 1 处
运行文件与导入模块用不同名称

命令行向解释器指定实际文件路径,import语句则按模块名和模块搜索规则查找,通常不写.py后缀或普通文件路径。两个入口解析名字的规则不同,不能把命令行路径语法直接粘进import。

标准import语句里的模块名受标识符与关键字语法约束,文件存在不保证可用同名直接import;其他加载API可能有不同入口,不能绝对称这种文件永远无法加载。

import写模块名或包的点路径,不写操作系统目录分隔符或.py后缀。import mod.py在语法上可能被解释为包mod的子模块py,却不是加载名为mod.py的源文件;模块搜索目录另由导入路径决定。

import b或包的点路径使用模块名称,不写盘符、目录分隔符或把.py当文件扩展参数;包路径是名字层级。实际查找由对应机制完成,冻结发行也不表示所有可能动态依赖从此无需资源路径。

普通import语法的名字部分应是可用标识符并避开关键字,.py是常规源码后缀。现代标识符也可含符合规则的Unicode字符,不只ASCII字母数字下划线;其他动态加载机制的命名能力另论,不能把普通import限制说成整个导入系统唯一能力。

运行文件与导入模块用不同名称保存独立卡片。

原书依据 · 5 处
UNIX可执行脚本(#!)

Unix直接执行脚本依赖解释器声明和执行权限,显式解释器启动又是另一条路。

脚本直接执行有系统前提

Unix风格脚本用首行shebang指定解释器,并由系统执行权限支持直接启动;显式调用解释器读取脚本则是另一入口,不必依赖同一直接执行权限。shebang对Python看似注释,对操作系统却是启动信息,不能把两层解释混同。

脚本直接执行有系统前提保存独立卡片。

原书依据 · 1 处
环境查找提高灵活性也引入依赖

shebang用env按PATH寻找解释器,可避免每个脚本硬编码安装位置,但所选程序取决于环境中的搜索次序。env自身路径与执行环境仍需存在且正确,不能把一行env视为任何平台都无条件可移植。

环境查找提高灵活性也引入依赖保存独立卡片。

原书依据 · 1 处

点击文件图标

点击源码依赖文件管理器与系统的程序关联。

启动解释器需定位正确程序关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
在Windows中点击图标

图标只是另一启动入口,显示外观本身不证明运行或错误可见。

源码文件与运行入口分开关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
input的技巧

末尾等待输入可延迟窗口关闭,但输入语义与错误处理应分开。

流重定向属于启动环境关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
末尾暂停不能兜住早期错误

脚本正常执行到末尾时,input可等待标准输入而延迟退出窗口;若提前异常终止,末尾代码根本不会执行。因此这一展示技巧不是错误捕获,也不宜无条件放入自动化脚本,否则可能阻塞无人值守运行。

末尾暂停不能兜住早期错误保存独立卡片。

原书依据 · 2 处
文本输入不等于执行输入

Python3的input返回读取文本,Python2的raw_input承担类似角色;Python2的input还会把文本求值,不能按同名接口直接迁移。用eval(input())会把数据解释成代码,应有完全不同的信任边界,不能当一般读取用户文本的替代方案。

Python3 input返回文本,Python2对应raw_input;不要把旧input求值语义混入文本读取。原文称控制台输出需按提示输出与读取回复两种职责区分。

文本输入不等于执行输入保存独立卡片。

原书依据 · 2 处
图标点击的其他限制

图标窗口可能在错误后关闭,诊断需要可保留的错误观察通道。

末尾暂停不能兜住早期错误关联本项背景,实质主要讲解在对应位置。

错误消息定位不等于确定根因关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处

模块导入和重载

导入初始化模块并缓存,重载是显式重新执行且不重绑外部所有名称。

再次导入通常复用模块对象

常规首次导入会定位并执行模块以建立对象,之后同一运行环境再次导入通常复用缓存,不自动重跑修改后的源码。它不是重复import语句完全无效,而是复用了已有模块;编辑文件与内存中对象更新是不同动作。

在同一解释器中按相同模块身份导入,通常复用已加载对象,因此适合共享服务或状态。不同名字加载、不同解释器或显式重载等会改变情形;共享状态也带来修改可见性与协调责任。

sys.modules按模块身份记录已加载对象,重复同名导入通常从中取得引用,不重复所有顶层动作。失败、缓存调整或其他加载方式会影响结果,默认一次不是无条件进程终身保证。

simple首次导入执行print并设置spam=1;随后把模块属性改成2,再普通导入不会自动执行赋值把它还原。需要区分源码是否修改、缓存模块对象与显式重载;重新写import不是重启初始化的接口。

再次导入通常复用模块对象保存独立卡片。

原书依据 · 5 处
模块重载不会更新所有引用

重载重新执行模块代码,但先前from导入所绑定的名称不自动改绑为新对象。通过module.attribute读取更新的模块属性与保留旧对象引用有不同结果;重载不是把所有实例和依赖都重建,需按实际引用判断。

reload能重新执行相应模块代码,却不是把整个程序所有引用和依赖重建为全新状态。考虑重载前应区分模块属性更新、其他位置保存的旧对象与外部资源,不能当作无风险的完整重启。

已from绑定的函数引用通常不会因原模块reload自动换成新函数。导入形式的取舍除了输入长度,还包含来源辨识与后续动态更新预期。

现代importlib.reload对适用的已加载模块重新执行代码,更新模块字典中的相应绑定。可用于交互开发或有设计约束的动态定制,但并不保证外部连接只建立一次、所有客户端无缝更新或整个系统保持一致。

模块属性重新定义后,后来经module.attr取值会看到当前绑定;此前from取得的旧对象和已有类实例等通常仍引用原版本。当前reload接收已成功加载的模块对象,不是字符串模块名,返回值也不应在自定义加载情形下一概忽略身份变化。

修改changer.py后普通import仍可能复用已加载函数和message,reload再执行顶层才使模块属性指向新版。该例说明交互开发机制,不是对生产服务器定期自动重载的无条件建议;重跑顶层副作用仍需控制。

reload(A)重跑A中的import B/C通常只取缓存,不递归重载B/C。若要更新整组依赖,必须另有明确范围和顺序设计,不能因入口重载成功就认定全依赖已刷新。

from取得的X可仍指旧对象,module.X的后续读取则取当前模块属性。重载既不是向所有别名广播改绑,也不会自动替换现有实例所属类;应按实际更新需求重新获取相关对象。

若只from module import function,本地未必有module名可传reload。取得模块并重载后,还要经module.function调用当前属性,或重做from取得新版;先前function名称不会因刷新模块自动重绑。

模块重载不会更新所有引用保存独立卡片。

原书依据 · 10 处
模块的显要特性:属性

模块把属性放入命名空间,from把选定属性对象绑定到当前空间。

模块命名空间隔离名称

模块把定义组织为自己的名称空间,通过模块对象访问其属性。不同模块可各自使用相同属性名而不直接冲突;客户端仍需明确引用哪个模块,名称隔离不等于模块之间不存在共享对象或副作用。

模块通常提供独立名称空间,并可由源码、扩展或其他加载机制形成;不等于每个任意文件都是可导入模块。import取得模块引用,from取得指定属性绑定;历史imp.reload入口已被现代importlib.reload取代。

模块顶层绑定通常成为模块属性,客户端可经模块引用访问,不必把所有名称混进自己环境。源码文件便于跨会话保存定义,但模块对象状态仍属于具体运行环境,不因文件存在就永久保存运行时修改。

模块命名空间承载顶层绑定并经模块对象属性提供访问;其他代码持有模块引用后也可能修改它,名称隔离不等于强制只读或安全沙箱。

普通可导入Python源码可直接保存定义与顶层绑定,无需另写module声明。它仍须是有效代码并能由相应加载机制找到,不能把几乎任何文本文件理解为任意格式都可直接导入。

模块把一组名称与对象关联在一起,并以属性形式供持有模块引用者访问。源码文件是常见载体,命名空间和物理文件不是同义;模块对象也会有解释器提供的元信息。

module2顶层的import sys、name赋值、func定义与klass定义都会绑定为模块属性,顶层print则执行实际输出。dict提供模块名称到对象的字典,keys()才是视图;原文需要list的对象应指键视图,不是字典本身。

模块把接口与内部名称组织为命名空间,但持有模块引用的客户端通常仍能访问和修改其可取得属性。内部命名约定帮助协作,不是权限边界;接口设计与可信代码约束须区别。

模块命名空间隔离名称保存独立卡片。

原书依据 · 9 处
导入绑定名称不深复制对象

import通常把模块对象绑定到当前名称,from则将选定属性的对象绑定到当前空间。原文“复制”指这种绑定效果,不是对对象做深复制;名称覆盖可能发生而不警告,应按需要选择显式导入和属性访问。

import通常在当前作用域绑定模块引用,from则绑定选定属性对象,均先完成所需模块加载。from并非只执行被选函数所在片段,也不会自动复制其对象内部内容。

import module1在当前作用域建立模块引用,module1.printer取得其函数属性后才可调用。这种限定名保留来源上下文,也不把模块所有成员自动摊到本地名称空间。

from module1 import printer将当前module1.printer所引用的对象绑定到本地printer;此后该名称不是一个每次自动追踪模块属性的活链接。源码模块仍照常加载,名称简短不减少成只加载一个函数。

from small import x,y把对象引用绑定到当前作用域,x=42只重绑本地x,而y[0]=42修改与small.y共享的列表。导入可以出现在普通条件或函数体中,是否执行由运行控制流决定;绑定仍受该代码块作用域规则约束。

from module import name1,name2可概念化为取得模块后分别绑定当前属性对象,并且一般不额外绑定本地module名。加载和执行模块时可能运行所有顶层代码,不因只选一属性就自动节省其他初始化工作;精确加载机制仍有特殊情况。

nested2从nested1取得X和printer后把本地X改成88,printer仍使用其定义模块中的X=99;nested3写nested1.X=88才改变相应模块绑定。共享函数对象不会自动切换其全局环境到调用者。

导入绑定名称不深复制对象保存独立卡片。

原书依据 · 7 处
对象内省仍需理解返回范围

dir可帮助查看对象可用名称,模块中常同时出现用户定义和解释器提供的特殊属性。它给出探索线索,不代表每个名称都应由调用者使用,或仅凭名称列表就了解对象契约;不同版本/对象的返回范围应实际确认。

对象内省仍需理解返回范围保存独立卡片。

原书依据 · 2 处
import和reload的使用注意事项

交互重载有状态和依赖范围,重新启动常是更清楚的比较入口。

模块重载不会更新所有引用关联本项背景,实质主要讲解在对应位置。

原书依据 · 10 处
模块搜索路径不同于程序搜索路径

Python按模块搜索路径查找导入对象,系统PATH则用于找到可执行程序。PYTHONPATH只是影响模块路径的输入之一,还会有运行入口和标准位置等;不能以脚本不在当前目录就断言唯一办法是改该环境变量。

脚本所在目录与启动时的工作目录可以不同,交互、-m和其他运行方式也可能改变初始查找位置。应查看该运行环境实际sys.path,并考虑包上下文;相对包导入的点号不是操作系统工作目录的简单替代。

修改sys.path可影响后续需查找的模块,但不自动替换sys.modules已缓存对象,也不改变操作系统PATH。运行时变更通常不直接持久化到下次启动;列表可含ZIP路径等入口,不保证每项都是普通目录。

原文PATHONPATH是PYTHONPATH拼写误差,环境与站点配置也有解释器、虚拟环境和启动参数作用范围,不保证机器每个程序都必处理同一配置。导入路径不是操作系统执行文件PATH。

938的02541和正文区分PATH的解释器定位与PYTHONPATH模块定位;显式解释器路径可不靠PATH找到程序。具体启动器/IDE继承环境可能不同,不能一概说环境配置对IDE完全无关。TCL_LIBRARY/TK_LIBRARY是另一层GUI库查找,不等于Python模块路径。正文末尾yumt kinter不作为可运行安装命令;是否需要GUI依赖由对应发行环境决定。

模块搜索路径不同于程序搜索路径保存独立卡片。

原书依据 · 5 处

使用exec运行模块文件

exec执行读到的源码,与模块导入的命名空间和缓存机制不同。

执行源码不等于导入模块

exec可执行读到的代码而不走通常的模块导入缓存;在原交互示例中,默认执行的赋值可能覆盖当前名称。重新读文件执行可看到修改,却不自动获得独立模块命名空间,需明确执行上下文和可信来源,不能把它当无副作用的文件加载。

源码模块的首次导入通常需定位、必要时编译、执行以建立模块内容;它是运行时加载机制,不能等同C预处理的文本包含。扩展等加载器可有不同实现,不强行套成所有模块都编译.py。

执行源码不等于导入模块保存独立卡片。

原书依据 · 2 处

IDLE用户界面

IDE将编辑、运行与调试放在一个界面,但仍依赖真实语言运行环境。

集成界面不改变语言规则

IDE集中编辑、运行、浏览和调试任务,帮助减少启动操作成本。它仍调用解释器并依赖相应库,界面便利不意味着具有另一套通用语言语义;应区分工具自动做的环境准备与程序本身依赖。

集成界面不改变语言规则保存独立卡片。

原书依据 · 1 处
IDLE基础

编辑文件、保存磁盘版本与启动用户进程是分开的动作。

编辑缓冲与磁盘版本分开

编辑器里改过的文本未必已成为磁盘源码,运行入口需要明确执行哪一版。IDLE原例在Run Module前提醒保存,并可重新启动用户进程;保存提醒降低误跑旧版的风险,但不能泛化为任何工具任何模式都自动重置所有状态。

编辑缓冲与磁盘版本分开保存独立卡片。

原书依据 · 1 处
使用IDLE

IDE可能提供隐含搜索路径、工作目录和进程配置,离开工具后不一定成立。

编辑器运行环境也是输入

工具可能设置工作目录、搜索路径、顶层名称或用户子进程,使代码在其界面中容易运行。换到终端或其他启动入口时,这些准备不一定存在;应把真实依赖显式识别,不能因IDE内成功就断言可在任意部署环境运行。

编辑器运行环境也是输入保存独立卡片。

原书依据 · 1 处
进程隔离与界面线程要分清

把用户代码与IDE界面分进程,可减少部分阻塞对工具的影响,但又引入进程通信和连接条件。原书单进程启动是当时故障排查途径,改变隔离方式会改变行为,不能把界面没有响应直接归因程序逻辑,或把切模式当无条件修复。

进程隔离与界面线程要分清保存独立卡片。

原书依据 · 1 处
高级IDLE工具

断点和浏览器提供不同观察:前者看暂停执行状态,后者看静态组织。

断点观察依赖暂停位置

断点使程序在特定执行位置暂停,便于观察当时的变量与控制流;对象或文件浏览则帮助定位定义。错误消息跳转到行只是导航,不证明那一行就是根因。观察应注明运行状态和暂停位置,不能把静态源码外观当已执行结果。

断点观察依赖暂停位置保存独立卡片。

原书依据 · 1 处

其他的IDE

开发工具可按功能、宿主集成和安装负担比较,而不是按推荐语直接选。

工具比较需明确功能与成本

IDE可能提供代码完成、重构、调试、版本控制或平台组件集成,功能更多也可能增加安装和环境依赖。应按当前任务需要比较这些维度,不能把“更高级”视为任何用户都更合适;原书产品功能、收费与排名属于历史描述。

工具比较需明确功能与成本保存独立卡片。

原书依据 · 3 处

其他启动选项

常规启动之外还有面向特定场景的其他入口。

嵌入式调用

嵌入时由宿主触发解释器运行,源码的来源与启动者可不同。

集成可以双向组织组件关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
冻结二进制的可执行性

冻结后的包仍可经系统常规入口启动,开发时则需可改源码与反馈。

打包独立程序不等于编译加速关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
文本编辑器启动的选择

文本编辑器也可组合启动工具,无需一定采用全套IDE。

工具比较需明确功能与成本关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
其他的启动选择

启动来源还可以是文件管理器、另一个程序或服务宿主。

源码文件与运行入口分开关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
未来的可能

启动机制随平台演变,书中设想并非已实现的能力。

我应该选用哪种

环境选择有任务背景,错误消息、输出追踪、交互调试提供不同观察。

工具比较需明确功能与成本关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
调试观察要对应待解问题

错误消息指出异常发生处,输出追踪可补充执行路径和数值,调试器则可逐步暂停并查看状态。按当前疑问选择证据,不把某一种手段当唯一方式,也不凭熟悉代码就省去必要上下文;临时输出还需避免干扰程序结果。

787给pdb.run(“main()”)与python -m pdb main.py args两类入口,以及IDE的观察方式。按需要查看状态选择工具;这类入口会执行目标,不能当只读查看源码。本节“pdb/IDE很少使用”是作者当时印象,不当当前统计。

调试观察要对应待解问题保存独立卡片。

原书依据 · 2 处
异常后调试利用现场信息

事后调试利用异常发生时保留下来的执行信息,帮助检查失败路径,而不是从程序起点再次猜测。原书以pdb.postmortem说明这一入口,具体可见内容仍受当时状态和接口限制;查看现场不自动说明根因或修复方式。

787列pdb.pm()事后分析入口,用失败保留信息追踪异常路径;它是诊断工具,不自动恢复原程序或证明根因。未调用调试器。

异常后调试利用现场信息保存独立卡片。

原书依据 · 2 处

本章小结

启动章小结回顾入口,下一部分进入对象类型。

本章习题

七题复习交互、脚本、GUI与命名空间。

习题解答

八项编号答案补充导入缓存和IDLE局限,编号与前面七题并不一一对应。

再次导入通常复用模块对象关联本项背景,实质主要讲解在对应位置。

模块命名空间隔离名称关联本项背景,实质主要讲解在对应位置。

原书依据 · 14 处

第一部分 练习题

七项练习要求比较启动、错误、导入位置与文档,解答可能补充正文。

错误消息定位不等于确定根因关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
练习环境验证不等于完整正确性

输入简单表达式或运行最小文件,可验证某个入口和解释器的基本链路;它不证明大型程序、依赖或所有平台已正确。练习应明确验证对象,再区分成功启动、输出符合预期与业务完整性,不能用一条Hello World代替全面验证。

练习环境验证不等于完整正确性保存独立卡片。

原书依据 · 1 处

第二部分 类型和运算

第二部分转入类型与作用在对象上的操作。

第4章 介绍Python对象类型

对象类型规定一个值支持哪些操作。数字参与计算,字符串表达文本,列表保存有序引用,字典按键关联值;同一个符号在不同类型上可能具有不同含义。这里的广览为后续专章建立地图,也提醒读者先看操作所需能力,而不靠值的显示外观猜测契约。

表达式处理对象,语句、模块与程序在其上组织行为。

对象把数据与可用操作联系起来

对象是程序处理数据的载体,类型决定相关操作;表达式创建或处理对象,语句组织表达式与行为,模块再组织程序。它们是理解代码的不同层次,不意味着所有语句都必须包含新对象创建,或每个对象都需用户自写类。

正则对象、GUI组件、套接字等通常通过其模块或类构造,与字面量入口不同;需要import不改变它们同属对象的事实,内置类型也不都必须有专用字面量。

对象把数据与可用操作联系起来保存独立卡片。

原书依据 · 2 处

为什么使用内置类型

内置对象免去常见结构的重实现,定制结构也可在其上组合。

先确认内置结构能否表达问题

列表和字典等现成类型已承担常见存储与访问工作,定制结构也可组合它们,例如用列表管理栈。先确认需求是否已有合适表达,可避免重复实现底层机制;性能通常优化过不代表任何场景都优于特化实现,仍须匹配实际操作。

先确认内置结构能否表达问题保存独立卡片。

原书依据 · 1 处
Python的核心数据类型

核心类型有不同生成语法和操作,字面量不等同不可变常量。

字面量描述语法不保证不可变

字面量是直接写出某类值的语法,如字符串或列表形式,不等于名称永不能改绑或生成对象不可变。应分别区分表达式写法、对象类型和可变性;不能把英文literal或constant一词直接当C++ const式限制。

字面量描述语法不保证不可变保存独立卡片。

原书依据 · 1 处
动态跟踪类型不取消操作约束

名称可在运行时绑定不同类型对象,但对象能接受哪些操作仍由其类型与接口决定。动态类型不是没有类型检查,更不表示任意两种对象能相加;原文强类型用来强调这种操作约束,不当所有语言共有的严格分类标准。

动态跟踪类型不取消操作约束保存独立卡片。

原书依据 · 1 处
序列与映射用不同身份取值

列表以位置组织有序对象,字典以键定位值,两者适合表达不同访问需求,也都可包含其他对象形成嵌套。选用时先问要按位置还是键识别数据,不能因都能装多个值就忽略访问契约;历史字典无序的细节后文需区分版本。

序列按位置、映射按键取值,集合另有成员代数;这些是教材的操作分类,不是全部对象的穷尽类型系统。

序列与映射用不同身份取值保存独立卡片。

原书依据 · 6 处
程序构件也可以作为对象传递

函数、模块和类在Python中也以对象形式出现,可被名称引用或放入容器。它们并不因参与组织程序就脱离对象模型;能传递也不意味着具有相同调用或存储接口,具体操作仍取决于对象类型。

程序构件也可以作为对象传递保存独立卡片。

原书依据 · 1 处

数字

数字运算、表示和库函数各有边界,大整数能力也受资源与输出条件限制。

整数精度与输出限制分开

Python3整数可扩展所需精度,不受固定机器整数位宽直接溢出的同一限制,但运算仍消耗时间和内存。巨大整数存在不代表十进制转换或打印总可用;当前CPython还可限制整数字符串转换位数,原书len(str(2**1000000))输出不能无条件照搬。

大整数精确扩展需要额外存储和运算工作,不能承诺任意大小都可无代价计算;Python2长整数显示L与Python3统一int是版本差异。

整数精度与输出限制分开保存独立卡片。

原书依据 · 3 处
显示舍入不改变存储值

repr偏向可识别对象的表示,str偏向展示,两者输出可随类型与版本不同。浮点数还可能无法精确表示十进制值,打印得短不等于误差消失;原书把3.1415*2现象仅称显示问题不够完整,当前最短表示也不是完整精确十进制展开。

显示舍入不改变存储值保存独立卡片。

原书依据 · 2 处
数学工具与基本运算分工

加乘幂等表达式完成基本运算,math提供pi、sqrt等数学工具,random提供数值生成与序列选择。使用模块先导入相应对象;示例产生一个值不证明任意随机性质或所有数值输入均有效,仍应按接口契约选择。

random提供随机浮点数、整数和序列抽取等不同接口;应按任务选择及核对端点,未执行原例或宣称得到某随机输出。

NumPy是另行安装的数组数值扩展,SciPy等在此仅为进一步工具入口;不能把其矩阵/向量能力当标准内置列表或math自动具有。

数学工具与基本运算分工保存独立卡片。

原书依据 · 3 处

字符串

字符串以有序序列保存文本,可按相对位置访问。

字符串也是有序序列

字符串保存文本,并支持按位置读取;取单个位置仍得到字符串,而不是另一种单字符专用类型。序列强调顺序和位置,不等于所有序列都可原地修改;列表、元组与字符串仍有不同可变性和元素约束。

str保有从左到右的字符位置,单字符仍是长度1字符串,没有独立char类型。str的长度按Unicode码点计,不等同编码后的字节数或屏幕可见字形数。

非空字符串索引取长度1字符串,因此可继续取[0];若原容器项是其他类型,就必须按实际对象接口判断能否继续。

字符串也是有序序列保存独立卡片。

原书依据 · 3 处
序列的操作

序列提供索引、切片、连接与重复,其语义由对象与边界共同决定。

负索引按序列长度定位

正向索引从0开始,负索引按序列长度换算,如S[-1]指最后一项。它不是任意越界都自动循环取模;应确认有效范围。索引表达式可以计算得到,但对于字符串序列,结果仍须符合所用索引接口要求。

负索引从末端计数但不是取模,不保证任意越界负数都有效;-0仍为0。字符串索引结果仍是单字符str。

负索引按序列长度定位保存独立卡片。

原书依据 · 2 处
切片先明确定义排除端点

常见正步长切片X[I:J]包含起点而排除终点,省略边界按其规则补齐。它选择的是一段结果,不应据完整切片就推断总会分配不同身份的对象,尤其不可变字符串无需靠拷贝隔离写入;负步长等完整规则后文另读。

正步长S[i:j]包含起点而排除终点;S[1:]从偏移1即第二项开始,原文“第一个元素”需按偏移区别。S[:]对列表是顶层拷贝,对字符串不保证另分配不同身份对象。

切片先明确定义排除端点保存独立卡片。

原书依据 · 3 处
同一操作依赖对象接口

加号对数字表示加法,对字符串表示连接;相同操作形式由实际对象支持的语义决定。可复用代码因此能接受提供兼容操作的不同对象,但不是把所有类型隐式互转或任意混用;必须仍符合共同接口。

动态类型允许代码对支持相同操作的对象复用,仍需对象接口满足所做操作;不承诺任意新类型自动兼容。

字符串+用于连接,*用于按次数重复,不会把加法里的整数自动转换成文本。动态分配无需预声明长度,但内存和输出大小仍有限,重复大文本应考虑资源。

str/list/tuple可共享部分序列操作,但不是任意被称序列的对象都支持+和*,range等就不同;自定义类型还需实际实现相应协议。

列表+列表产生连接后的列表,列表不能直接加字符串;str(list)变成整个列表的文本表示,list(text)则拆为字符元素,二者转换不是保留原数据结构的同一种动作。

方法与分类操作相互补充,但不同类型支持范围各异;文件的外部状态改变也不宜简单按内存容器的可变/不可变标签推导。

同一操作依赖对象接口保存独立卡片。

原书依据 · 9 处
不可变性

字符串不可原地写入,但名称可以改绑另一个字符串;可变性属于对象而非名称。

可变性边界

可变性描述对象能否原地改变,和名称能否重新绑定是两件事。字符串不支持位置赋值,可以计算另一字符串再绑定原名;列表、字典则提供原地修改操作。元组位置不可改也不表示其中引用的所有对象都递归冻结,选择结构时应明确需要保护哪层状态。

不可变对象不支持自身结构的原处改写,仍可重绑定名字;元组包含的可变对象却能变化,不能由外层不可变推断整个嵌套结构深度冻结。可变类型可原处改,不意味着其所有方法都会改原对象。

答案把list和bytearray称为不可变是笔误;二者支持原处修改,不能凭该句修改正确类型模型。

列表既支持序列的取值/切片,也支持原处增删和修改;可变性描述对象,不意味着变量重绑定会让其旧别名改绑。

字符串/元组顶层不可原处修改,可构造结果再绑定名称;元组内可变对象共享仍会产生侧面可见变化,不能说不可变对象永远无任何共享副作用。

可变性边界保存独立卡片。

原书依据 · 5 处
类型特定的方法

字符串方法完成查找、变换、分割和格式化,返回值不等于修改原对象。

同一操作依赖对象接口关联本项背景,实质主要讲解在对应位置。

原书依据 · 9 处
字符串查找需区分零与未命中

find返回首个匹配偏移,0表示在开头,-1表示没找到;直接按真假判断会把这两种情况误用。应按接口规定比较失败值,不能把未命中当合法的最后一位索引使用。

find所得位置用于切片前需先检查-1,否则会把末尾偏移误当匹配位置。replace直接按字面子串替换,默认全部,可传count限制次数;并非正则替换或安全模板引擎。

字符串查找需区分零与未命中保存独立卡片。

原书依据 · 2 处
字符串变换应接收返回结果

replace、upper和去空白等操作提供变换后的字符串值,不在原字符串内改写。split则返回分割出的部分列表,内容测试返回布尔结果;方法调用的名字不足以判断返回形态或副作用,需按真实契约接收并使用结果。

拼接、切片重组、replace或格式化都不原处覆写原str;需要保留新值时接收结果。不可变不保证任意一次未改变值的操作都一定分配新身份对象,不能以is测试变换是否成功。

可用list(text)建立字符列表,多次替换元素后用”“.join合回str;这是修改可变中间结构而非让原str可变,不凭原书泛化就宣称所有任务性能更好。

line.rstrip().upper()通过每次返回的str继续操作,不原处修改原行;列表解析可收集split后的列表或比较结果等,结果类型取决于左侧表达式。

字符串变换应接收返回结果保存独立卡片。

原书依据 · 4 处
文本格式化区分模板和参数

格式化把提供的值填入模板,原例%表达式与str.format都能构造文本结果。模板位置和实参必须匹配,得到字符串不代表它对任何HTML、查询或其他输出上下文都安全;格式化只是值到文字的组织。

%左侧模板指定%s/%d等目标,右侧提供对应值,多项通常以元组供给;返回字符串后才决定保存或打印。%s按str形式转文本,不自动针对输出所处HTML/SQL等上下文转义。

复杂数字/对齐输出可先格式化成字符串再print;sep/end不是完整格式引擎,也不提供目标上下文转义。

文本格式化区分模板和参数保存独立卡片。

原书依据 · 3 处
寻求帮助

名称列表用于发现入口,帮助文档才说明参数与返回规则。

对象内省仍需理解返回范围关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
先定位接口再查具体契约

发现方法名后,可对具体方法查help以了解参数、返回结果与可选行为,例如replace的count约束替换次数。对整个类型求帮助可能过宽,先从待解问题定位小入口更有效;文档说明仍不等同已在当前输入上执行验证。

先定位接口再查具体契约保存独立卡片。

原书依据 · 1 处
编写字符串的其他方法

文字写法、转义和编码表示分开,文本与二进制文件接口也不同。

转义写法不同于字符数量

源码中的反斜线转义可表示换行、制表或零字符;几个源码字符可能只生成一个字符串元素。单引号与双引号都可包围文本,三引号可直接保留其中的多行内容;不能据原始源码拼写长度直接判断求值后长度。

转义换行或制表不按源码两个字符计算,零字符也不会自动终止Python字符串。此处ASCII例len为5只说明实际字符数,Python3 str不能一概称字节长度。

转义写法不同于字符数量保存独立卡片。

原书依据 · 2 处
原始字符串仍有语法边界

raw写法减少反斜线转义处理,便于表达某些路径或模式,但仍需满足字符串字面量的引号和结束规则,不是任意原始字节的容器。它与Python3的bytes类型也不同,不能因raw一词就当二进制数据。

raw适用于含反斜杠的路径/正则源码,仍不能以奇数个反斜杠收尾;要在末尾保留一个反斜杠,可与普通转义字符串拼接等。它不校验路径存在或自动创建文件,open(…,w)仍有覆盖风险。

原始字符串仍有语法边界保存独立卡片。

原书依据 · 2 处
文本与字节需要明确转换

Python3的str表达Unicode文本,bytes表达字节序列;在文件和通信边界需明确文本编码与解码。文本模式与二进制模式接收和返回的对象不同,不能沿用Python2的str含义混用;原文最后一句译法混乱不当二进制文件返回str的规则。

Python3 str表示Unicode文本,bytes为字节序列,bytearray是可变字节序列;不能把ASCII入门例的字节数说法推广到任意str文本。Python2的str/unicode分工属于旧版。

bytearray可修改的是字节整数序列,不能把任意Unicode文本字符直接当单字节修改;频繁编辑文本应按实际表示和编码任务选择工具。

文本读取返回str,写入需str,数字需显式转换;二进制返回bytes且写入字节类对象。两者不是凭打印外观相近就能混用。

Python3文本模式按编码解码并可转换换行,bytes保留原始字节;bytes[0]取整数,切片取bytes。原书“所有字符串都是Unicode”需限定str,不包括bytes;编码/换行具体行为可配置。

792将国际化文本、图像/音频/打包数据与ASCII场景比较:场景决定所用接口,但ASCII内容并不消除str/bytes类型边界。sys.getdefaultencoding不能当文本文件默认编码的通用查询;encode/decode方法默认UTF-8,文件默认值则由该接口/配置/版本决定。旧文“美国Windows ASCII或UTF-8”不作为本机或所有平台事实。

795详细定义bytes为0..255整数序列:索引得int、切片得bytes、list得到整数;打印尽量显示ASCII不改变其本质。bytearray可原地修改字节,不能任意用Unicode字符直接赋入。str是码点序列,不把它当内存已按UTF-8编码或按平台默认编码储存的对象;ASCII文本只是其子集。原文Python2.8为版本笔误,保留2.X/2.6语境,不创造2.8版本。

796明确文本读取解码到str、写str时编码,二进制读取bytes、写字节类对象且无文本换行转换。模式带小写b选择这个接口,+与读写权限是另一维度;数据虽是CSV/XML等文本,也可能在边界先按bytes取得后交给专用解析器,不能只凭扩展名保证文本open必正确。

798的02151-02154对照B=bspam与S=eggs,bytes[0]为115而str[0]为e,切片各保留类型,list各为整数或单字符文本;两种类型都拒绝元素赋值。原文“可以把str/bytes/整数赋给偏移”与紧接的TypeError相矛盾,按实际图及不可变定义记录为不能赋值。

799列str.encode/bytes(text,encoding)与bytes.decode/str(bytes,encoding)两组对称接口。Python3这些方法默认UTF-8,不是按任意平台更换;sys.getdefaultencoding的显示不能替代open的具体默认策略。类型接口不会普遍自动混合str与bytes,是否接受仍由每个函数契约定义。

806与02170-02176完整对照2.6 str字节、u字面量、Latin1/UTF8转换、普通str不识别u/U转义、ASCII混合成功及C4非ASCII混合UnicodeDecodeError。隐式升级不是检测真实编码,必要时仍先decode(latin1)。2.6 codecs.open提供指定编码读写Unicode的旧接口说明,不能把它当Python3独立bytes模型;u前缀在3.0不可用也不代表3.3以后仍禁止。

814原文“二进制不会返回原始内容”与其后定义矛盾:二进制读取确实保留原始字节,不进行文本解码/换行转换。默认r/rt为文本输入;写入需要str或二进制字节类对象,模式与内容显示相似不能绕过类型契约。

815的02199向文本file写abc加换行,关闭再重新打开读取,结果为str。图中write返回注释写字节数不准确:文本write计字符,不能由ASCII例字节恰好同数推广。file在Python3不再是Python2那个内置构造名,但仍应为变量取能说明角色的名称。

821及02222给Python26的u文本、Latin1/UTF8编码和codecs.open写读,分别返回字节str或unicode。此为旧接口示例,不能仅换变量名就假定所有新旧文件类型、错误和版本兼容;对应转换方向仍是写编码、读解码。

文本与字节需要明确转换保存独立卡片。

原书依据 · 15 处
模式匹配

正则模式描述匹配结构,捕获组提供局部结果,匹配方法自身也有限定。

模式匹配须核对起点和分组

正则可描述空白、字符段及分隔结构,括号捕获对应部分供后续读取。原例re.match从字符串开头尝试,不能当在任意位置搜索;.*等模式也有范围规则,不是任何情况下跨所有字符。使用捕获前先确认匹配成功,三个斜线分段示例不等于任意路径解析器。

823的02223-02225以(.) down (.) on (.*)三组从句子提取子串,对照文本与字节形式;group前需先确认match非None,点默认不跨换行,星号默认贪婪,不能把任意文本解析都套进这一模式。模式与目标混用str/bytes会TypeError。书中Python3.0的bytearray匹配输出展示为bytearray组,不据旧输出承诺当代所有bytes-like输入都保留可变结果类型。

模式匹配须核对起点和分组保存独立卡片。

原书依据 · 2 处

列表

列表按位置组织任意对象,且大小与元素可通过相应操作改变。

序列与映射用不同身份取值关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
序列操作

列表共享常见序列操作,但结果容器与原地修改仍需区分。

切片先明确定义排除端点关联本项背景,实质主要讲解在对应位置。

序列与映射用不同身份取值关联本项背景,实质主要讲解在对应位置。

原书依据 · 9 处
类型特定的操作

列表方法可原地增删、排序与反转,修改与返回结果需分别理解。

原地修改不同于返回新容器

列表append、sort和reverse等修改原列表,和连接或切片生成结果的操作不同。应按接口确认修改对象与返回值,不把原地排序直接当新排序列表接收;共享该列表的其他引用也会看到原地变化。

append、sort、reverse原处修改且不返回修改后的列表,L=L.append(x)会把名称改绑None;sorted返回新列表,reversed返回反向迭代器,需按结果契约使用。

+=等可选择原处运算,因此不保证与写成x=x+y的共享引用效果完全相同,后面专节需按类型和操作限定。

L=L.append(4)先修改原列表,再把L绑定到None;若还有其他引用,它们仍指向被修改列表,不能说所有对象一定丢失并立即被回收。

list.append和list.sort原处修改并返回None,所以L=L.append(x)把名称改绑为None。并非所有原处修改方法都返回None,例如pop还返回被删除项;应看具体接口的业务结果。排序字典键可用sorted(d),不要把keys().sort()当作可遍历结果。

L=L.append(item)先修改原列表再把L绑定为None;对象可能仍被其他名称引用。若需要保留容器引用,按接口分开修改和使用,不把所有带副作用调用都强行当返回新对象。

945的02578-02579先keys=list(D.keys()),再keys.sort()并遍历;也可for key in sorted(D)。不能把keys赋为sort返回值,排序遍历也不意味着原字典被改成按键顺序。02577的map(ord,S)需按显示需求物化,02580-02581的while/for/成员测试按任务选择,不据此宣称某写法性能更优。

原地修改不同于返回新容器保存独立卡片。

原书依据 · 7 处
删除操作还要区分返回值

pop按位置移除并返回被移除项,del删除相应目标但不是同样返回对象的方法。remove又是按值寻找移除,操作目标不同;不能因都使列表变短就把调用或返回契约互换。

pop按位置删除并返回元素,remove按值移除匹配项,del按目标删除而非返回数据;index查位置且未命中会抛异常,不能按str.find返回-1的规则处理。

dict.pop(key)按键删除并返回值,与list.pop(index)按位置不同;缺键且无默认值仍会抛KeyError。copy只浅复制,values/items在Python3返回视图而非旧版列表。

删除操作还要区分返回值保存独立卡片。

原书依据 · 3 处
边界检查

列表可增长但单项越界访问或赋值不会自动补齐位置。

列表增长不靠越界单项赋值

列表支持改变长度,但直接读取不存在的位置或对该单项赋值会报错,不会自动补出中间位置。需要增项时使用append等实际增长操作;切片赋值又有自己的规则,不能将单项越界结论无差别套给切片。

列表增长不靠越界单项赋值保存独立卡片。

原书依据 · 1 处
嵌套

嵌套容器按层取值可表达矩阵,但不自动获得数值数组语义。

嵌套结构按层解释索引

列表可包含其他容器,连续索引先得到某一层对象,再在该对象上取值。原例M[1][2]先取第二行再取该行第三项;嵌套列表只是结构表达,不自动保证规则矩阵形状、同一数据类型或向量化算术。

列表的matrix[row][col]先取该行列表再取列项;matrix[row]取出的不是该行副本,修改它可影响原结构。容器允许不等长行,不能因画为3×3就自动保证矩阵形状或数值运算规则。

字典可把姓名、工作列表、地址映射等组织成记录,连续索引逐层读值;数据结构清晰不等于自动校验每层字段或取代所有带行为的类。

嵌套列表/元组/字典可组合结构,链式索引每一步都基于上一步实际对象类型。索引成功不代表任意层深都成立;需核对结构和键/位置,不凭最终想要的数据猜中间路径。

嵌套结构按层解释索引保存独立卡片。

原书依据 · 5 处
列表解析

解析表达式把遍历、转换和可选过滤组合,收集容器决定结果语义。

列表解析组合遍历与转换

列表解析按输入迭代,把表达式应用到各项并收集结果;可加过滤条件选择要保留的项。提取矩阵列是对每行取相同位置,不改写原矩阵。新列表不保证表达式无副作用,执行顺序与被处理对象仍影响结果。

解析把每项表达式结果收集到列表;Python3 map返回惰性迭代器,原图用list(map(…))才得到列表,不能把正文“map收集为新列表”不加版本限定。

[expr for x in source]按迭代次序求expr并收集结果,适合构建列表;它不是自动懒序列。与手写append循环的输出机制相近,但作用域等语言细节仍可能不同,不因形式短就保证所有场景语义和性能完全相同。

map要求可调用对象,列表解析直接书写逐项表达式,二者都可由迭代来源取值。选择时结合输出需求、可读性与求值方式,而不是认定表达式形式必然更高级。

[ord(x) for x in text]直接收集表达式值;list(map(ord,text))先取得map再物化。若传lambda求平方也可实现相似结果,但函数调用和表达式形式不同,代码长短不替代语义判断。

方括号解析建列表,圆括号形式建生成器,集合花括号解析收元素,字典花括号解析收键值对。可接受迭代来源不表示输出都惰性;集合与字典还受可哈希元素或键及重复合并规则影响。

列表解析组合遍历与转换保存独立卡片。

原书依据 · 7 处
生成器按请求推进结果

生成器表达式保存可逐项产生结果的计算,next等消费动作推进它;列表解析则收集已计算的结果。两者都可遍历并转换,但计算时机与消费状态不同,不能把生成器当可任意反复读取的完整列表。

生成器按请求推进结果保存独立卡片。

原书依据 · 1 处
收集容器改变结果保留规则

相同输入转换成列表可保留顺序及重复,集合只保留不同元素,字典按键组织唯一位置。原例对spam取字符编码时,重复p在集合/字典中不产生独立重复成员;选择收集容器就选择了保留哪些信息,而不只是换括号。

收集容器改变结果保留规则保存独立卡片。

原书依据 · 1 处
惰性映射需要明确消费方式

Python3的map返回可迭代结果,list可将其消费为收集好的列表。函数应用、逐项消费与最终物化分别有成本和状态,不能据返回map对象就认为所有输出已算完;也不能把Python2原有返回形式套到Python3。

惰性映射需要明确消费方式保存独立卡片。

原书依据 · 1 处

字典

字典按键映射,与序列按位置不同;历史无序说明需版本限定。

序列与映射用不同身份取值关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
映射操作

字典可按键创建或替换值,新增键和列表越界赋值有不同契约。

键赋值可以建立新的映射

字典可由键值对或逐键赋值构造,给新键赋值会建立映射,给已有键赋值替换关联值。方括号中的含义由对象决定:字典用键,列表用位置;同样写X[k]不表示相同的缺项与增长行为。

d[new_key]=value新增映射,已有键则替换其值引用;del d[key]删除对应键值项。列表越界单项赋值不会自动增长,应使用适合列表的append/切片等方法。

键赋值可以建立新的映射保存独立卡片。

原书依据 · 2 处
重访嵌套

字典和列表组合可表达多层记录,改绑外层名称与内部对象生命周期不同。

嵌套结构按层解释索引关联本项背景,实质主要讲解在对应位置。

自动内存管理不包办资源生命周期关联本项背景,实质主要讲解在对应位置。

原书依据 · 9 处
键的排序:for循环

按键排序输出与字典自身顺序不同,for和while又用不同推进规则。

插入顺序不等于按键排序

要按键顺序输出字典,可对键生成排序结果,再按该顺序查值;这不会把原字典改成按键排序。现代字典保留插入顺序仍可能不同于所需排序;键是否可比较、具体排序规则也需明确。

Python3.7起普通dict保留插入顺序,原书Python2.6⁄3.0无序背景不能推广现行版本;保留顺序也不赋予列表切片或隐式按键排序语义。

原书键顺序例针对旧版本;若业务要求按键有序,仍应明确sorted及键的可比较性,而不是把现代插入顺序当键排序结果。

sorted(d)按键值排序返回列表,d.keys().sort()不成立;如果依赖现代插入顺序应明说版本,不能把二者混成一个顺序概念。

插入顺序不等于按键排序保存独立卡片。

原书依据 · 4 处
遍历与条件循环推进方式不同

for从可迭代对象逐项取得值,循环变量指向当前项;while按条件决定是否继续,循环体需按目标推进状态。原例倒数同时更新x使条件终止,不是对已有序列逐项取值;两者都能重复工作但控制契约不同。

while在每次进入主体前检查条件,主体需有能推进状态或退出的机制;条件始终为真不代表程序自动发现任务完成。

遍历与条件循环推进方式不同保存独立卡片。

原书依据 · 2 处
迭代和优化

迭代协议统一容器与逐项生成对象,优化应在正确与可测基础上进行。

列表解析组合遍历与转换关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处
迭代协议

可迭代对象能提供迭代器,迭代器按请求逐项产生值,直到耗尽。for、解析等可用同一协议处理不同对象,不要求输入物理存成列表;字典通常先取迭代器再按次取得键,不能直接把字典当next的目标。一次性迭代器的消费状态与可重复遍历容器不同。

Python3 range是可迭代范围对象,不像Python2普通range那样直接构造整数列表;把几个整数解包给名称不自动建立正式枚举类型。

for可用于序列以及dict、文件等其他可迭代来源;实际顺序与项由对象迭代协议决定,不把for定义成仅支持有序序列。

Python3 zip产生惰性迭代器而非元组物理列表,range产生可迭代范围对象;二者都可交给for,不因都延后产值就把它们当同一类迭代器。

enumerate可用next逐项推进,消费后的对象保有进度;for不要求用户手动计数,但也不会自动把同一迭代器重置到起点。

可迭代对象不必预存所有元素,也不限可按索引取值的序列;先通过iter取得迭代器,再逐项消费。map、for等可复用这一访问协议,但in也可能使用专门成员协议,不能说所有操作内部一律线性扫描。

原文脚注交替使用术语,笔记明确iterable支持取得迭代器,iterator支持next并通常iter返回自身;仅有可调用属性名next不替代完整协议契约。

for取得迭代器后反复推进,遇StopIteration正常停止;手动while可模拟这一步,但只捕获结束信号,处理元素的异常不应误判成正常耗尽。

用户类型可定义iter取得迭代器,或以从零索引开始、按IndexError结束的序列协议支持迭代。yield函数与生成器表达式是后章详解入口;不是给任意列表表达式机械加括号就保持所有类型和求值语义不变。

含yield的函数是生成器函数,其调用结果才是支持next的生成器迭代器;生成器函数对象本身不能因此直接逐项next。普通容器的可迭代与自身为迭代器仍须区分。

容器的iter应提供可next推进的迭代器;用户类也可借这一协议进入for等环境,旧式按索引getitem还有后备路径。迭代对象和生成器并非同义,文件按行、字典按键是各自接口语义。

定义iter的类可产出一般迭代器,不必就是语言yield创建的生成器类型;生成器函数的调用结果才是生成器对象。支持相同迭代接口不意味着类型和send等附加方法相同。

iter(obj)通常先通过iter取得迭代器,再用next推进其next直到StopIteration;缺少相应迭代入口时可走序列式getitem回退并以IndexError结束。若提供的iter本身出错或显式禁用,不能一概认为会自动回退。Python3迭代器方法是next,旧Python2名称为next,内置next(…)包装调用可减少版本写法差异。

迭代协议保存独立卡片。

原书依据 · 13 处
先确认瓶颈再选择优化写法

先让程序表达清楚并正确完成目标,再用测量确认需要优化的部分。解析与显式循环可表达相近计算,但速度依版本、输入和实际操作而异,原书快两倍不是所有场景保证;计时、剖析与语义验证应分别进行。

787“配置”指profiling而非应用配置文件,先测实际瓶颈,再比较候选写法;Psyco/Shedskin、旧.pyo或改写C都是当时列举的不同路线,不据名字担保任意代码提速。版本升级也须确认兼容与实测,不把最新必然更快当定律。

先确认瓶颈再选择优化写法保存独立卡片。

原书依据 · 2 处
不存在的键:if测试

新增键与读取缺键行为不同,分支与默认值要明确表示缺失。

缺键应与合法空值区分

D[k]读取缺失键会报错;可按需求用成员测试、get默认值或异常路径。选择默认值时应考虑它是否也是合法数据,不能把缺键、None和0混成一种状态;给新键赋值能扩展字典,不意味着读取也自动创建键。

d.get(key,default)在缺键时给默认值,不会把该键自动插入;已存在且值为None仍返回None。要区分缺键与合法空值,应另用in或明确哨兵。

可预先in测试、捕获KeyError或用get给缺失值;哪一种合适取决于缺键是否正常、默认值是否有歧义,不能把任何异常都吞掉后当0。

缺键应与合法空值区分保存独立卡片。

原书依据 · 3 处
条件分支按表达式真值选择

if根据条件真值决定是否执行其块,elif检查其他条件,else给出其余情况。成员检查可作为条件,但它回答的是键是否存在,不是其值是否非空;应让条件表达真正要判断的状态。

if/elif从上到下选择首次为真分支,都不成立才进入else;分支顺序是行为的一部分,不是所有条件为真就全部执行。

原例仅在输入通过前置条件并解析后比较num,20落入平方分支。边界值与条件顺序应一起读取,不能先对未解析字符串作数值比较。

一旦某个if/elif测试为真,就执行其块并不再求后续测试;无真分支且没有else时,该语句不执行任何分支动作。

原书语境的无switch说明不能推广整个Python3系列;3.10引入match/case模式匹配,但它也不是与C switch所有细节相同。本文只介绍原书if和查表机制,不假造已读完整match教程。

条件分支按表达式真值选择保存独立卡片。

原书依据 · 5 处

元组

元组是不可变序列,有索引切片等读取接口而无列表式增删。

元组固定的是元素位置关系

元组支持序列读取及index/count等操作,但不支持对位置赋值或append改变长度。它可以引用嵌套列表等对象,固定的是元组自身的元素引用关系,不会递归冻结每个内部对象。括号分组和元组构造的完整语法后文再分辨。

元组固定顶层元素引用位置,索引读取实际对象;内嵌列表仍可变。“元组不支持任何方法”与表9-1的index/count矛盾,准确是没有append等原处修改方法。

元组index查首次位置、count计数,不改变元组;sorted(tuple)得到列表,若需元组再转换。内嵌列表的元素能变,不意味着元组顶层赋值也允许。

元组可表达不应变更的顶层组合,名字仍能重绑定,嵌套可变对象也能修改;这不是整个对象图的常量保证。作字典键还要求全部相关元素可哈希,不能把任意元组都视作合法键。

小结再次说元组没有方法是旧措辞残留,本书已展示index/count;不支持原处修改不等同没有任何方法。

重建单元组再与尾部拼接能产生目标值,名称随后重绑定;不等于原处修改旧元组。

元组固定的是元素位置关系保存独立卡片。

原书依据 · 7 处
为什么要用元组

不可变序列适合表达不应被随意重排或换项的集合契约。

元组固定的是元素位置关系关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处

文件

文件对象连接外部内容,模式决定文本/二进制与读写契约。

文本与字节需要明确转换关联本项背景,实质主要讲解在对应位置。

原书依据 · 15 处
文件对象由打开接口建立

文件对象通过open等接口连接外部文件,路径、模式与权限决定可做哪些操作。文本写入模式w可能创建或截断文件,不是无副作用的值字面量;应先明确读写目的和关闭责任,不能把示例文件名当安全的任意可覆盖目标。

open返回具有读写等能力的流对象,不是把外部文件整体变成可索引列表。不同模式与具体流类型决定接口能力,表中read/seek等不能一概视为任意文件类对象都支持。

逐行迭代可按需处理文本,read一次读完与readlines物化整表会增加内存需求;仍应明确文件关闭,不把临时open的回收时机当跨实现保证。

for line in file按行读,for char in file.read()则先物化全文再逐字符;分块read适合按字节处理等任务。逐行仍可能有超长单行,不承诺任意文件都恒定小内存或无资源风险。

逐行迭代避免readlines先物化全文,但长行、下游累积列表等仍消耗内存,不能按原文“免疫内存爆炸”承诺任意大小数据安全。

逐行处理可以直接for line in file,资源生命周期仍应由with等清楚管理。列表解析会收集全部输出,不因来源是文件就成为恒定内存处理;协议自动取行也不表示没有读取I/O。

文件对象由打开接口建立保存独立卡片。

原书依据 · 6 处
读取方式决定物化范围

read可一次读取较多或全部内容,readline逐行,文件迭代可逐行推进。选择方式影响内存和消费状态,“不读它”实际是让迭代接口读取而非数据未被访问;读取数量的单位还需按文本或二进制接口确认。

947的02599-02600比较readlines/read全量统计与for line in open(name)逐行累计。逐行避免整个文件同时物化,但仍需容纳单行且代码未显式关闭文件;正文字符数按文本解码和换行转换计算,不能仅加行数就对任意编码恢复原字节长度,字节统计应使用相应二进制语义。

读取方式决定物化范围保存独立卡片。

原书依据 · 2 处
其他文件类工具

类文件接口可用于多种系统对象,外观相似不保证所有能力一样。

类文件外观不保证同样能力

管道、套接字、描述符与持久化接口可共享部分读取写入外观,却连接不同资源并有不同定位、通信或锁定能力。应按实际对象确认支持的操作,不能把有read/write就视为可随机定位的普通磁盘文件。

标准流、套接字、管道、子进程流与持久键存储可提供部分文件式接口,但不保证可seek、同一阻塞行为或相同读写类型;按任务核对具体能力和资源关闭方式。

类文件外观不保证同样能力保存独立卡片。

原书依据 · 2 处

其他核心类型

集合、精确数值、布尔与None分别表达不同值和比较需求。

集合按可哈希元素去重

set以不同元素的成员关系为核心,支持交、并与差,不保留输入的重复次数,也不以位置索引。元素需符合可哈希的契约,不应简单把“元素不可变”解释成set自身不能修改,或据显示顺序推断排序。

set自身可add/remove,原文称其不可改变与代码冲突;不可变可嵌套的是frozenset。元素需可哈希而非只看外层不可变,含列表的元组也不能作集合元素。set不保证位置或插入顺序,去重转换不能保留原序列次序。

集合与字典解析也支持for/if,区别在于收集成集合元素或键值项。集合会合并相等元素,重复字典键会由后值覆盖;更换容器不能忽略这些信息损失。

集合按可哈希元素去重保存独立卡片。

原书依据 · 3 处
数值表示按精确性需求选择

二进制float、十进制Decimal与有理数Fraction采用不同表示。原例Decimal在精度设为2时将1/3得到0.33,而Fraction能保留分子分母关系;十进制并非任何运算都无限精确,仍有上下文精度和舍入。应按计算目标选择,不把更整齐的显示当精度证明。

Decimal从十进制字符串建立值可避免先经过二进制float近似;它不是任意表达式都精确,非终止小数等运算仍受上下文约束。

数值表示按精确性需求选择保存独立卡片。

原书依据 · 3 处
None是具体值而非未绑定名称

None可显式表示暂无值并赋给名称,所以print该名称能得到None;未绑定名称则是另一状态。布尔真值判断还会把0或空容器等视为假,不能靠真假把所有无值状态合并。应按实际接口区分缺省、合法空值与失败。

None是NoneType唯一值,可作为未知内容占位;[None]*100只预置列表长度,不限制之后增长。名称绑定None与名称未定义不同。

None是具体值而非未绑定名称保存独立卡片。

原书依据 · 2 处
如何破坏代码的灵活性

类型可内省,但按兼容操作设计往往比硬编码某个容器类型更可复用。

接口优先于过窄的类型筛选

若代码只需要某种操作,按兼容接口设计可接受更多合适对象;强行只允许一种具体类型可能无必要地缩小复用范围。type与isinstance各有用途,类型验证并非一律错误,边界校验、子类规则或业务约束确有需要时应明确其责任。

times的x*y按实参支持的操作工作,数字可乘,字符串可与整数重复;原文两个字符串也可乘的断言不成立。可迁移的契约是支持指定运算,不是传入任何两对象都能成功;静态类型语言也有多态,不能把多态专属于动态语言。

intersect第一参数要可遍历,第二参数要能完成所需成员测试;兼容性不取决于两者必须同类型。协议还涉及状态和结果保证,不能把方法存在当作业务等价。

900的02467 typetest只给带省略内容的框架:按关键字/位置取值后用isinstance(value,type)拒绝;02468只展示注解接口。未展开的allargs建立和errmsg等不能当完整实现。使用isinstance也不能概括为精确类型相等:它可接受子类。作者给调试/语言接口等例外,选择应由实际契约决定,而非绝对禁止类型检查。

接口优先于过窄的类型筛选保存独立卡片。

原书依据 · 4 处
用户定义的类

自定义类把状态与操作放在一起,由实例分别保存数据。

类把实例状态与方法结合

Worker把姓名与薪酬作为实例状态,构造时分别赋值;lastName读取姓名,giveRaise修改该实例pay。方法调用自动关联处理的实例self,所以两个实例可有相同方法而保有不同数据。类是可选的组织工具,不因有记录就必须取代字典。

结构图: 类图只展示原文真实Worker,不虚构继承、额外实现或实例类型。

classDiagram
 class Worker {
  name
  pay
  +__init__(self, name, pay)
  +lastName(self)
  +giveRaise(self, percent)
 }

class可定义新的对象类型,把相关行为与各实例状态组织起来,并可继承定制。它不只是函数包,实例化、属性规则与协议支持都参与其行为;是否采用取决于问题结构,不由开发时间长短机械决定。

可把实例理解为记录具体数据的对象,把类理解为提供相应行为与类型关系的结构。类和实例本身也都是对象,可通过属性访问;模块通常缓存一份只是默认身份机制,不是绝对只能存在一个模块对象。

类把实例状态与方法结合保存独立卡片。

原书依据 · 3 处
剩余的内容

核心对象与语言组织对象都属于对象模型,面向对象设计是更具体的组织选择。

面向对象可选而非强制写类关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处

本章小结

对象章回顾序列、映射、方法和可变性,为后续细节建立框架。

本章习题

六题复习核心类型、可变性、序列、映射和多态。

习题解答

答案回顾类型与操作,并需保留版本、不可变层级和接口的限定。

同一操作依赖对象接口关联本项背景,实质主要讲解在对应位置。

序列与映射用不同身份取值关联本项背景,实质主要讲解在对应位置。

原书依据 · 15 处

第5章 数字

数字章节把计算语义与表示方式连起来:整数、浮点、复数及其他数值工具服务不同需求,精度和范围不能仅由打印结果判断。除法、取整、位运算及集合操作各有规则,历史版本变化也会改变表达式含义。选择工具前应先明确数学对象、输入范围与期望结果。

数字章从值对象进入各种表示和运算。

Python的数字类型

数字相关工具包括多种表示、精度与运算接口,不是单一类型。

数值表示按精确性需求选择关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
数字常量

字面量写法决定所建类型,整数进制写法与显示字符串又不同。

整数精度与输出限制分开关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
进制表示不同于整数值本身

0x、0o、0b前缀用不同进制表达整数,生成的仍是整数对象。hex/oct/bin返回相应形式的字符串,int(text,base)再按给定进制解释文本;不能把显示字符串与数值对象或不同类型混同。

0o377、0xFF和0b11111111都表达255,bin/oct/hex产生字符串而int(text,base)解析文本;Python2前导0旧八进制写法不要直接迁移到Python3。

手工解析二进制字符串可从0开始逐位做acc*2+bit,前提是每个bit已经验证为0或1;原例不替代输入校验。标准int(text,2)直接表达按二进制解析的意图。

format的b/x/o可生成相应进制文本,但默认不带bin/hex/oct的前缀;要前缀需对应规格,不能把“等同bin”理解成字节完全相同。

进制表示不同于整数值本身保存独立卡片。

原书依据 · 4 处
浮点字面量也可用科学计数

小数点或科学计数写法可建立浮点对象,即使值在数学上恰是整数,也不因此变成int类型。指数记号属于字面量表示,不是执行**幂运算语法;实际精度受浮点实现限制,不能按十进制书写位数推断精确存储。

浮点字面量也可用科学计数保存独立卡片。

原书依据 · 1 处
复数由实部和虚部组成

复数可写为含j的虚部与实部组合,或由complex构造;其运算按复数规则进行,不等于用两个普通数值做文本拼接。内部浮点表示仍有精度边界,不能由类型更复杂推断无限精确。

可用real、imag取出实虚部,cmath处理复数数学函数;1j*1j=-1,括号仍影响实虚部算式分组。不能把支持算术概括成也支持大小排序。

复数由实部和虚部组成保存独立卡片。

原书依据 · 2 处
内置数学工具和扩展

数字操作既有表达式/函数,也有类型方法,谓词与转换要区分。

值是否为整不等于对象是int

浮点数的is_integer检查该浮点值是否无小数部分,不把对象改成int,也不等同type检查。as_integer_ratio等提供另一表示,bit_length描述整数的二进制长度;方法应按对象和返回契约使用,不能只凭名称里的integer推断同一作用。

值是否为整不等于对象是int保存独立卡片。

原书依据 · 1 处
Python表达式操作符

表达式需分清分组、求值、混合数值转换及版本差异,不能只凭符号外观理解。

同一操作依赖对象接口关联本项背景,实质主要讲解在对应位置。

原书依据 · 9 处
优先级规定分组而非任意先执行

优先级决定运算怎样结合,例如乘法先结合再与加法组合;括号可明确改变分组并便于阅读。同级通常左结合,幂有不同结合方式;分组与运行时是否求值还要结合短路等规则,不能把括号解释成其中任何片段都无条件最先执行。

优先级规定分组而非任意先执行保存独立卡片。

原书依据 · 2 处
链式比较共享中间求值

X按相邻关系检查,可理解为X且Y并具有中间表达式不重复求值等规则。原文将后半误写为Y,语义错误;也不能简单把中间有副作用的表达式复制两遍再称完全等价。

1==2按1==2且2解释,前者为假即停止;不能先把False作为0再和3比较。多个不一致方向的比较虽合法但会降低可读性。

链式比较共享中间求值保存独立卡片。

原书依据 · 2 处
数值升级不意味着任意类型互转

常见int/float/complex混合运算可使用相应数值转换,但这一经验不能推广到所有数字扩展组合或字符串等其他对象。Decimal等另有契约,所谓“最复杂类型”只是原书的简化说明,不是任意类型之间统一的自动排序转换。

Fraction与整数运算可保留分数,与float混合会转为浮点计算;若要保持有理精度,应在发生近似前选择合适输入和运算类型,不在结果末尾补一次转换。

数值升级不意味着任意类型互转保存独立卡片。

原书依据 · 3 处
身份比较不同于值相等

is判断是否为同一对象,==按对象的相等语义比较值;值相等不保证身份相同。原文以内存地址类比身份是实现层的解释,不能把它当所有Python对象可直接暴露或稳定不变的物理地址。也不要凭某次小数值缓存结果决定用is做一般值比较。

普通数字相等或大小比较给出布尔结果;相等性与前文同一对象身份判断分开,不把数字类型混合可比较推广到任意对象的大小排序。

True==1成立而True is 1为False,是值相等与对象身份不同的具体对照;不建议用is与数字字面量比较。

分别创建的等值列表可==为真而is为假;小整数或字符串缓存可能让多次求值得到同一对象。缓存范围与环境不可当一般程序契约,sys.getrefcount图中的837也只是该次环境观察。

等值容器可不同身份,小字符串或常量缓存可共享身份;更长字符串也不保证永远不缓存。不要用字符串长度或一次交互结果推断可依赖的is规则。

身份比较不同于值相等保存独立卡片。

原书依据 · 5 处
短路判断控制右侧求值

and仅左侧为真时继续求右侧,or仅左侧为假时继续求右侧,not按真值取反。这些是条件求值规则,和整数位与/位或不是同一种操作;不能把符号&与逻辑and按名称互换。原表为机制入口,后文再补返回操作数等完整语义。

or在首个真值对象处停止,and在首个假值对象处停止;若一直未提前停止则返回最后操作数,不会自动替换成统一1/0。

短路判断控制右侧求值保存独立卡片。

原书依据 · 2 处

在实际应用中的数字

本节引出交互数字例子,将验证前面的表达式规则。

变量和基本的表达式

名称先绑定值,表达式再按优先级与具体除法版本计算。

优先级规定分组而非任意先执行关联本项背景,实质主要讲解在对应位置。

数值升级不意味着任意类型互转关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
名称使用前需已有绑定

名称记录对对象的绑定,在表达式中读取时必须能解析到已有值;Python不会为任意未绑定名称自动补0。累加器、列表等应按任务显式初始化,但初始化形式要符合所需接口,不能仅靠未声明就假定已存在。

使用名称前需能解析到已有绑定,赋值只是建立绑定的一种方式;本节初始化计数器说明不能靠未定义名称自动得到0。

未绑定名读取会报错,而非自动给默认0/None;名称可由参数、导入等其他绑定形式创建,不一定必须显式写=。

名称使用前需已有绑定保存独立卡片。

原书依据 · 3 处
数字显示的格式

浮点值、显示策略与格式化输出应分开。

显示舍入不改变存储值关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
比较:一般的和连续的

数字比较产生布尔结果,链式比较按相邻条件求值;对象显示有面向使用者与调试表示之分。

链式比较共享中间求值关联本项背景,实质主要讲解在对应位置。

身份比较不同于值相等关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处
对象显示形式不保证可逆

str通常给出适于阅读的文本,repr提供便于识别、调试的表示;它们都返回字符串,并不改变原对象。repr看似代码也不保证可安全或完整地还原对象,不能因此直接eval外部文本。历史浮点显示长短例仅说明表示差异,不是当前版本固定输出规则。

路径回显的双反斜杠是字符串表示中的转义,print显示每处实际一个;不能数回显字符来推断内容长度。

对象显示形式不保证可逆保存独立卡片。

原书依据 · 2 处
除法:传统除法、Floor除法和真除法

除法需要同时区分语言版本、操作数类型和向负无穷与向零两种取整方向。

负数整除并非向零截断

对内置整数和浮点数,//把商向负无穷取整,因此5//-2为-3,而math.trunc(5/-2)向零得到-2。正数例恰好相同,不能据此互换;//若含浮点操作数仍可返回浮点值,取整方向不等于返回int类型。

负数整除并非向零截断保存独立卡片。

原书依据 · 1 处
除法语义要连同版本读取

Python3中内置int/float的/做真除法,整数相除也可得浮点结果;//做floor除法。Python2传统/在两个整数时做floor除法,有浮点数时做浮点除法。迁移历史代码需先确认原意;Python2可用future division或浮点操作数切换真除法,不能机械替换所有/。

除法语义要连同版本读取保存独立卡片。

原书依据 · 1 处
整数精度

任意精度整数减少固定位宽溢出问题,但仍消耗内存与计算时间。

整数精度与输出限制分开关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
复数

复数表示两个浮点分量,支持相应算术与专门模块。

复数由实部和虚部组成关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
十六进制、八进制和二进制记数

进制转换是整数值与文本表示之间转换,执行文本代码属于更大的能力和风险。

进制表示不同于整数值本身关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
解析数值不必执行字符串代码

把数值文本转为整数应使用int(text,base)并处理不合法输入;eval会按Python表达式编译求值,允许的能力远超进制解析。来源不可信时,把它当转换函数会带来执行任意表达式的风险;转换和执行代码应由任务需求明确区分。

习题答案再次给出eval可转换同时有安全问题,应选匹配需求的int(text,base)而不是执行输入。

int/float等解析数值与eval执行表达式能力不同,从文件读来的文本不会因为在本地文件就自动可信。按实际格式选解析器,不能把保存对象表示再eval当不受输入威胁的通用持久化。

原文称exec唯一缺点是编译开销并不完整:把输入拼进可执行代码还会扩大可执行内容及命名空间影响。这里只为按名称加载模块时,应使用相应加载接口并约束来源,不为简单名字解析引入任意代码执行。

解析数值不必执行字符串代码保存独立卡片。

原书依据 · 4 处
位操作

位操作把整数解释为位串,用掩码组合标志;位数应依据数值而非显示前缀。

位掩码在一个整数中组合标志

把不同开关分配到不同二进制位,可用位或组合、位与检查掩码、位移调整位置。原例1<为4,1|2为3;这些逐位运算不等同具有短路行为的and/or。外部二进制协议可需要这种表示,普通业务数据仍应先选清晰的结构。

824的02230-02231从解包的7和bspam[0]=115继续按位与/或/异或。与掩码取交集可测试某位,或可设指定位置,异或会翻转指定位置而不是总清零;对byte值索引得到整数后沿相同规则处理。普通竖线与按位或符号用于数学/代码操作,不是增加一个对象字段或修改原不可变bytes。

位掩码在一个整数中组合标志保存独立卡片。

原书依据 · 2 处
整数位数不含符号与进制前缀

int.bit_length返回表示整数绝对值所需的二进制位数,不包含符号或0b前缀,0的位数为0。原例正数256的bin文本长度减2恰为9;把此捷径套到0或负数会多算数字0或负号,不能当普遍算法。

整数位数不含符号与进制前缀保存独立卡片。

原书依据 · 1 处
其他的内置数学工具

数学工具按函数契约选择,数值舍入、取整与格式化文本不能混为一谈。

数学工具与基本运算分工关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
数值舍入与格式化返回值不同

round进行数值舍入,格式化生成用于显示的字符串;二者都不原地修改原数字。Python3对内置float,round(x)省略ndigits返回整数,round(x,n)返回float;原文“仍为浮点”需要这个参数条件,代码图也显示无ndigits时为3。浮点近似仍可能影响舍入。

原文答案统称四舍五入过于粗略;Python3内置round的等距离情况采用偶数选择,且float表示误差仍会影响结果,不能直接用该词承诺十进制半入规则。

数值舍入与格式化返回值不同保存独立卡片。

原书依据 · 2 处
内置名称与模块入口分别查找

abs、pow等常用内置函数可从内置命名空间查找,math.sqrt等先导入模块后按属性访问。模块需要导入不意味着它是第三方依赖;同一平方根可有函数、表达式与内置幂等写法,选择时仍应核对定义域和返回值,不能只因一个正数例相同就认定所有输入完全等价。

内置名称与模块入口分别查找保存独立卡片。

原书依据 · 1 处

其他数字类型

数字家族还有十进制与有理数表示,为不同精确性需求补充工具。

小数数字

Decimal以十进制表示并按上下文进行运算;精度、显示小数位与构造输入需要区分。

数值表示按精确性需求选择关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
小数精度不是小数点后位数

decimal上下文的prec规定运算有效数字总数,不能当小数点后位数。原文把prec=2用于两小数并显示2000.33的例子不支撑该解释:Decimal字符串构造保存输入,不按prec自动舍入。处理固定小数位还需明确量化规则,不能只改prec。

小数精度不是小数点后位数保存独立卡片。

原书依据 · 1 处
局部小数上下文限制精度影响

在decimal.localcontext创建的with范围里调整ctx.prec,可使该范围运算使用临时精度,退出后恢复外层上下文。这样能避免一次低精度实验影响后续计算;它恢复的是上下文设置,并不会重新计算或补回已舍入结果丢失的数字。

749及02091用decimal.localcontext() as ctx设置prec=2,再做1.00/3.00;退出恢复外层配置,保存在x中的已计算结果不会重新获得丢失精度。精度是有效数字总数,不是统一小数位数;本节不用线程说法推断所有现代构建的上下文隔离实现。

局部小数上下文限制精度影响保存独立卡片。

原书依据 · 2 处
分数类型

Fraction用分子分母保留有理值并约分,浮点转换精确保持已近似值而不是原始意图。

数值升级不意味着任意类型互转关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
分数以有理表示保留精确值

Fraction保存整数分子分母并约分,1/3能以Fraction(1,3)精确表示;十进制有限精度除法只能保留舍入值。它不靠设置固定小数位实现精度,原文把分数也描述成固定小数控制不准确;分子分母变大仍有存储和运算成本。

分数以有理表示保留精确值保存独立卡片。

原书依据 · 1 处
转成分数不会补回浮点原意

as_integer_ratio或Fraction.from_float忠实表示现有float的二进制有理值,不能保证得到输入十进制文本原本想要的分数。需要精确保留有理输入时,直接从分子分母或文本建立;limit_denominator是在分母上限内找近似,不是无条件恢复原值。

转成分数不会补回浮点原意保存独立卡片。

原书依据 · 1 处
集合

集合按唯一元素支持集合代数与可变操作,哈希约束、空集合语法和结果顺序均影响使用。

集合按可哈希元素去重关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
集合代数比较的是成员关系

交集保留双方共同元素,并集合并所有唯一元素,差集保留左方独有元素,对称差保留仅一方拥有元素。<和>表示真子集/真超集而非按大小排序;集合无位置索引,读显示次序不能推出元素顺序。

集合代数比较的是成员关系保存独立卡片。

原书依据 · 1 处
集合表达式与方法接受范围不同

set的交并等运算符通常要求集合操作数;union/intersection等方法可接受一般可迭代对象。add把一个可哈希对象当整体加入,update遍历输入逐项合并,二者不能按是否都有新增元素而混用。

集合表达式与方法接受范围不同保存独立卡片。

原书依据 · 1 处
空花括号建立字典而非集合

空集合写set(),{}建立空字典;非空{a,b}是集合而{key:value}是字典。集合解析{x*x for x in iterable}计算后收集唯一结果,不保留重复次数;需要计次或保持位置时应选其他容器。

空花括号建立字典而非集合保存独立卡片。

原书依据 · 1 处
访问集合可防止循环重复处理

遍历带回环结构时,用集合记录已经处理的节点身份,进入节点前检查并更新,能避免同一节点被反复访问。记录键须符合任务中的节点身份和可哈希要求;只用数据值会把不同但等值节点混为一谈,集合本身不替代遍历算法。

reloadall以visited记录已处理模块,在递归或多条引用路径指向同一模块时避免反复处理。访问记录应围绕对象身份和失败策略设计;一个简单去重表解决遍历循环,却不自动解决重载副作用。

ListTree用类对象作为visited字典键,遇到已访问类只输出see above,避免菱形继承的共同祖先重复展开;id只用于显示标签。该图本来允许多路径共享祖先,去重不证明发生了合法继承环;str__每次重设实例的访问表,也不等于并发或重入调用已有隔离。

访问集合可防止循环重复处理保存独立卡片。

原书依据 · 3 处
布尔型

bool为int子类,真值角色与数值相等不意味着对象身份相同。

身份比较不同于值相等关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
布尔值有整数兼容与独立身份

bool只有True和False两个值,并继承int的部分数值行为,所以True==1且True+4得5;但True不是整数1那个对象。条件与标志通常写True/False来表达含义,不能因此把Python3关键字当可任意重绑定的普通变量名。

bool(obj)读取真值并给True/False,不把原对象永久变成整数1或0;if本身可使用协议真值,不要求输入必须是bool类型。

布尔值有整数兼容与独立身份保存独立卡片。

原书依据 · 2 处

数字扩展

第三方数值扩展提供专门数组、向量和科学计算工具,需与语言内置分开。

数学工具与基本运算分工关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处

本章小结

数字章汇总表示与运算工具,并转入理解赋值的引用模型。

本章习题

九题回顾优先级、平方根、转换、舍入和进制。

习题解答

答案按表达式分组、数字类型与转换工具解释前九题。

数值舍入与格式化返回值不同关联本项背景,实质主要讲解在对应位置。

解析数值不必执行字符串代码关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处

第6章 动态类型简介

变量名称不自带固定类型,而是在运行中引用对象。赋值可以改绑名称,原地修改则让其他别名看到同一对象的新状态;复制是否隔离又取决于复制深度。这个引用模型贯穿函数、模块和类,不能由“我没有修改另一个变量名”推断共享对象没有变化。

动态类型章通过名字、对象、引用解释灵活类型与多态的基础。

缺少类型声明语句的情况

不需先声明固定变量类型,但类型与名字绑定仍有明确运行规则。

动态类型关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
变量、对象和引用

赋值将名字绑定到对象,引用不是把名字串在一起,内存布局属于实现解释。

名称使用前需已有绑定关联本项背景,实质主要讲解在对应位置。

动态类型关联本项背景,实质主要讲解在对应位置。

原书依据 · 8 处
对象引用

赋值把名称绑定到求值所得对象,b=a让两个名字引用同一对象,不会让b永久追随a这个名字,也不自动复制对象。随后重绑定a只改a的绑定;若修改共享的可变对象,各引用都能观察变化。引用可用箭头理解,不需把它当应用可直接操作的C指针。

a=3、b=a后a改绑字符串或a=a+2,都不改变b仍引用的3;变量不通过另一个变量形成永久跟随。整数不可变,所以加法结果是另一值而非原处改写3。

L2=L1共享列表,L1[0]=24使两名称都看见同一列表变化;L1=24仅改绑。L2=L1[:]建立另一顶层列表,可隔离顶层项替换。

字符串拼接后赋给B仍只是重绑定B;共享列表上B[0]则修改A也指向的对象;B=A[:]后顶层项替换只影响B。三种情况需先画清实际引用关系。

X所指列表同时放入L和D时,修改共享对象可从三处观察到,修改的是同一对象而非三个副本。需要隔离时在建立容器成员时显式拷贝。

参数、for目标、导入、函数与类定义也会建立名字绑定,共同使用对象引用模型;赋值目标为容器项或属性时,还需对象支持实际写入操作。

对象引用保存独立卡片。

原书依据 · 6 处
类型属于对象,而不是变量

对同一名字重复赋值是改绑到不同类型对象,不是把原对象改造成其他类型。

动态类型关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
对象的垃圾收集

失去可达引用的对象可由自动管理回收,引用计数与循环检测有实现边界。

自动内存管理不包办资源生命周期关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
循环引用不随外部计数自动归零

对象直接引用自身,或两个对象相互引用时,即使外部入口丢失,彼此引用也可能使引用计数不为0。因此单靠计数归零不能判定所有不可达对象,需要循环垃圾检测等机制。识别循环是解释生命周期的工具,不是没有证据就关闭gc的理由。

L.append(L)建立自身引用;循环显示与垃圾检测处理的是不同责任,能打印并不证明没有生命周期或遍历问题。

循环引用不随外部计数自动归零保存独立卡片。

原书依据 · 2 处

共享引用

共享引用指多个名称指同一对象;重绑定一个名称不改变另一个名称所指对象。

对象引用关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
共享引用和在原处修改

共享可变对象会传播原处修改,拷贝则需区分顶层容器和内部对象。

对象引用关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
浅拷贝仍共享内部对象

list切片和copy.copy通常复制外层容器,内部元素仍按引用共享;因此修改嵌套可变元素仍可能互相可见。copy.deepcopy按其协议递归复制结构,但不把“任意对象都能完全隔离”当保证。选择复制深度需先确认哪些状态应共享。

list/tuple之间转换主要建立外层容器,不深拷贝内部值;tuple(existing_tuple)等也不保证总有不同身份对象,不能用“每次转换必新分配”理解隔离状态。

L[:]、list(L)、dict.copy只复制顶层结构,内部引用可仍共享;deepcopy按协议递归处理,还受对象类型、定制与外部资源限制,不能承诺任意结构都完全独立。

切片复制顶层列表后,原列表顶层项替换可隔离;“无共享”不应读成内部元素也全部复制。所谓高级拷贝在此是顶层浅拷贝,不是deepcopy。

deepcopy是按对象复制协议递归处理,不能把答案“所有组成部分”扩成复制文件描述符、外部服务状态等任意资源。

L[:]复制外层列表,修改副本的顶层项不改原列表,但嵌套可变元素仍可共享。tuple(L)阻止元组自身的增删和项替换,却不冻结嵌套对象,也会改变可用接口;不能把转元组当通用深度只读防护。

字典复制练习要求新建外层映射,内部可变值仍可能共享;不能把序列X[:]直接用于普通dict来复制。合并练习还须明确相同键采用哪一侧值,参数顺序可能改变结果。

浅拷贝仍共享内部对象保存独立卡片。

原书依据 · 7 处
共享引用和相等

值相等与同一对象是两种判断,缓存会影响身份观察但不应影响一般相等判断。

身份比较不同于值相等关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处

动态类型随处可见

赋值与引用模型贯穿参数、循环、导入和属性,帮助统一理解可变对象副作用。

同一操作依赖对象接口关联本项背景,实质主要讲解在对应位置。

原书依据 · 9 处

本章小结

总结动态类型、引用、共享修改、回收与相等,转入字符串细节。

本章习题

三题对照字符串改绑、共享列表修改、切片隔离。

习题解答

答案以名字改绑和列表原处变更解释三个结果。

对象引用关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处

第7章 字符串

字符串以序列接口提供索引、切片和组合,但字符串不可原地修改,所谓修改通常产生新对象。转义写法、显示结果与实际字符也不同,格式化则把数据组织成文本表示。后面的Unicode章节继续追问文本怎样编码为字节,因此这里不能把字符数、显示长度和存储字节数合成一个量。

字符串是不可变有序序列,Python3文本、字节和可变字节数组需分别理解。

字符串也是有序序列关联本项背景,实质主要讲解在对应位置。

文本与字节需要明确转换关联本项背景,实质主要讲解在对应位置。

原书依据 · 18 处

字符串常量

字符串字面量有多种引号、转义和前缀写法,其作用与对象类型要分清。

字符串前缀需要结合语言版本

r改变字面量转义处理,b建立字节字面量;u在Python2区分Unicode文本,但Python3.3已恢复u/U前缀并仍得到普通str。原书“仅Python2.6”是当时Python3.0范围,不能当整个Python3系列限制;前缀不是任意可互换装饰。

798的b/B适用单/双/三引号,r控制转义,二者功能不同。u/U在3.0取消属历史,Python3.3已恢复且得到普通str;不能扩成整个Python3禁止u前缀。未把源码中字节字面量直接允许任意非ASCII字符。

字符串前缀需要结合语言版本保存独立卡片。

原书依据 · 2 处
单双引号字符串是一样的

单双引号不改变字符串类型,相邻字面量拼接与逗号构造序列不同。

引号选择不改变字符串类型

单引号和双引号都界定相同的字符串类型,可用另一种引号减少转义。引号是源码界定符,通常不属于字符串内容;回显选择何种引号只是表示策略,不代表对象又换了一种类型。

引号选择不改变字符串类型保存独立卡片。

原书依据 · 1 处
相邻字面量可在编译时连接

相邻字符串字面量可直接拼成一个字符串,适合在括号内跨行组织文本;这是字面量语法,不使两个变量名相邻也能连接。增加逗号会改变表达式结构,如生成元组;运行期连接仍需明确操作。

相邻字面量可在编译时连接保存独立卡片。

原书依据 · 1 处
用转义序列代表特殊字节

转义将源码序列解释为实际字符,显示形式与字符数量不同,二进制与Unicode须分开。

转义写法不同于字符数量关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
未知转义不是可靠的反斜杠写法

原书未知转义保留反斜杠的历史行为,不应成为路径写法的依赖:Python3.12对此给出SyntaxWarning,官方还标记未来可能成为语法错误。要保留反斜杠,用明确的双反斜杠或符合语法的raw字面量,避免因字符组合恰好未识别而侥幸工作。

未知转义不是可靠的反斜杠写法保存独立卡片。

原书依据 · 1 处
raw字符串抑制转义

raw让反斜杠保留为文本,但外围引号语法约束仍然存在。

原始字符串仍有语法边界关联本项背景,实质主要讲解在对应位置。

对象显示形式不保证可逆关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
三重引号编写多行字符串块

三引号保留多行文本与空白,文档字符串只是特定位置的字符串用途。

注释与字符串内容要区分关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
三引号保留文本中的换行缩进

三引号可以容纳多行字符串,源代码里的换行与缩进会进入内容;不是自动去缩进的模板。需要精确输出时要检查首尾空行和每行空格,print与repr显示换行的方式也不同。

多行三引号保留换行和其中的#文本,相邻字面量在括号内连接则不自动补换行,字面量外#才是注释。

三引号保留文本中的换行缩进保存独立卡片。

原书依据 · 2 处

实际应用中的字符串

字符串基础运算、方法和格式化分别提供文本处理工具。

基本操作

拼接、重复、成员测试与遍历是不同的序列操作,返回值和运算类型应明确。

同一操作依赖对象接口关联本项背景,实质主要讲解在对应位置。

原书依据 · 9 处
字符串成员测试不返回位置

sub in text判断是否包含子串,返回布尔值;text.find(sub)返回首次位置或-1。只需存在性时用in可直接表达任务,不把0位置误当未找到;for逐项遍历得到字符字符串,不是把循环变量变成可修改的内存指针。

字符串成员测试不返回位置保存独立卡片。

原书依据 · 1 处
索引和分片

索引取单项,切片按排除终点和步长选择范围;省略边界还依赖方向。

负索引按序列长度定位关联本项背景,实质主要讲解在对应位置。

切片先明确定义排除端点关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
切片默认边界随步长方向变化

S[i:j:k]从起点按步长推进并排除终点;k不能为0。k为负时省略端点按反向遍历设置,所以S[::-1]可反转;不能仍把省略值机械填成0和len(S)。显式终点-1与省略终点不同,负索引转换会改变所选范围。

944第2题L[4]越界而L[-1000:100]截断,L[3:1]为空;这些是普通内置列表示例,不是所有用户对象的索引协议。负步长L[3:1:-1]改变方向,不能把正文“分片一定从左到右”当普遍结论;分片赋值空列表与索引赋空列表分别删除范围/保存一个空列表元素。

切片默认边界随步长方向变化保存独立卡片。

原书依据 · 2 处
删行尾前要确认实际终止字符

line[:-1]无条件删最后一项,仅当确定每行都有终止字符时才可用于去换行。末行没有换行会被误删有效内容;rstrip可有针对性地删除行终止字符,但无参数会删其他尾部空白,应按任务选择。

rstrip()清掉尾部空白,rstrip(chars)按字符集合清除而非匹配整个后缀;当尾部空格本身有意义时,不应只为删换行就无差别清理。

line[:-1]无条件删最后字符,rstrip()还删尾部其他空白;根据要保留的内容选精确清理规则,不能只是为了去换行而误删有效尾空格。

rstrip()会去掉全部匹配尾部空白,最后一行也未必有换行,原例所有readlines结果都有换行不是通则。精确清理要按实际终止符与保留空白要求选择,输入文件仍需明确关闭。

删行尾前要确认实际终止字符保存独立卡片。

原书依据 · 4 处
字符串转换工具

文本与数字转换要明确目标,字符编码值和数字字符数值不是同一概念。

进制表示不同于整数值本身关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
转换方向决定相加还是连接

文本”42”与整数1不能直接相加,int(text)+1表达算术,而text+str(1)表达连接。按输入语义选择转换并处理无效数字文本;能显示成数字不意味着原对象已是数字,也不应把eval当通用解析。

str不能直接求数值平方,先int(text)才可按整数语义运算,仍可能遇到非法输入异常;不能因为文本看似数字就自动推转换成功。

转换方向决定相加还是连接保存独立卡片。

原书依据 · 2 处
字符码点不同于数字字符值

Python3 ord取得单个Unicode字符的码点,chr按码点建立字符,不局限ASCII,也不是取得编码后的单个字节。ord(“5”)与int(“5”)分别回答字符编码身份和十进制数值,不能混用;码点连续性也不意味着任意字符加1就得到语义上的下一个字符。

ASCII题例是Unicode码点范围内的子集,ord/chr在Python3不只处理ASCII。

ord对单字符str返回Unicode码点,chr反向建立对应字符;ASCII是其有限子集。本例spam字符恰在ASCII范围,不能把所有str码点一概称ASCII编码或把ord当字节编码过程。

794的02149对ord(a)=97/hex/chr、02150对chr(196)=Ä。它们显示Unicode码点与字符的对应,在Latin-1范围又恰与单字节值相同;不能因此把ord当成任意编码的字节序列,或说它由平台默认编码决定。

字符码点不同于数字字符值保存独立卡片。

原书依据 · 4 处
修改字符串

字符串内容不可原处修改,所谓修改通常是构造结果并重新绑定。

字符串变换应接收返回结果关联本项背景,实质主要讲解在对应位置。

文本与字节需要明确转换关联本项背景,实质主要讲解在对应位置。

原书依据 · 19 处

字符串方法

方法调用组合属性取得与可调用对象调用,字符串方法依具体返回与参数契约使用。

属性取得不等于方法已经调用

object.attribute先读取属性,object.method(args)再对取得的可调用对象传参并使用返回结果。去掉括号通常得到方法对象而非执行结果;属性也不保证可调用,需核对接口。同名方法跨类型存在不意味着参数和语义完全一致。

file.close只取得绑定方法,file.close()才请求关闭;同样,函数名也是可传递对象,不加括号通常不是调用。以with管理文件能减少遗漏显式关闭的路径。

b.spam读取模块属性所引用的函数,b.spam(“gumby”)形式才请求调用;这里spam实际签名为spam(text),输出文本与spam标记。属性也可能是非可调用数据,不能见点号就加括号。

属性取得不等于方法已经调用保存独立卡片。

原书依据 · 3 处
字符串方法实例:修改字符串

字符串替换可按字面子串进行,多次编辑可先组织片段再一次连接。

字符串查找需区分零与未命中关联本项背景,实质主要讲解在对应位置。

字符串变换应接收返回结果关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
用分隔符连接可迭代字符串

sep.join(parts)由分隔符字符串发起,把可迭代对象中的字符串连接起来,在各项之间插入sep。先收集片段再join可避免逐次累积大字符串的反复复制;元素必须满足字符串接口,不能自动把整数转文本,也不会多加一个尾分隔符。

用分隔符连接可迭代字符串保存独立卡片。

原书依据 · 1 处
字符串方法实例:文本解析

文本结构决定按固定位置还是分隔符解析,split参数会影响空字段语义。

解析方式取决于字段边界约定

固定宽度字段可按约定偏移切片,变宽且由分隔符隔开的字段可用split。首先确认数据格式,再选解析工具;普通按逗号split不识别CSV引号内逗号或转义,不能仅因原例三字段可行就当通用CSV解析器。

解析方式取决于字段边界约定保存独立卡片。

原书依据 · 1 处
空白分隔与指定分隔符语义不同

text.split()按连续空白分组并忽略首尾空白,不是仅按一个空格切。显式split(sep)按完整sep字符串切分,连续分隔符可产生空字段,sep也可以多字符;要保留缺失字段位置时不能随意省略参数。

空白分隔与指定分隔符语义不同保存独立卡片。

原书依据 · 1 处
实际应用中的其他常见字符串方法

字符串方法分别清理边界、转换大小写和测试条件,不自动启用正则模式。

删行尾前要确认实际终止字符关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
字符串方法按字面条件匹配

startswith/endswith检查字面前后缀,in判断子串存在;普通find/replace等不把正则元字符当模式。需要正则时应明确使用相应re接口,但并非所有文本任务都需要模式引擎。先按所需结果选布尔测试、位置查找或替换。

字符串方法按字面条件匹配保存独立卡片。

原书依据 · 1 处
最初的字符串模块(在Python 3.0中删除)

旧string字符串操作函数被对象方法替代,但模块内其他工具仍然存在。

移除旧函数不等于删除整个模块

历史string.replace(text,old,new)等基本字符串函数被str对象方法替代,Python3应使用text.replace等契约。string模块仍提供常量、模板等工具;读到“旧模块调用删除”不能推出import string已无效或把模块全部依赖机械移除。

答案一面泛称string弃用一面保留常量,准确范围是旧基本字符串函数调用,不是整个模块废弃。

移除旧函数不等于删除整个模块保存独立卡片。

原书依据 · 2 处

字符串格式化表达式

百分号格式把转换目标与输入组合,返回文本而非直接打印或修改原字符串。

文本格式化区分模板和参数关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
格式化方案的历史预测不作现状

原书对%与format何者将废弃的讨论是当时预测,不是废弃公告。读旧代码应理解各自语法和返回值,并依据目标运行版本的文档判断兼容;不能据预测在当前笔记中断言%格式已删除。

文本长度偏好是作者比较,不证明某种语法普遍更易维护;按字段定位、依赖是否显式和目标版本选择,不基于“未来会淘汰”改代码。

本节明确%废弃尚未发生,预测不能当已发布事实;本次按官方当前选定版本文档保留两种语法,不虚构废弃期限。

格式化方案的历史预测不作现状保存独立卡片。

原书依据 · 3 处
更高级的字符串格式化表达式

格式目标分离转换类型、最小宽度、对齐和精度,动态值有相应输入位置。

格式宽度是最小输出宽度

%格式的width指定最小字段宽度,较短时按对齐和补位规则填充,不是把较长值截断成该宽度。-、+、0控制左对齐、正号和补零等外观,结果仍是字符串,显示位数不改变原数值。

格式宽度是最小输出宽度保存独立卡片。

原书依据 · 1 处
格式精度的意义依类型代码变化

%f/%e的precision控制小数位数,%g控制有效数字,%s的precision可限制输出字符数,不能统一理解成小数点后位数。用*动态给宽度或精度时,对应整数先于被格式化的值消耗输入元组项,需核对顺序。

格式精度的意义依类型代码变化保存独立卡片。

原书依据 · 1 处
基于字典的字符串格式化

映射格式按键取值,名字空间快照的范围和输出目标仍需约束。

映射格式按键名取得参数

%(name)s等转换从右侧映射按键取值,适合模板中的具名字段;模板引用的键需要在映射中存在。vars()无参数取当前局部名字空间,不等于全程序所有变量。显式构造需要的值字典更易看清依赖,格式化本身不保证HTML/XML输出安全。

映射格式按键名取得参数保存独立卡片。

原书依据 · 1 处

字符串格式化调用方法

format与百分号格式部分重叠,语法、选择与历史背景需分别理解。

基础知识

format用位置和关键字参数绑定花括号替换字段,返回新的文本结果。

格式字段显式绑定位置或名字

template.format用{0}、{1}等选位置实参,用{name}选关键字实参,也可混用显式位置与名字。字段与所供参数须对应,不能把关键字未提供解释成自动查询同名局部变量;返回文本可继续split/replace,但不修改模板。

字段很多时显式位置或名字可让依赖更清楚;自动编号是可选简写,不强迫放弃显式字段。%映射也可通过键引用,不能把任一方案的优势绝对化。

格式字段显式绑定位置或名字保存独立卡片。

原书依据 · 2 处
添加键、属性和偏移量

format字段可以按受限语法访问对象属性与索引,复杂表达式应先计算再提供参数。

格式字段不是完整表达式环境

format中的.name读取属性、[index]执行受限索引语法,不能照搬任意Python表达式、负列表偏移或切片。需要取末项、切片或计算时,先在模板外算好再传入。字典键与列表索引还依对象getitem契约,不能把“只支持正偏移”推广成任何映射都拒绝含负号的字符串键。

格式字段不是完整表达式环境保存独立卡片。

原书依据 · 1 处
添加具体格式化

format把字段定位、显示转换与格式规范分层,并可从其他参数取得动态规格。

进制表示不同于整数值本身关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
格式转换与规格分两步应用

{value!r:spec}先按!r做repr转换再对结果应用格式规格;!s和!a分别选择str和ascii。冒号后规定宽度、对齐和类型表示,不是赋值或更改原对象。没有强制转换时由值的format解释规格,不能假设所有自定义对象接受相同数字格式。

格式转换与规格分两步应用保存独立卡片。

原书依据 · 1 处
格式对齐要明确符号与填充位置

format的<、>、^分别左对齐、右对齐、居中;=把数字填充放在正负号之后数字之前,不是任意标记字符后补位。width是含填充等的最小总宽度,不能把对齐当截断较长内容的方法。

格式对齐要明确符号与填充位置保存独立卡片。

原书依据 · 1 处
动态格式规格可由参数供给

format的格式规格内部可用嵌套字段取得宽度或精度,如将精度作为另一参数传入;先替换嵌套字段再解释规格,不能无限递归嵌套。只格式化单一值时,内置format(value,spec)提供相应入口,与模板字符串的format方法区别开。

动态格式规格可由参数供给保存独立卡片。

原书依据 · 1 处
与%格式化表达式比较

两种格式化可通过预组织数据达到相近目标,自动编号与分组是有版本起点的功能。

格式化方案的历史预测不作现状关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
自动编号与数字分组各有语义

Python3.1起str.format可用{}自动按顺序取位置参数,仍可用命名字段明确依赖;不要混用自动和手工位置编号。逗号分组在数字格式里按三位一组插入分隔符,只改变显示,不能把分组后的文本直接当原始数值或默认本地化格式。

自动编号与数字分组各有语义保存独立卡片。

原书依据 · 1 处
为什么用新的格式化方法

格式化方案的功能、显式引用和参数结构影响可读性,单个元组作为值需额外包装。

格式字段显式绑定位置或名字关联本项背景,实质主要讲解在对应位置。

格式化方案的历史预测不作现状关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
格式化单个元组需区分参数容器

%右侧的元组通常表示一组替换参数;若想把一个元组整体给单个%s,需外包为一项元组,如(template % (value_tuple,))。format接受普通位置参数,传入元组本身可作为一个值。先区分参数容器与要显示的数据,避免把元组元素错当多个替换值。

格式化单个元组需区分参数容器保存独立卡片。

原书依据 · 1 处

通常意义下的类型分类

类型分类用共享操作帮助迁移知识,属于教学组织而非穷尽所有类型。

同样分类的类型共享其操作集合

数字、序列、映射按不同操作组织,具体类型与支持的协议仍需核对。

序列与映射用不同身份取值关联本项背景,实质主要讲解在对应位置。

同一操作依赖对象接口关联本项背景,实质主要讲解在对应位置。

原书依据 · 15 处
可变类型能够在原处修改

可变性说明对象本身能否原处改变,名字重绑定和内部元素变化应区别。

可变性边界关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处

本章小结

字符串章汇总字面量、序列操作、方法、格式和可变性,进入容器类型。

本章习题

七题检查方法特定性、切片通用性、编码、不可变文本和解析。

习题解答

答案回顾方法与表达式、字符串不变性和解析,并需纠正其中类型/模块措辞。

移除旧函数不等于删除整个模块关联本项背景,实质主要讲解在对应位置。

可变性边界关联本项背景,实质主要讲解在对应位置。

字符码点不同于数字字符值关联本项背景,实质主要讲解在对应位置。

原书依据 · 11 处

第8章 列表与字典

列表按位置保存可变序列,字典按键保存映射。列表切片赋值可以改变长度,字典按已有键更新或建立新关联;这些操作都依赖对象协议而非统一的“容器修改”。排序、视图、复制与共享的区别决定后续遍历和更新是否符合预期。

列表与字典都是可变容器,用不同定位方式组织其他对象。

列表

列表按位置保存对象引用,允许异构和嵌套,与底层值复制不同。

可变性边界关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
列表存储元素引用而非隐式副本

列表按位置保存对象引用,元素可为不同类型和嵌套容器;把对象放入列表不会自动深拷贝。对列表项重新赋值会替换该位置引用,修改被共享的元素对象则可能在别处可见。CPython内部数组解释帮助理解索引,不是所有实现或实际速度的统一保证。

列表存储元素引用而非隐式副本保存独立卡片。

原书依据 · 1 处

实际应用中的列表

进入列表交互例子以说明具体操作。

基本列表操作

列表合并与重复生成列表,跨容器转换影响所得元素含义。

同一操作依赖对象接口关联本项背景,实质主要讲解在对应位置。

原书依据 · 9 处
序列重复复制的是元素引用

列表*次数重复元素引用,不是对每一项深拷贝;若元素是同一可变对象,多个位置会共享它。字符串元素不可变时不易看到该差别;需要独立嵌套容器时,应分别构造对象而非只重复外层。

重复不可变0与每次构造可变列表不同,不能把五个0例推广到[[]]*5会得到五个独立列表。

X=L*4重复L元素引用,Y=[L]*4则四项都指L本身;L顶层项替换可反映到Y各位置,而X对应顶层引用未被改绑。先确定重复的是哪一层,不能只看输出里数字相同。

序列重复复制的是元素引用保存独立卡片。

原书依据 · 3 处
列表迭代和解析

列表解析与显式循环可表达逐项变换,map在Python3中需区分迭代器与结果列表。

列表解析组合遍历与转换关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处
索引、分片和矩阵

嵌套列表通过连续索引逐层取得对象,可表示矩阵但不自动具有矩阵代数。

嵌套结构按层解释索引关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
原处修改列表

原处修改与新建结果需区分;索引/切片、追加扩展、排序及删除各有契约。

原地修改不同于返回新容器关联本项背景,实质主要讲解在对应位置。

删除操作还要区分返回值关联本项背景,实质主要讲解在对应位置。

原书依据 · 10 处
切片赋值可改变列表长度

L[i:j]=values可理解为以右侧元素替换左侧片段,普通步长切片无需元素数相等,可插入、覆盖或删除。右侧先求值,所以重叠切片可先取得要放入的值;这种两步模型为理解用途,不是可观察的逐步执行保证。扩展步长切片另有长度约束。

切片赋值可改变列表长度保存独立卡片。

原书依据 · 1 处
单项赋空列表不等于删除项

L[i]=[]把该项换成一个空列表对象;L[i:j]=[]删除整个指定片段,del L[i]删除单项。按替换目标是一个位置还是一个范围理解,不能只看右侧都是[]就推相同结果。

综合题要求对照索引放空列表与切片赋空列表的不同:前者保留一个元素位置,后者删范围。给普通切片赋非可迭代整数不符合替换输入契约。

单项赋空列表不等于删除项保存独立卡片。

原书依据 · 2 处
追加单对象与扩展多项不同

append(x)把x作为一项追加,extend(iterable)逐项加入;L+[x]生成新列表而append原处修改。想加入一个列表整体与加入其各元素应先区分,避免不知不觉多一层或少一层嵌套。

原例列表+=可迭代对象按多项扩展,类似extend,而不是append把整个对象作为单项。要看是否希望保留对象边界及共享副作用,不能只按快慢替换。

追加单对象与扩展多项不同保存独立卡片。

原书依据 · 2 处
排序键不改写保留的元素

sort(key=func)用每项的键来决定顺序,结果仍保留原元素;预先把所有字符串lower后再排序则真的改变了数据内容。reverse=True调整排序方向,默认比较还要求对象可排序,不能靠Python2跨类型顺序推断Python3混合列表能排序。

排序键不改写保留的元素保存独立卡片。

原书依据 · 1 处
列表末端可作后进先出栈

用append在列表末端入栈、pop从末端出栈,最后进入的元素最先取出。该工具组合不等同先进先出队列;还需处理空栈pop错误,不能仅凭两个成功操作说明所有边界都通过。

列表末端可作后进先出栈保存独立卡片。

原书依据 · 1 处

字典

字典按可哈希键组织值引用,可变映射不等同序列与按位置索引。

插入顺序不等于按键排序关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
字典按键映射而非按位置数组

字典通过键映射到值,键须满足哈希与相等约定;值可为任意对象引用。d[1]意为键1而非第二项,不能因为有插入顺序就把方括号索引变成位置索引。内部哈希结构解释快速查找,但不保证任何输入规模/冲突情况都恒定时间。

键约束是可哈希且相等/哈希行为稳定,而非仅凭“不可变”字样判断;包含不可哈希元素的元组也不能作为键。

944第5题02569的整数与纯整数元组作键合法,但正文“任何不可变对象”过宽,键实际要可哈希,含不可哈希成员的元组并不因此合格。第7题的混合类型+不支持须限定示例,不能扩为所有混合类型相加都非法,例如数值类型另有规则。

字典按键映射而非按位置数组保存独立卡片。

原书依据 · 3 处

实际应用中的字典

字典交互从按键取得值开始,顺序说明限原书版本。

字典的基本操作

字典方括号、成员测试与键视图分别取值、判断键存在和遍历键。

键存在不能由非空值代替关联本项背景,实质主要讲解在对应位置。

插入顺序不等于按键排序关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处
字典键视图不是列表或迭代器本身

Python3 d.keys()返回可迭代的键视图,不是物理列表,也不是具有next状态的迭代器本身。list(d.keys())物化列表,iter(view)才取得迭代器;视图可反映字典变化,不能将二者生命周期混同。

keys/values/items视图可反映源字典后续变化,list(view)才物化当时结果;视图可迭代但不是next迭代器本身。原书旧回显不列内容是版本行为,不作当前固定显示规则。

keys/values/items返回视图,可取得迭代器,却不能直接next视图或按列表方式索引。视图不是快照;list(view)才在消费时物化一份元素引用列表。遍历中改变映射大小还可能失败,不能把动态反映解释为任意变更都安全。

字典键视图不是列表或迭代器本身保存独立卡片。

原书依据 · 3 处
原处修改字典

字典可通过新键赋值增长,与列表单项索引的边界不同。

键赋值可以建立新的映射关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
其他字典方法

字典方法按任务读取视图、默认值、合并或取走值,各自保留不同副作用。

缺键应与合法空值区分关联本项背景,实质主要讲解在对应位置。

删除操作还要区分返回值关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
字典更新按键覆盖冲突值

target.update(source)原处把source各键值写入target,同名键的旧值被覆盖;它不是合并嵌套值或自动处理冲突的策略。需要保留双方数据或检测重复时,先明确定义冲突规则,不因操作名称叫update就默认增量合并内部对象。

字典更新按键覆盖冲突值保存独立卡片。

原书依据 · 1 处
语言表

语言表说明直接按键查值和遍历字典;keys既非必须也不自动排序。

遍历字典默认得到键

for key in d可直接逐键遍历,再用d[key]读取值;也可用items遍历键值对。d.keys()不会自动排序,想按键序输出可显式sorted(d),还要确保键之间有可比较关系。原文“非序列就不能直接for”与实际代码相矛盾,应以可迭代协议理解。

for key in d可直接逐键,视图方法不是必经;现代插入顺序保证与旧例显示分别注明。

按键排序遍历可用sorted(d),无需先d.keys()再尝试原处sort。sorted返回独立排序列表,原字典仍保持自身的迭代顺序;图中Python3.0的显示顺序不覆盖现代插入顺序保证。

遍历字典默认得到键保存独立卡片。

原书依据 · 3 处
字典用法注意事项

字典可按坐标只存非空项,也可组装记录;默认值与类似映射的外部接口仍须核对契约。

缺键应与合法空值区分关联本项背景,实质主要讲解在对应位置。

嵌套结构按层解释索引关联本项背景,实质主要讲解在对应位置。

字典按键映射而非按位置数组关联本项背景,实质主要讲解在对应位置。

原书依据 · 11 处
稀疏结构只保存实际有值的位置

用坐标元组作为字典键,可只存少数有值位置,避免为整个巨大网格预分配元素。未存坐标不是自动有一个0,取值时需由任务定义缺失语义并用get/存在检查/异常处理给默认值。字典键99也不代表已有100项列表。

稀疏结构只保存实际有值的位置保存独立卡片。

原书依据 · 1 处
映射式外观不保证存储契约一致

DBM、shelve等可借用按键读取的映射外观,但持久化、值类型、关闭资源和输入安全等仍依具体接口。学习dict可迁移操作思路,不能因支持方括号就假设与内存字典完全等价;原书CGI/anydbm是历史API例,不能直接当当前部署代码。

映射式外观不保证存储契约一致保存独立卡片。

原书依据 · 1 处
创建字典的其他方法

字典构造语法适用不同输入来源,共享默认值还受引用语义影响。

字典构造按输入形态选语法

字面量适合直接列出键值,逐键赋值适合动态建立,dict(name=value)把关键字名作字符串键,dict(pairs)从成对输入构造。关键字名还须符合语法,不能把任意外部字符串直接写作参数名;成对序列中重复键会由后值覆盖。

字典构造按输入形态选语法保存独立卡片。

原书依据 · 1 处
同值初始化可能共享可变对象

dict.fromkeys(keys,value)把同一个value对象用于各键,不为每键深拷贝。0或None不可变时通常合适;若value为列表,修改一处可被其他键看到。需要独立可变值时,可用字典解析逐键构造新对象,而非只换语法后继续共享同一对象。

fromkeys用于0默认值不会有原处改0的共享问题,但仍是共用值引用,换成可变对象时须重新评估。

同值初始化可能共享可变对象保存独立卡片。

原书依据 · 2 处
Python 3.0中的字典变化

字典解析计算键值,视图反映变化并有受限集合语义;排序与比较需要实际业务规则。

字典键视图不是列表或迭代器本身关联本项背景,实质主要讲解在对应位置。

键存在不能由非空值代替关联本项背景,实质主要讲解在对应位置。

插入顺序不等于按键排序关联本项背景,实质主要讲解在对应位置。

原书依据 · 10 处
字典解析按计算后的键收集值

{key_expr:value_expr for item in iterable}逐项计算键和值以构造字典,计算后的重复键会覆盖已有对应值。dict(zip(keys,values))按迭代配对;zip默认到较短输入结束,不验证两侧等长。构造映射前需检查重复键和配对完整性,避免静默丢失。

dict(zip(keys,values))方便按位置建立映射,但短来源截断和重复键覆盖都可能使结果少于预期;构造成功本身不证明每个输入字段都有对应且唯一。

多层解析可生成多个相同键,字典保留该键最后产生的值;集合合并相等元素,列表保留重复。现代字典保持插入顺序,覆盖已有键并不自动把它移到末端,不能套用旧图无序措辞。

字典解析按计算后的键收集值保存独立卡片。

原书依据 · 3 处
字典视图集合运算有元素约束

keys视图成员唯一可哈希,可作集合式交并;items视图对键值对做集合式操作还要求值可哈希。values可重复且不提供同样集合语义;不能把“都是视图”理解为三者接受相同操作。

字典视图集合运算有元素约束保存独立卡片。

原书依据 · 1 处
字典大小比较需先定义比较目标

Python3字典==可比较键值内容,但不能直接用<或>给字典排大小。显式排序items后作字典序比较只是一种人为规则,不等同项数大小或任意业务优先级,还要求参与比较的键值可比较。先定义目标,不能机械用排序键列表丢弃值的差异。

sorted(d.items())后比较只在其键值可比较时定义一种字典序;相等性可直接使用字典自身==,不用为判断相等先对整个结构排序。

字典大小比较需先定义比较目标保存独立卡片。

原书依据 · 2 处

本章小结

总结列表与字典的定位方式、可变性和增长手段,转入元组与文件。

本章习题

四题回顾构造与原处修改列表/字典。

习题解答

答案列出不同构造和原处修改操作,需保留返回契约与引用边界。

序列重复复制的是元素引用关联本项背景,实质主要讲解在对应位置。

同值初始化可能共享可变对象关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处

第9章 元组、文件及其他

元组提供有序且外层不可变的组合,里面的对象仍可能可变;文件则提供带位置和模式的外部数据接口。复制、相等、身份、真假值与类型判断回答不同问题,不能互相代替。文件还引入资源生命周期,正常读取之外必须考虑关闭、编码和错误路径。

元组、文件与共同类型属性结束核心对象之旅,随后以易错点巩固。

元组

元组是固定顶层引用位置的不可变序列,仍可包含各种对象并支持非修改方法。

元组固定的是元素位置关系关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处
实际应用中的元组

单项元组靠逗号区别分组表达式,转换和非修改方法并不破坏其不可变性。

元组固定的是元素位置关系关联本项背景,实质主要讲解在对应位置。

浅拷贝仍共享内部对象关联本项背景,实质主要讲解在对应位置。

原书依据 · 14 处
单项元组由逗号区别分组

(value)只是括号分组,(value,)才是一个元素的元组;没有歧义时可省元组括号,但函数调用等语境需明确参数与元组数据的边界。空元组写(),不能把圆括号本身当任何情况下都会创建元组的标志。

单项元组由逗号区别分组保存独立卡片。

原书依据 · 1 处
为什么有了列表还要元组

不可变顶层可表达固定关系,但键的合法性和嵌套状态仍有条件。

元组固定的是元素位置关系关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处

文件

文件对象是对外部流的接口,操作和状态不同于内存序列。

文件对象由打开接口建立关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
打开文件

打开模式决定读取、截断、追加与二进制处理,路径和缓冲参数还受具体契约限制。

打开模式决定截断与追加行为

open的r读取,w会创建或截断已有文件,a追加;+表示可读写,b选择字节接口而非文本解码。相对路径依据进程当前工作目录,不保证等于脚本所在目录。选择模式前先明确是否允许覆盖,不能只把w理解成一般“可写”。

打开模式决定截断与追加行为保存独立卡片。

原书依据 · 1 处
无缓冲选项不能照搬到文本流

Python3 open(…,buffering=0)仅允许二进制模式,不能将原书0无缓冲说明直接用于文本文件。文件参数也可为路径类对象或描述符,不是所有参数都必须字符串;缓冲层与文本编码层应分别理解。

无缓冲选项不能照搬到文本流保存独立卡片。

原书依据 · 1 处
使用文件

文件读写涉及类型转换、资源释放和缓冲,不能把自动回收当关闭或耐久性保证。

自动内存管理不包办资源生命周期关联本项背景,实质主要讲解在对应位置。

文本与字节需要明确转换关联本项背景,实质主要讲解在对应位置。

原书依据 · 19 处
刷新语言缓冲不等于持久落盘

flush把Python层缓冲向底层流提交,不能仅据此承诺断电后数据仍在。需要磁盘同步语义时还要按平台和文件系统规则处理,如常规文件先flush再fsync;关闭也不自动等于事务提交,原文“迫使进入硬盘”须区分层次。

刷新语言缓冲不等于持久落盘保存独立卡片。

原书依据 · 1 处
文本流位置不直接等同字节偏移

二进制文件可按相应字节位置定位,文本流还要处理编码和换行。Python3文本tell通常给可恢复位置的标记值,seek应使用允许的0或此前tell结果等组合;不能任意拿字符数或底层字节偏移当合法文本seek位置。

947的02601-02602将file对象传入两个计数函数,每个先seek(0)再读,使前一个消耗到末尾不影响后一个统计。这个开头复位对可定位流成立,不保证管道等任意类文件对象支持;文本seek合法值也不等于任意字节偏移都可用。

文本流位置不直接等同字节偏移保存独立卡片。

原书依据 · 2 处
实际应用中的文件

文件例子串联行读取、文本字节区别、对象序列化、二进制布局和显式关闭。

文件对象由打开接口建立关联本项背景,实质主要讲解在对应位置。

文本与字节需要明确转换关联本项背景,实质主要讲解在对应位置。

解析数值不必执行字符串代码关联本项背景,实质主要讲解在对应位置。

原书依据 · 25 处
文件结束与空白行返回不同

文本readline在文件末尾返回空字符串,空白行通常含换行符而非空串。write/writelines不会自动追加换行,需按所需文本布局明确提供;写入返回字符数也不等同业务完整写入或安全落盘的证据。

共享已打开文件给两个统计函数时,第一次读取会推进位置,第二次可能从EOF开始;要明确是否重置或重新打开,也要保证来源可定位。计行和计字符是不同结果,文本字符数不等于字节数或用户可见字形数。

775及02131对照input和文件读取:input去掉行末换行,空行得到空串,EOF则抛EOFError;readline的EOF空串与含换行的空行相区分。循环用except EOFError:break结束输入,用else处理本次实际读到的行。异常不等于业务失败,SystemExit/KeyboardInterrupt可表达退出或中断;warnings属于另有过滤规则的警告机制,不能以此说所有警告都会像raise那样传播。

文件结束与空白行返回不同保存独立卡片。

原书依据 · 3 处
pickle加载仍需可信输入

pickle可把Python对象结构与字节流转换,但恶意pickle在加载时可执行代码。原文把它推荐给无法信赖的数据来源是关键错误;只反序列化可信且未被篡改的数据,不能把换掉eval当输入安全已经解决。

shelve内部使用pickle,因而加载信任边界与pickle相同,不应将不可信来源的文件直接解包为对象。这里仅说明读取代码的安全前提,没有打开或生成任何shelve文件。

本节提及把pickle字节流写文件或经网络传送;接收后载入仍须遵守可信来源前提,不能将通用序列化等同可安全接受任意网络数据。此处只读原书片段,没有打开文件、网络或反序列化。

825二进制模式正确仅解决流接口,不能让任意来源pickle变安全。载入仍只针对可信且未被篡改的数据;本文未载入或生成任何pickle文件。02233文本读取所示是UnicodeEncodeError,不能仅凭这图断言一定发生输入解码错误,更不推导所有协议字节都不可解码。

pickle加载仍需可信输入保存独立卡片。

原书依据 · 4 处
对象序列化需要格式与版本约定

pickle保存并重建对象结构,读写使用匹配协议的字节流,不是通用明文跨语言格式或任意对象都可保存。协议支持、类定义与导入环境会影响恢复,不能把示例字典相等推广为所有对象/所有版本无条件兼容。

pickle支持许多常用内置对象和满足条件的实例,但不支持任意对象无条件往返。类定义可定位性、依赖版本及对象状态都会影响重建,不应把“几乎任何”理解为可以不加考虑地替代所有定制存储格式。

pickle可序列化整个shop对象图,重建后通过可定位的类定义取得行为,但不保证恢复为同一内存身份或把全部方法代码存进字节流。保存与载入要考虑类模块可用性及格式兼容,本节一次操作简写也不替代资源关闭和实际读取验收。

825及02232-02236对照dumps默认/协议0都为bytes,文本dump类型失败,wb/rb对象往返成功,另给2.6协议0文本旧用法。二进制模式避免文本解码/换行改变序列化字节;不能由此承诺所有协议、类定义和2/3数据差异都无条件兼容,书中3.0默认协议3不当当前默认值。protocol0可读也不消除二进制文件接口要求。

对象序列化需要格式与版本约定保存独立卡片。

原书依据 · 4 处
二进制布局需明确字节序与宽度

struct按约定布局打包与解析,双方需一致的字节序、字段大小和对齐。原例>i4sh表示大端4字节整数、4字节数据和2字节短整数,不是2位整数;Python3的4s参数需字节数据,图中普通str写法不可直接沿用。不是所有二进制文件都需struct解包。

824的02226-02229采用>i4sh,表示大端4字节整数、4字节数据、2字节短整数,总10字节;unpack按同一格式得到(7,bspam,8),decode后的str不符合字节缓冲接口。书图Python3仍向4s传普通spam字符串,不能直接沿用到现代要求字节数据的调用;这不是字符编码替代方案。未有布局定义的字节也不会被struct自动识别。

二进制布局需明确字节序与宽度保存独立卡片。

原书依据 · 2 处
上下文管理让文件退出时关闭

with open(…) as f把文件使用限制在代码块,正常结束或异常退出都由上下文协议关闭文件;try/finally也可明确清理。它保证清理路径不等于忽略异常、成功保存所有内容或自动回滚已经写出的部分。

727的with open示例将文件操作放进协议范围,退出时关闭;只有支持协议的对象才适用。with还包含进入操作,不是任意对象都可直接替代finally。关闭文件不等于写入事务回滚或忽略写失败。后面的C/Python对照展示把错误处理集中在外层的组织方式,不表示Python检测一切业务错误或可以省去所有必要验证。

738与02061-02062给MyError(Exception):pass、stuff(file)抛MyError、外部open后try/finally close。finally让正常语言退出时尝试关闭文件,但close也可能失败,不能单凭调用过它就宣称输出已可靠持久化至磁盘或所有写入已成功。open若自己失败,则尚未进入这段try,也无已建立file可供该finally清理。不把本节用于说明关闭的最小类另造一个相同想法的异常类型卡。

749的02088-02089对照with open与显式open/try/finally close:文件管理器返回自身给as目标,而一般管理器未必如此。close限定使用范围,不依赖垃圾回收及时发生;路径是书中本地文件例,未访问或创建该路径。

777及02134-02135给同一文件处理的try/finally与with;前者通用、显式,后者复用已有协议并含进入动作。作者当时对with少见/哲学不符的评价不是当前使用统计或禁用规则。输出刷新不等于物理持久性或写入已完整成功;清理也可用于连接,但本节未给真实服务器实现。

上下文管理让文件退出时关闭保存独立卡片。

原书依据 · 5 处
其他文件工具

外部流具有不同访问能力和生命周期,Python3实现类位于io而非旧内置file。

类文件外观不保证同样能力关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
文件构造入口与实现类型分开

Python3通常通过open建立具体流对象,旧内置file名称已移除,实现类型在io模块中。要检查或扩展接口应看实际类型与io协议,不能把所有open返回值都当同一个具体类,也不只凭旧类名迁移全部行为。

文件构造入口与实现类型分开保存独立卡片。

原书依据 · 1 处

重访类型分类

对象按共享操作与可变性分类,自定义类可通过协议方法参与具体操作。

同一操作依赖对象接口关联本项背景,实质主要讲解在对应位置。

原书依据 · 9 处
特殊方法为对象提供具体操作

自定义类实现特定协议方法,可以让实例响应索引、相加等操作;不必同时模拟某个内置类型的所有接口。原文MySequence只是接口草图,getitem对应索引,add对应加法;不能据空草图宣称实现已经可运行或具备所有序列行为。

结构图: 只列原图真实类和签名,不补造父类、方法体或不存在的类型。

classDiagram
 class MySequence {
  +__getitem__(self, index)
  +__add__(self, other)
 }

特殊方法为对象提供具体操作保存独立卡片。

原书依据 · 1 处

对象灵活性

嵌套容器组合引用,连续索引依次取得更深层对象。

嵌套结构按层解释索引关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处

引用VS拷贝

多个容器可引用同一对象,复制要选择隔离层次而非机械消除共享。

对象引用关联本项背景,实质主要讲解在对应位置。

浅拷贝仍共享内部对象关联本项背景,实质主要讲解在对应位置。

原书依据 · 13 处

比较、相等性和真值

复合对象比较依元素与协议,身份和相等性不是同一判断,排序更有类型前提。

身份比较不同于值相等关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
序列字典序由首个差异决定

列表或元组的排序比较通常逐项进行,首次不等元素决定顺序,公共前缀相同时还要考虑长度。参与项必须支持实际比较;不是把对象转成显示字符串后比字面文本,也不能把这种规则推广到集合或所有自定义对象。

序列字典序由首个差异决定保存独立卡片。

原书依据 · 1 处
Python 3.0的字典比较

字典相等性可保留,而大小比较需要明确数据比较策略。

字典大小比较需先定义比较目标关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
Python中真和假的含义

条件测试使用对象真值,None是实际对象而非未定义,具体对象可定制真值协议。

None是具体值而非未绑定名称关联本项背景,实质主要讲解在对应位置。

布尔值有整数兼容与独立身份关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
真值测试需区分空值与缺失意图

常见内置对象中数值0、空容器、None为假,非零或非空通常为真;这方便条件测试,但0或空容器也可能是合法业务值。要判断缺失应按具体哨兵或状态,不把if value自动当“已提供有效数据”。自定义对象还可按协议定义真值甚至抛错。

if 1恒为真而if not 1为假,例子用于显示真值,并不要求条件必须写True/False。

真值测试需区分空值与缺失意图保存独立卡片。

原书依据 · 2 处
Python的类型层次

类型、函数、模块和解释器内部单位也是对象,可用同样引用机制组织。

类型本身也可作为对象传递

类型对象可像其他对象一样赋给名称、放入容器、传给函数;type(obj)返回其类型对象。原图按用途把容器、数字、可调用对象和内部对象分类,不是完整继承树,类别之间也不互斥;不能由一条分类箭头推导真实父类关系。

内置类型名如list、dict、int指向可调用类型对象,构造与转换用途相连;types模块提供FunctionType等其他类型名称。原文byte应按实际bytes等标识符核对,不造不存在内置名。

类型本身也可作为对象传递保存独立卡片。

原书依据 · 2 处
Type对象

运行时类型对象与isinstance可用于检查,子类与操作契约影响选择。

类型本身也可作为对象传递关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
精确类型与子类判断回答不同问题

type(obj)得到确切类型,和某类型比较会排除它的子类;isinstance(obj,T)接受T实例及其子类。校验应由接口或数据契约决定,不能因多态就一律禁止类型检查,也不能因为isinstance为真就断言业务数据满足全部约束。

Python2经典类实例的type曾统一显示为通用instance,Python2新式类和Python3普通类则以所属类作为实例类型。原书用这一差别解释迁移时的类型观测;历史type结果不应套到当前普通类,也不说明所有内置类型都允许子类化。

本节比较C与D的实例、同一C的两个实例,以及Python2经典/新式和Python3的不同type结果,具体支持类型观测的版本边界。type相等只回答确切类型,isinstance还接受适用的子类;是否需要检查仍由业务契约决定,不照搬原文“类型检查通常错误”为一律禁止。

精确类型与子类判断回答不同问题保存独立卡片。

原书依据 · 3 处

Python中的其他类型

扩展和模块可构造其他对象,是否需要导入不决定对象能力或可变性。

对象把数据与可用操作联系起来关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
内置类型陷阱

进入对象引用、重复、循环和不可变性的常见陷阱回顾。

赋值生成引用,而不是拷贝

赋值共享引用,明确顶层复制可隔离对应层的修改。

浅拷贝仍共享内部对象关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处
重复能够增加层次深度

直接重复列表与重复包含列表的外层列表,会得到不同的引用层次。

序列重复复制的是元素引用关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
留意循环数据结构

循环容器的显示有防护,但自己的递归遍历仍需防止反复访问。

循环引用不随外部计数自动归零关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
循环显示被省略不代表遍历安全

列表包含自身时,repr可用[…]省略递归部分,避免打印无限展开。这是显示协议的防护,不会自动替用户的递归遍历检测环;需要按节点身份等适当方式记录访问状态,不能把省略号当实际数据元素或以普通值相等替代所有环检测。

943的02561-02562以L=[1,2];L.append(L)和真实指针图展示末项指向同一列表,不是拷贝。打印检测后省略循环,不意味着任意递归遍历也会终止;遍历器需按任务记录已访问对象。附录的旧pyc无源文件加载与手工reload说明只按历史布局解释,不能从移动源文件必然推断现代缓存被导入。

循环显示被省略不代表遍历安全保存独立卡片。

原书依据 · 2 处
不可变类型不可以在原处改变

不可变对象需构造结果再重绑定,可避开自身原处修改但并不深度冻结容器内容。

可变性边界关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处

本章小结

总结元组、文件、序列化与共享引用,然后进入程序语句。

元组固定的是元素位置关系关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处

本章习题

六题回顾元组重建、open默认模式、序列化、深拷贝和真值。

习题解答

答案说明对象重建和文件工具,仍须遵守此前真值、方法和复制边界。

元组固定的是元素位置关系关联本项背景,实质主要讲解在对应位置。

浅拷贝仍共享内部对象关联本项背景,实质主要讲解在对应位置。

原书依据 · 14 处

第二部分 练习题

综合题对照值、引用、切片边界与容器操作,新增交换绑定和边界组合的自测入口。

单项赋空列表不等于删除项关联本项背景,实质主要讲解在对应位置。

字符串也是有序序列关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
交换绑定先计算右侧再赋左侧

在X,Y=Y,X中,右侧先根据当前绑定取得对象,再按左侧目标分别绑定,因此能交换名字而不先覆盖其中一个来源。它不要求修改原对象内容,也不是让两个名称永久互相指向;目标数与解包规则仍需匹配。

交换先取得右侧旧值再绑定,不需用户临时变量;实现是否优化掉临时元组不影响语言求值顺序,不承诺必然分配该对象。

交换绑定先计算右侧再赋左侧保存独立卡片。

原书依据 · 2 处

第三部分 语句和语法

第三部分进入语句与语法。

第10章 Python语句简介

语句把表达式组织为可执行流程,缩进定义代码块边界。读取交互输入后要区分终止信号、合法数据和错误,不能把任何非空文本都当可计算值。理解语句的结构后,才能在后续循环、函数和异常中准确判断哪些代码属于同一控制范围。

语句组织程序动作,表达式处理对象并由语句控制何时执行。

语句组织动作而表达式产生值

表达式建立或处理对象,语句组织赋值、选择、循环等程序动作。模块容纳语句,函数和类定义也由语句建立相应对象;这是一种程序组织层次,不表示每条语句都必产生可接收返回值或Python只能采用一种编程范式。

模块本身也是对象,语句可导入模块或建立类/函数;层次是理解组成而非把模块只能静态包含语句、对象绝不能携带代码绝对化。

语句组织动作而表达式产生值保存独立卡片。

原书依据 · 2 处

重访Python程序结构

程序、模块、语句、表达式与对象形成由组织到求值的理解层次。

语句组织动作而表达式产生值关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
Python的语句

语句表预告控制、定义、异常和资源管理,表达式语句与语言保留字不是同一分类。

程序组织工具承担不同职责关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
函数调用不因独占一行变成关键字

Python3 print是内置函数,独占一行时构成表达式语句;它不是因为常作一行动作就成为保留字。yield是具有专门语法的表达式,虽可单独出现也不等同普通函数;阅读迁移代码需区分语法角色与常见排版。

普通=赋值语句不能直接嵌入if测试当值,==才做相等比较;这不排除后续版本另有专门赋值表达式语法,不能泛化为Python任何绑定都绝不能用在表达式中。

函数调用不因独占一行变成关键字保存独立卡片。

原书依据 · 2 处

两个if的故事

C风格与Python if对比,后者采用冒号、缩进与换行表达结构。

Python增加了什么

复合语句首部与主体由冒号和缩进结构区分。

复合语句首部用冒号引出主体

if/for/def等复合语句在首部后用冒号引出语句体,常见多行主体按缩进组成块。漏冒号属于语法问题,不能只调缩进解决;冒号也有切片/映射等其他语境,需按所处语法判断。

复合语句首部用冒号引出主体保存独立卡片。

原书依据 · 1 处
Python删除了什么

条件括号可选、简单语句通常按逻辑行结束,块结构由缩进界定。

缩进层级决定语句块归属

同一多行代码块的语句应有一致缩进,退回外层缩进表示离开该块;不是靠大括号表示Python的语句体。缩进错误会改变结构或导致语法错误,不能只当排版问题;空格与制表符混用还可能使不同显示环境产生歧义。

Python的else通过结构缩进对应其if,避免C悬挂else的视觉误读;仍需根据缩进检查实际逻辑。不能将“所见即所得”夸为格式正确即可保证语义正确。

if或循环改变通常从上到下的执行路径,缩进块组织哪些动作受条件或迭代控制;不能把文件每行都想成无条件逐行运行。

原例是三个嵌套代码块不是三个导入模块:顶层/外层if/内层if分别组织动作。块结构、源文件和模块对象应区分。

缩进层级决定语句块归属保存独立卡片。

原书依据 · 4 处
逻辑行不同于任意物理换行

多数简单语句每逻辑行写一条,无需结尾分号;括号内的隐式续行等允许多个物理行合成一条语句。同样,条件两侧括号通常可省但仍可用于分组,不能把“可省”误写成Python禁止括号或分号。

括号闭合是隐式续行解析的一部分,不能把任何一对闭合括号都解释成整个逻辑行立刻结束,也不能给任意语句套括号。

逻辑行不同于任意物理换行保存独立卡片。

原书依据 · 2 处
为什么使用缩进语法

一致缩进使视觉结构与语法结构对齐,但不能由可读排版保证整个程序正确。

缩进层级决定语句块归属关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
缩进宽度统一避免视觉歧义

代码块使用一致缩进策略,避免空格与制表符混用导致不同编辑器看到不同层级。语法允许不同缩进量不意味着团队不需统一规范;风格与语法分开判断,不把某个历史编辑器的显示当解释器的缩进规则。

Python按词法规则展开tab到制表位,不依某个编辑器看到的宽度;使缩进依赖tab/空格等价形式的混用可引发TabError。团队宜统一策略,不把解释器支持tab当任意混用都安全。

不要混用制表符和空格来让代码只在某个编辑器设置下看似对齐,顶层无嵌套代码须从左边界开始。原文“第1行”应理解为起始列而不是程序只能写在文件第一物理行。

缩进宽度统一避免视觉歧义保存独立卡片。

原书依据 · 3 处
几个特殊实例

简单语句可有限压行,括号内隐式续行与单行主体都有边界。

括号续行延续解析而非逐行执行

圆括号、方括号或花括号尚未闭合时,可把表达式延续到后续物理行。解释器先按完整逻辑结构解析,不是写到下一行就提前执行一部分未完成语句;续行缩进主要服务可读性,不能与新语句块缩进规则混淆。

闭合括号等构成完整逻辑行的条件,续行内排版与新块缩进不同。三引号换行保留文本,而相邻字符串字面量拼接不自动加入换行。

括号续行延续解析而非逐行执行保存独立卡片。

原书依据 · 2 处
单行主体只容纳简单语句

if condition: action可把简单主体放在冒号后,分号也可分隔同一逻辑行的简单语句;嵌套复合语句或else分支不能据此任意挤在一行。过度压行会模糊分支与诊断位置,通常仍按清楚多行块组织。

单行主体只容纳简单语句保存独立卡片。

原书依据 · 1 处

简短实例:交互循环

交互循环示例将语句结构落实到读取、处理与退出。

一个简单的交互式循环

循环每次读取输入,遇明确终止值退出,其余输入执行转换与输出。

文本输入不等于执行输入关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
交互循环先区分终止命令与数据

循环读取文本后先检查终止命令,再处理普通数据,可避免把stop交给数值转换。while True需要明确退出路径;break退出当前循环,循环外的结束动作仅在控制流到达时执行,异常等其他退出不保证同样经过该动作。

print(Bye)在循环外,正常break后可到达,循环内打印则每次执行;控制层级与异常路径都需考虑,不把示例末尾动作当可靠资源清理。

终止命令在读取年龄前检查,正常名字路径才继续年龄输入与运算;读取流到EOF会另抛异常,不能把所有结束都看成用户输入stop。

读取可放while True主体里先保存再判断结束,或循环前预读并在轮尾更新;关键是每轮读一次与正确结束哨兵,不靠缺省假值推断所有数据源的结束。

交互循环先区分终止命令与数据保存独立卡片。

原书依据 · 4 处
对用户输入数据做数学运算

文本输入需按目标数值解析后运算,循环外语句与每次处理不同。

转换方向决定相加还是连接关联本项背景,实质主要讲解在对应位置。

交互循环先区分终止命令与数据关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
用测试输入数据来处理错误

预检与分支可给出输入错误提示,但字符分类不完全等价于数值转换合法性。

条件分支按表达式真值选择关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
字符为数字不保证整数解析契约

isdigit识别数字字符,不能作为int可接受文本的完整判据:它可能接受某些int不接受的Unicode数字形式,也会拒绝int允许的正负号或周围空白。应按业务允许语法验证,或直接转换并捕获预期ValueError,不能仅以几个ASCII样例宣称输入已全验证。

字符为数字不保证整数解析契约保存独立卡片。

原书依据 · 1 处
用try语句处理错误

try按异常路径恢复预期失败,else组织正常成功动作,捕获范围应尽量精确。

异常捕获要匹配预期失败范围

把可能失败的int转换放在try中,并针对预期ValueError恢复输入错误,比列举所有数字语法更直接。原例裸except过宽,可能吞下中断或其他编程错误;捕获不等于自动完全修复,应保留未预期失败的可见性。

724两图将fetcher(x,4)包在except IndexError中,catcher在处理器打印之后执行整个try之后的continuing。捕获能改变默认终止路径,却不会自动返回失败点、完成原运算或重试;处理器若再次失败也不保证继续。服务器需要保持运行是使用动机,捕捉本身不等于服务器状态已恢复正确。

733及02048-02052展示按顺序的多类处理、末尾裸except与except Exception。裸except还能拦截SystemExit/KeyboardInterrupt等控制性异常;Exception通常排除这些直接属于BaseException的类型,但仍可能遮住普通编程错误。因此换成Exception并不自动获得恰当恢复策略,应明确预期失败和未预期失败的去向。

736与02058-02059将kaboom([0,1,2],spam字符串)的TypeError交给外层处理器,随后resuming here。处理器正常结束意味着原异常停止传播,不代表列表/字符串操作已成功或状态清理完成;需要重试时须另写显式控制逻辑,捕获本身不提供恢复失败点的续执行。

759指出为规避逐个枚举而使用裸except,会连同内存错误、中断、退出或try主体中的编程错误一起截住。期望恢复的是库定义的那一类失败,而非证明库调用发生的所有异常都可恢复;自有分类根比全局宽捕获更能表达这种边界。

778的02136裸except打印sys.exc_info前两项,是顶层观察失败的示例,不是自动恢复。把范围扩到整个程序可能同时截住中断/退出/编程错误;若处理器自己失败也没有这层处理器替自己兜底,必须明确需要继续还是向外传播。

783的02141-02145给三类风险:内层裸except阻断外层IndexError处理;sys.exit(40)的SystemExit被捕获后继续;字典名称拼错产生NameError却被填入None。具体希望处理缺键时应捕获KeyError,保持不相关名称错误可见;换成Exception只排除部分退出事件,仍会吞NameError等编程错误。正文/图中拼写形态略异,关键是实际引用了未定义名称,不能将其误写为真的KeyError。

异常捕获要匹配预期失败范围保存独立卡片。

原书依据 · 7 处
try的else限定成功路径

try的else在try正常完成而未走异常等提前退出时执行,适合放只有成功后才做的操作;其自身异常不由同一个try的except捕获。与if的else区别来自所附属的语句结构,不能只看else文字猜条件。

734与02053-02055对照三种布局:try之后的共同后续、显式else成功分支、把成功操作塞进try。最后一种会将成功操作自己的IndexError也归给原except,产生错误分类;else使同级except只保护指定主体。else本身失败仍可向外传播或经过finally,并非没有异常风险。

try的else限定成功路径保存独立卡片。

原书依据 · 2 处
嵌套代码三层

成功解析后再按数值范围分支,嵌套层次表达前置条件。

条件分支按表达式真值选择关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处

本章小结

语句章汇总一般行/块结构与例外,交互例将其组合起来。

本章习题

八题检查语句结束、嵌套、续行、分号、try与冒号。

习题解答

答案回顾语法规则与异常用途,需保留逻辑行及捕获边界。

逻辑行不同于任意物理换行关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处

第11章 赋值、表达式和打印

赋值左边是目标,右边先产生需要分配的值;解包与增强赋值又增加了数量匹配和对象修改规则。表达式语句在交互环境可能显示结果,文件运行则通常需要显式输出。print把对象转成文本写入流,返回值、显示值与写入目标因此是三件不同的事。

赋值、表达式语句与打印是基本动作,本章补充它们的可选形式。

赋值语句

赋值将求值所得对象交给名称或可赋值目标,其他语法也可建立名称绑定。

对象引用关联本项背景,实质主要讲解在对应位置。

名称使用前需已有绑定关联本项背景,实质主要讲解在对应位置。

原书依据 · 9 处
赋值语句的形式

赋值形式包含单目标、解包、多目标共享与增强更新,它们不都只是同一文字替换。

原地修改不同于返回新容器关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处
解包按位置分配可迭代对象

a,b=source按位置把可迭代对象中的值绑定给目标,不要求右侧是元组。无星号时项数须匹配,有嵌套目标还要每层结构匹配;它与a=b=source把同一对象给多个目标是不同机制。

右侧可为一般可迭代对象,含嵌套目标时各层按所需形状逐层解包;for头也适用,但Python3函数定义参数不支持旧Python2直接嵌套元组参数形式。

for(a,b) in rows对每行做解包,嵌套或带星号目标按同样赋值规则;必须行形状满足要求,不能因SQL行例就断言所有驱动结果都是列表元组。

文件也能提供序列解包所需的逐行元素;普通解包要求项数吻合,星号目标接收剩余项。可迭代协议统一了取值入口,却不取消结构与项数约束。

旧版def f((a,(b,c)))把结构解包放进参数头,Python3不支持这种形式;可接收T后在函数体显式写a,(b,c)=T,仍须满足结构和项数。它与调用中的*展开、for目标解包不是同一种语法位置。

对(name,age,job)记录做[age for (name,age,job) in rows]会检查每行三项结构;row[1]按位置投影的约束不同。Python3不支持lambda参数头直接元组解包,旧版map例要区分语法位置。

解包按位置分配可迭代对象保存独立卡片。

原书依据 · 6 处
序列赋值

序列解包可匹配嵌套形状、交换名称和分离首项,但仍按实际可迭代接口执行。

交换绑定先计算右侧再赋左侧关联本项背景,实质主要讲解在对应位置。

解包按位置分配可迭代对象关联本项背景,实质主要讲解在对应位置。

迭代协议关联本项背景,实质主要讲解在对应位置。

原书依据 · 21 处
首尾拆分与原处弹出影响不同

front,L=L[0],L[1:]取得首项并把L改绑为剩余列表,原列表别名仍可指完整旧列表;L.pop(0)原处删首项,别名能观察变化。不能因得到同样front就把两者当副作用完全等价,空输入边界仍要处理。

首尾拆分与原处弹出影响不同保存独立卡片。

原书依据 · 1 处
Python 3.0中的扩展序列解包

星号目标收集未分配剩余项为列表,仍受普通目标数量与同层单星号约束。

星号解包收集剩余项为列表

a,*rest,c=source先匹配两端普通目标,其余项收集为list给rest;即使source是字符串,rest也不是子字符串。剩余0项给空列表、1项也给单项列表;不足以满足普通目标仍报错,不能用星号掩盖必需字段缺失。

for(a,*b,c)将一行两端取出、中间保存在b列表;手动切片tuple行返回tuple,与星号list有类型差异,不能仅比较元素相同就称完全等价。

星号解包收集剩余项为列表保存独立卡片。

原书依据 · 2 处
星号解包目标仍有结构限制

同一层目标列表至多一个星号目标,它可处于首中尾;裸*name=source不是合法独立目标,要成为如*name,=source的目标列表。for的目标同样遵循解包规则;星号收集会物化剩余项,不把它当无限流可无代价拆分的方法。

星号解包目标仍有结构限制保存独立卡片。

原书依据 · 1 处
多目标赋值语句

链式多目标赋值共享一次求值结果,不可变改绑与可变修改出现不同观察。

多目标赋值共用同一个对象

a=b=[]让a和b引用同一列表,b.append后a也看到变化;a=b=0后b=b+1只改b绑定。需要两个独立可变容器时分别构造,不能把链式初始化当自动复制,也不能由整数例推共享列表安全。

A=B=C=[]共享同一列表,原处修改对别名可见;而分别建立对象可隔离顶层状态。答案的A=0,B=0,C=0示意应读作独立语句,不能当逗号分隔多个普通赋值的合法源码。

多目标赋值共用同一个对象保存独立卡片。

原书依据 · 2 处
增强赋值语句

增强赋值只求一次目标并可能原处更新,共享引用语义比缩写长度更重要。

追加单对象与扩展多项不同关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
增强赋值不总等价普通加后改绑

+=先求目标一次,再按对象协议运算并写回;list +=常原处扩展,别名能看见变化,list=list+other则生成结果再重绑定。整数和字符串等不可变值另按相应运算建立结果。不能把自动原处优化推广到每个自定义可变类型或任意二元符号。

增强赋值不总等价普通加后改绑保存独立卡片。

原书依据 · 1 处
变量命名规则

命名分语法、关键字、内置遮蔽与惯例,版本迁移及下划线规则需保留上下文。

运行文件与导入模块用不同名称关联本项背景,实质主要讲解在对应位置。

动态类型关联本项背景,实质主要讲解在对应位置。

原书依据 · 10 处
标识符合法性与命名惯例分开

名字区分大小写,通常以字母或下划线开头,后续可含数字;Python3还按Unicode标识符规则接受更多字符。语法合法不代表语义清楚或符合团队风格;内置名称如open可被重新绑定,但会遮蔽原入口,关键字如class则不能当普通变量赋值。

标识符合法性与命名惯例分开保存独立卡片。

原书依据 · 1 处
下划线命名具有不同约定与机制

_name通常表示内部接口且默认不被import*导出,但显式all可规定导出;name留给文档化系统协议;类内__name触发避免冲突的名称改写,不是安全访问控制。交互_保存上次结果是环境角色,不使所有普通代码里的_都神奇更新。

模块_X通常表达内部使用并影响默认星号导入,不应和类的双下划线名称改写或强制访问控制混淆。all描述导出集合而非隐藏所有其余对象。

下划线命名具有不同约定与机制保存独立卡片。

原书依据 · 2 处
功能预览与功能废弃含义不同

future语句可在特定模块启用将来成为标准的语义;废弃警告则提示某个已有行为将停止推荐或支持。两者都帮助迁移,但不能把新功能的可选预览统称该功能“已废弃”,也不能由旧版关键字表推断全部新版保留字。

功能预览与功能废弃含义不同保存独立卡片。

原书依据 · 1 处

表达式语句

表达式语句可保留副作用而丢弃结果,交互回显和脚本执行的输出行为不同。

函数调用不因独占一行变成关键字关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
表达式结果与副作用分别处理

把函数调用单独写一行,可执行其副作用而不保存返回值;不返回有意义结果的普通Python函数通常返回None,并非没有返回对象。交互环境可回显非None结果,脚本里单写名称不会自动打印其值,需明确输出或保存。

表达式结果与副作用分别处理保存独立卡片。

原书依据 · 1 处
表达式语句和在原处的修改

把原处修改方法的返回值再赋给容器名,会把名称改绑None。

原地修改不同于返回新容器关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处

打印操作

打印是将对象文本写入输出流的便捷接口,不等同任意文件写入。

打印把对象转成文本再写入流

Python3 print默认把对象按str意义转为文本写到sys.stdout,并提供分隔/终止格式;write通常要求已经构造好的字符串。stdout只是默认目标,可以连接终端、文件或其他流,不能因看到print就断定用户一定在屏幕看到内容。

打印把对象转成文本再写入流保存独立卡片。

原书依据 · 1 处
Python 3.0的print函数

print的参数分为对象、分隔符、终止串与目标流,均服务文本输出。

文本格式化区分模板和参数关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
打印分隔符与结束串职责不同

print(*objects,sep=…,end=…)在对象之间插sep,整次输出末尾插end;默认空格和换行。sep为空不去掉对象内容自带空白,end为空只抑制附加换行,不改变已有文本。零对象调用通常只输出end,不能把参数图的可选表示照字面写入代码。

打印分隔符与结束串职责不同保存独立卡片。

原书依据 · 1 处
打印目标要给可写流而非路径

print(…,file=stream)使用具备相应文本write接口的流,不自动把路径字符串打开。普通文件需用合适模式打开并管理关闭,print不会替调用者保证资源清理或安全覆盖;二进制流也不能不加转换就当文本目标。

file参数或旧>>目标都给流对象,不是文件名文本;发送诊断到stderr可与正常stdout输出分开,是否显示由实际流环境决定。

打印目标要给可写流而非路径保存独立卡片。

原书依据 · 2 处
Python 2.6 print语句

Python2打印语句使用逗号和>>专用语法,迁移时需按输出契约理解。

旧打印逗号不等同元组分隔意图

Python2 print x,y语句用逗号分隔输出项,行尾逗号影响换行;print >>stream指定目标。Python3用函数的sep/end/file表达对应意图;旧语法不能照搬为Python3表达式,也不能把末尾逗号总当元组创建。

旧打印逗号不等同元组分隔意图保存独立卡片。

原书依据 · 1 处
打印流重定向

单次目标选择与全局stdout替换影响范围不同,替换后需要恢复调用前的流。

打印目标要给可写流而非路径关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
替换标准输出会影响共享使用者

把sys.stdout改绑为另一个流,会影响随后使用该默认对象的打印,可能影响其他线程或库代码。单次print(file=…)可限定目标而无需全局改绑;显式file或已保存流的代码不必跟随stdout,子进程输出也不会因此自动被捕获。

Python对象层重定向与Shell文件描述符/管道重定向作用层次不同,不把前者当任意程序和子进程输出的完整替代。

替换标准输出会影响共享使用者保存独立卡片。

原书依据 · 2 处
输出恢复应回到替换前的流

临时重定向前保存当时sys.stdout,并在可靠清理路径恢复;sys.stdout代表进程启动原始流,可能不同于调用者已经设置的外层流。恢复成启动流会破坏嵌套重定向意图,不能把“原始”与“进入前”混用。

输出恢复应回到替换前的流保存独立卡片。

原书依据 · 1 处
版本独立的打印

兼容打印需按版本启用语义,文件式写接口可承接文本但不自动具有全部文件能力。

替换标准输出会影响共享使用者关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
旧打印加括号不总等于新函数

Python2未启用print_function时,print(a,b)可被当成打印一个元组,和Python3多参数调用输出不同。Python2.6的future print_function可切换语义;只把源码包上括号不能保证兼容,自动迁移工具也需核对目标版本与结果。

旧打印加括号不总等于新函数保存独立卡片。

原书依据 · 1 处
文本接收器按写入协议承接打印

FileFaker草图通过write(self,string)接收打印传来的文本,说明输出可交给适配对象处理。write可能被多次调用,不应假定一次调用就是整行或完整业务事件;接口相似不保证可seek或有底层文件。

结构图: 只保留原图FileFaker及真实签名,不虚构文件继承、存储机制或未出现方法。

classDiagram
 class FileFaker {
  +write(self, string)
 }

文本接收器按写入协议承接打印保存独立卡片。

原书依据 · 1 处

本章小结

赋值、表达式与打印章总结绑定和输出形式及返回None陷阱。

本章习题

四题检查多目标赋值、共享可变对象、sort返回值与打印目标。

习题解答

答案对照共享初始化、原处排序与打印重定向。

多目标赋值共用同一个对象关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处

第12章 if测试和语法规则

条件语句根据表达式的真假选择路径,真假并不等于对象是否存在或是否为某种特定类型。分支、查表和条件表达式可表达相似决策,但可读性与默认处理不同。块结构和表达式优先级共同决定执行含义,应让条件直接表达业务问题。

if章把分支语法、通用块结构与真值表达式结合起来。

if语句

if条件选择决定执行动作,允许嵌套但仍需可理解的结构。

通用格式

if依次求测试并只选首个真分支,否则可执行默认else。

条件分支按表达式真值选择关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
基本例子

最小if可只含测试与主体,也可追加else处理相反条件。

真值测试需区分空值与缺失意图关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
多路分支

多路分支可按条件顺序或映射数据表达,默认值与动作副作用决定等价范围。

条件分支按表达式真值选择关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
查表分支适合由键选择值

键到结果值的映射可用字典表达,缺键用get或显式检查提供默认;有顺序、范围或复杂条件时if/elif更直接。函数可作为表值再调用来延后动作;若在建表时就调用各函数,会先执行它们,不能当只执行所选分支。

查表分支适合由键选择值保存独立卡片。

原书依据 · 1 处

Python语法规则

控制流、块界定、空白和文档字符串共同构成语法模型,各种空白并非一概忽略。

缩进层级决定语句块归属关联本项背景,实质主要讲解在对应位置。

注释与字符串内容要区分关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处
代码块分隔符

缩进检测块边界,错误对齐会改变归属或报错,制表符混用有额外风险。

缩进层级决定语句块归属关联本项背景,实质主要讲解在对应位置。

缩进宽度统一避免视觉歧义关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处
语句的分隔符

逻辑行可以由括号或显式续行跨物理行,文本内容与注释另有规则。

括号续行延续解析而非逐行执行关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
一些特殊情况

显式续行遗漏可能形成合法但错误的独立表达式,括号可更清楚地包住求值范围。

三引号保留文本中的换行缩进关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
续行标记遗漏可能悄悄改变计算

若x=1+2+3的行尾漏掉续行反斜杠,下一行+4仍可独立成为合法表达式语句,于是x是6而非10,不一定报语法错误。用括号明确包住整个表达式,可减少这种边界歧义;格式变化时仍要核对实际参与求值的项。

续行标记遗漏可能悄悄改变计算保存独立卡片。

原书依据 · 1 处

真值测试

布尔运算短路并返回操作数,条件测试其真值与得到bool对象是两回事。

短路判断控制右侧求值关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
逻辑与或返回被选中的操作数

x or y在x为真时返回x,否则求y并返回y;x and y在x为假时返回x,否则求y并返回y。结果可能是列表、字典或数字,不必是bool;not才给True/False。短路还决定右侧是否执行,不能与位运算&/|互换。

逻辑与或返回被选中的操作数保存独立卡片。

原书依据 · 1 处

if/else三元表达式

条件表达式只求所选分支,and/or和列表选择技巧分别有假值与提前求值陷阱。

条件表达式只求选中的分支

Y if X else Z先判断X,只执行并返回所选Y或Z。若动作复杂,用完整if更易审阅;[Z,Y][bool(X)]会先构造两侧结果,不能用来保留相同短路副作用。

条件表达式只求选中的分支保存独立卡片。

原书依据 · 1 处
与或组合不等价任意条件选择

X and Y or Z仅当X为真且Y也为真时返回Y;如果期望分支Y合法为0、空串或空容器,就会错误落到Z。要根据X选择且保留假值结果,用Y if X else Z;别靠未明确的真值假设模拟分支。

答案再次明确Y真值前提,若条件选中合法假值则必须用真正条件表达式。

(a and b) or c在a为真且b为假值时仍取c,与b if a else c不等价;若分支需要调用,也要区分保存表达式值与执行语句。不能因它能塞进lambda就把两者无条件替换。

与或组合不等价任意条件选择保存独立卡片。

原书依据 · 3 处
用或取默认会覆盖合法假值

A or default在A为假时选默认,0、False、空容器都可能因此被替换。若任务只把None认作未提供,应显式判断A is None;or链适合明确要首个真值对象的场景,不自动等同首个存在值。

x=x or []会把显式传入的空列表也替换为新列表;x is None仅把约定的None视为缺省。若API允许None本身为有效值,则还需其他区分缺省的设计,不可用假值测试替代契约。

用或取默认会覆盖合法假值保存独立卡片。

原书依据 · 2 处
短路表达式可能跳过必要动作

f1() or f2()在前者为真时不执行后者。若两项动作都必须发生,应分别调用,再组合保存的结果;不要把有必要副作用的工作藏在条件右侧却只测试最终真值。

短路表达式可能跳过必要动作保存独立卡片。

原书依据 · 1 处
真值协议回退取决于方法是否存在

Python3优先用bool给真值;未定义该方法时才用len,二者均无时实例默认真。不是bool返回False后再用长度推翻它,原文末段把回退条件写混。协议方法返回类型和错误也要遵守契约,不能只按空非空猜。

Python3普通真值测试优先使用适用bool,无此入口时才考虑len,两者均无则对象通常为真。bool返回False不意味着再尝试长度,若钩子抛错也不应机械改走回退;bool须返回bool,len须给出合法非负长度。

原书Truth/C多个替代版本展示Python2的nonzero与Python3的bool区别。仅在另一版本留下未识别名称时,测试可能因默认真而碰巧得到相同结果;要验证实现,应覆盖真实假值路径并按目标版本入口判断,不能把一次True当钩子已被调用的证明。

真值协议回退取决于方法是否存在保存独立卡片。

原书依据 · 2 处

本章小结

if章收束分支、语法、短路真值与条件表达式,转入循环。

本章习题

四题回顾多路分支、条件表达式、续行与布尔值。

习题解答

答案回顾分支表达式的真值前提与续行,需保留语法边界。

与或组合不等价任意条件选择关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处

第13章 while和for循环

while靠状态更新与条件配合推进,for让可迭代对象提供下一项。break提前退出,continue跳过本轮余部,而循环else对应没有通过break提前结束的路径。选择循环结构时,要同时说明它怎样前进、何时结束以及找不到结果时怎样处理。

while按条件重复,for按迭代器提供元素推进,后续工具组合不同遍历需求。

while循环

while每轮先测条件,初值为假时主体一次也不运行。

遍历与条件循环推进方式不同关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
一般格式

while可追加else处理条件最终为假的正常路径。

循环else处理正常耗尽

循环因条件变假或迭代耗尽而正常结束时可执行else;break跳过它。主体一次没运行也可能执行else,所以它不是“至少处理成功一次”的证明;异常或return等提前离开也不会因没break就必执行else。

搜索遇匹配break时跳过else,耗尽候选时走未找到;空候选也走else,不能根据执行else推断候选曾被检查。

for正常耗尽走else,break/异常等离开不走;已执行主体仍可最后改绑目标,不能把其最终值强行等同源中最后项。

循环else处理正常耗尽保存独立卡片。

原书依据 · 3 处
例子

while例分别以永真、缩短文本、递增计数和底部break控制进展。

循环进展与终止条件需配合

while可通过状态更新使条件最终为假,也可在主体末端检查后break实现先做一次再判断的流程。退出判断位置决定主体是否至少执行一次;不能只把while True当任务会自动结束的模板,还需考虑错误和外部中断。

本练习的2**X在每轮相同,可先求目标后搜索,避免重复计算。只有表达式不依赖被修改状态、且移动求值不会改变异常或副作用时才适合外提;这里未做性能测量。

循环进展与终止条件需配合保存独立卡片。

原书依据 · 2 处
break、continue、pass和循环else

break退出最近循环,continue跳过本轮剩余,pass只是空语句。

退出循环与跳过本轮作用不同

break终止最近一层循环并跳过其else,continue只结束本轮剩余动作,再按对应循环规则继续。嵌套时它们不自动退出所有外层循环;pass则什么也不做,执行后照常走下一语句,不能代替continue。

原例先递减x,再按奇偶continue,避免跳过递减导致停在同一状态;另一写法直接以if包住打印。选择表达方式先看所有路径是否推进和语义是否清楚,不把continue本身一律视为错误。

退出循环与跳过本轮作用不同保存独立卡片。

原书依据 · 2 处
一般循环格式

break/continue一般嵌在条件里,以实际任务选择退出或继续。

pass

pass满足必需语句位置,Ellipsis是实际对象,空主体循环仍消耗执行资源。

空语句占位不表示暂停执行

pass在语法需要语句时提供空动作,适合尚待实现的主体;while True: pass依旧不停运行,不会休眠或等待事件。占位函数正常返回None并不表示已交付功能,吞异常的pass也可能隐藏失败。

空语句占位不表示暂停执行保存独立卡片。

原书依据 · 1 处
省略号对象不同于空语句

…在Python3表达式中得到Ellipsis对象,单独写作表达式语句时结果可被丢弃,所以可看似占位。它不是None或pass本身,赋给变量会保存实际Ellipsis值;不能用它声称原定函数逻辑已经实现。

省略号对象不同于空语句保存独立卡片。

原书依据 · 1 处
continue

continue可减少一层嵌套,但必须保证跳过前已完成必要的状态推进。

退出循环与跳过本轮作用不同关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
break

交互循环在读取名称后退出,年龄处理另需转换并考虑输入流结束。

交互循环先区分终止命令与数据关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
循环else

loopelse可表达搜索未找到的路径,但算法输入域与退出含义仍需验证。

循环else处理正常耗尽关联本项背景,实质主要讲解在对应位置。

交互循环先区分终止命令与数据关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处
质数示例需先限定整数与下界

从y//2向下试因子的示例只在满足预期的整数输入域才有意义;小于2不是质数,不能因为循环一开始就不执行而落入else就判为质数。浮点或负数也不能直接套用,需要明确验证与边界处理。

946的02591-02592加y<=1分支并用y//2递减试除,仍接受浮点并以打印报告,无数学整数域检查。某些非整数会被错误地当作prime,因此它是教学循环练习而非可靠质数API;将while换for不替代算法和输入域修正。

质数示例需先限定整数与下界保存独立卡片。

原书依据 · 2 处
for循环

for处理可迭代来源,不限有位置顺序的序列。

迭代协议关联本项背景,实质主要讲解在对应位置。

原书依据 · 13 处
一般格式

每轮for将下一项赋给目标,循环后绑定与空输入需单独考虑。

循环else处理正常耗尽关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
for每轮重绑目标而非改来源

for目标每轮由迭代器给出的项重新赋值,在主体改绑目标名不会自动改下一项或源容器。结束后名称仍可能存在,但空输入不会由循环给它任何值;因此不能无条件在循环后把目标当最后元素使用。

for每轮重绑目标而非改来源保存独立卡片。

原书依据 · 1 处
例子

for组合累积、解包、搜索与文件扫描,结果容器与副作用由各具体操作决定。

解包按位置分配可迭代对象关联本项背景,实质主要讲解在对应位置。

星号解包收集剩余项为列表关联本项背景,实质主要讲解在对应位置。

文件对象由打开接口建立关联本项背景,实质主要讲解在对应位置。

原书依据 · 14 处
嵌套搜索的退出只影响对应内层

外层逐个测试键,内层逐项搜索;匹配后break只终止内层,内层else表达该键未找到。若仅需成员判断,可用key in items清楚表达,但涉及取匹配对象或额外副作用时仍要保留任务契约。

嵌套搜索的退出只影响对应内层保存独立卡片。

原书依据 · 1 处
筛共同项不等于集合交集

遍历seq1并把在seq2中的项追加到列表,会保留seq1顺序及重复项;数学集合交集则去重且无这种位置顺序。因此需要决定输出是有序筛选列表还是唯一成员集合,不能直接互换容器运算。

intersect与[x for x in seq1 if x in seq2]保留第一来源顺序与重复项;集合交集按成员去重,不能直接替换仍需要保留重复或顺序的结果。第二来源是普通序列时反复成员查找会重复扫描,成本不能因函数封装消失。

本例intersect以第一来源为基准,对每项检查是否属于其余每个来源,遇缺失break,全部通过才由内层for/else收集。第一来源的重复仍保留;union则按扫描顺序收集尚未出现在结果中的元素。它们与内置set运算在顺序、去重和可哈希要求上不一定相同。

筛共同项不等于集合交集保存独立卡片。

原书依据 · 3 处

编写循环的技巧

计数和并行遍历工具可减少手动状态,但Python3返回类型应区分。

迭代协议关联本项背景,实质主要讲解在对应位置。

原书依据 · 13 处
循环计数器:while和range

range表示含起点排除终点的等差整数范围,值遍历与位置遍历有不同意图。

整数范围是可迭代序列而非迭代器

Python3 range保存起点、终点、步长并可重复迭代,是不可变整数序列,本身不具有next推进状态。range(stop)从0到stop前,负步长可递减,步长不得0;list(range(…))物化所有值,不能为看内容就忽视大范围内存代价。

小结将range与zip/map并列为迭代器过宽,range是可迭代序列而zip/map为迭代器;共同可for不意味可同样next使用。

原例R=range后I=iter®,next推进I而非R,说明range本身与取得的迭代器不同;物化list®与流式消费是不同内存选择。

原文标题把range叫迭代器,但图中仍以I=iter®取得可next推进的对象。现代Python3的range是不可变序列,也支持切片、成员测试等,不能沿用仅迭代/索引/len的旧版能力清单;需要列表操作时才考虑list®。Python2的xrange名称是历史迁移信息。

整数范围是可迭代序列而非迭代器保存独立卡片。

原书依据 · 4 处
需要偏移时再按范围索引遍历

只需元素时for item in values直接表达遍历;需要访问或修改特定位置时才考虑range(len(values))等偏移。偏移是定位信息不是元素本身,别把for i in values当自动下标,也不要仅为手动计数增加多余状态。

直接元素循环、切片、索引更新或解析适于不同目标;不能把答案偏好泛化为任何出现range都错误,固定次数或明确位置操作仍合理。

需要偏移时再按范围索引遍历保存独立卡片。

原书依据 · 2 处
非完备遍历:range和分片

有步长的偏移和切片可产生相同选项,但中间对象与内存行为不同。

跳步遍历可在索引与切片间权衡

range(0,len(s),k)逐偏移取元素,s[::k]先得到切片再遍历,常可选同样位置但前者不需物化整个切片。切片常更直观,大序列则要考虑复制成本;选择依据实际需不需要索引和资源约束,不把一种语法当所有任务唯一正确选择。

原书对字符串S[::2]会产生新字符串,列表切片产生新列表;先切片一次再多次迭代可避免内循环重复切片,但仍物化相应结果。并非所有可切片对象都复制全部数据,例如某些类型可返回轻量视图或范围描述,所以成本应依据具体类型,而非统一把切片说成结果列表。

跳步遍历可在索引与切片间权衡保存独立卡片。

原书依据 · 2 处
修改列表:range

改绑循环变量不替换源列表位置,原处更新与结果列表有不同别名效果。

更新列表位置不同于改绑循环名

for x in L后x+=1只改当前名字绑定,不会把新整数写回L。若要替换列表每个位置,可按索引赋值;若用[x+1 for x in L]则得到新列表,改绑L也不改变旧列表别名。元素本身可变时原处修改又不同,应按实际引用层次判断。

按索引原处加10与L=[x+10 for x in L]在L显示值上可相似,旧列表的其他别名是否看到变化却不同;不能为省代码机械替换有共享契约的更新。

更新列表位置不同于改绑循环名保存独立卡片。

原书依据 · 2 处
并行遍历:zip和map

zip按位置配对来源,截断与旧mapNone补齐语义不同,构造字典还可能覆盖重复键。

字典解析按计算后的键收集值关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
并行配对默认到最短来源结束

zip按位置产出来自各来源的元组,默认到最短可迭代对象耗尽即停止,不验证其他来源是否还有剩余。要保留最长来源或要求等长,应明确使用相应补齐/验证策略,不能把zip理解成自动对齐缺失数据。Python3输出惰性迭代器,配对不代表并发线程执行。

并行配对默认到最短来源结束保存独立卡片。

原书依据 · 1 处
映射函数与配对工具不可混用契约

Python2 map(None,…)曾按最长来源补None;Python3不保留这一退化用法,但map(func,…)仍存在。map对配对项调用函数,zip产出元组;迁移时先确认是否依赖补齐、结果列表或函数副作用,不能只改名称。

映射函数与配对工具不可混用契约保存独立卡片。

原书依据 · 1 处
产生偏移和元素:enumerate

enumerate把计数与元素一起产出,避免外置计数器但不把计数当所有容器的键。

迭代协议关联本项背景,实质主要讲解在对应位置。

原书依据 · 13 处
枚举计数与元素一起推进

enumerate(iterable)每次产出计数和元素组成的元组,可直接解包使用。默认从0计数,在列表等位置序列上可当偏移;对一般来源计数只是迭代位置,不一定是对象键。enumerate对象是迭代器,不因逐项产生就与生成器函数对象类型相同。

枚举计数与元素一起推进保存独立卡片。

原书依据 · 1 处

本章小结

循环章汇总while/for、控制跳转和辅助遍历工具,转入协议。

整数范围是可迭代序列而非迭代器关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处

本章习题

五题比较两循环、控制语句、else与索引工具。

习题解答

答案强调能直接遍历时减少手动状态,特殊索引需保留具体意图。

需要偏移时再按范围索引遍历关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处

第14章 迭代器和解析,第一部分

迭代把取得数据的过程封装为协议,for、解析式和许多内置工具都可消费它。可迭代对象与一次性迭代器不同,惰性生成也不保证结果永远不被物化。面对文件、字典视图或map等对象时,应确认谁持有遍历状态以及下一轮是否还有数据。

本章从for的共同协议进入列表解析,后续函数章再扩展生成工具。

迭代器:初探

可迭代概念从存储序列推广到按需产值来源。

迭代协议关联本项背景,实质主要讲解在对应位置。

原书依据 · 13 处
文件迭代器

文件迭代器逐行推进,用StopIteration区别协议耗尽而非空串结果。

文件对象由打开接口建立关联本项背景,实质主要讲解在对应位置。

迭代协议关联本项背景,实质主要讲解在对应位置。

原书依据 · 19 处
迭代耗尽不是返回合法空值

文件readline到EOF返回空字符串,而next(file)到EOF抛StopIteration。后者把正常元素和结束信号分开,for可自动处理耗尽;空行通常是含换行的字符串,不能与EOF混淆。普通处理异常不能因为循环会处理StopIteration就都吞掉。

迭代耗尽不是返回合法空值保存独立卡片。

原书依据 · 1 处
手动迭代:iter和next

iter启动可迭代来源,next推进特定迭代器;容器与单次进度对象有不同复用方式。

迭代协议关联本项背景,实质主要讲解在对应位置。

原书依据 · 13 处
重复遍历能力取决于迭代器归属

iter(list)可建立各自独立进度的迭代器,next(list)本身不成立;文件等迭代器通常iter(f) is f,重复取得并不会重置已有文件位置。两变量共享同一迭代器也共享消费进度,不能因都能for就假定任意次数从头遍历。

Python3的map、zip和filter结果自身是迭代器,list(result)会消费它,之后再for不会自动从头开始;需要再遍历须重新构造或保存已物化数据。不能因range也可用于for就推断它们都能独立反复遍历。

同一range可产生I1、I2两个独立迭代器,推进I1不推进I2;同一zip或map上两次iter通常都指向原对象,别名消费共享状态。生成器对象同样是单次状态对象;生成器函数再次调用则会创建新对象,不能混淆函数和返回对象。

iter(G) is G,同一G的I1、I2共享消费状态,list(I1)只取剩余项并使其他别名也耗尽。这里的生成器指调用产物而非生成器函数对象;普通列表可产生独立迭代进度,但遍历期间修改列表仍会影响所见数据。

本例只能消费一次的原因是Squares把iter和推进状态放在同一个对象且不重置,不是iter协议天生只能单次。生成器函数每调用一次可产生新生成器,但同一个生成器结果仍共享一次推进状态。列表推导式一次物化全部结果与按次产生结果的成本不同,不能无条件断言某种写法最快。

重复遍历能力取决于迭代器归属保存独立卡片。

原书依据 · 5 处
特殊方法协议查找有类型层规则

next(obj)等协议操作并不简单等于任意普通属性查找后调用obj.next。特殊方法通常须定义在类型上,实例的动态转发可能只让显式属性调用成功。原书Python3.0 popen包装例展示这种差异,不能据属性存在就断言完整协议兼容。

popen.next与next(popen)差异被原书明确视作Python3.0实现问题,不把此旧例泛化为所有版本for绕过协议,或将单次旧异常当接口设计常规。

类可通过特定协议方法支持索引、运算符等语法,使自定义对象与相应工具协作。它不意味着任意内置类型的全部操作都能被随意中断或重载;需要实现对应协议并满足其契约。

可提供intersect显式方法,也可用and让对象支持&表达式。没有自定义该方法不总意味着完全无能力,还需考虑继承或相应后备规则;必须按具体协议解释,而非任意双下划线名都会自动触发。

特殊方法名与具体语言操作之间有既定协议,并非任意双下划线名都会被自动调用。缺少某个方法时的结果由该协议的继承、回退或默认行为决定,例如加法还可能涉及反射方法,不能统一断言缺add就必然立即失败;隐式特殊方法查找也不同于一般实例属性访问。

包装器实现getattr并不能自动让print、索引等隐式特殊方法操作全部转发。此处str必须在包装类上显式提供并调用str(self.person),因为隐式协议查找有类型层规则,通常绕过实例的通用属性访问钩子。直接显式读取obj.str与print(obj)的机制不能混为一谈。

特殊方法会在相应语言操作中被调用,但不能把所有协议都概括为返回值原样成为表达式结果:初始化、赋值和字符串表示等各有返回值契约。缺少某方法可能触发继承、反射或默认行为,也可能报错;并非任意双下划线名都有效,或所有语法均有可重载入口。

本表还列出getattribute/getattr、属性写删、描述符与new/del等不同阶段钩子。其调用和返回要求各不相同,不能将del的触发理解为每次del语句立刻析构,或把object默认方法与所有操作缺失都报错混为一谈;后续实际定义按对应协议解释。

Python3切片读取和写入使用带slice键的getitem/setitem,不应照抄旧getslice/setslice作为现代入口。旧hex/oct与现代index的历史差别仅按原书版本对照使用。

trace.wrapper的getattr只在普通查找失败时转发,不自动处理属性赋值、删除和Python3隐式运算符协议。因此不能据列表append或字典keys示例认定len、索引和打印都已经完整代理;所需特殊协议应在包装类型上明确实现或继承。

对特定语法和内置操作的隐式特殊方法查找通常直接采用类型层定义,绕过实例字典及普通getattribute链;显式obj.len访问仍是另一条路径。不能据getattr能代理一般字段,就推断len或运算符也已代理。官方数据模型2026-11-06核验:https://docs.python.org/3/reference/datamodel.html#special-method-lookup 。

712再次将包装getattr与print/str区分:隐式协议按类型层规则处理,不保证经过实例的一般属性回退。普通字段/方法转发仍可能工作,所以不能把原文“类在Python3失效”扩成整个包装对象所有访问均失败;应逐项实现所需协议。

850用两个测试类说明显式属性读取与隐式协议调度不同。

结构图:

classDiagram
class GetAttr {
 eggs$
 spam
 __init__(self)
 __len__(self)
 __getattr__(self, attr)
}
class GetAttribute {
 eggs$
 spam
 __init__(self)
 __len__(self)
 __getattribute__(self, attr)
}

这是02314中的实际类,区别于848同名简例。两类自己提供len返回42,因此len(X)按类上的方法工作,不是读取钩子“拦截了len”。它们都未给类定义getitem/add/call,所以3.0测试中的索引/加法/调用失败;显式X.call仍可由普通读取取得钩子返回的lambda。 GetAttr的显式str通常被继承的默认方法满足,不走缺失回退;GetAttribute可截住显式X.str,但print(X)的隐式字符串协议仍走类型层默认方法。书中2.6结果须区分经典GetAttr与显式object派生的GetAttribute,不能概括为全部Python2类查找都从实例进行。对需要的协议,包装类型可显式实现或继承代理方法,通用属性回退本身不提供这一保证。旧os.popen.next差异只是当时实现的例子,不推导当前标准库仍有相同故障。

851十图依次展示Manager显式str、删后3.0默认显示、2.6经典类不同结果、统一读取仍无隐式str、最终显式提供str恢复嵌入对象显示。对普通方法的第二次person访问可用基础获取减少;这不能让隐式print进入getattribute。需要的协议也可从适当超类继承,不限定必须逐类重复同一代码;不以原文“唯一选择”否定其他有同一协议支持的设计。

891的02437-02439比较Python2传统类与Python3:同一Private代理在3中仍拒绝age显式读取,但print取包装类默认显示,+找不到代理add而失败。02440-02441仅给补str/add/getitem/call的骨架;所列方法没有展示failIf检查,所以只能说明委托位置,不能宣称私有特殊方法已经受控。图中call参数为*args但调用处写*arg,是拼写不一致,不是可直接运行的完整方案。

特殊方法协议查找有类型层规则保存独立卡片。

原书依据 · 15 处
其他内置类型迭代器

字典、范围和枚举等以各自协议产项,历史包装器问题不等于当前所有对象差异。

遍历字典默认得到键关联本项背景,实质主要讲解在对应位置。

整数范围是可迭代序列而非迭代器关联本项背景,实质主要讲解在对应位置。

特殊方法协议查找有类型层规则关联本项背景,实质主要讲解在对应位置。

原书依据 · 22 处

列表解析:初探

列表解析表达逐项变换但创建新列表,与原处修改别名行为不同。

更新列表位置不同于改绑循环名关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
列表解析基础知识

解析遍历来源,把逐项表达式结果收集成新列表,性能与作用域仍需具体分析。

列表解析组合遍历与转换关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处
在文件上使用列表解析

文件迭代可直接作为列表解析来源,变换结果仍全部收集。

删行尾前要确认实际终止字符关联本项背景,实质主要讲解在对应位置。

字符串变换应接收返回结果关联本项背景,实质主要讲解在对应位置。

原书依据 · 8 处
来源流式不等于结果不物化

对文件逐行迭代做列表解析,可以避免先readlines建立一份原始行列表;但最终变换结果仍全部存入新列表。大文件需要按最终输出大小考虑内存,不能因输入按行读取就称整个处理流式或恒定内存。

用list(zip(…))查看或保存全部结果会立即消费并建立列表,恢复的正是相应内存成本。为了交互显示而物化的写法不应机械搬到仅需逐项处理的大数据路径;字典视图和range也不能一概称为同一种生成器。

set或dict消费生成器仍会建立完整容器;集合/字典解析也会在表达式求值时消费来源。若要逐项交付键值对,可用((k,v) for …)生成器,但那是元组流而非可随时按键查询的完整映射。

来源流式不等于结果不物化保存独立卡片。

原书依据 · 3 处
扩展的列表解析语法

解析中的筛选先决定是否接纳当前项,多重for按嵌套次序构造组合。

解析筛选先于结果表达式

[expr for x in source if cond]先为当前x测试cond,只有成立才求expr并收集。它与在expr中写条件表达式不同:前者减少结果项,后者通常仍为每个输入产生一个结果。过滤条件也必须适用于实际输入,直接取line[0]不能推广到可能含空字符串的任意列表。

[x*x for x in source if x%2==0]仅对筛选通过的项计算结果,保留输入次序;这与先map后filter可能具有不同计算和异常行为。比较替代表达式时须确认先后顺序。

解析筛选先于结果表达式保存独立卡片。

原书依据 · 2 处
多重解析遵循嵌套循环顺序

[x+y for x in A for y in B]等同于先取一个x,再完整遍历B,为每对元素求结果。两个可重复遍历来源形成笛卡尔组合,并非无重复排列;内层若是单次迭代器,第一次耗尽后会影响后续外层项。多层筛选和嵌套难以辨认时,显式循环更利于维护。

多个for按从左到右对应外到内循环,每个if只在此前变量已绑定的上下文中测试。要理解复杂式,可展开为逐层缩进的for/if再检查结果顺序与项数;例中偶数与奇数组合是笛卡尔组合而非一对一zip。

集合和字典解析同样从左到右展开for/if,输入求值次序与最终容器显示次序不是一回事。集合显示不能拿来倒推嵌套循环执行顺序,也不保证额外迭代层次会产生相同数量的不同成员。

多重解析遵循嵌套循环顺序保存独立卡片。

原书依据 · 3 处

其他迭代环境

同一迭代协议能支撑排序、归约、构造和调用解包,但消费与结果语义不同。

解包按位置分配可迭代对象关联本项背景,实质主要讲解在对应位置。

集合按可哈希元素去重关联本项背景,实质主要讲解在对应位置。

原书依据 · 9 处
迭代接口不决定消费策略

sorted从可迭代来源收集元素后返回新列表;map和filter在Python3按需产项;sum等归约返回聚合值。共同接受iterable不代表相同内存、耗尽时间或结果类型。列表本身也可迭代,原文将真正列表与可迭代对象对立只是区分物化结果与惰性对象的历史措辞。

filter保留谓词真值成立的原项,map产出函数结果,reduce则消费来源得单个累计结果。Python3的filter/map按需推进,reduce不因此自动变成迭代器;range也不是图注所称的iterator。

迭代接口不决定消费策略保存独立卡片。

原书依据 · 2 处
行字符串极值按文本比较

max(file)和min(file)比较逐行字符串的字典序,结果不是最长或最短行。要比较长度等业务属性,应明确对应比较键;不能把可使用迭代协议误当作所有输入都有预期业务意义。

行字符串极值按文本比较保存独立卡片。

原书依据 · 1 处
星号调用会消费可迭代参数

f(*items)把可迭代来源展开为位置参数,参数个数仍须满足函数接口;用文件作来源会按行消费。zip(*rows)可把等长行转为列,但先要展开外层,普通zip还会按最短行截断;它不是对任意不规则数据无损求逆的操作。

调用*pargs可用任意可迭代来源并消费其元素,函数头的*pargs却总是元组收集器。旧apply(func,args,kwargs)是Python2历史接口,现代调用以func(*args,**kwargs)表达,不混同两侧方向。

星号调用会消费可迭代参数保存独立卡片。

原书依据 · 2 处

Python 3.0中的新的可迭代对象

Python3把若干原先返回列表的接口改成惰性对象,展示需要物化时才使用list。

来源流式不等于结果不物化关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
range迭代器

range按规则表示整数序列,迭代器由iter另行取得。

整数范围是可迭代序列而非迭代器关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
map、zip和filter迭代器

map、zip、filter的结果自身保存单次迭代进度。

重复遍历能力取决于迭代器归属关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
惰性变换随消费执行

map与filter在结果被请求时推进来源并应用函数,而不是仅创建结果对象就完成所有处理。调用有副作用或可能失败的函数时,这影响副作用和异常出现的时点;filter按返回值的真值选项,不要求返回对象必须是布尔单例True。

Python3 map按请求调用函数并产结果,list(map(…))才物化全部。本例mymap用append后返回列表,因此结果值可相似,求值时点和内存行为却不同;函数不必是内置的,也可传lambda或用户定义函数。

惰性变换随消费执行保存独立卡片。

原书依据 · 2 处
多个迭代器VS单个迭代器

同一来源能否拥有独立遍历进度,要看iter是否返回新状态对象。

重复遍历能力取决于迭代器归属关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
字典视图迭代器

字典视图反映底层映射,而视图自身与由它得到的迭代器不同。

字典键视图不是列表或迭代器本身关联本项背景,实质主要讲解在对应位置。

遍历字典默认得到键关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处

其他迭代器主题

后续章节把生成器和用户定义对象接入同一迭代协议。

迭代协议关联本项背景,实质主要讲解在对应位置。

原书依据 · 13 处

本章小结

本章收束共同协议、解析和Python3惰性工具的联系。

本章习题

四道习题检查循环、解析、迭代环境与文件读取。

习题解答

答案重申for处理耗尽、解析收集结果及文件按行消费。

文件对象由打开接口建立关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处

第15章 文档

注释为源码读者解释意图,文档字符串则附在运行时对象上,可被帮助工具读取。dir、help和手册服务不同深度的查询:知道名字不代表已经知道签名、前提和返回语义。文档与测试都需要随真实接口变化维护,不能只为工具展示而写说明。

文档把语法与工具知识转为他人可理解和可查询的说明。

Python文档资源

不同资源回答不同层次的接口问题。

按问题层次选择文档入口

查对象有哪些名字可先看dir,查某个接口的用法可看help或docstring,查语言规则和标准库的完整契约应转向对应版本手册。源码注释、交互帮助、官方参考与书籍互为补充,属性名清单不能替代行为说明。

Library Reference解释内置对象和标准库,Language Reference解释语法与语言语义;教程提供循序入口。查旧书示例时须匹配所用Python版本,图示Windows帮助菜单是当时发行方式,不是跨平台现行入口保证。

按问题层次选择文档入口保存独立卡片。

原书依据 · 2 处
#注释

源码注释适合解释局部意图,接口说明应便于调用者找到。

局部注释解释难懂的实现意图

字符串外的#使其后文本成为注释,适合解释局部难点、选择原因和限制。模块、函数、类的使用方式可放在能被文档工具提取的docstring中;两者分工比只重复每行代码更能帮助维护。

局部注释解释难懂的实现意图保存独立卡片。

原书依据 · 1 处
dir函数

dir帮助发现属性名,不能单凭名字判断完整契约。

属性清单不等于接口说明

dir(obj)可用于探索属性名并唤起记忆,但不会说明参数、返回值或副作用;双下划线项常对应语言协议。对象还可定制dir结果,因此不要把它当作所有可访问属性的完备证明;需进一步查help、文档或类型契约。

习题把dir称为所有属性清单是教学简化;定制内省与动态属性存在时,不保证完备。模块索引也取决于当前环境与发现机制,旧GUI入口不能直接用于现代版本。

模块的dict可检查已存储名称,dir提供便利的名称清单而不是完整行为契约。name通常标明模块自身导入名称(作为入口时常为main),并非导入者的名字;file也不保证每个内置或动态模块都具备。

listing(module,verbose=True)遍历模块字典并展示属性,不保证所有对象都有file,下划线前缀也不证明属性一定由解释器创建。它是教学内省工具,不是任意模块的完整安全检查或API说明。

dir(instance)通常列出自身和继承得到的许多名称,并可受定制dir影响;其结果服务于交互探索,不保证是全部属性或完整接口契约。双下划线名称中包含实际协议接口,也不能一概认作无意义内部细节并删除;应按显示用途选择。

本节dir显示自身和继承名称,旧新版本输出集合不一致;dir通常用于交互探索,可由对象定制,并不保证完整。双下划线名称包含用户可实现的协议,不全是解释器私有实现,也不等于可忽略的垃圾名称。

属性清单不等于接口说明保存独立卡片。

原书依据 · 6 处
文档字符串:doc

首条字符串可成为对象的可查询文档;内容约定与语法要求需区分。

文档字符串依赖定义中的位置

模块、函数、类或方法定义体的首条字符串字面量可成为其docstring,并通过对象.doc读取。前面的普通注释和空行不妨碍该位置;任意位置的三引号字符串却不会自动变成该对象的文档。打印属性是查看文本,不能替代把准确说明写进源码。

docstr.py把模块、func、spam类和method的文档写在各自定义体开始位置,通过相应doc获取。可以用三重引号写多行,但不是必须三重引号,也不是任意位置的字符串字面量都会成为该对象的文档字符串;优化等配置也可影响文档保留。

文档字符串依赖定义中的位置保存独立卡片。

原书依据 · 2 处
文档内容约定不同于语法标准

语言识别docstring的位置,却不强制统一的正文标记格式。仍应采用项目明确的说明约定,交代行为、参数、结果和必要限制;PEP257也已提供非强制的通用约定。原书缺少统一格式的感受不能扩展为从无任何规范。

本节建议用文档字符串说明对象做什么,用#说明局部复杂表达式如何工作。这是帮助读者的写作选择,不是编译器强制的内容分类;准确性与真实契约比只满足形式更重要。

文档内容约定不同于语法标准保存独立卡片。

原书依据 · 2 处
PyDoc:help函数

help在已有对象文档之外整理签名和成员结构。

帮助报表结合文档与对象结构

help(obj)使用pydoc整理docstring及可取得的签名、成员等信息,比单独打印doc更便于浏览。把对象作为参数时,应先能取得该对象;help(str.replace)与只写对象名的引用不同。报表质量仍取决于实际文档和可内省的信息,不代表接口已被测试。

docstr的help报表除文档字符串外,还列出模块、文件、类、方法与函数结构,所以帮助信息不是仅把doc原样拼接。报告内容依当前导入对象及运行环境,旧版示例不应当作现代所有环境的固定输出。

787复述PyDoc把docstring与对象信息组织成帮助,链接第15章已学用法;有帮助报表不等于接口已通过测试。

帮助报表结合文档与对象结构保存独立卡片。

原书依据 · 3 处
PyDoc:HTML报表

HTML文档可导航模块结构,但收集信息会导入目标。

文档内省可能触发模块副作用

pydoc查文档会导入目标模块,因此模块顶层代码可能运行,输入请求、文件写入等也可能发生。需要仅脚本执行的入口应放入主程序保护中;对未知模块先了解导入行为。生成文档不是保证无执行的静态读取。

模块导入时执行顶层语句,def建立函数对象,其函数体通常稍后调用;顶层print或初始化工作却可立即发生。这也是文档内省等间接导入可能产生副作用的原因,必要启动行为应有明确入口。

文档内省可能触发模块副作用保存独立卡片。

原书依据 · 2 处
文档报表对应当前解释器环境

pydoc按当前环境与导入路径定位模块,同名包的文档可能随环境和版本改变。HTML导航可显示可发现模块及链接,却不能证明包含所有潜在动态模块;查问题时应确认报表对应实际运行的版本。

文档报表对应当前解释器环境保存独立卡片。

原书依据 · 1 处
标准手册集

语言规则与工具API使用不同参考手册。

按问题层次选择文档入口关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
网络资源

官网与网络资料可作学习入口,事实仍须匹配版本。

已出版的书籍

书籍适合系统学习,版本变化另以对应手册确认。

系统讲解与版本核验分开使用

书籍的组织和解释可支持长期学习,但出版周期意味着接口细节可能落后。理解概念后,应以实际使用版本的官方说明核验已变化的功能;作者网站更新也需查看具体内容,不能只因书仍有价值就认定旧例全部可运行。

系统讲解与版本核验分开使用保存独立卡片。

原书依据 · 1 处

常见编写代码的陷阱

语法、别名和返回值陷阱应在日常编码中形成明确检查点。

缩进宽度统一避免视觉歧义关联本项背景,实质主要讲解在对应位置。

原地修改不同于返回新容器关联本项背景,实质主要讲解在对应位置。

属性取得不等于方法已经调用关联本项背景,实质主要讲解在对应位置。

运行文件与导入模块用不同名称关联本项背景,实质主要讲解在对应位置。

原书依据 · 18 处

本章小结

文档章收束注释、内省、帮助与版本手册,并引出函数。

本章习题

习题检查文档分工、查看入口、属性发现与模块索引。

习题解答

答案对应本章文档资源,历史GUI入口保留历史边界。

属性清单不等于接口说明关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处

第三部分 练习题

部分练习要求用等价逻辑改写搜索,并分清显示、返回列表与惰性map。

循环进展与终止条件需配合关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
按所需结果选择搜索结构

只需判断成员是否存在时可用in;需要首次匹配位置或逐项处理时,显式遍历或相应搜索接口更贴合。把while标志位改成for/else,可让正常耗尽分支直接表达未找到,但改写应保留匹配、空输入与结果契约。简短本身不证明行为等价。

按所需结果选择搜索结构保存独立卡片。

原书依据 · 1 处

第四部分 函数

进入函数部分。

第16章 函数基础

函数将一段计算封装成可调用对象,def执行时建立定义,调用时才执行函数体。参数形成输入边界,return形成结果边界;打印只是副作用,不能代替交给调用者的值。合理分解让任务可复用,也迫使作者说明调用前提与失败处理。

函数把可重复操作封装为有参数和结果的部件。

函数封装可重复使用的操作

把同一操作放进函数,用参数表达变化,可让多个调用点共享一处实现。修改行为时减少副本同步负担;但只有责任和语义相近的代码才适合共用,不能仅凭外观相似就把不同契约强行合并。

把可变的输入由参数传入同一搜索实现,比每次复制后改变量名更能避免算法修改遗漏。它解决的是相同责任的重复维护,仍须明确返回结果语义。

intersect(seq1,seq2)在每次调用建立res,对seq1逐项测试在seq2中的成员关系,最后返回列表。模块封装有利于导入复用,但可导入路径与依赖仍需满足,不代表计算机中的任意程序自动能找到它。

函数封装可重复使用的操作保存独立卡片。

原书依据 · 3 处

为何使用函数

除了减少重复,函数还把大流程划分为职责明确的子任务。

函数边界帮助分解复杂流程

复杂任务可拆成混合、准备、烘烤等职责明确的步骤,每个函数完成可理解的子任务,再由调用关系组成流程。这样可以分别理解和修改较小部件;拆分应围绕实际职责,而不是机械地把每几行包装成函数。

函数边界帮助分解复杂流程保存独立卡片。

原书依据 · 1 处

编写函数

函数对象、调用、返回与作用域是不同层次的机制。

形参绑定不等于复制实参对象

调用把实参对象绑定到函数的形参名。函数内把形参改绑到另一对象,不会自动改绑调用者的变量;若通过形参修改共享的可变对象,调用者却可能看到变化。理解参数传递要区分名称改绑与对象原处修改。

times(2,4)把两个整数对象绑定到x和y后求乘积;times字符串与整数可执行重复。形参名可接受不同类型,不表示任意实参组合都支持函数体中的运算。

L.append(x)修改已找到的列表对象,不因此把L认定为局部名称;L=other则是名称绑定。增强赋值也含目标绑定,不能因为某次原处更新就忽略作用域规则。

整数、字符串和列表等在传参时都不会自动复制对象,形参名绑定到实参对象。不可变对象无法被原处修改,所以某些效果像值传递;可变对象可被修改,但这不把调用者变量名本身变成可改绑的引用参数。

changer(a,b)中的a=2改绑本地a;b[0]=spam修改b和调用者L共同引用的列表项。因此调用后原X可不变而L内容变化,L仍引用原列表;不是把b这个形参名变成调用者的变量。

形参绑定不等于复制实参对象保存独立卡片。

原书依据 · 5 处
作用域声明选择名称绑定位置

global指定名称使用模块级绑定,nonlocal指定已有封闭函数作用域中的绑定;声明本身不创建或修改对象值,也不是把名称变成所有模块共享的全局变量。具体赋值仍由相应语句完成。

global x使本块内x关联到定义模块的全局绑定;实际执行x=value才创建或更新该绑定。只读取全局y、z通常不必声明,若要重新绑定则需要相应global。声明应在同块对名称使用之前,不能把声明本身当赋值。

内层函数可直接读取封闭函数中的自由变量;若要把该名称改绑到新对象,须nonlocal指向最近的已有封闭函数绑定。通过已取得引用修改可变对象与名称改绑不同,不应说任何状态修改都必须声明。

nonlocal选择最近且已存在的封闭函数绑定,不能让赋值自动在模块全局或内置空间创建同名变量。它适合闭包中的可变计数状态;不存在符合条件绑定会构成语法错误,而非调用时随意新建外层名称。

global读取从模块全局再到内置,赋值写模块;nonlocal仅关联最近已有的封闭函数绑定,不退回全局或内置。正确性来自绑定规则,不能从“略过局部”推导不经测量的通用加速收益。

nonlocal关联的名称必须在某个封闭函数块有相应绑定,语法分析会检查是否存在;有合法绑定但运行时尚未赋值又是另一问题。不能用nonlocal给任意外层凭空选择位置,也不能把只有模块同名变量当满足条件。

作用域声明选择名称绑定位置保存独立卡片。

原书依据 · 6 处
def语句

def定义函数体,调用时按控制流执行它并获得结果。

普通函数无显式结果也返回空值

普通函数执行return expr会把表达式结果作为调用值;执行裸return或正常走到函数体末尾会返回None。它们都不同于打印信息给终端;调用者要继续使用结果,须取得返回对象。异常退出和生成器的yield行为应另行区分。

有return的times返回x*y的结果;交互提示符会展示结果,脚本中裸调用不因此自动打印。要供后续运算使用,可把调用结果绑定到名称,返回对象与显示它是两件事。

proc打印输入后自然结束,调用结果是None;打印了信息不表示返回了该字符串。生成器含yield时的调用结果又是生成器对象,不能把所有没有return的函数一概当None调用。

普通函数无显式结果也返回空值保存独立卡片。

原书依据 · 3 处
def语句是实时执行的

执行def才创建并绑定函数对象,函数体通常在调用时执行。

定义函数与执行函数体分开

执行def语句会创建函数对象并把名称绑定到它;函数体通常等调用才运行。因此可以在条件分支中选择要建立的定义,也可让多个名称引用同一个函数。运行时创建不意味着Python没有预先解析或字节码编译阶段。

def times(x,y): return x*y在运行def时绑定函数,尚不要求存在调用实参x、y;每次调用才绑定形参并求乘法结果。模块导入可执行其顶层def,交互输入也能建立同样的函数对象。

函数体可引用稍后才绑定的全局函数名,只要实际调用并查找时该名称已可用。把嵌套函数改成参数传递的独立函数有时简化结构,但有状态闭包并非一律应展开。

顶层直接调用func1前须已执行其def;func1体中引用func2可等到调用时再找,但那时func2仍须已经绑定。把定义和入口执行清楚分开能减少顺序陷阱;不能从函数体延迟推出任意前向引用总成立。

定义函数与执行函数体分开保存独立卡片。

原书依据 · 4 处
函数对象可通过别名传递调用

othername=func把同一函数对象交给另一个名称,othername()仍调用该对象,赋值本身不调用函数。用户定义函数还能携带属性以记录信息,但这不意味着所有可调用对象都允许任意附加属性。

nested.state+=1修改函数对象属性,不重新绑定封闭名称nested,所以不为这个操作声明nonlocal nested。函数名在外层作用域可被闭包读取,属性存储则让状态也能从返回函数对象访问。

schedule=[(echo,arg),…]保存的是函数引用和参数;遍历解包后func(arg)才执行动作。把调用结果误存为函数会提前执行并失去之后可调用的对象;具体函数也可由工厂返回并携带闭包环境。

func.count和func.handles附在函数对象上,函数调用结束后仍可随对象存在;持有该函数引用的外部代码也可访问。它与真正局部名称或自动封装不同,且多个别名指向同一函数时会看到相同属性状态。

函数对象可通过别名传递调用保存独立卡片。

原书依据 · 4 处

第一个例子:定义和调用

定义创建可调用对象,调用表达式请求运行。

定义

times将乘法表达式放进函数体,由调用参数决定具体行为。

定义函数与执行函数体分开关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
调用

调用把对象传给形参,返回值能继续作为表达式结果使用。

普通函数无显式结果也返回空值关联本项背景,实质主要讲解在对应位置。

形参绑定不等于复制实参对象关联本项背景,实质主要讲解在对应位置。

原书依据 · 8 处
Python中的多态

多态依赖兼容操作契约,而非任意对象都能通过。

接口优先于过窄的类型筛选关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
接口灵活不取消业务校验

仅按精确内置类型筛选可能排除兼容对象,但由此不能推出检查输入没有意义。支持操作协议仍可能有值域、单位或安全限制,应校验业务前提,并在合适边界报告错误。让不兼容运算抛异常是一种机制选择,不替代所有校验与测试。

习题批评的是阻断兼容对象的过窄类型测试,而非所有验证。仍需确认接口的实际行为和值域,并按责任处理不匹配;返回None也可表达没有结果,不是给它赋名永远无意义。

接口灵活不取消业务校验保存独立卡片。

原书依据 · 2 处

第二个例子:寻找序列的交集

重复粘贴同一搜索逻辑会让修改分散。

函数封装可重复使用的操作关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
定义

把筛选逻辑参数化后由return交还可继续使用的结果。

函数封装可重复使用的操作关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
调用

例中的intersect按第一来源顺序筛共同项,不是真正集合交集。

筛共同项不等于集合交集关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
重访多态

协议兼容还包括重复消费和状态语义。

接口优先于过窄的类型筛选关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
成员测试可消耗单次迭代来源

对单次迭代器做in测试可能沿途消费,查找失败还可能耗尽来源。intersect对第二来源反复使用in,因此即便文件等支持迭代,也未必具有可重复成员查询的语义。可按需求重新取得来源、重置可定位流或物化可重用容器,并评估代价。

多次in检测仍要求其他来源的成员测试语义可重复;把单次迭代器直接套入这组算法可能因消费进度出错。零来源时本例intersect访问args[0]失败,而union返回空列表,也需分别定义接口。

成员测试可消耗单次迭代来源保存独立卡片。

原书依据 · 2 处
本地变量

本地名称与由它引用的对象具有不同寿命。

返回对象不依赖本地名称继续存在

intersect的参数名、循环目标x与res通常属于本次调用的本地绑定。函数返回res引用的列表后,调用者可继续持有列表,不要求本地名称res继续可见;对象是否存活取决于仍存在的引用,不能把离开函数说成其所有对象必定立即销毁。

返回对象不依赖本地名称继续存在保存独立卡片。

原书依据 · 1 处

本章小结

函数定义、调用、返回、协议兼容与本地状态形成基本模型。

本章习题

五道题检查复用、创建时点、默认结果、函数体执行和类型检查。

习题解答

答案重申运行def才创建、调用才运行普通函数体,以及协议导向复用。

接口灵活不取消业务校验关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处

第17章 作用域

名称按作用域查找,赋值则决定它归属哪一层。闭包可保留外层绑定的访问路径,但保留不是把创建时的值自动冻结;global与nonlocal又各自选择修改的命名空间。先确定谁拥有状态,再解释调用之间为何共享或隔离,才能避免回调和计数器中的误判。

作用域说明名称在哪里绑定和查找,也是控制依赖的重要工具。

Python作用域基础

名称绑定位置决定其可见范围,函数调用位置不改变词法环境。

词法位置决定名称所属作用域

函数使用的名称由定义所在的词法结构决定查找环境,不会因为换一个调用者就自动读取调用者的局部变量。模块X与函数内同名X可以是不同绑定;这种隔离减少名称冲突,却不阻止两处名称引用同一可变对象。

modb调用moda.f时,f中的global X仍关联moda的绑定,modb自己的X不自动成为其外层环境。导入链和调用链都不会让普通裸名称向调用者查找;若要显式使用外界对象,应通过参数或引用提供。

otherfile.py中另设X=66不会改变manynames.f对其定义模块X=11的读取。函数使用的全局命名空间来自定义所属模块,而非调用者或导入者当前绑定;显式修改定义模块属性或使用声明的写入另论。

词法位置决定名称所属作用域保存独立卡片。

原书依据 · 3 处
作用域法则

模块全局、本次调用的局部绑定与对象修改有不同边界。

形参绑定不等于复制实参对象关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
全局名称属于定义所在模块

Python通常以模块划分全局名称空间;函数的global指向其定义模块,不代表所有文件共用一份名称表。交互代码通常在main模块环境中运行,其他模块也有各自绑定;跨模块访问通常通过模块对象属性。

示例用global var、thismod.var和sys.modules中的已载入模块引用操作同一模块状态。关键是取得相同模块对象;直接作为main运行再按普通名导入可能得到不同模块身份,不能无条件推断任意自导入都修改当前脚本对象。

全局名称属于定义所在模块保存独立卡片。

原书依据 · 2 处
每次普通调用有独立局部绑定

普通函数每次调用建立本次局部绑定,参数、局部赋值、for目标以及import/def绑定都可属于它。递归调用也有各自状态,不是所有调用共用一个局部变量表;但共享引用、闭包等仍能共享对象或状态。

示例X和func由模块顶层绑定;func(Y)中的参数Y与Z=X+Y的Z属于本次调用,读取模块X无需global。局部名称不会冲突,不保证通过共享对象产生的效果也与外界完全隔离。

classtree每次递归调用都拥有本次cls与indent绑定,父调用在递归返回后继续遍历其他基类。独立绑定不保证对象被深复制;共有基类可能沿不同路径被多次访问,极深图也仍受递归资源限制。

每次普通调用有独立局部绑定保存独立卡片。

原书依据 · 3 处
变量名解析:LEGB原则

LEGB规定普通函数裸名称的查找方向,属性访问另有规则。

作用域规则

普通函数中的裸名称按局部、封闭函数作用域由近到远、定义模块全局、内置的层次解析,找到对应绑定后停止。当前函数内有绑定操作的名称通常认定为局部,读到未赋值局部不会继续向外借值;global与nonlocal可以明确绑定范围。该规则不等于obj.name的属性查找,也不表示按调用栈查调用者变量。

LEGB中的E是词法上包围当前函数的函数作用域,可有多层,不是运行时调用者的局部环境。旧版本发展史仅作背景,不把嵌套函数视为现代代码中必然罕见的坏实践。

函数中对裸名称赋值通常使其归属当前局部作用域,global可指向模块绑定,nonlocal可指向已有的外层函数绑定。引用遵循局部、外层函数、模块及内置规则,不能把类体或所有特殊作用域无条件照搬成同一种LEGB情形。这里“如果赋值就不是全局变量”必须连同声明例外理解。

作用域规则保存独立卡片。

原书依据 · 3 处
属性查找不同于裸名称解析

spam是裸名称,适用相应作用域规则;object.spam先解析object,再按对象属性机制查spam,可能涉及类型和继承。查不到属性不能简单地继续到模块或builtins搜索同名变量;应先分清表达式属于哪种查找。

交互环境的main.X显式读取模块属性,可与当前函数的本地X并存。这里先解析模块对象再取其X,不是让一个裸名称同时有两种作用域。

X.Y.Z先解析X,再取X对象的Y,然后在所得对象取Z;后两步不按LEGB逐层找同名变量。所得对象可以是模块、函数或实例等,属性可能可调用也可能只是数据,不能把点路径当函数调用或文件系统路径。

X在代码作用域中解析,obj.X则先求出obj,再按该对象属性协议访问X;模块与类定义中的执行作用域可以初始化对象属性命名空间,但这不代表所有点号访问都遵循LEGB,或方法裸名称会自动搜索类属性。

obj.X先确定接收对象,再按其属性规则读取或写入X。对普通实例数据赋值可建立自身绑定,但描述符、setattr等可能引入其他行为;不能把“并没有其他作用”视为任何对象都成立的保证。模块对象也有自身属性规则,而非名称点号后继续执行LEGB。

属性查找不同于裸名称解析保存独立卡片。

原书依据 · 5 处
作用域实例

同一示例能同时含模块绑定与调用局部绑定。

每次普通调用有独立局部绑定关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
内置作用域

内置名称可被近处绑定遮蔽,应显式区分内置模块与实现细节。

内置名称遮蔽不等于改写内置对象

在函数中把open绑定为字符串,会遮蔽该函数对内置open的裸名称访问,却未改写builtins.open本身。需要显式访问原内置函数时,可import builtins后使用builtins.open;偶然遮蔽会让后续调用失败,名称选择需避免误导。

内置名称遮蔽不等于改写内置对象保存独立卡片。

原书依据 · 1 处
内置模块不同于隐式内置映射

Python3显式访问内置命名空间使用builtins,Python2历史名称是builtin。builtins则是实现细节,可能是模块或字典,不能依赖它总与builtins是同一对象;普通内置名称调用通常不要求先导入builtins。

内置模块不同于隐式内置映射保存独立卡片。

原书依据 · 1 处

global语句

global调整函数内名称读写的命名空间,不是类型声明。

作用域声明选择名称绑定位置关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
最小化全局变量

共享全局状态让函数行为依赖调用顺序,理解成本向整个程序扩散。

共享全局状态隐藏调用顺序依赖

多个函数改写同一全局X时,只看某一个函数通常不能知道随后X的值,必须追踪之前谁修改过它。能用参数和返回值表达的数据流应尽量显式表达;确需持久状态时,也应明确责任、修改入口和并发协调。

参数与返回值把主要依赖集中在可见接口中;全局、跨模块修改和I/O则可能把依赖藏在外部。不是所有副作用都应消除,实例状态更新等若属于明确契约就可合理存在,关键是让边界可理解。

共享全局状态隐藏调用顺序依赖保存独立卡片。

原书依据 · 2 处
最小化文件间的修改

模块对象属性可被其他模块修改,封装入口让这种变化更可见。

共享状态修改入口应明确

import first后可改first.X,这会改变模块对象的属性,而非仅改当前模块私有副本。把修改放进first.setX(new)之类明确入口,可让维护者发现哪些操作负责变化,并集中校验;函数包装本身仍不自动保证线程安全或禁止外部直接赋值。

本地x重绑不回写small.x;通过模块引用写small.x才修改该模块属性。取得模块引用未必只能用一条import,也可由参数等提供;核心是明确修改的是哪个对象。对共享列表的索引修改与名称改绑仍不同。

读取外部提供的接口与直接改写外部全局绑定有不同耦合效果。必要状态修改应由有责任的接口表达,不能只因模块可访问就到处赋值;函数调用也可能有副作用,仍需说明契约。

共享状态修改入口应明确保存独立卡片。

原书依据 · 3 处
其他访问全局变量的方法

global与模块属性访问可以指向同一已导入模块绑定。

全局名称属于定义所在模块关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处

作用域和嵌套函数

封闭层来自源代码中包围当前函数的函数定义。

作用域规则关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
嵌套作用域的细节

读取封闭绑定与改绑该绑定有不同声明要求。

作用域声明选择名称绑定位置关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
嵌套作用域举例

闭包延续封闭绑定,工厂调用和默认参数捕获又有各自时点。

定义函数与执行函数体分开关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
闭包可在外层返回后保留绑定

内层函数引用词法外层的名称,返回后仍可通过该函数使用相应绑定,这种函数与保留环境构成闭包。外层执行结束不要求相关状态全部销毁;返回函数对象不同于当场调用它。

action=lambda x:(lambda y:x+y)的外层调用创建保留x的内层函数,第二次调用才传y并求和;def和lambda都可构造这种闭包。叠写多次调用虽然短,若读者难以分辨创建和执行层次应改为具名步骤。

原文称局部名称只在调用执行期间存在,是普通调用的简化。外层绑定若由闭包等保持可在调用返回后继续存在;不能把函数外不能用g.X读取局部变量,误作所有局部关联对象都会立即销毁。

闭包可在外层返回后保留绑定保存独立卡片。

原书依据 · 3 处
工厂调用可生成独立闭包状态

maker(N)每次调用生成引用本次N的action(X),因此maker(2)与maker(3)可分别计算平方和立方。独立的是调用建立的绑定;若两次N引用同一可变对象,内部数据仍可能共享,不能把工厂调用等同于深复制。

tester(0)和tester(42)各自建立计数绑定,nonlocal更新所属绑定,因此两组调用可以独立递增。独立绑定不保证起始对象绝不共享:若传入可变引用,还须核对对象语义,不能照搬每次必有全新对象的措辞。

工厂调用可生成独立闭包状态保存独立卡片。

原书依据 · 2 处
闭包读取绑定不冻结创建时值

在同一循环中创建多个lambda并引用循环变量i,若在循环结束后调用,它们通常都读取最终i;创建多个函数对象不自动保存每轮快照。闭包保留的是可随后变化的绑定,回调执行时点会影响观察结果。

lambda也有局部参数和词法封闭环境,能读取外层绑定并使用默认参数。它遵循与相应函数相同的迟绑定边界,不因写得短就自动保存创建时的所有外层值。

若循环完再调用各闭包,它们通常读取循环变量最终值;若在循环推进前就调用,则所见可能不同。需要每轮保留当前对象时可用默认参数等显式捕获,不能把所有回调任意时点都简化成永远只取最后值。

闭包读取绑定不冻结创建时值保存独立卡片。

原书依据 · 3 处
默认参数在定义时取得对象

lambda x,i=i把定义该函数时求得的当前i放入该函数默认参数,后续未传i时使用它,可区分循环产生的回调。它捕获对象引用而非深拷贝,可变默认对象仍可能在调用间共享,调用者显式传参也能覆盖默认值。

示例def print30(…,file=sys.stdout)在定义时取得输出对象,后来重绑sys.stdout不会自动改变该默认。原版在函数体kargs.get时才读取sys.stdout,两版不能在所有重定向情境下一概称为等价;需要动态默认时可显式设计延迟解析。

默认对象与函数定义关联保存,改变它会影响后来使用该默认的调用。显式传参可选择其他对象;为状态延续而故意用可变默认也应说明共享边界,不能只把它当自动每次初始化。

默认参数在定义时取得对象保存独立卡片。

原书依据 · 3 处

nonlocal语句

nonlocal让内层函数改绑已有封闭函数名称。

作用域声明选择名称绑定位置关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
nonlocal基础

global与nonlocal分别明确模块和封闭函数的改绑目标。

作用域声明选择名称绑定位置关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
nonlocal应用

名称被局部赋值判定后,较早读取也不能自动回退到外层。

工厂调用可生成独立闭包状态关联本项背景,实质主要讲解在对应位置。

作用域声明选择名称绑定位置关联本项背景,实质主要讲解在对应位置。

原书依据 · 8 处
局部未赋值读取不会向外回退

nested内写state+=1会把state认定为局部绑定,前面的print(state)因本地尚未有值而触发UnboundLocalError,尽管外层有同名state。需要改绑外层计数时用nonlocal;只调整语句顺序不能表达原本的共享状态责任。

函数内后面出现X=88,也足以使前面的裸X读取按局部名称处理并因未绑定失败,不会先借用模块X。global可选择模块绑定,却也改变后续赋值目标;若要同时访问两者可显式写模块属性,避免模糊责任。

局部未赋值读取不会向外回退保存独立卡片。

原书依据 · 2 处
为什么使用nonlocal

跨调用保留状态有多种组织方式,选择取决于共享范围和访问接口。

函数对象可通过别名传递调用关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
状态保留方式决定共享边界

跨调用状态可以放在不同位置,各自改变可见性和共享范围。

方式 共享和访问边界
模块全局绑定 多个函数或工厂结果可能共用,重新初始化会互相影响
闭包与nonlocal 每次工厂调用可有独立绑定,由闭包操作
实例属性 状态通过self显式访问,可由方法封装
函数属性 状态挂在函数对象上,也可从外部经属性访问

独立对象仍可能引用共享的内部数据;任何方式都不自动提供并发协调。

闭包、默认参数、全局和对象属性都可延续状态,但对象保留不等于本地名称从此全局可见。根据期望共享范围选择,并确认重置或改绑会影响哪些调用。

状态保留方式决定共享边界保存独立卡片。

原书依据 · 2 处
实例调用可映射到调用方法

类可以定义call(self,label),使实例H(label)按该协议执行,而不要求用户写H.nested(label)。这让带实例状态的对象提供函数式调用入口;可调用不等于它就是普通函数,也不意味着其状态对外绝对不可见。

实例call可按普通函数签名接收位置、关键字、默认和仅关键字参数;C的几种签名是替代方案,不能保证任意一种都接受示范中的全部形式。调用语法仍需匹配具体签名,*args/**kwargs也不自动取消重复参数等检查。

实例调用可映射到调用方法保存独立卡片。

原书依据 · 2 处

本章小结

作用域规则与设计边界共同决定函数可维护性。

本章习题

六组X代码检查读写位置,第七题检查状态组织方式。

习题解答

答案区别局部、全局和nonlocal改绑的可观察结果。

状态保留方式决定共享边界关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处

第18章 参数

实参怎样提供与形参怎样接收是相互配合的两侧。位置、关键字、默认值和可变参数决定绑定规则,实际对象仍按引用传递。默认对象的创建时机与可变性会影响多次调用,所谓通用包装也必须保留目标接受参数和返回结果的契约。

参数传递关注对象绑定,后续匹配规则关注实参对应哪个形参。

传递参数

可变与不可变参数都通过相同的对象绑定机制传递。

形参绑定不等于复制实参对象关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
参数和共享引用

名称改绑与索引赋值在共享对象上产生不同结果。

形参绑定不等于复制实参对象关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
避免可变参数的修改

控制副作用需先确认API是否承诺修改输入,拷贝还要分层次。

浅拷贝仍共享内部对象关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处
参数防护须符合修改契约

避免被调函数影响输入时,可在调用端或函数内部建立副本,但先确认接口是否本来就承诺原处修改。若调用者依赖该修改,悄悄换副本会违反契约;选定职责后再决定返回新对象还是修改传入对象。

避免调用者不知情的输入修改;若更新共享对象正是接口责任,应清楚说明,而非为追求表面自包含悄悄丢掉必要效果。封闭状态也能延续信息,不能把全局说成不用类就唯一或总是最佳方案。

参数防护须符合修改契约保存独立卡片。

原书依据 · 2 处
对参数输出进行模拟

多个逻辑结果可打包成一个对象,由调用者显式接收。

解包按位置分配可迭代对象关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
多结果返回由调用者显式改绑

return x,y返回一个元组对象;调用者用X,L=func(…)解包并改绑自己的名称。函数内部并没有因返回就直接改绑调用者变量,因此可清楚表达输入和结果,也不依赖原处修改来模拟输出参数。

返回对象、原处修改共享输入、修改模块状态和外部I/O都是可能的通信通道。优先让输入与结果在接口中清楚可见,副作用则在契约中说明;全局变量不因线程场景就自动成为必要方式。

多结果返回由调用者显式改绑保存独立卡片。

原书依据 · 2 处

特定的参数匹配模型

实参到形参的匹配方式多样,绑定底层仍是对象引用。

参数匹配不同于对象传递机制

位置、关键字、默认值和额外参数收集决定哪个对象交给哪个形参;匹配完成后仍是形参绑定对象,不因改用关键字就自动复制或改变可变性。排查问题应分开看匹配是否正确与被调函数如何使用共享对象。

参数匹配不同于对象传递机制保存独立卡片。

原书依据 · 1 处
基础知识

调用者可按位置或名称传值,定义者可提供默认与参数类别。

关键字标签属于形参接口

f(name=value)按形参名匹配对象,能提高调用可读性并避免部分位置歧义。名称因而成为可见接口的一部分;重命名被关键字使用的形参会影响调用者,且并非所有参数都允许关键字传递。

name、age、job等清楚的形参名可让关键字调用传达参数含义;关键字只确定绑定,不会保证值域、单位或业务规则正确,仍需接口约定。

GUI按钮等选项多时,按名称提供所需项比长串位置占位更明确。sorted的key与reverse等是配置入口,key指投影比较键而非只能对字典排序;具体可接受方式仍以其签名为准。

关键字标签属于形参接口保存独立卡片。

原书依据 · 3 处
仅关键字参数须按名称传入

定义中位于*args或独立*之后的形参是keyword-only,只能用名称传值。它们适合需要明确标签的配置项;有默认值才可省略,无默认值的仅关键字参数仍是必填。

def process(*args,notify=False)把所有位置项作为处理数据,notify只能按名称指定并可默认False。独立*可声明仅关键字区而不接收多余位置项;同一区内可同时有必填和可选参数。

_reps写成仅关键字形参可让配置界面更明确,省去手工pop;这解决声明与匹配便利,不能自动消除与目标关键字冲突,也不改变目标本身的调用契约。

仅关键字参数须按名称传入保存独立卡片。

原书依据 · 3 处
匹配语法

相同符号在定义和调用两个位置承担相反方向。

参数收集与调用展开方向相反

def f(*args,kwargs)将额外位置参数收进元组、额外关键字参数收进字典;f(*items,options)则把来源展开为单独实参。名字args、kwargs是惯用名,不是关键字。收集的是对象引用,不会复制每个参数内部内容。

def中的*args把未匹配的位置项收进元组,**kwargs把未匹配关键字收进新字典,空时也各有对应空容器。调用的*接受可迭代对象,而赋值解包中的星号目标收列表;相似符号不保证相同结果容器。

定义头中仅关键字形参必须在*或*args后、kwargs前;调用处则是在关键字绑定阶段提供值,既可显式写notify=,也可经映射传入。两种语法位置不能混为一套排序规则。

factory(aClass,*args,kwargs)先收集调用方的实参,再展开给目标。kwargs不修复重复关键字、未知参数或位置/关键字冲突;零参数可适用于没有必需构造参数的目标。

参数收集与调用展开方向相反保存独立卡片。

原书依据 · 4 处
默认值只补未提供的参数

def f(a,b=2)给未提供b的调用使用默认值;f(b=value)则是在调用端按名字传值。显式传None、0或空字符串仍算提供了值,不因是假值就自动替换为默认;两处name=value都不是给调用者同名变量赋值。

对f(a,b=2,c=3),f(1,c=6)显式给a和c,b使用默认2;关键字可跳过中间可选项,却不能跳过仍无默认的必填参数。def中的默认与调用中的名称匹配不同,结果仍由函数体决定。

本例name必传而job与pay有默认值;同一段位置参数定义中,有默认值的参数后不能再放无默认值的位置参数。该规则不能扩大为所有形态参数都需如此,例如仅关键字参数允许具有不同的默认值安排。None与0是此教学模型的约定,并非现实人员状态的通用业务规则。

默认值只补未提供的参数保存独立卡片。

原书依据 · 3 处
细节

匹配应保证必填参数有值、一个参数不被重复赋值,并区分新旧语法。

调用匹配拒绝重复和缺失绑定

调用先按位置填充可接受位置的形参,再把关键字匹配到相应名称,并用默认值补遗漏项;额外参数仅在对应收集器允许时接收。对同一形参同时按位置和名称给值会报错,不能像字典更新一样用后值覆盖;缺少必填参数也会失败。

调用匹配拒绝重复和缺失绑定保存独立卡片。

原书依据 · 1 处
调用顺序限制须区分版本

旧书把调用中的展开必须放最后描述为通则;Python3.5起允许多次*和展开,以及后继续显式关键字。语法仍有限制,例如普通位置项不能写在显式关键字之后,*展开不能放在展开之后。定义头与调用表达式应分别判断,不能共用一张旧版顺序表。

原图把展开后出现c=7列为语法错误,对应Python3.0语境;现代Python3.5起允许这种调用顺序。定义头的kwargs仍位于形参列表末端,不能用现代调用泛化去放宽定义语法。

897所述位置/关键字、无默认/有默认的先后约束应保留旧版上下文,不扩为现代所有解包及仅关键字参数形式的统一规则。这里使用的普通位置形参例足以解释简化切片算法,不据此生成通用签名解析器。

调用顺序限制须区分版本保存独立卡片。

原书依据 · 3 处
关键字参数和默认参数的实例

关键字能明确选择覆盖哪个可选参数,默认值保留其他项。

默认值只补未提供的参数关联本项背景,实质主要讲解在对应位置。

关键字标签属于形参接口关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
任意参数的实例

任意参数收集和展开让包装器可转发调用,但不取消目标签名限制。

参数收集与调用展开方向相反关联本项背景,实质主要讲解在对应位置。

星号调用会消费可迭代参数关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
关键字展开须满足映射契约

f(**options)把映射条目展开为关键字实参,键必须是字符串。目标函数仍要接受这些关键字,重复给同一形参赋值会失败;它不是把整个字典作为一个位置参数传入,也不同于构建字典时重复键后值覆盖。

关键字展开须满足映射契约保存独立卡片。

原书依据 · 1 处
通用转发仍应保留调用结果

包装器可用def tracer(func,*args,kwargs)接收目标及实参,再return func(*args,kwargs)转发并交还结果。只调用目标却不return会把正常结果丢成None;通用打包也不证明参数符合任意目标签名,错误仍需按接口处理。

通用转发仍应保留调用结果保存独立卡片。

原书依据 · 1 处
Python 3.0 Keyword-Only参数

仅关键字选项让可变位置数据与控制配置明确分开。

仅关键字参数须按名称传入关联本项背景,实质主要讲解在对应位置。

参数收集与调用展开方向相反关联本项背景,实质主要讲解在对应位置。

调用顺序限制须区分版本关联本项背景,实质主要讲解在对应位置。

原书依据 · 10 处
min调用

变参可接收若干候选值,但最小值比较仍须有一致顺序。

极值接口须规定可比较范围

通用min样例可以用*args接收若干候选,但候选之间必须支持所需比较。现代Python不会给任意对象自动建立总顺序,例如数字和None、字典或不支持有序比较的实例组合可能失败;动态类型与参数数量灵活不取消比较前提。

adder通用化仍受+操作支持和输入值域约束,字典不因都是容器就支持加法;以首项或适当初值归约要说明空输入。多种调用匹配形式不改变对象传递机制。

极值接口须规定可比较范围保存独立卡片。

原书依据 · 2 处
满分

线性扫描维护当前最小项,排序则计算更完整的顺序。

非空极值扫描维护当前最优项

以首项作为当前最小值,逐个比较其余候选并在更小时替换,就能得到非空输入的最小项。这样无需假设一个适用所有类型的数值初始哨兵;接口仍须明确空输入如何报告,以及元素是否可比较。

内置min/max可接收单个可迭代来源或多个候选位置参数,日常使用应优先核对现成接口。这里的自写版展示变参和遍历机制,不是另建生产实现或声称与所有内置选项完全等价。

非空极值扫描维护当前最优项保存独立卡片。

原书依据 · 2 处
求极值不必为全部元素排序

只需最小项时,单次扫描做线性数量的比较;先复制成列表再排序取得首项会完成额外的排序与物化工作。实际速度还受内置实现、数据已有顺序和比较成本影响,不能只凭C实现就保证更快。Python排序是自适应归并路线,原书称其指数型并不正确。

求极值不必为全部元素排序保存独立卡片。

原书依据 · 1 处
空输入失败应有明确接口语义

允许多种元素类型的极值接口不宜随意把某个普通元素当作失败哨兵。可以规定空输入抛出明确异常,或设计有区分的结果形式;依赖偶然索引越界虽会失败,却可能让错误含义不清。库接口应把非空前提和失败形式讲清。

空输入失败应有明确接口语义保存独立卡片。

原书依据 · 1 处
加分点

把比较动作作为参数,可共享极值遍历骨架。

策略函数可参数化比较规则

minmax(test,*args)负责遍历并维护当前候选,test(arg,res)负责判断新项是否更合适。传小于或大于比较可复用同一遍历实现;策略仍须与数据和目标一致,不因可调用就保证满足排序或选择规则。

策略函数可参数化比较规则保存独立卡片。

原书依据 · 1 处
结论

内置极值函数已提供常用能力,自写版本的价值在展示复用模式。

非空极值扫描维护当前最优项关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处

一个更有用的例子:通用set函数

多来源共同项筛选与去重合并仍须保持各自结果语义。

筛共同项不等于集合交集关联本项背景,实质主要讲解在对应位置。

成员测试可消耗单次迭代来源关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处

模拟Python 3.0 print函数

print30用变参演示输出协议,演示接口与内置接口仍有差别。

演示原型不保证完整接口兼容

print30先str化各位置项,按sep连接并添加end,再调用目标file.write;这展示变参与流式接口配合,却不等于完整复刻内置print。示例未同样处理所有None选项等边界,并且先建立完整输出字符串;判断可替代性需按实际接口契约核对。

自写myreduce直接sequence[0]和切片,因而要求相应序列操作,不具备内置reduce对一般可迭代来源的全部适用范围。教学模拟需要标明差异,不能仅因常见列表输出一致就认定接口等价。

演示原型不保证完整接口兼容保存独立卡片。

原书依据 · 2 处
使用Keyword-Only参数

显式配置形参能拒绝未知选项,默认对象求值时点也影响行为。

默认参数在定义时取得对象关联本项背景,实质主要讲解在对应位置。

关键字标签属于形参接口关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
配置接口应拒绝未知选项

用**kwargs接收选项后只get已知键,会让拼错的选项被忽略,调用者误以为设置生效。显式仅关键字形参可由调用匹配拒绝未知名;也可从选项字典pop合法项后检查剩余键。开放扩展与严格校验应由接口明确选择。

配置接口应拒绝未知选项保存独立卡片。

原书依据 · 1 处

本章小结

参数匹配与共享引用共同决定调用行为。

本章习题

五道调用题检查位置、关键字、收集和展开。

习题解答

答案展示不同匹配规则和返回通道。

多结果返回由调用者显式改绑关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处

第19章 函数的高级话题

递归把问题分解交给相同函数,lambda和其他函数工具则让计算可作为对象传递。高阶使用仍需明确状态、终止和参数接口。注解能携带元信息,却不会仅凭语法自动完成类型验证;归约和极值工具也需要说明空输入及初始值的边界。

本章把函数对象能力与设计原则接在基本调用模型之上。

函数设计概念

职责与依赖比单看函数长度更能说明设计质量。

共享全局状态隐藏调用顺序依赖关联本项背景,实质主要讲解在对应位置。

参数防护须符合修改契约关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
函数聚合围绕单一清楚目标

一个函数最好能用简短说明讲清一个统一目标;若把多个可独立复用的任务揉在一起,修改和理解会相互牵连。长度与深层嵌套可提示需要拆分,但不是固定行数判据,拆分仍应保留完整责任和清楚接口。

小且只在该处使用的动作可内联lambda;有清楚领域含义、复杂逻辑或多处复用时,命名def通常更便于理解。减少临时名称不是消除所有冲突或提高性能的保证。

函数聚合围绕单一清楚目标保存独立卡片。

原书依据 · 2 处

递归函数

递归以直接或间接的自调用处理结构,仍需终止策略。

递归必须有终止与缩减条件

函数直接或通过其他函数再次调用自身就是递归。每层应处理更小的子问题并朝可终止的边界推进,否则会持续产生调用。它适合与递归结构对应的任务,但简单线性遍历通常不必用它替代循环。

mysum调用nonempty、后者再调用mysum构成间接递归,仍须靠缩短尾部和空表基例终止。判断递归不能只搜函数体内是否写了自身名称,要看调用关系是否回到原函数。

递归必须有终止与缩减条件保存独立卡片。

原书依据 · 2 处
用递归求和

列表求和的基例是空表,递归步把首项与剩余之和合并。

递归调用先下降再合并结果

mysum(L)在空表返回0,非空时求L[0]+mysum(L[1:])。每层等待较短尾部返回,之后逐层合并加法结果;不同调用有各自局部L绑定。列表切片还会创建新列表,因此不能只按元素相加次数判断全部开销。

递归调用先下降再合并结果保存独立卡片。

原书依据 · 1 处
编码替代方案

更换基例能拓展可加类型,却改变空输入契约和物化行为。

递归必须有终止与缩减条件关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
归约初始值决定输入边界

以0作空序列和的基例适合相应数值加法,却不能直接支持字符串拼接。用唯一剩余项作基例可支持更多兼容的+操作,但需要非空输入。泛化运算时应同时说明初始值、空输入和结合顺序,而非仅去掉类型检查。

946的02584-02586以首个实参初始化再累加其余项,避免手工为每种类型造空值;但args[0]仍要求至少一项,空调用未处理。首版将非int假定为可切片序列,对float也不成立;两版只在加法可组合的输入上有意义,不能把“混合类型都不能加”当通则。关键字版本的累加次序也应符合目标操作,不假定任意操作交换律。

归约初始值决定输入边界保存独立卡片。

原书依据 · 2 处
星号解包可迭代不等于惰性

first,*rest=L可从可迭代来源取得元素,但会把余项收集为列表,输入仍须至少一项且能够完成消费。递归再处理rest也会建立新容器;可接受文件等来源并不意味着按需输出或恒定内存。

星号解包可迭代不等于惰性保存独立卡片。

原书依据 · 1 处
循环语句VS递归

线性累积用循环可避开每项一层函数调用,但循环体也须看开销。

线性累积优先直接遍历

单纯逐项累加通常可直接for遍历,避免递归每项建立调用状态的成本。原例while每次L=L[1:]仍会复制尾部,不能只因换成循环就认定没有额外分配;对具体实现分析,比按语法形式宣称绝对性能更可靠。

线性累积优先直接遍历保存独立卡片。

原书依据 · 1 处
处理任意结构

不规则嵌套结构可沿子结构递归,但应限定叶子类型和无环前提。

嵌套遍历须识别子结构与叶子

sumtree遍历列表:遇子列表递归求和,遇数值叶子累加。递归层数对应结构深度,因而无需事先写固定数量的嵌套循环;输入仍须满足叶子可加、结构可终止等前提。循环引用或过深嵌套需要额外处理,不能以任意形状承诺无限安全。

嵌套遍历须识别子结构与叶子保存独立卡片。

原书依据 · 1 处
显式待办栈可替代递归调用栈

递归保存尚未完成的子问题,显式栈也可保存这些待办节点,再由循环逐项处理。因此固定层数的朴素嵌套循环不适合未知深度,不等于任何循环算法都无法遍历;选择时应考虑可读性、深度和状态管理。

显式待办栈可替代递归调用栈保存独立卡片。

原书依据 · 1 处

函数对象:属性和注解

函数既可调用,也可作为携带元信息的普通对象处理。

间接函数调用

保存函数对象让动作选择和动作执行可以分离。

函数对象可通过别名传递调用关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
函数内省

函数内省能显示结构,但代码对象字段不等于稳定完整调用契约。

函数代码内省要核对字段含义

用户函数可通过name、code等属性检查部分结构。代码对象co_varnames可能同时含参数和局部变量,不能把整份清单都当形参;co_argcount也不代表所有参数类别的总数。工具应根据目标版本和所需语义选择内省接口,而非只凭字段名猜测。

函数代码内省要核对字段含义保存独立卡片。

原书依据 · 1 处
函数属性

函数属性能直接持久保存信息,可见性取决于函数引用。

函数对象可通过别名传递调用关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
Python 3.0中的函数注解

注解附加接口信息,默认值给遗漏参数提供对象,两者职责不同。

函数注解不自动执行类型校验

def中的参数注解写在名称后冒号处,结果注解在箭头后;它们描述额外接口信息,Python不会仅因写了int就自动校验或转换实参及返回值。工具或装饰器可以另外解释注解,何时检查取决于那层机制,不能把注解本身当业务验证。

习题中的注解字典模型是旧版说明,注解本身不自动强制业务类型,但其他工具可解释并校验。现代版本的注解求值时点另有变化,不能把元信息概括成任何访问都毫无动作。

899的02462-02466将rangetest(a=(1,5),c=(0.0,1.0))换成参数注解中的元组,包装器再读func.annotations。两段代码的验证循环都是pass,输出字典与6只证明取得配置并调用目标,没有实现范围拒绝。注解版少一层保存配置的工厂,但仍需实参名称定位。作者把单个注解表达式的多用途冲突作为取舍,不代表技术上禁止组合元数据;这里按旧版语义说明,不能将其当现代完整注解工具。

函数注解不自动执行类型校验保存独立卡片。

原书依据 · 3 处
注解默认值与求值时点要区分

a:SomeType=value中的注解与默认值分别提供信息和遗漏时使用的对象。原书Python3.0的注解表达式立即求值;现代行为需按版本及future设置区分,Python3.14默认延迟求值。读取或解析未知注解可能执行代码,不应从只看元数据推断无副作用。

注解默认值与求值时点要区分保存独立卡片。

原书依据 · 1 处

匿名函数:lambda

lambda表达式产生函数对象,执行函数体仍需调用。

匿名函数表达式不等于立即执行

lambda表达式计算得到一个函数对象,可传入其他调用、放进容器或绑定名称;其函数体要等该对象被调用才执行。匿名只是不用由def直接命名,也可把返回对象赋给变量,并不代表函数无法被引用或复用。

匿名函数表达式不等于立即执行保存独立卡片。

原书依据 · 1 处
lambda表达式

lambda用单个表达式描述返回结果,仍具有参数和词法环境。

闭包读取绑定不冻结创建时值关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
匿名函数体限于单个表达式

lambda参数列表后是一个表达式,其求值结果成为返回值;不能在函数体写多条普通语句。可以使用条件表达式等表达式形式,但复杂流程更适合def,以便清楚命名、分步表达与编写文档。

条件表达式可用于lambda,Python3中的print也是函数调用表达式,可直接调用;原书必须改用sys.stdout.write是旧print语句语境遗留。复杂循环和多步副作用可用def清楚表达,不必先构建一份只为触发副作用的列表。

匿名函数体限于单个表达式保存独立卡片。

原书依据 · 2 处
为什么使用lambda

动作表保存可调用对象,查表后只执行所选动作。

函数聚合围绕单一清楚目标关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
动作分派表延迟执行所选函数

把lambda或已定义函数放入字典,可先按键选出动作,再用括号调用。构建表时创建或取得函数,通常不执行它们的函数体;若把调用结果放进去,则会提前执行。它适合简单键到行为的映射,还须决定未知键的处理方式。

动作分派表延迟执行所选函数保存独立卡片。

原书依据 · 1 处
如何(不要)让Python代码变得晦涩难懂

表达式能容纳选择与函数调用,但不应为了lambda强行隐藏多步流程。

匿名函数体限于单个表达式关联本项背景,实质主要讲解在对应位置。

与或组合不等价任意条件选择关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
嵌套lambda和作用域

回调可借闭包延迟把事件关联到实例方法。

闭包可在外层返回后保留绑定关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
闭包回调连接实例方法

按钮的command可保存一个无参lambda,等事件触发时再调用self.onPress(message)。闭包捕获可取得的self绑定,让回调关联到该实例;不是创建按钮时就执行onPress。示例只展示按钮创建依赖与回调调用,没有继承或所有权保证。

结构图: 类图(原文MyGui方法签名;Button为使用到的外部类型,未虚构其完整接口):

classDiagram
class MyGui {
  makewidgets(self)
  onPress(self, message)
}
class Button
MyGui ..> Button : 创建并提供command回调
Button ..> MyGui : 事件经回调调用onPress

闭包回调连接实例方法保存独立卡片。

原书依据 · 1 处

在序列中映射函数:map

map把函数应用到来源的每项,惰性内置与物化自写版有差别。

惰性变换随消费执行关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
多来源映射逐组提供函数实参

map(func,A,B)每次从A、B各取一项作为func的两个位置实参,按来源进度组合,并在最短来源耗尽时停止。它不是自动多线程并行,函数参数数目及输入协议仍需匹配;要检查长度不等须另设契约。

mymap(func,*seqs)可用zip(*seqs)形成每轮参数元组,再func(*args)产结果。返回列表版先完成全部结果;yield或生成器表达式版可按请求产值,仍按最短来源截断且要求至少一个有效来源契约。

多来源映射逐组提供函数实参保存独立卡片。

原书依据 · 2 处

函数式编程工具:filter和reduce

筛选决定保留项,归约按顺序把累计值与下一项合并。

迭代接口不决定消费策略关联本项背景,实质主要讲解在对应位置。

演示原型不保证完整接口兼容关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
归约按顺序更新累加状态

functools.reduce(fn,items)以首项为累计值,之后依次fn(累计值,下一项),得到单个结果;若提供initializer,它先作为累计值,空来源时即为结果。没有initializer的空来源不能凭空推断结果;非结合运算也不能随意调整归约次序。

归约按顺序更新累加状态保存独立卡片。

原书依据 · 1 处

本章小结

高级函数章收束设计、递归、注解及函数式工具。

本章习题

六问检查lambda/def、工具区别、注解、递归与函数设计。

习题解答

答案将函数对象、协议消费和设计责任联成一体。

函数注解不自动执行类型校验关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处

第20章 迭代和解析,第二部分

解析式、生成器和迭代工具让处理过程可以组合,却具有不同的求值时机、重用能力和内存行为。比较性能前必须让各方案完成同样的工作,避免把创建惰性对象与算完所有结果相比。计时框架本身也有成本,旧机器的数字不能代替当前任务的测量。

本章以解析和生成器把表达式处理与按需迭代联系起来。

回顾列表解析:函数式编程工具

列表解析能逐项求任意表达式,不局限于一个既有函数调用。

列表解析组合遍历与转换关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处
列表解析与map

map和解析可得到相似列表,但是否物化及使用的操作要明确。

字符码点不同于数字字符值关联本项背景,实质主要讲解在对应位置。

列表解析组合遍历与转换关联本项背景,实质主要讲解在对应位置。

原书依据 · 11 处
增加测试和嵌套循环

解析把筛选与变换按嵌套上下文组合。

解析筛选先于结果表达式关联本项背景,实质主要讲解在对应位置。

多重解析遵循嵌套循环顺序关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
列表解析和矩阵

矩阵用列表嵌套表示时,索引维度和结果形状须同时辨认。

嵌套解析决定矩阵结果形状

对按行存放的M,M[row][col]先取行再取列。双for写在同一解析中收集为平面列表;把列解析放在行解析里面,才得到每行一个子列表的二维结果。M与N对应位置相乘是逐元素乘积,不是按行列求内积的矩阵乘法。

嵌套解析决定矩阵结果形状保存独立卡片。

原书依据 · 1 处
矩阵投影依赖形状前提

[row[1] for row in M]取第二列,前提是每行都有该位置;[M[i][i] for i in range(len(M))]取主对角时,按此写法还要求每行足够长。嵌套列表本身不保证规则矩形、方阵或两个矩阵形状一致,输入不满足时应明确处理。

矩阵投影依赖形状前提保存独立卡片。

原书依据 · 1 处
理解列表解析

解析的方便性要和输出物化、实际速度以及数据结构契约一起判断。

删行尾前要确认实际终止字符关联本项背景,实质主要讲解在对应位置。

解包按位置分配可迭代对象关联本项背景,实质主要讲解在对应位置。

原书依据 · 10 处
迭代形式性能须按具体工作比较

map、解析和for的耗时取决于表达式、函数调用、数据与解释器版本,不能把旧测试快两倍泛化成语言保证。还应比较是否建立同样结果:只构造惰性map与生成完整列表并不完成同样工作。保持清晰,再对实际任务度量。

同一语法在不同Python版本、硬件和输入上可能表现不同。旧书结果只能说明其测试情境,生成器节省预建输出列表也不意味着状态和输入内存总被最小化;测量应对准真实任务。

旧版abs映射和x+10用户lambda两组计时排名不同,显示每项工作内容会改变比较。不同机器上的绝对时间也不能直接证明版本改进;应在相同条件比较实际代码,而非沿用map或解析恒快的结论。

876及02393-02396对照Python2实际列表map与Python3惰性map,版本分支在3中用list(map(…))确保完成输出列表,2中额外包list反而增加复制。range在Python3是可迭代范围序列而非普通迭代器,准备/存储方式和版本差异也影响比较。1.542为原书2.6特定环境结果,不能据此给当前map/解析排通用名次。

迭代形式性能须按具体工作比较保存独立卡片。

原书依据 · 4 处

重访迭代器:生成器

生成器函数和表达式把结果生成分散到消费请求中。

按需产值推迟计算而非消除计算

生成器不必预先创建完整结果列表,可按请求分步计算并交付,适合只消费部分结果或结果集大的处理。若最终转成list仍须完成全部计算并存放输出;生成器本身保存的状态或大对象也占内存,不保证任意流程恒定内存。

yield把控制显式交回推进它的调用者,不会自动并行执行。生成器可组织协作式步骤,但单次结果的耗时、内部累积状态和外部阻塞操作仍需设计;不把内存及性能更好当无条件保证。

生成器表达式不预先建立完整结果列表,但最左for的可迭代来源表达式会立即求值并建立迭代入口,不能说创建时完全没有动作。sorted最终仍需收集排序;sum等可逐项累计,消费工具不同,整体资源行为也不同。

先把每个来源list化再yield元组,只延迟输出而没有保留输入的流式消费;无限来源无法完成物化。长度/索引版又要求有len和索引,不能称所有可迭代对象通用;生成器表达式的最左来源表达式也可能在创建时就求值。

按需产值推迟计算而非消除计算保存独立卡片。

原书依据 · 4 处
生成器函数:yield VS return

生成器把函数执行分成创建、推进、暂停和终止,且允许向暂停点传值。

迭代协议关联本项背景,实质主要讲解在对应位置。

按需产值推迟计算而非消除计算关联本项背景,实质主要讲解在对应位置。

原书依据 · 17 处
生成器暂停保留执行状态

调用含yield的生成器函数通常先取得生成器对象;推进时才运行其主体,yield交出一项并保留局部绑定和执行位置,下次推进从暂停点继续。正常结束后不会因再次iter就重启。

结构图:

stateDiagram-v2
  [*] --> 已创建: 调用生成器函数
  已创建 --> 执行中: next或sendNone
  执行中 --> 已暂停: yield交出结果
  已暂停 --> 执行中: next或send恢复
  执行中 --> 已结束: return或到达末尾
  已结束 --> [*]

图只展示正常产值路径;异常、throw和close需要另看接口规则。

表达式(c*4 for c in text)与timesfour(text)的yield循环可产相似序列,生成器函数更便于加入分支和多步状态。二者的产物都可手动next或自动for,但已消费实例不能靠再iter重启;新表达式求值或重新调用工厂才创建新实例。

生成器暂停保留执行状态保存独立卡片。

原书依据 · 2 处
生成器终止应与产值区分

yield提供一个可迭代结果,return或走到末尾结束生成器,调用者推进时得到StopIteration信号。return可以出现在函数体的不同控制流位置,并非只能在末尾;现代Python不应在生成器体内用raise StopIteration模拟正常结束,漏出的该异常会转成RuntimeError。

原书允许next(it)抛出的StopIteration直接漏出myzip生成器,这是旧行为。现代生成器内应在适当取值边界捕获耗尽并return;否则依PEP479变成RuntimeError。只把map改list不能同时修好现代终止规则。

生成器终止应与产值区分保存独立卡片。

原书依据 · 2 处
发送值交给暂停的产值表达式

对暂停在x=yield item的生成器调用send(value),value成为该yield表达式的结果并赋给x,随后继续到下次产值;send返回新yield出的项。next相当于发送None。首次启动还没有可接收值的暂停点,须先next或send(None),不能直接send任意值。

发送值交给暂停的产值表达式保存独立卡片。

原书依据 · 1 处
异常注入与关闭有独立协议

throw在生成器暂停处注入异常,生成器可按异常处理逻辑继续或终止;close请求在暂停处以GeneratorExit结束,并允许执行清理。它们不是所有迭代器共有的方法,不能仅凭支持next就假定有send、throw或close。

异常注入与关闭有独立协议保存独立卡片。

原书依据 · 1 处
生成器表达式:迭代器遇到列表解析

生成器表达式产生迭代器,消费它的工具仍决定最终内存行为。

按需产值推迟计算而非消除计算关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
生成器表达式括号依调用位置

单个生成器表达式作为函数唯一实参时,可省去它自身那层括号,如sum(x*x for x in values)。若还传reverse等其他实参,就应保留生成器表达式括号。括号形式描述生成器,不是用逗号构造元组的另一写法。

生成器表达式括号依调用位置保存独立卡片。

原书依据 · 1 处
生成器函数VS生成器表达式

生成器表达式适合短变换,生成器函数容纳多条语句。

生成器暂停保留执行状态关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
生成器是单迭代器对象

同一生成器的多个引用共享进度,容器可另建独立迭代器。

重复遍历能力取决于迭代器归属关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
用迭代工具模拟zip和map

模拟map与zip能暴露来源配对、消费、状态复用及边界契约。

多来源映射逐组提供函数实参关联本项背景,实质主要讲解在对应位置。

生成器终止应与产值区分关联本项背景,实质主要讲解在对应位置。

按需产值推迟计算而非消除计算关联本项背景,实质主要讲解在对应位置。

原书依据 · 8 处
截断配对与补齐配对语义不同

普通zip与多来源map在最短来源结束时停止;补齐版本继续到最长来源,用pad填缺失项。两者决定是否丢弃较长来源的尾项,不能只因接口形状相似就替换。pad若可能是合法数据,还应保留足够信息区分缺失与真实值。

截断配对与补齐配对语义不同保存独立卡片。

原书依据 · 1 处
空参数边界不能只靠全部为真

all([])为真,any([])为假。原书用while all(seqs)的myzip若零参数进入循环,会不断产生空元组;改成yield只会把问题变成无限空结果流。开始前必须按接口确认来源集合非空或明确返回空迭代,不能把全部来源未空当作来源确实存在。

空参数边界不能只靠全部为真保存独立卡片。

原书依据 · 1 处
重复推进需要固定迭代器集合

iters=map(iter,args)本身是一次性迭代器,第一次遍历它取得子迭代器后就耗尽,下一轮不能再次取得同一组对象;map对象真值又不随耗尽变假。用list等保存子迭代器集合可让外层重复遍历,而各子迭代器仍保存自身进度。

重复推进需要固定迭代器集合保存独立卡片。

原书依据 · 1 处
重复头部弹出会搬移列表元素

myzip的pop(0)版每轮从各个列表头取值,会移动后续元素;对长列表反复使用会累积搬移成本,且预先list化需要额外存储。若目标只是顺序读取,保存迭代器再逐项推进更符合访问模式;仍须正确处理耗尽与空来源。

重复头部弹出会搬移列表元素保存独立卡片。

原书依据 · 1 处
内置类型和类中的值生成

内置类型与用户类型都能按迭代协议交付值。

迭代协议关联本项背景,实质主要讲解在对应位置。

原书依据 · 13 处

Python 3.0解析语法概括

解析的定界符选择输出形态而非统一惰性。

列表解析组合遍历与转换关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处
解析集合和字典解析

集合与字典解析立即构建容器,键值对流则是另一种结果。

来源流式不等于结果不物化关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
针对集合和字典的扩展的解析语法

集合去重和字典重复键覆盖会改变嵌套解析的可见结果。

字典解析按计算后的键收集值关联本项背景,实质主要讲解在对应位置。

多重解析遵循嵌套循环顺序关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处

对迭代的各种方法进行计时

迭代性能结论需由具体版本与实际消费模式支持。

迭代形式性能须按具体工作比较关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
对模块计时

计时器把目标调用放进边界,以时差与结果同时观察工作。

计时区间应明确包括哪些工作

计时应取结束时间减开始时间,明确循环、调用、准备与输出哪些位于边界内。原书timer返回耗时及最后一次结果,能初步检查操作确实发生;图中公式是停止减开始,正文倒序为误述。现代时钟选择需匹配经过时间或CPU时间目标。

876的timer类保存func/alltime,call用开始/结束时钟包住目标调用,先取得result,再更新alltime、打印并return result。

结构图:

classDiagram
class timer {
 func
 alltime
 __init__(self, func)
 __call__(self, *args, **kwargs)
}

图取02393。统计区间包含目标函数执行,打印在结束取时之后;若目标抛异常,结束取时/累加/打印均不会运行,所以alltime不是所有失败尝试时间之和。每个装饰目标各有一个timer实例和累计值。 原书time.clock是旧接口,Python3.8已移除;现代选择应按经过时间/CPU时间目标选相应受支持时钟,不照抄旧代码宣称当前可运行。本节装饰器不保存每个结果列表以外的历史输入,也没有自动重试或并发累计保证。

计时区间应明确包括哪些工作保存独立卡片。

原书依据 · 2 处
重复计时前须确认状态可重复

重复调用会再次发生目标函数的副作用;若输入被消耗、缓存变热或状态被修改,每轮可能不再做同样工作。准备和重置应按问题选择放在计时内外,次数也须合法,不能把第一次与后续路径混成一个无条件代表值。

重复计时前须确认状态可重复保存独立卡片。

原书依据 · 1 处
计时脚本

比较列表构造要迫使惰性方案完成相同数量的工作。

比较惰性方案须消费相同结果

若一个测试生成完整列表,另一个只创建生成器或map而不消费,就不是同等工作。比较完整构造耗时时,应把惰性结果同样消费并检查输出;若真实业务只取部分项,则应按部分消费另测,而非一概要求物化。

Python2 map本已物化,再套list会增加拷贝;Python3套list才强制产值。跨版本测试要说明是否测同样产物及是否含额外复制,不能只用相同表面代码认定公平。

答案把两者都概括成建列表是历史混用;Python3 map默认返回惰性迭代器,列表解析建立列表,实际工作需按消费方式判断。

946的02593-02598分别给简易重复timer、sqrt的循环/map/解析、sqrt/pow/**比较和字典解析/循环计时。计时前应确认完整工作及结果可比,最后结果一致不证明所有输入等价;旧2.6⁄3.0、硬件、循环范围及计时方法决定该组数字,不导出现代固定速度排名。time.clock及旧mytimer引用按历史说明。

比较惰性方案须消费相同结果保存独立卡片。

原书依据 · 4 处
计时结果

操作函数与测试环境改变时,迭代方式的相对排名也会变化。

迭代形式性能须按具体工作比较关联本项背景,实质主要讲解在对应位置。

比较惰性方案须消费相同结果关联本项背景,实质主要讲解在对应位置。

原书依据 · 8 处
计时模块替代方案

配置化计时器可测重复总时间或最佳单次,两者含义不同。

仅关键字参数须按名称传入关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
最佳计时是下界而非典型延迟

重复总耗时除以次数与取多次单次耗时的最小值,回答不同问题。最小值常帮助减少其他进程干扰,估计较少干扰下的执行下界,却不是生产负载的典型或尾部延迟;仍应查看各次结果并说明计时条件。

最佳计时是下界而非典型延迟保存独立卡片。

原书依据 · 1 处
计时框架开销会污染微小任务

目标很短时,函数调用、循环和时钟读取等框架成本可能与目标相当。要了解基线并按相同条件比较,不能把整个测得时长都解释成目标表达式本身;长任务相对更容易减轻这一比例影响,但仍需实际测量。

计时框架开销会污染微小任务保存独立卡片。

原书依据 · 1 处
包装器配置可能截走目标参数

timer用_reps配置自身,再把剩余kwargs传给目标。若目标也有同名参数,包装器可能先消费它,无法按原意转发;下划线降低偶然冲突,却不保证透明。设计通用包装器应清楚区分自身配置与目标准备的参数。

包装器配置可能截走目标参数保存独立卡片。

原书依据 · 1 处
其他建议

先找整体瓶颈,再对相关方案做局部测量。

先定位瓶颈再比较局部替代

局部代码更快未必改善整体程序,应先用探查结果确认耗时集中在哪里,再比较有代表性的实现。timeit帮助小片段重复计时,profile类工具帮助发现热点,两者目的不同;环境、GC和准备步骤也应按任务说明。

先定位瓶颈再比较局部替代保存独立卡片。

原书依据 · 1 处

函数陷阱

本节集中检查函数使用中的边界陷阱。

本地变量是静态检测的

局部绑定归类由整个函数块的语法决定,而非按执行到哪行决定。

局部未赋值读取不会向外回退关联本项背景,实质主要讲解在对应位置。

属性查找不同于裸名称解析关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处
默认和可变对象

可变默认值若被修改,会把状态带入下一次省略该实参的调用。

用或取默认会覆盖合法假值关联本项背景,实质主要讲解在对应位置。

默认参数在定义时取得对象关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
可变默认参数会跨调用共享

def saver(x=[])只在执行def时创建默认列表,多次省略x的调用会修改同一个对象,导致结果跨调用累积。若期望每次新建,可用None作默认并在函数体检查x is None后创建列表;仍要明确显式传入列表是否应被原处修改。

两版Set的value=[]默认对象仍在定义时创建并被多次省略调用共享,但构造器另建内部列表,再迭代value加入内部对象,没有在构造中修改这个默认列表。因此不能仅凭签名就断言本例已产生跨实例累积;真正风险取决于是否改变共享默认对象。

可变默认参数会跨调用共享保存独立卡片。

原书依据 · 2 处
没有return语句的函数

普通函数无显式返回仍给None,副作用与结果是不同通道。

普通函数无显式结果也返回空值关联本项背景,实质主要讲解在对应位置。

原地修改不同于返回新容器关联本项背景,实质主要讲解在对应位置。

原书依据 · 10 处
嵌套作用域的循环变量

循环中定义的回调读取同一外层绑定,创建时捕获应有明确形式。

闭包读取绑定不冻结创建时值关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处

本章小结

解析、生成器、计时与函数陷阱汇成函数部分收束。

本章习题

五问检查解析形态、生成器函数、yield和map的区别。

习题解答

答案重申生成器协议,但须辨认函数对象、调用产物和一般迭代器。

迭代协议关联本项背景,实质主要讲解在对应位置。

比较惰性方案须消费相同结果关联本项背景,实质主要讲解在对应位置。

原书依据 · 17 处

第四部分 练习题

部分练习串联参数、合并、拷贝、成员搜索与同工作量计时。

浅拷贝仍共享内部对象关联本项背景,实质主要讲解在对应位置。

极值接口须规定可比较范围关联本项背景,实质主要讲解在对应位置。

原书依据 · 9 处

第五部分 模块

进入模块部分。

第21章 模块:宏伟蓝图

模块把一组定义保存在独立命名空间,导入让其他代码取得可复用对象。查找模块、准备代码与执行顶层语句是相关但不同的步骤;模块缓存又意味着再次导入未必重新执行。搜索路径配置只是找到候选的条件,找到对象不等于其字段已经全部初始化。

模块把可复用的工具与名称组织为独立单元。

模块命名空间隔离名称关联本项背景,实质主要讲解在对应位置。

原书依据 · 9 处

为什么使用模块

模块既划分名称,也能让多个客户端共享同一加载对象。

模块命名空间隔离名称关联本项背景,实质主要讲解在对应位置。

再次导入通常复用模块对象关联本项背景,实质主要讲解在对应位置。

原书依据 · 14 处

Python程序架构

程序架构由文件与导入关系共同组织。

如何组织一个程序

入口负责启动和编排,支持模块提供可导入工具。

入口编排与模块工具分工

顶层入口启动应用并编排流程,支持模块提供函数、类或数据等可复用工具。两者通常都是可执行Python文件,角色由使用方式和入口设计决定;可导入模块也会执行顶层代码,不能假设导入就绝无动作。

入口编排与模块工具分工保存独立卡片。

原书依据 · 1 处
导入和属性

导入连接模块,属性引用再取得具体工具。

属性取得不等于方法已经调用关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
导入把模块连接为程序

示例a.py导入b模块,再调用b.spam(text);b还可使用c及标准库,c也可能依赖b。导入建立可访问的模块对象引用,b.spam再取属性并调用,不是把b源码原样粘进a。循环依赖可能遇到尚未初始化完的属性,图中相互导入不是安全保证。

结构图:

flowchart LR
  A[入口a.py] -->|导入| B[模块b.py]
  B -->|导入| C[模块c.py]
  C -->|导入| B
  B --> S[标准库模块]
  C --> S

导入把模块连接为程序保存独立卡片。

原书依据 · 1 处
标准库模块

标准库提供常用能力,但可用范围仍受平台与安装构建影响。

标准库名称不保证全平台可用

标准库让常见任务有统一文档与发行入口,但模块可能依赖平台、可选组件或具体Python版本。查库时应核对可用性和版本说明,不因它属于标准库就断言任何安装都必有全部模块或行为一致。

标准库名称不保证全平台可用保存独立卡片。

原书依据 · 1 处

import如何工作

首次导入涉及查找、必要编译和执行,重复导入通常走缓存。

执行源码不等于导入模块关联本项背景,实质主要讲解在对应位置。

再次导入通常复用模块对象关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处
1.搜索

模块标识与操作系统文件路径是两层概念。

运行文件与导入模块用不同名称关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
2.编译(可选)

字节码缓存减少加载时的重复编译,不取消执行。

字节码缓存服务加载阶段关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
3.运行

导入执行模块顶层语句,定义对象和副作用都可能发生。

文档内省可能触发模块副作用关联本项背景,实质主要讲解在对应位置。

模块重载不会更新所有引用关联本项背景,实质主要讲解在对应位置。

原书依据 · 12 处

模块搜索路径

路径配置提供候选位置,实际搜索受启动方式、环境与加载器影响。

路径前项可能遮蔽预期模块

路径式查找可能先找到较前目录的同名模块,使本来期待的库被本地文件遮蔽。排查错误版本或循环导入时应确认实际加载来源;不要把脚本目录和当前工作目录混为一处,也不要把所有导入都简化成sys.path文件扫描。

同名源码与扩展同时出现会依具体查找器的规则选择,路径式查找还受目录顺序影响。用明确的模块名称与布局减少偶然依赖,不把旧书不保证永久不变的挑选顺序当跨实现承诺。

包内用绝对import string可跳过隐式同级优先,却仍可能找到程序查找路径前部的本地string。避免与库重名并确认实际加载来源,不能把绝对导入当标准库专用选择器。

路径前项可能遮蔽预期模块保存独立卡片。

原书依据 · 3 处
路径配置作用范围要明确

PYTHONPATH向所启动解释器提供额外查找位置,持久设置可能影响多个环境或版本;sys.path是当前运行时所见配置。选择局部或持久配置时应明确影响范围,不为一个项目随意改变全局查找结果。

原图Windows的PYTHONPATH用分号分隔多个目录,.pth则每行一个路径;其他平台分隔约定和站点目录位置可能不同。照抄旧安装目录前应确认目标解释器实际环境,不能把示例盘符当通用默认。

跨目录导入不总必须设置PYTHONPATH,包安装、当前环境默认路径和其他机制也可能已满足;只在确认实际查找需要后选择配置,旧四组件清单不是所有启动模式的完整算法。

脚本修改sys.path可影响同一解释器其他模块的后续路径式查找;删除库路径可能破坏尚未加载的依赖。缓存已加载模块未必因此失效,重绑列表与原列表的别名也须区分;修改不会自动持久化到下一次解释器启动。

环境变量与站点文件是否影响具体程序取决于解释器、启动选项和环境;系统持久配置不同于当前sys.path修改,但不是所有程序无条件共享一份配置。

939的02542-02546示范import spam、csh setenv、ksh export、Windows set及每行一个目录的.pth。持久系统环境修改不会自动重配已启动解释器;终端局部设置只影响相应环境及继承它的后续进程,不是全机器每程序都受同一值影响。旧autoexec.bat、XP/Vista菜单、注册表路径和Python30目录仅为历史例,不当当前操作指南。

路径配置作用范围要明确保存独立卡片。

原书依据 · 6 处
路径配置文件由站点机制处理

站点目录中的.pth可按行添加存在的路径并去重,不是放在任意文件夹就自动生效。现代site处理还允许特定import行在启动时执行,故路径文件也可能携带初始化动作;它与用于隔离覆盖路径的._pth不是同一种文件。

939的.pth内容相对于其所在目录或用绝对路径;能否加载取决于站点机制检查的目录与启动模式。不能在任意目录放一个.pth就期待解释器自动读取,也不能把旧安装位置清单当所有版本的完整规则。

路径配置文件由站点机制处理保存独立卡片。

原书依据 · 2 处
配置搜索路径

配置格式依平台区分,环境变量列表与路径文件行格式不同。

路径配置作用范围要明确关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
搜索路径的变动

实际路径应按运行方式核对,不靠猜测工作目录。

模块搜索路径不同于程序搜索路径关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
sys.path列表

sys.path展示当前路径式查找配置,修改它不等于重新加载缓存对象。

模块搜索路径不同于程序搜索路径关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
模块文件选择

import的统一接口可以面向不同的模块来源。

路径前项可能遮蔽预期模块关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
模块导入名不限定物理载体

同一import名称可由源码、字节码、扩展、包、内置或归档等加载机制提供,调用者通常再通过模块属性使用功能。它统一访问方式,却不保证不同实现的行为、平台能力和初始化副作用相同;同名竞争应明确依赖和来源。

导入钩子能扩展模块查找与加载来源,例如归档内容,不代表所有模块都先按普通文件规则处理。统一import语法让客户端获取模块引用,具体支持的来源和限制仍取决于加载器。

扩展模块可用其他语言实现后通过导入暴露函数与对象,源码模块客户端的访问形式可相似。外部实现仍受解释器、ABI和平台条件约束,不因名字统一就自动跨实现兼容。

包提供层级模块名称和对子模块的访问,文件系统目录是常见实现,但不能仅凭任意目录存在就判定它按预期可导入。普通包与现代命名空间包的构成条件不同,路径识别须结合导入机制。

模块导入名不限定物理载体保存独立卡片。

原书依据 · 4 处
高级的模块选择概念

导入可由加载钩子扩展,优化缓存与安装工具则须按版本理解。

模块导入名不限定物理载体关联本项背景,实质主要讲解在对应位置。

字节码缓存服务加载阶段关联本项背景,实质主要讲解在对应位置。

原书依据 · 8 处
安装位置与导入发现相互配合

安装工具把包与必要元数据放到目标环境可发现的位置,通常可减少手工路径设置,但必须是实际运行所用环境。原书distutils/setup.py是历史方案,distutils在Python3.12已不属标准库;旧安装脚本不能不经迁移直接当现代通则。

安装位置与导入发现相互配合保存独立卡片。

原书依据 · 1 处

本章小结

模块隔离名称并通过导入形成依赖,具体加载规则仍有版本边界。

本章习题

五问检查模块对象建立、路径与载体及命名空间。

习题解答

答案回顾模块命名空间与路径配置,仍应避免历史清单泛化。

模块命名空间隔离名称关联本项背景,实质主要讲解在对应位置。

路径配置作用范围要明确关联本项背景,实质主要讲解在对应位置。

原书依据 · 15 处

第22章 模块代码编写基础

模块文件中的顶层赋值、def与class产生可供导入者使用的属性。import绑定模块对象,from把选定属性绑定到导入者自己的名称;后者不建立一条自动随原模块重绑定更新的别名。用完整模块路径观察状态,更容易区分名称归属与共享对象。

模块源码不需要专门模块声明,导入机制把内容组织为对象。

模块命名空间隔离名称关联本项背景,实质主要讲解在对应位置。

原书依据 · 9 处

模块的创建

可导入的源码名称与加载位置要适配普通import语法。

运行文件与导入模块用不同名称关联本项背景,实质主要讲解在对应位置。

模块导入名不限定物理载体关联本项背景,实质主要讲解在对应位置。

原书依据 · 9 处

模块的使用

import与from共享加载动作,区别在调用者得到哪些绑定。

导入绑定名称不深复制对象关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处
import语句

import建立模块名称后,用点访问其成员。

导入绑定名称不深复制对象关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处
from语句

from缩短属性的引用形式,同时建立独立的本地名称绑定。

导入绑定名称不深复制对象关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处
from*语句

通配导入把一批名称带入当前模块,易模糊来源和覆盖绑定。

通配导入削弱名称来源边界

from module import *批量绑定模块导出的名称,容易覆盖同名本地绑定并使来源不清;显式导入所需名称或保留模块限定名更便于追踪。导出集合也受all或默认下划线规则影响,并非无条件导入每个顶层名称。Python3这种形式限模块层使用。

显式from也可能覆盖当前同名绑定;普通import虽然不铺开成员,绑定模块名时同样可能覆盖该名称。保留清楚来源与别名比只选某一种语句就认为永无冲突更可靠。

包的all可指定通配导入应导出的名称,包含合适的子模块名时可触发相应加载;缺少它不表示自动扫描并载入全部子模块。包初始化中显式建立的属性与导出列表是接口设计选择,不是强制私有保护。

有all时按其中列出的名称导出;无all时通常排除下划线开头名称。故即使以下划线命名,也可被all明确列入通配导出,这与默认过滤不同。两种机制都不禁止显式导入或module.attr访问。

多个from *可能按执行次序覆盖同名func,阅读调用处难以看出来源。显式列名、别名或模块限定能让依赖更清楚;即使只用一次星号导入也不自动排除内置名称、本地重绑等其他来源。

默认星号导入过滤下划线名,但显式all可列入它们,不能无条件说下划线名永远不导出。显式访问与模块接口惯例分开理解。

通配导入削弱名称来源边界保存独立卡片。

原书依据 · 6 处
导入只发生一次

重复同身份导入复用对象,不重跑顶层初始化。

再次导入通常复用模块对象关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
import和from是赋值语句

导入是运行时绑定,名称改绑与共享对象修改仍要区分。

导入绑定名称不深复制对象关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处
文件间变量名的改变

修改模块绑定需取得模块引用,经属性明确写入。

共享状态修改入口应明确关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
import和from的对等性

from可用加载加属性绑定理解,但不是只加载所选片段。

导入绑定名称不深复制对象关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处
from语句潜在的陷阱

限定模块名和显式别名可同时保留同名工具。

通配导入削弱名称来源边界关联本项背景,实质主要讲解在对应位置。

模块重载不会更新所有引用关联本项背景,实质主要讲解在对应位置。

原书依据 · 16 处
导入别名可保留同名工具

先from M import func再from N import func,会让后者覆盖本地func绑定。可保留M.func与N.func的模块限定访问,也可用from M import func as m_func等显式别名;关键是本地名称不同,不是from天然不能共存。

答案所谓同名工具必须import只是未考虑别名的简化;显式as别名也能保留两个from导入结果。命名明确与旧引用更新责任比一律禁用某种语句更有意义。

import dir1.dir2.mod后通常绑定顶层dir1,不自动在本地额外绑定dir2与mod。from dir1.dir2 import mod或import dir1.dir2.mod as mod可取得较短引用;选择模块对象或属性值也影响后来更新时是否跟踪当前属性。

即使两个包的函数名相同,也能用from … import function as不同别名保留两者。明确包标识与本地绑定别名分别解决来源与名称碰撞,原文一概不能from仍是未考虑别名的简化。

同名属性可用from加as分别绑定,模块限定名也可保留来源。一个本地名称一次关联一个对象,不代表同一程序不能给不同对象不同别名。

import module as local或from module import attr as local绑定所选本地名,不重命名原模块或属性。导入两个utility时可分别用util1/util2,深层包也可绑定短模块别名;别名名称同样须避免覆盖现有重要绑定。

导入别名可保留同名工具保存独立卡片。

原书依据 · 6 处

模块命名空间

模块的顶层绑定成为属性命名空间。

模块命名空间隔离名称关联本项背景,实质主要讲解在对应位置。

原书依据 · 9 处
文件生成命名空间

顶层语句建立属性,模块字典和内省工具提供观察入口。

模块命名空间隔离名称关联本项背景,实质主要讲解在对应位置。

属性清单不等于接口说明关联本项背景,实质主要讲解在对应位置。

原书依据 · 15 处
属性名的点号运算

多层点号逐步沿对象属性取值,而裸名称才从作用域查找。

属性查找不同于裸名称解析关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
导入和作用域

函数在哪个模块定义,就使用相应模块的全局环境。

词法位置决定名称所属作用域关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
命名空间的嵌套

属性引用链可沿已导入模块继续深入,但不等于包名解析。

模块属性链不同于包导入路径

若mod2导入mod3,就可通过mod2.mod3.X沿对象属性取值。这个关系不自动使mod2成为包,也不保证import mod2.mod3有效;后者按包和子模块标识加载。对象中存在同名属性与导入系统能解析该层级,是两种不同条件。

导入后dir1、dir1.dir2与dir1.dir2.mod对应模块对象,属性链可读取各级定义。reload接收的是表达式求得的模块对象,而非把点分名称当文件路径字符串。

模块属性链不同于包导入路径保存独立卡片。

原书依据 · 2 处

重载模块

重载可在解释器运行期间重新执行模块,但不是完整更新所有状态。

模块重载不会更新所有引用关联本项背景,实质主要讲解在对应位置。

原书依据 · 10 处
reload基础

重载通常沿用模块字典,更新新绑定却可能保留旧名称和外部引用。

模块重载不会更新所有引用关联本项背景,实质主要讲解在对应位置。

原书依据 · 10 处
重载保留未覆盖的旧绑定

reload通常保留原模块字典,在其中重新执行代码。新版源码若不再定义某个旧名称,该名称仍可能留在字典中,因此重载不等于新进程从空环境导入。是否保留缓存或清理旧名应由更新设计明确决定。

重载保留未覆盖的旧绑定保存独立卡片。

原书依据 · 1 处
reload实例

changer展示普通重导入与显式重载看到不同源码版本。

模块重载不会更新所有引用关联本项背景,实质主要讲解在对应位置。

原书依据 · 10 处

本章小结

本章将导入绑定、命名空间和重载区别串联。

本章习题

五问检查模块创建、导入形式、重载及from陷阱。

习题解答

答案回顾来源透明、命名冲突与更新引用的取舍。

导入别名可保留同名工具关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处

第23章 模块包

包给模块名称增加层级,普通包的初始化文件建立包接口,相对导入则依赖所属包的语境。目录位置、包限定名和磁盘绝对路径不是同一概念。模块作为入口直接运行或按包方式启动,可能获得不同身份,因此移动文件不只是修正一条路径。

包在模块名称之上提供层级组织,包内引用还需区分相对导入。

模块导入名不限定物理载体关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处

包导入基础

点分名称相对于顶层可发现的包定位子模块。

包容器位置与点分名称分开

import dir1.dir2.mod的普通文件布局中,查找入口应能发现dir0下的dir1,再由包路径继续找dir2与mod。点分名称表达模块层级,dir0是外部容器位置;把dir0/dir1误当顶层入口可能使模块身份和导入方式改变。

盘符、目录分隔符或../属于文件系统路径,不能直接替代普通import的点分标识。合法的容器位置可由环境和安装配置提供,代码再使用dir1.dir2.mod;点号不意味着任意文件路径字符串都能直接写成导入名。

包容器位置与点分名称分开保存独立卡片。

原书依据 · 2 处
包和搜索路径设置

导入语句用模块标识,平台路径放在配置中。

包容器位置与点分名称分开关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
init.py包文件

普通包初始化文件建立包属性并控制导出,现代包类型也须区分。

通配导入削弱名称来源边界关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
普通包初始化文件形成包接口

普通文件包的init.py在首次加载时执行,顶层绑定成为包的属性,也可显式导入准备对外提供的对象。它可为空,仍不同于类的init方法;初始化若连接外部资源等会产生导入副作用,应明确需要与失败边界。

例中dir1初始化定义x,dir1.dir2初始化定义y,mod.py定义z;导入dir1.dir2.mod会按需完成各级加载。重复导入通常不重跑已完成初始化;重载某一级也不自动递归重载其所有子模块。

普通包初始化文件形成包接口保存独立卡片。

原书依据 · 2 处
包初始化要求须区分包类型

原书Python3.0普通包要求路径中各包目录有init.py,外部容器无需它。现代Python3.3起还支持无init.py的隐式命名空间包,因此不能把旧约束当所有包的定义;需按目标布局和版本判断。

本节带init目录的定义是普通包模型;现代命名空间包和自定义加载器使“完整查找总结”不能照搬为所有导入算法。先确定包和模块身份,再区分顶层查找与子模块包路径。

答案所说init不可选只对所述旧版普通包模型成立,现代隐式命名空间包另论。外部容器是否需要init也取决于其本身是否作为包名参与导入,而非单凭目录存在。

包初始化要求须区分包类型保存独立卡片。

原书依据 · 3 处

包导入实例

逐级加载普通包时,各级init定义各自属性。

普通包初始化文件形成包接口关联本项背景,实质主要讲解在对应位置。

模块属性链不同于包导入路径关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
包对应的from语句和import语句

深层导入的名称绑定可用from或别名缩短。

导入别名可保留同名工具关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处

为什么要使用包导入

包名称使工具归属更明确,也可减少顶层查找入口。

层级包名表达工具所属范围

database.client.utilities比裸utilities表达更多归属,可在不同系统中保留同名子模块。共同包根下可让路径配置围绕较少的入口组织;仍要保证顶层包名和安装环境正确,层级名不会自动解决所有同名发行冲突。

system1与system2分别启动时,入口环境可找到各自utilities;第三个程序却不能只凭裸import utilities同时表达两套身份。用system1.utilities与system2.utilities等明确包名,能把归属加入模块标识,减少只靠调整路径先后的隐含选择。

层级包名表达工具所属范围保存独立卡片。

原书依据 · 2 处
三个系统的传说

两个可独立启动的系统在被第三方复用时,会暴露裸模块名冲突。

层级包名表达工具所属范围关联本项背景,实质主要讲解在对应位置。

导入别名可保留同名工具关联本项背景,实质主要讲解在对应位置。

原书依据 · 8 处

包相对导入

包内部依赖可按完整包名或显式相对名称表达。

相对导入依赖当前包上下文

包内可用完整绝对包名,或from . import sibling等显式相对形式。点号表示当前包及父包层级,不是当前工作目录的文件相对路径;模块需要有效的包上下文,直接把内部文件当孤立脚本运行可能不满足条件。

from . import spam取得当前包的spam,from .spam import name从相应子模块取属性;from .. import spam从父包层级解析。一个点是当前包,每多一个点上移一级,不能越出可用顶层包,也不能写import .spam替代from形式。

mypkg.main内from . import string明确关联mypkg.string,完整from mypkg import string也可指向包工具,但仍须解析mypkg身份。更多前导点相对父包层级,不是任意跳到文件系统父目录;到达可用顶层边界后不能继续上溯。

交互或把包内文件当独立脚本运行,可能没有相对导入所需包上下文;把代码按包模块入口运行与直接执行物理文件不是同一种模式。目录位置本身不替代模块元信息。

相对导入依赖当前包上下文保存独立卡片。

原书依据 · 4 处
Python 3.0中的变化

Python3默认绝对导入,包内同级依赖应显式表达。

绝对导入不等于绝对文件路径

Python3中import name和无前导点的from name import item默认使用绝对模块名称解析,不自动优先尝试当前包的同级模块。绝对指模块命名方式,实际查找仍受环境和路径等机制影响;它不是盘符开头的文件路径,也不保证一定选中标准库。

原节末段说Python3.0的import modname仍默认相对,与该节前文和现代规则矛盾;笔记按Python3默认绝对名称解析处理。相对导入选择包路径,不能把没有前导点但带中间点的普通包导入误当相对。

默认绝对import string不再自动优先取mypkg内同级名,但仍可能被sys.path前面的同名文件遮蔽,不能承诺一定取标准库。相对语法也依赖已确定的包上下文和包路径,不是完全脱离环境。

绝对模块名仍可经sys.path中的相对或绝对文件系统位置发现;显式相对模块名则按当前包及前导点解析。中间有点但无前导点的名称仍可属于绝对导入,不能把两套术语混用。

绝对导入不等于绝对文件路径保存独立卡片。

原书依据 · 4 处
相对导入基础知识

显式前导点选择包内相对名称,层数须由包结构判断。

相对导入依赖当前包上下文关联本项背景,实质主要讲解在对应位置。

绝对导入不等于绝对文件路径关联本项背景,实质主要讲解在对应位置。

原书依据 · 8 处
为什么使用相对导入

显式相对名让读者区分包内依赖与顶层模块来源。

相对导入依赖当前包上下文关联本项背景,实质主要讲解在对应位置。

绝对导入不等于绝对文件路径关联本项背景,实质主要讲解在对应位置。

原书依据 · 8 处
相对导入的作用域

绝对与相对描述模块名称解析基准,不是路径字符串是否含盘符。

绝对导入不等于绝对文件路径关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
模块查找规则总结

查找概述在普通路径式导入模型中有用,但不是所有加载器的全规则。

包初始化要求须区分包类型关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
相对导入的应用

多种同名string测试说明相对引用固定包内目标,绝对引用仍受环境影响。

路径前项可能遮蔽预期模块关联本项背景,实质主要讲解在对应位置。

相对导入依赖当前包上下文关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处
显式相对目标缺失不会回退

from . import string选择当前包的相应对象或子模块,不是优先尝试包内再退回顶层标准库string。指定的包内目标不满足要求时应报告失败;静默改取外部同名工具会改变接口身份,因此不能把相对导入仅理解为搜索偏好。

末题答案声称相对spam之后再搜索sys.path,与前文失败测试冲突;显式相对目标不回退成顶层同名spam。包路径的来源可能由环境确定,但那不同于目标失败后改为绝对模块名。

显式相对目标缺失不会回退保存独立卡片。

原书依据 · 2 处

本章小结

本章收束层级包名、初始化及相对引用的解析边界。

本章习题

五问检查init、别名、普通包条件和导入基准。

习题解答

答案需同时保持旧版普通包边界与相对解析不回退原则。

包初始化要求须区分包类型关联本项背景,实质主要讲解在对应位置。

显式相对目标缺失不会回退关联本项背景,实质主要讲解在对应位置。

导入别名可保留同名工具关联本项背景,实质主要讲解在对应位置。

原书依据 · 11 处

第24章 高级模块话题

模块可以成为对象来检查、再导出和管理,但动态能力也带来缓存、身份与依赖时序问题。主程序保护区分入口动作和可复用定义;循环导入、重载及路径修改则需要理解已建立的对象引用。改变一处名称不会自动更新所有已经取得旧对象的代码。

高级模块章将接口可见性、入口设计及动态加载工具联系起来。

在模块中隐藏数据

模块封装把名称组织起来,不自动禁止外部修改。

模块命名空间隔离名称关联本项背景,实质主要讲解在对应位置。

原书依据 · 9 处
最小化from*的破坏:_X和all

下划线默认排除与all显式导出只作用于通配导入。

通配导入削弱名称来源边界关联本项背景,实质主要讲解在对应位置。

下划线命名具有不同约定与机制关联本项背景,实质主要讲解在对应位置。

原书依据 · 8 处

启用以后的语言特性

future导入让一个代码单元选择已实现的兼容性语义。

未来特性导入按代码单元生效

from future import feature启用解释器已提供的特定语义,并非下载未来版本或任意新功能。它通常必须置于模块开头允许的位置(可在docstring等之后),并影响相应代码单元;不同版本中已成默认或仍需选择的功能要分别确认。

未来特性导入按代码单元生效保存独立卡片。

原书依据 · 1 处

混合用法模式:name和main

主程序保护让同一文件既提供工具也可直接运行。

主程序保护区分入口与导入

if name==”main“中的代码只在该模块充当主程序时按条件执行,可调用命令行入口或自测试。普通导入时仍执行模块顶层的定义与未受保护语句;这个检查不是阻止整个文件执行或保证零导入副作用的开关。

把minmax自测试放入主程序保护可避免普通导入时自动运行测试调用;图中顶层print(name)却仍会打印。要让模块导入安静,须同时检查所有顶层副作用,不能只看到有保护块就断定无输出。

formats把selftest与sys.argv适配放入入口保护,commas和money可被其他代码调用,docstring还能供help展示。接口复用不代表原格式器覆盖全部边界,尤其浮点表示与舍入规则要按具体显示要求核对。

本例把实例创建与打印放在if name == “main“块内,使直接运行person.py时展示测试输出,通常导入person时不运行这组入口语句。保护块之外的类定义及其他顶层语句仍会执行,所以不能据此保证导入完全没有副作用;也可把独立检查放进专门测试模块。

940说明python -m 模块名按模块搜索路径定位并作为main运行,不加.py后缀;这不同于普通import时使用原模块名。包内模块可用其包限定名称启动,不能把-m后的模块名称概括成任意显式相对导入表达式。

主程序保护区分入口与导入保存独立卡片。

原书依据 · 5 处
以name进行单元测试

自测试调用放入入口保护,保护外的跟踪输出仍会在导入时执行。

主程序保护区分入口与导入关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
使用带有name的命令行参数

formats同时展示库函数、命令行适配及格式算法边界。

主程序保护区分入口与导入关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
命令行字符串须解析并校验

普通脚本可从sys.argv读取传入字符串,再按接口转为数值或其他对象;入口保护让这些操作不随库导入自动执行。读取位置前须检查数量,转换也可能失败。argv[0]在普通脚本中通常表示入口,但不能推广所有启动模式都必为同样脚本路径。

940的02547-02555列解释器语法、main.py打印argv、文件/-c/标准输入/-m及pdb/profile/cProfile/-u/help调用。python main.py a b -c中的-c在脚本位置之后,是脚本参数而不是解释器-c;-c代码入口argv[0]示为-c,标准输入为-,-m示为模块实际路径,不能说所有首项永远是源码文件名。解释器选项须在对应代码入口之前区分。正文-0是-O排印问题,2.6兼容选项和3.0调试器异常属于历史,不据此描述当前支持矩阵。

命令行字符串须解析并校验保存独立卡片。

原书依据 · 2 处
分组显示可从低位逐段拼接

commas把数字文本每次拆出最右三位,再放到已处理结果前并按需加逗号,从低位分组。它是文本显示操作,不是修改原数值;符号、小数和地区分隔约定应另定规则,不能把正整数文本工具当通用数值解析器。

分组显示可从低位逐段拼接保存独立卡片。

原书依据 · 1 处
显示拆分应保留舍入进位

原码money先用int(N)取整数,再从%.2f结果只取最后两位小数;舍入跨整数边界时,两部分可能不一致。生成时推演:正值9.999的两位显示应进位到10.00,该拆法却组合成9.00。应以同一次完整舍入后的表示再拆分,不能丢掉进位;此推演未执行。

显示拆分应保留舍入进位保存独立卡片。

原书依据 · 1 处

修改模块搜索路径

运行时搜索路径改变会影响同一解释器中的后续查找。

路径配置作用范围要明确关联本项背景,实质主要讲解在对应位置。

模块搜索路径不同于程序搜索路径关联本项背景,实质主要讲解在对应位置。

原书依据 · 11 处

Import语句和from语句的as扩展

as为当前作用域选择绑定名,可以简化长路径并避免覆盖。

导入别名可保留同名工具关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处

模块是对象:元程序

模块对象提供可编程观察入口,工具自身也要遵守模块身份与属性条件。

属性清单不等于接口说明关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
属性名称字符串可用于动态读取

getattr(module,name)可把运行时字符串解释为属性名,无需把它拼成Python表达式执行。普通模块的已存属性也能从dict读取,但属性机制与直接字典访问在动态定制对象上可能不同;缺失属性应按接口明确处理。

属性名称字符串可用于动态读取保存独立卡片。

原书依据 · 1 处
同文件双身份会分离模块状态

作为脚本运行的mydir位于main,其自测试又import mydir时通常按模块名建立另一身份。两者即使来自同一源码,也可能有各自顶层绑定并重复初始化。需要共享状态时应确认实际模块身份,不能仅凭文件路径相同就假定单例。

直接运行recur1.py的main与之后按recur1名称导入的模块可能是两份对象,使循环示例表现不同。它不是循环依赖已被通用解决,仍要从每个模块初始化到哪一步分析。

同文件双身份会分离模块状态保存独立卡片。

原书依据 · 2 处

用名称字符串导入模块

运行时模块名称字符串应交给加载接口,不是裸import中的变量替换。

解析数值不必执行字符串代码关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
字符串导入使用模块加载接口

x=“string”后写import x,导入标识仍是字面模块名x,不会读取变量值。运行时名称可用importlib.import_module(name)等专用接口加载;import对点分名称的默认返回层级另有规则。模块名作为数据处理,比拼exec代码更清楚,但加载仍可能执行模块初始化。

字符串导入使用模块加载接口保存独立卡片。

原书依据 · 1 处

过渡性模块重载

递归遍历模块对象可演示传递重载,但不构成通用安全更新方案。

模块重载不会更新所有引用关联本项背景,实质主要讲解在对应位置。

访问集合可防止循环重复处理关联本项背景,实质主要讲解在对应位置。

原书依据 · 13 处
模块属性扫描不是完整依赖图

扫描module.dict中的模块对象可找到部分直接引用,找不到只from取得函数等对象后未保存模块引用的全部关系,也不保证动态依赖都显现。因而递归属性扫描不能宣称覆盖系统全部导入依赖,所见引用图与真正更新需求须区分。

模块属性扫描不是完整依赖图保存独立卡片。

原书依据 · 1 处
批量重载须限定可更新边界

原例无差别递归可能走入sys、扩展或其他不适合重载的模块,重跑初始化也可能破坏共享状态。批量更新应先规定允许模块、资源生命周期、失败行为和更新顺序;visited去重或模块类型测试都不证明热更新安全。

批量重载须限定可更新边界保存独立卡片。

原书依据 · 1 处

模块设计理念

模块应围绕统一目标组织,并让跨模块状态变化可追踪。

共享状态修改入口应明确关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
模块聚合围绕统一用途

模块内工具应围绕共同目标组织,减少无关职责和对其他模块内部状态的隐含依赖。外部调用通过清楚的函数、类或数据接口协作;共享全局写入会引入顺序和可见性问题,应有明确理由与入口。

模块聚合围绕统一用途保存独立卡片。

原书依据 · 1 处

模块陷阱

接下来检查高级模块用法的常见边界。

顶层代码的语句次序的重要性

名称须在实际求值时可用,函数体延迟执行不消除所有定义顺序要求。

定义函数与执行函数体分开关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
from复制变量名,而不是连接

from带来的名称是独立绑定,不是来源名称的自动别名连接。

导入绑定名称不深复制对象关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处
from*会让变量语义模糊

通配导入越多,简单名称的实际来源越难判断。

通配导入削弱名称来源边界关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
reload不会影响from导入

重载更新模块属性,不主动追踪所有已取出的引用。

模块重载不会更新所有引用关联本项背景,实质主要讲解在对应位置。

原书依据 · 10 处
reload、from以及交互模式测试

交互重载先需模块引用,再明确使用哪版成员。

模块重载不会更新所有引用关联本项背景,实质主要讲解在对应位置。

原书依据 · 10 处
递归形式的from导入无法工作

循环导入会在模块尚未执行完时暴露部分命名空间。

循环导入可见未完成的模块

recur1先绑定X,再导入recur2,最后才计划绑定Y。recur2反向取得缓存中的recur1时,只能看到当前已有属性;此时from recur1 import Y会失败。改用模块引用也只有把Y读取延迟到初始化完成后才可能避免同一问题。

结构图:

sequenceDiagram
  participant A as recur1
  participant B as recur2
  A->>A: 绑定X
  A->>B: import recur2
  B->>A: from recur1 import X
  A-->>B: 已有X
  B->>A: from recur1 import Y
  A-->>B: Y尚未绑定,导入失败

优先减少循环依赖;确需互相引用时,明确初始化与延迟读取的边界。

947第7题解释先导入recur2时的具体顺序:recur1的import取回尚在初始化的模块对象,未立即索取缺失字段,之后recur2的from读取已完成recur1.Y。但这不是把import换from或更改入口总能修复循环的普遍规则;后续字段使用时间仍决定成败。

循环导入可见未完成的模块保存独立卡片。

原书依据 · 2 处

本章小结

高级模块章收束接口、身份、内省与依赖更新。

本章习题

五问检查导出、入口身份、字符串加载和路径配置。

习题解答

答案的导出和路径作用范围仍需附带实际条件。

通配导入削弱名称来源边界关联本项背景,实质主要讲解在对应位置。

路径配置作用范围要明确关联本项背景,实质主要讲解在对应位置。

原书依据 · 12 处

第五部分 练习题

练习把模块接口、入口、路径、重载和循环加载联系起来。

文件结束与空白行返回不同关联本项背景,实质主要讲解在对应位置。

同文件双身份会分离模块状态关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处

第六部分 类和OOP

进入类与面向对象部分。

第25章 OOP:宏伟蓝图

类把共同的行为定义与每个实例的状态连起来。继承表达从超类取得或覆写行为,组合表达把其他对象作为成员协作;两种复用关系不应混为一谈。方法访问会绑定主体实例,因而同一个函数定义能在不同对象上操作各自状态。

类为组织实例状态、行为与可定制关系提供工具,使用仍需职责判断。

面向对象可选而非强制写类关联本项背景,实质主要讲解在对应位置。

类把实例状态与方法结合关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处

为何使用类

继承和组合用于表达不同关系,类还提供实例与协议组织能力。

特殊方法协议查找有类型层规则关联本项背景,实质主要讲解在对应位置。

原书依据 · 15 处
继承与组合表达不同关系

复用对象行为前应分清关系。

关系 原书领域示意 用途
继承:是一种 比萨机器人属于机器人 复用和定制基类行为
组合:包含并协作 机器人使用机械臂与马达 让组件各自承担任务

这是领域关系对比,原文没有具体类型声明与方法签名;不能仅因代码可复用就把组件画成父类。

继承可表达对共有行为的定制,组合可让控制器管理成员或包装协作者;一个容器里的成员本身又可以使用继承。选择取决于语义与职责关系,不由“继承总是最佳”的笼统排序决定,也不能只凭调用方向判断类型关系。

名词与动词可作为发现候选对象和行为的起点,但并非每个名词都应变成类、每个动词都应变成方法;仍需确认职责、状态和协作关系。原书把组合泛指嵌入对象,较严格图示还应区分创建持有、外部聚合与临时依赖。

第31章练习以两张图对比关系:Zoo是类型继承;Scene组织三个成员实例,而不是继承三个角色。

结构图:

classDiagram
class Animal
class Mammal
class Cat
class Dog
class Primate
class Hacker
Animal <|-- Mammal
Mammal <|-- Cat
Mammal <|-- Dog
Mammal <|-- Primate
Primate <|-- Hacker

图31-1给出六种类型。题目要求Animal.reply通过self.speak产生动态分派,未给完整方法定义和参数列表,图中不补造签名。

classDiagram
class Scene
class Customer
class Clerk
class Parrot
Scene o-- Customer : 组织实例
Scene o-- Clerk : 组织实例
Scene o-- Parrot : 组织实例

图31-2要求Scene.action协调成员line动作,但未给完整构造/生命周期实现,因此用聚合表达已知组织关系,不断言独占销毁。成员本身可再使用继承;图和预期台词都只是练习规格。

948的02624-02625把Lunch/Customer/Employee/Food分工:Lunch持有cust/empl;order传食品名与employee到Customer.placeOrder,Employee.takeOrder构造Food,Customer保存food,result再让Customer.printFood输出food.name。

结构图:

classDiagram
class Lunch {
 cust
 empl
 __init__(self)
 order(self, foodName)
 result(self)
}
class Customer {
 food
 __init__(self)
 placeOrder(self, foodName, employee)
 printFood(self)
}
class Employee {
 takeOrder(self, foodName)
}
class Food {
 name
 __init__(self, name)
}
Lunch *-- Customer
Lunch *-- Employee
Customer --> Food : 保存返回的对象
Employee ..> Food : 创建

这是组合与委托,不是Lunch继承Customer或Food;未点餐时food为None,代码没有提前调用printFood的防护,不推断所有调用顺序都合法。

继承与组合表达不同关系保存独立卡片。

原书依据 · 5 处
实例绑定独立不保证对象深隔离

通常调用类会建立实例自己的属性绑定,可保存不同对象的数据,并共同使用类提供的行为。绑定独立不代表类属性或嵌套可变对象都自动复制,也不保证所有定制类调用必然生成独一新对象。

普通类调用通常生成新的实例并通过类提供行为,这是与常规模块缓存身份不同的组织方式;定制new或元类等可能改变调用结果,实例独立命名空间也不保证共享可变对象被复制。模块单份同样是默认导入缓存模型而非所有环境的绝对限制。

类属性可由多个实例通过查找共享,若该值是可变对象,原地修改会对使用同一对象的实例产生影响。实例上建立同名普通数据属性往往遮蔽类属性,这与修改类中共享对象不同;描述符和定制属性访问另有规则。

在普通属性存储模型中,self.name=value建立或更新当前实例的属性,不会仅因类中定义了方法就自动修改类属性。但若属性由描述符、setattr等控制,赋值路径可以不同;独立绑定也不意味着赋入的可变对象被深复制。

实例绑定独立不保证对象深隔离保存独立卡片。

原书依据 · 4 处

概览OOP

OOP术语需要结合后续具体代码建立理解。

属性继承搜索

属性查找可沿实例、类和基类关系取得名称,但一般规则不止朴素爬树。

实例所属关系不同于类继承

图中C1继承C2和C3,I1与I2则是C1创建的实例,不是C1的子类。实例name可各自保存数据,类上x/y及基类属性可供共享查找;图的边必须区分继承与实例所属。

结构图: 类图(本项原图只给属性,没有方法签名,未补造):

classDiagram
class C2 {
  x
  z
}
class C3 {
  w
  z
}
class C1 {
  x
  y
}
class I1 {
  <<instance>>
  name
}
class I2 {
  <<instance>>
  name
}
C2 <|-- C1
C3 <|-- C1
I1 ..> C1 : 实例所属,非继承
I2 ..> C1 : 实例所属,非继承

图28-1把执行class S1/S2、定义X(S1,S2)、调用X()及实例方法中的self属性连接起来。类头的基类列表建立类之间的继承关系,调用类建立实例与其类型的关系;实例不是其类型的子类。类和实例属性也可在类语句外赋值,因此图只是常见创建路径,不是排他的合法路径。

实例所属关系不同于类继承保存独立卡片。

原书依据 · 2 处
继承查找应按解析顺序理解

本例普通属性中,C1重新定义的x优先于C2.x,z按基类次序在C2找到,w来自C3;实例自己的name可直接提供值。现代多继承按线性化方法解析顺序处理,描述符等还会影响属性优先级,不能把任何结构都理解成任意深度优先遍历。

原书将属性查找概括为从对象向上搜索,并据此解释子类专有化。这可帮助理解普通数据示例,但类对象属性查找、实例描述符优先级以及隐式特殊方法等不能全部套用同一个朴素树搜索;多继承仍以方法解析顺序等真实规则为准。

继承查找应按解析顺序理解保存独立卡片。

原书依据 · 2 处
类和实例

类为一类实例组织行为,实例承载具体对象数据。

类把实例状态与方法结合关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
类方法调用

普通实例方法访问绑定处理对象,self把这个对象显式交给方法体。

普通方法绑定实例作为首参

普通函数定义为类属性后,经实例读取通常形成绑定方法,调用时自动把该实例放到首个参数位置。self是惯用名,不是关键字;通过类直接调用相应函数时需明确传实例。静态方法、类方法等有不同规则,不能把所有类内可调用对象都当同样绑定。

setname通过self给I1和I2分别写name;I1.setname与C1.setname都能取得属性,但前者的普通方法绑定与后者的函数访问并不等价,调用时显式传参要求不同。

函数upperName(self)在类外定义时是普通函数,调用需传入带name属性的对象。把它赋给rec.method后,经x.method取得会形成绑定方法,调用时自动带入x;rec.method(x)则显式提供实例。绑定来自函数作为类属性的机制,不来自参数恰好拼成self,也不是把函数赋到任意实例属性都自动得到同样行为。

对于此处类中定义的普通函数,经实例调用会把该实例作为首参,显式按类取函数调用则要自行传入相应对象。self有助区别实例属性与局部名称,但方法也可经其他实例引用访问状态,并非语言强制只能经这个拼写读写属性。静态方法与类方法另有绑定规则。

NextClass.printer(self,text)经x.printer(“instance call”)自动带入x;NextClass.printer(x,“class call”)显式传入同一对象,二者都更新x.message。原图末尾的unbound method必须接NextClass实例的错误属于旧式未绑定方法语义,不能照抄为现代Python3的错误保证;当前普通函数仍须满足参数与方法体使用对象的要求。

保存object.changeColor得到的绑定方法,会携带对应实例,使稍后cb()无需再次显式传入self;这不是丢掉实例,而是把实例引用与函数共同保存。lambda默认参数也可捕获当时对象,但具体状态共享与调用时机仍须按相应机制判断,不能给各种做法作无条件优劣排序。

Spam.doit(self,message)经object1.doit取出时形成绑定方法,可赋给x后稍后x(message)。经类取得Spam.doit在Python3中是普通函数,调用时需按真实签名传入目标;Eggs.m2里的self.m1也遵循相同绑定过程。保存可调用引用不等于已经运行函数体。

普通方法绑定实例作为首参保存独立卡片。

原书依据 · 7 处
编写类树

方法通过self建立实例属性,初始化钩子可保证构造后具备所需状态。

普通方法绑定实例作为首参关联本项背景,实质主要讲解在对应位置。

特殊方法协议查找有类型层规则关联本项背景,实质主要讲解在对应位置。

原书依据 · 22 处
实例初始化建立必要属性

原例先调用setname(self,who)才建立self.name;若接口要求实例一建立就有名字,可把同一赋值放到init(self,who)。init负责初始化已创建实例,不应把它概括为完整对象分配过程;子类覆写初始化时也须考虑继承契约。

结构图: 类图(原书两个替代实现,分别展示,未把两版本合成一个类):

classDiagram
class C1 {
  setname(self, who)
}
class C2
class C3
C2 <|-- C1
C3 <|-- C1
classDiagram
class C1 {
  __init__(self, who)
}
class C2
class C3
C2 <|-- C1
C3 <|-- C1

方法中的self.name写入相应实例,两个图都未声明name为共享类属性。

本章习题把无init的实例概括为空命名空间,是普通简单类的教学模型。实际还涉及继承所得初始化、new及实例存储规则;不能从没有在当前类体写init推断对象必然没有状态,也不能把初始化钩子等同完整分配过程。

实例初始化方法init与包文件init.py是不同机制,前者用于对象初始化,后者用于普通包的初始化;名称相似不代表调用时机或作用相同。

阅读init通常能了解实例建立时需要的状态,但属性也可能在后续方法、继承或动态赋值中创建,因此不能把构造函数里出现的名称当作全部实例属性的完整清单。

把方法所依赖的必要属性在初始化中建立,可使成功构造后的对象满足预定初始约束,减少“先调某方法才能调另一方法”的隐式前置顺序。但这不自动保证后续任意外部修改仍保持约束,也不要求每一个动态属性都必须在初始化中出现。

实例初始化建立必要属性保存独立卡片。

原书依据 · 5 处
OOP是为了代码重用

子类可定制共有接口的部分行为,处理器则依赖协作者契约来复用流程。

覆写定制行为并保留共有接口

Employee提供通用行为,Engineer只覆写computeSalary(self)。调用同名方法时,由实际对象及属性解析决定使用哪个实现,未覆写的行为可继续继承。这种定制仍需满足共有接口的语义,不能仅凭方法同名就认为任意子类都可替换。

结构图:

classDiagram
class Employee {
  computeSalary(self)
  giveRaise(self)
  promote(self)
  retire(self)
}
class Engineer {
  computeSalary(self)
}
Employee <|-- Engineer

图仅反映原书骨架,方法体为省略号,没有可核实的薪资算法;示例未执行。

继承允许在子类定义同名行为来定制基类的通用实现,避免直接修改基类。它是可用的扩展机制,不意味着任何修改都必须增加子类,也不意味着模块/函数完全无法组合或定制。

覆写定制行为并保留共有接口保存独立卡片。

原书依据 · 2 处
依赖协作接口复用处理流程

processor(reader,converter,writer)反复读取数据,把数据传给转换器,再交给写入器;原例在读取结果为假时结束。复用来自对read()、可调用转换器和write(data)契约的依赖,不要求调用者知道具体文件或网络实现,也不必强制所有对象共享一个自定义基类。

结构图:

classDiagram
class Reader {
  read(self)
  other(self)
}
class FileReader {
  read(self)
}
class SocketReader {
  read(self)
}
Reader <|-- FileReader
Reader <|-- SocketReader

原文还以FtpReader、FileWriter、TapeWriter、XmlWriter示意替代对象,但未给出其完整类型定义和方法签名。processor是独立函数,未画成类;是否以假值代表结束必须与数据源约定,不能直接套用于允许空记录的数据流。

依赖协作接口复用处理流程保存独立卡片。

原书依据 · 1 处
框架复用仍需要设计契约

框架可预先组织通用流程或默认行为,让使用者通过实现扩展点来定制应用,减少重复编写与直接修改已有代码。收益取决于扩展接口、职责和依赖是否合理;继承是本章展示的办法之一,组合与函数协作也能承担复用,不能把树形属性搜索当作面向对象设计的全部。

本章比较从头重写、原处修改基类和复制整类的维护成本,说明子类定制可保留共有行为并减少重复。作者称没有其他工具能支持这种开发方式,是本章强调继承的教学表述;不能据此否定组合、委托或策略函数。是否采用继承仍须确认语义关系、接口兼容性与预期变化,代码短或存在复用并不足以单独决定。

框架复用仍需要设计契约保存独立卡片。

原书依据 · 2 处

本章小结

本章以类、实例和继承查找建立后续编码的概念地图。

本章习题

习题回顾实例、类、初始化及基类声明。

习题解答

解答再次连接class执行、类调用、普通方法绑定与初始化。

实例初始化建立必要属性关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处

第26章 类代码编写基础

class语句建立类对象,实例构造再把该类用于具体对象。属性可以位于实例或类上,查找规则决定读取到哪一份;在实例上重新赋值也可能只形成遮蔽,而不是修改类字段。理解这个分层,才能解释共享默认行为与独立实例数据。

本章将类对象、实例命名空间及继承等抽象落到class语法。

类产生多个实例对象

类对象可作为实例工厂,实例通常保存各自状态并复用类行为。

实例绑定独立不保证对象深隔离关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
类对象提供默认行为

class是执行后产生对象的语句,其体内顶层名称形成类属性。

实例绑定独立不保证对象深隔离关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
执行类体建立类属性

执行class语句会执行类体并建立类对象,随后把它绑定给类名。类体顶层赋值及def建立的名称通常进入类的属性命名空间,可通过属性访问;方法体内部的局部赋值则不会因此成为类属性。类体在定义时运行,普通方法体在被调用时运行,不应混淆两者时机。

到达并执行class语句时才建立相应类对象和类名绑定;定义可以出现在模块加载或其他被执行的代码路径中。编译可先发生,但这不意味着运行前已经存在本次定义的类对象。已有同名旧绑定与本次定义也须区分。

原书一般形式中,类体顶层data=value产生类属性,method中的self.member=value在调用时建立实例状态。并非文本上嵌套在class里的任何赋值都自动变成类属性:方法局部名称和显式global等情况应按对应作用域处理。

执行class时会执行类体的顶层print、赋值、条件和def等语句,def此时建立函数,而不是因此立即运行方法体。类体可有多种合法语句,但仍须遵守语法位置限制,不能把“任何种类”理解为return等在任何类体都合法。

执行类体建立类属性保存独立卡片。

原书依据 · 4 处
实例对象是具体的元素

方法中的self指向当前实例,普通实例属性赋值建立该对象状态。

实例绑定独立不保证对象深隔离关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
第一个例子

FirstClass把共享方法与各实例自己的data绑定连接起来。

实例状态可在方法调用后建立

FirstClass没有自定义初始化,在setdata(self,value)中才给self.data赋值。x和y可保存不同类型的数据,同时经类取得相同的方法;若在赋值前调用display,普通模型下会因缺少data属性而触发AttributeError,而非未定义裸变量名的NameError。

结构图:

classDiagram
class FirstClass {
  setdata(self, value)
  display(self)
}
class x {
  <<instance>>
  data
  anothername
}
class y {
  <<instance>>
  data
}
x ..> FirstClass : 实例所属,非继承
y ..> FirstClass : 实例所属,非继承

实例字段反映原书最终演示状态,不是类中声明的共享字段。普通可写实例可从类外建立或修改属性,但不能据此推断任何对象的任何属性都能写入。

实例状态可在方法调用后建立保存独立卡片。

原书依据 · 1 处

类通过继承进行定制

子类用同名属性定制行为,方法中的self访问仍以实际实例查找。

覆写定制行为并保留共有接口关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
方法内属性查找仍面向实例

在继承方法内执行self.attr时,self仍是接收调用的实际实例,因此可能取得实例状态或子类覆写的行为;并非因为方法定义在基类就把所有属性固定到基类。普通属性解析、描述符及特殊方法的隐式查找应分别理解,不能一概套用朴素实例优先树搜索。

方法内属性查找仍面向实例保存独立卡片。

原书依据 · 1 处
第二个例子

SecondClass覆写display而复用FirstClass.setdata,定制不改写FirstClass本身。

子类覆写不改写基类定义

SecondClass重新定义display(self),通过继承继续使用FirstClass.setdata(self,value)。因此z.display()调用子类版本,而FirstClass实例x仍使用基类版本;新增子类本身没有改写基类方法。若子类显式修改共享基类状态则另当别论。

结构图:

classDiagram
class FirstClass {
  setdata(self, value)
  display(self)
}
class SecondClass {
  display(self)
}
FirstClass <|-- SecondClass

原文把同名替换有时称为重载,这里更明确称覆写,避免与按参数签名选择方法或运算符协议混淆。

Manager复用Person提供的初始化、lastName和字符串显示,只定制giveRaise;因此新增子类不要求重写全部方法。基类方法中的self仍可指向Manager实例,调用哪个实现要按具体名称解析,不能把所有行为一并固定到子类或基类。

D.attr=C.attr把类体执行时取得的对象绑定到D.attr;以后C.attr重绑定不自动重绑D.attr,若最初对象可变,仍可能共享同一对象。方法版本的D.meth=C.meth同样需按具体方法/描述符规则理解,现代普通函数别名不同于每次动态重新选择。显式C.meth(self)可指定这次调用,却不会自动参与协作式super链;这些手法不构成任意未来版本/初始化顺序均兼容的保证。

子类覆写不改写基类定义保存独立卡片。

原书依据 · 3 处
类是模块内的属性

类名是引用类对象的普通绑定,导入和属性路径仍遵守模块规则。

模块名与类名应分清绑定

执行import person把模块绑定到person,用person.person访问其中同名的类;from person import person则把类直接绑定到当前名称。模块可同时包含多个类、函数与变量,类是其中执行的一条定义语句,不能把模块名直接当成内部类。使用Person一类的大写类名有助分辨,但这是命名惯例而非强制语法。

person.py中的Person是该模块中的类;小写模块名、大写开头的类名及self是可读性惯例,不是名称绑定机制的强制要求。模块应保持相干职责,不能因为文件名是person.py就把日后任意无关逻辑持续塞入其中。

常规模块提供导入时的代码与名称组织,类可作为模块中执行定义的对象类型并通过调用创建实例。两者都暴露属性,不意味着模块就是只有一份的类或所有类只能在模块顶层定义;类也可在函数等位置动态建立。

模块名与类名应分清绑定保存独立卡片。

原书依据 · 3 处

类可以截获Python运算符

特殊方法把类对象与语言操作连接,采用前应判断操作是否符合对象语义。

特殊方法协议查找有类型层规则关联本项背景,实质主要讲解在对应位置。

原书依据 · 15 处
运算符接口应符合领域语义

特殊方法可让自定义对象参与加法、索引或字符串转换等语言操作。是否实现应由对象含义与调用方契约决定:向量加法可能自然,员工晋升通常用promote等明确方法更清楚。支持同名操作只保证入口存在,仍须满足参数、返回值与行为契约,不能仅凭一组方法名保证完全兼容。

向量或矩阵可能自然支持加法,而员工行为常更适合明确命名方法;选择依据是领域含义及调用者期待,而不是仅以工具开发者或应用开发者身份划分。实现入口后仍需核对真实语义,不能因同名操作齐全就宣称完全替代内置类型。

若对象自然需要某种序列、映射或数值接口,可实现对应协议;若操作符与对象职责无自然对应,明确命名方法往往更容易理解。统一语法入口并不免除语义、参数与返回值的接口设计。

运算符接口应符合领域语义保存独立卡片。

原书依据 · 3 处
第三个例子

ThirdClass展示初始化、加法与字符串协议,并对比产生新对象和修改当前状态。

实例初始化建立必要属性关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
新对象结果不同于原处修改

ThirdClass.add(self,other)用self.data+other构造并返回ThirdClass新实例,原对象保持原状态;mul(self,other)通过self.data*=other更新当前实例的属性且隐式返回None。这里data为字符串时,后者是把新字符串重新绑定到self.data,并非原地修改字符串本身。

结构图:

classDiagram
class SecondClass {
  display(self)
}
class ThirdClass {
  __init__(self, value)
  __add__(self, other)
  __str__(self)
  mul(self, other)
}
SecondClass <|-- ThirdClass

图反映实际定义签名,继承的setdata来自更上层FirstClass。str返回字符串供str/print使用,add的返回值成为表达式结果;两者不能替代彼此。

新对象结果不同于原处修改保存独立卡片。

原书依据 · 1 处
为什么要使用运算符重载

是否实现协议取决于对象的使用语义,初始化有助明确初始状态。

运算符接口应符合领域语义关联本项背景,实质主要讲解在对应位置。

实例初始化建立必要属性关联本项背景,实质主要讲解在对应位置。

原书依据 · 8 处

世界上最简单的Python类

动态命名空间解释了类属性共享、实例遮蔽及函数成为绑定方法的过程。

普通方法绑定实例作为首参关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处
实例赋值可遮蔽共享类属性

空类rec先在类对象上绑定name与age,x和y经类查找得到同一name。执行x.name赋值后,x有自己的name,y仍经rec取得原值。此处修改的是x的普通属性绑定,既没有复制全部类属性,也没有修改rec.name;若改为原地修改共享可变值,后果会不同。

SharedData.spam改为99会影响仍通过类取得该值的实例;随后x.spam=88只在普通实例x上建立同名绑定,y仍读取类值99。属性赋值并非永远无其他影响,还可能经过描述符或setattr等定制。

X.a从1改为2之后,已有I和新建J若仍通过X查找a都会看到2;这不是对所有实例字段的逐个写入。若实例或更近的子类已有自己的定义,实际查找可能不同。Record实例上保存name/job是另一种存储政策;不能因类也能临时充当命名空间,就随意改写第三方类并假定不影响其行为。

C.shared是类上的一个列表,C.init为每个实例另建perobj列表。x.shared.append会修改共享对象,y.shared也能看见;x.perobj.append只改x自己的列表。x.shared=新对象则在普通实例上新建绑定,与原处修改列表不同,不会自动复制或修改C.shared。

结构图:

classDiagram
class C {
 shared$
 __init__(self)
}
note for C "shared为类列表;构造器为每个实例新建perobj列表"

图对应02008的真实C。每个实例有不同perobj列表,只说明这一层新建;若元素仍引用外部可变对象,深层共享需另行判断。

实例赋值可遮蔽共享类属性保存独立卡片。

原书依据 · 4 处
命名空间字典只是部分对象视图

普通实例的dict显示自身保存的属性,通常不包括从类继承的属性;类的dict在现代Python中是只读映射代理,并非可任意写入的普通字典。class指向实例所属类,类的bases是直接基类元组,不能代替完整方法解析顺序。slots等还可能改变实例属性存储,故这些视图不是任何对象完整接口的通用清单。

普通实例的class.name可取得所属类的名称,避免把Person硬编码在共有显示中;实例dict可迭代自身保存的键。通过getattr(obj,key)读取会走属性访问规则,不一定等价于直接从字典取值;类字典映射代理、slots和定制访问都限制所谓通用性。

AttrDisplay自测中count属于TopTest,不出现在实例自身dict;attr1/attr2才是构造写入实例的字段。沿class/bases能探索类型结构,但要处理继承顺序与重复祖先,不能把字典合并当作完整属性语义。

X与Y可共享类上的hello/hola而各自保存独立字段绑定;X增加data1/data2不会自动在Y的实例字典增加键。实例class与类bases能显示结构连接,但类字典在现代Python中为映射代理,对象也不只是若干任意可写字典。

命名空间字典只是部分对象视图保存独立卡片。

原书依据 · 4 处
类与字典的关系

字典记录、类对象记录与实例记录在字段组织和行为约束上不同。

记录结构选择取决于约束

字典可用键表示记录,空类对象可用属性临时容纳一条记录,实例则让同一个类产生多条独立记录。加入初始化和方法后,类可把字段约定与相关处理组织在一起;但初始化只提供构建时的约定,不自动禁止之后删除属性、增加字段或赋入错误类型。

形式 例中组织方式 边界
字典 name/job等键 无自动方法绑定或固定字段约束
类对象记录 rec.name等类属性 共享这一个对象,重复记录较别扭
实例记录 pers1/pers2各自属性 普通动态实例可具有不同字段集合
带逻辑的类 Person初始化并提供info 同时组织状态与行为,仍需设计接口约束

结构图:

classDiagram
class Person {
  __init__(self, name, job)
  info(self)
}

这是本节实际实现:info返回(name,job)元组;没有补造薪酬方法或继承父类。

记录结构选择取决于约束保存独立卡片。

原书依据 · 1 处

本章小结

本章把类定义、实例状态、方法绑定和协议操作联系起来。

本章习题

九题复习模块/类、属性创建、self及特殊方法选择。

习题解答

解答回顾构建时初始化状态及类与实例属性的创建位置。

实例初始化建立必要属性关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处

第27章 更多实例

Person与Manager案例把状态、方法、继承和持久化放进一个逐步发展的对象模型。子类可复用通用方法并定制局部行为,组合则可以把管理逻辑留在外部对象;它们对类型和调用路径的影响不同。示例的薪资和记录操作用于说明机制,不是完整业务系统。

下一章逐步构建Person与Manager,再介绍对象持久化。

步骤1:创建实例

示例以person.py组织人员相关类,名称约定帮助读者区分模块与类。

模块名与类名应分清绑定关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
编写构造函数

构造函数把短期参数绑定保存为实例属性,并以默认值表达可选输入。

默认值只补未提供的参数关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
局部参数与实例属性是不同绑定

init(self,name,job=None,pay=0)中的job是这次调用的局部参数,self.job是实例上的属性。赋值把参数所指对象保存在实例上,供调用结束后的方法使用,并非把局部变量本身变成永久变量,也不自动复制对象或写入磁盘。

结构图:

classDiagram
class Person {
  __init__(self, name, job=None, pay=0)
}

这是当前版本实际签名,实例初始化保存name/job/pay;没有把这些字段画成共享类属性。

局部参数与实例属性是不同绑定保存独立卡片。

原书依据 · 1 处
在进行中测试

小步构建并反复运行可复现的测试,帮助及早检查当前实现。

增量开发保留可复现的检查

先实现最小可用结构,检查实例字段与默认值,再逐步加入行为并重新检查,可在改动较小的时候发现问题。交互式提示适合一次性探索,把固定检查保存下来则便于重跑;单纯打印只是观察,不等于自动断言通过,更不证明覆盖所有边界。原书展示了默认参数与显式关键字两条构造路径,此处仅阅读,未执行。

增量开发保留可复现的检查保存独立卡片。

原书依据 · 1 处
以两种方式使用代码

主程序保护使演示入口在直接执行时运行,库导入时只提供定义。

主程序保护区分入口与导入关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处

步骤2:添加行为方法

分散在类外的姓名与工资处理会形成重复规则和多处修改成本。

重复业务规则形成修改扩散

如果多处客户端都写name.split()[-1]或按比例更新pay,同一规则变化时就必须找到并修改所有副本,遗漏会造成不一致。把有共同含义的操作集中到明确接口,可让规则有一个维护位置;但需要先确认这些调用确实共享同一语义,而非仅表面代码相似。

把Person的计算公式复制到Manager再加bonus,会让相同计算规则分别存在两处。若未来共有逻辑变化,需要识别并同步两个实现;减少这一风险的方向是复用共同实现,并只集中表达实际变化部分,而非仅因复制短期容易就默认复制全部逻辑。

重复业务规则形成修改扩散保存独立卡片。

原书依据 · 2 处
姓名分割规则依赖输入约定

name.split()[-1]取非空分词序列的最后一项,并不是识别所有人名中姓氏的通用方法。它依赖输入非空且末段代表目标名称部分;空白名称会导致取末项失败,多种姓名文化或后缀也可能不满足规则。封装能集中调整规则,却不会自动让这一假设正确。

姓名分割规则依赖输入约定保存独立卡片。

原书依据 · 1 处
编写方法

方法封装将共享规则集中,并把查询结果与状态变更的不同责任表达出来。

封装集中实现仍需维护契约

把姓氏提取和工资更新从各个客户端移入Person.lastName与giveRaise,可集中规则并作用于任意满足约定的Person实例。lastName返回计算值供调用者使用,giveRaise更新当前实例状态;调用者仍需遵守输入和结果契约。实现可替换的范围取决于是否保持契约,而非藏到方法后就能随意改变行为。

结构图:

classDiagram
class Person {
  __init__(self, name, job=None, pay=0)
  lastName(self)
  giveRaise(self, percent)
}

图为本节实际版本,尚未加入下一节的字符串显示方法。

封装可把数据处理集中在对象接口之后,减少外部对实现细节的依赖,但不等于Python自动提供强制私有性。改变实现后不影响使用者,前提是相关可观察契约继续成立;方法存在、名称相同并不足以证明可替换。

封装集中实现仍需维护契约保存独立卡片。

原书依据 · 2 处
数值转换不等于业务舍入

示例giveRaise把self.pay*(1+percent)传给int,它将结果向零截断为整数,并不等同某种普遍适用的金额舍入。浮点格式化只改变显示,不能修复存储或计算规则;若实际领域需要特定精度、单位和舍入,应另行明确契约。本卡只解释原书代码边界,示例未执行。

数值转换不等于业务舍入保存独立卡片。

原书依据 · 1 处
参数假设应成为显式接口契约

示例假设percent在0与1之间,却没有实现范围校验;因此不能把注释中的希望当成运行时保证。按比例调整也意味着pay为0时仍为0,若需求是给出新的基础值,就需要不同操作而非假装这一公式已满足。验证应针对真正业务约定,不能机械断言所有范围外值都必然错误。

参数假设应成为显式接口契约保存独立卡片。

原书依据 · 1 处

步骤3:运算符重载

默认对象显示常不能直接表达实例业务状态。

默认对象显示不保证物理地址

普通对象的默认表示通常包含类型和身份相关信息,未必能帮助理解name/pay等字段。原书输出中的十六进制片段不应作为跨实现保证的真实物理内存地址,更不能把这种表示当持久主键或完整状态序列化格式。若需要可读状态,可设计明确的字符串表示。

lister把id(self)标成address。id代表对象身份并在存活期间保持,CPython文档的内存地址说明是实现细节,不保证跨实现为物理地址,更不宜持久化成业务主键。作者输出中的数值不同也不是算法错误。

默认对象显示不保证物理地址保存独立卡片。

原书依据 · 2 处
提供打印显示

字符串协议提供面向读者的实例显示,与开发者表示职责区分。

字符串表示区分使用目标

str(self)应返回适合阅读的字符串,本例显示Person的name/pay;print和str通常用它。repr偏向调试表示,交互式环境显示表达式结果通常使用它;缺少自定义str时可回退到表示机制,不是必然无法打印。两者的具体内容都由接口设计决定,不能认为repr天然完整、可执行或可逆。

结构图:

classDiagram
class Person {
  __init__(self, name, job=None, pay=0)
  lastName(self)
  giveRaise(self, percent)
  __str__(self)
}

这是本节加入str后的完整实际方法集合,返回的字符串仅是展示,不改变对象字段。

str与repr都必须返回str,返回其他对象不会自动转换成功。print/str通常采用str,缺省时可回退到repr;repr和常见交互表示不反过来借用str。内置列表等展示元素时通常用repr,故只定义str不保证嵌入容器后仍显示用户格式。任意自定义容器仍可选择自己的展示规则,不能说repr必在所有环境运行。

Printer的两个替代版本分别实现str和repr,其他真实签名同为init(self,val)。前者单独打印可显示值,但在列表表示中仍显示默认repr;后者常能兼顾这两类环境。repr只是一种显示接口,不保证无条件可逆构造或可安全用eval还原。

字符串表示区分使用目标保存独立卡片。

原书依据 · 2 处

步骤4:通过子类定制行为

已经具备实例、方法与显示协议后,示例转向用子类定制共有行为。

编写子类

Manager继承Person,在相同操作入口接受额外的定制参数。

子类定制参数仍须兼容调用契约

示例Manager.giveRaise(self,percent,bonus=.10)在传入percent之外,默认加入.10再参与比例更新。这里两个比例直接相加,属于作者为演示设计的约定,不是先后复合增长,也不代表现实奖金制度。为bonus设置默认值使已有giveRaise(percent)形式仍可调用;其余语义是否兼容仍需判断。

结构图:

classDiagram
class Person {
  giveRaise(self, percent)
}
class Manager {
  giveRaise(self, percent, bonus=.10)
}
Person <|-- Manager

本图只展示当前展开的继承与覆写接口,没有把默认参数当作验证过的业务规则。

子类定制参数仍须兼容调用契约保存独立卡片。

原书依据 · 1 处
扩展方法:不好的方式

复制原实现虽可得到当前效果,却使同一规则出现多个维护副本。

重复业务规则形成修改扩散关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
扩展方法:好的方式

子类通过明确调用基类实现,在复用共同逻辑的同时调整输入。

子类覆写不改写基类定义关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
扩展方法可委托共有实现

Manager.giveRaise把percent+bonus传给Person.giveRaise(self,…),沿用基类的计算和状态更新,避免复制完整公式。显式通过类取得普通方法函数时,需要自己传self;这也明确选择了Person这一版本,并非任意继承结构都能照搬同一路径。复杂协作多继承的分派须另行设计。

原例Sub.method(self)先做自身前置步骤,再显式调用Super.method(self),最后做后置步骤。这样复用默认行为,同时明确附加行为的先后次序;若基类调用失败,后置步骤未必运行,不能把普通顺序执行当成无条件清理保障。

扩展方法可委托共有实现保存独立卡片。

原书依据 · 2 处
覆写内部同名调用可能递归

Manager方法内部若按相同签名调用self.giveRaise(percent),self仍是Manager实例,通常会再次选中覆写方法并重复进入自身。若要调用特定基类实现,本例明确写Person.giveRaise(self,…);不能以为“方法写在子类里”就会自动跳到父类。同名调用是否递归仍取决于当时对象与属性解析,原文省略参数的self.giveRaise()在此具体签名下还可能先报缺少参数错误。

覆写内部同名调用可能递归保存独立卡片。

原书依据 · 1 处
多态的作用

同一调用表达式根据接收对象取得相应实现,共有显示方法则继续复用。

多态调用分派按接收对象解析

循环遍历bob、sue、tom,对每个对象调用giveRaise(.10),普通Person实例取得Person版本,Manager实例取得定制版本;不需要循环逐一按类型写分支。同时,三个对象可复用Person.str,所以多态不表示每个方法都必须有不同实现。对象仍须满足所调用操作的契约;任意对象仅有同名方法并不保证结果含义相容。

本节以运行期属性解析说明Python的接口多态,但多态并非只在无类型声明的语言存在,类型注解也不取消Python运行时对象行为。实际可替换性仍需考虑输入、结果和状态语义,而非仅凭调用同名方法。

练习要求Animal.reply调用self.speak,Cat可给自己的speak,删去Hacker的speak后会沿继承取得Primate版本。调用者保留reply这一入口,实际speak由接收对象及类层次决定;02024的meow/Hello world只是题目所示预期输出,不代表本次实现或执行。图的继承/组合关系另见继承与组合表达不同关系。

948的02626中Animal.reply调用self.speak,Mammal/Cat/Dog/Primate各覆写,Hacker只继承Primate实现,说明超类代码中的self仍是实际接收者。02627-02628的Actor.line分别取self.name和self.says(),在Customer/Clerk/Parrot中各自解析,Scene.action顺序委托三个成员。

结构图:

classDiagram
class Animal {
 reply(self)
 speak(self)
}
class Mammal {
 speak(self)
}
class Cat {
 speak(self)
}
class Dog {
 speak(self)
}
class Primate {
 speak(self)
}
class Hacker
Animal <|-- Mammal
Mammal <|-- Cat
Mammal <|-- Dog
Mammal <|-- Primate
Primate <|-- Hacker

动物分类只是人工教学模型,不据此推出现实分类结论;表演文本不作为独立知识转录。

多态调用分派按接收对象解析保存独立卡片。

原书依据 · 4 处
继承、定制和扩展

继承可以沿用、覆写已有操作,也可新增仅对子类有效的操作。

继承覆写与新增操作应区分

示例Manager可沿用lastName与字符串显示,覆写giveRaise,还可新增someThingElse。新增方法只扩大该子类提供的接口,不能由此假设所有Person对象也能调用它;共有调用方若依赖新增能力,需要明确额外契约。原图给someThingElse的参数与实现均为省略号,没有可核实的完整签名或行为,不补造成业务实现。

继承覆写与新增操作应区分保存独立卡片。

原书依据 · 1 处
OOP:大思路

在确有共同语义时,继承可把稳定实现与差异定制分开,减少重复维护。

框架复用仍需要设计契约关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处

步骤5:定制构造函数

子类初始化可裁剪输入,再明确委托父类建立必要的实例状态。

覆写初始化需明确状态建立责任

Manager.init(self,name,pay)不再要求调用方提供job,而是调用Person.init(self,name,“mgr”,pay)来复用初始化。覆写后不会自动再把所有基类初始化逐个执行;若仍依赖父类建立的name/job/pay,必须通过合适的初始化路径保证它们存在。直接调用基类是本例采用的方式,不是Python唯一支持的协作方式。

结构图:

classDiagram
class Person {
  __init__(self, name, job=None, pay=0)
}
class Manager {
  __init__(self, name, pay)
  giveRaise(self, percent, bonus=.10)
}
Person <|-- Manager

新旧构造签名不同是本节有意的接口裁剪,不能继续把原先传job的三参数构造当作当前签名。

示意Sub.init(self,x,y)通过Super.init(self,x)先复用默认初始化,再做自身步骤,明确各层所需参数。重新定义初始化不会自动在所有基类上补跑同名方法;直接点名父类只是此例的一种方式,不能宣称唯一方式。类体多次用同一名称定义init,后一次通常覆盖前一绑定,并非按参数数量自动重载。

章末通过Superclass.init(self,…)说明显式复用所需初始化,而不是重新复制代码;此写法限定于相应设计,现代协作初始化也可用其他受支持路径,不将它写成唯一路线。

覆写初始化需明确状态建立责任保存独立卡片。

原书依据 · 3 处
OOP比我们认为的要简单

本节把实例创建、方法、协议和定制初始化汇成基本学习路径。

组合类的其他方式

组合可通过包装与聚合管理协作对象,特殊方法需要单独设计转发。

特殊方法协议查找有类型层规则关联本项背景,实质主要讲解在对应位置。

原书依据 · 15 处
包装委托与继承是不同关系

替代版Manager不继承Person,而在初始化中保存self.person,并将部分操作传给这个Person。giveRaise调整参数后调用被包装对象,getattr在普通属性未找到时委托读取;这是“包含并控制”关系,不会自动让Manager成为Person子类,也不会自动把外部属性赋值转发给内部对象。

结构图:

classDiagram
class Person
class Manager {
  __init__(self, name, pay)
  giveRaise(self, percent, bonus=.10)
  __getattr__(self, attr)
  __str__(self)
}
Manager *-- Person : 构造并持有 person

这是与继承版二选一的实现,不将两版Manager合成一个类。被包装的Person行为继续按其自身定义执行。

列表扩展也有同一选择:把列表保存在包装对象中,显式导出所需操作;或创建list子类并继承已有行为。前者不自动成为list,后者也不自动满足应用新增的不变量。应按需要的接口与替换契约选择,不能仅按写法长短决定。

851重访同一组合版Manager,Person完整方法如下,Manager构造并持有它而非继承:

结构图:

classDiagram
class Person {
 name
 job
 pay
 __init__(self, name, job=None, pay=0)
 lastName(self)
 giveRaise(self, percent)
 __str__(self)
}
class Manager {
 person
 __init__(self, name, pay)
 giveRaise(self, percent, bonus=.10)
 __getattr__(self, attr)
 __str__(self)
}
Manager *-- Person : 构造并持有

02318-02320中lastName经缺失回退到嵌入对象,giveRaise在包装层调整percent后委托,显示则由显式str转交。删str只改变类型层显示支持,普通lastName委托仍在。02324的替代读取方法保留person/giveRaise自身访问,其余转发;02326又用基础获取person并对giveRaise返回lambda,减少额外钩子读取。最后版本不再显式定义giveRaise方法,也没有原可选bonus形参,不能说整套接口完全不变;普通manager.person也会被转向内部Person,而str用基础调用避开该路径。这些是替代类实现,不混为一个Manager。

包装委托与继承是不同关系保存独立卡片。

原书依据 · 3 处
聚合容器协调成员而非继承成员

Department在self.members中收集Person或Manager对象,addMember追加成员,giveRaise遍历调用各自的方法,showAll逐一打印。容器复用成员接口来协调一组对象,不需要自己继承Person;容器组合与成员内部的继承关系可以同时存在。

结构图:

classDiagram
class Department {
  __init__(self, *args)
  addMember(self, person)
  giveRaise(self, percent)
  showAll(self)
}
class Person
class Manager
Department o-- Person : members 可含
Department o-- Manager : members 可含

这里用聚合边,因为成员由外部创建后传入,不能从容器持有推断成员生命周期由容器独占。图没有虚构Person与Manager在所有替代实现中都相同的继承关系。

聚合容器协调成员而非继承成员保存独立卡片。

原书依据 · 1 处

步骤6:使用内省工具

显示中硬编码类型名与字段清单,会随类演化产生同步维护点。

显示字段清单也是维护契约

Person.str写死Person和name/pay,Manager继承后仍显示Person,且无法从输出确认job。若希望显示动态类名和实例字段,可引入内省;但显示什么本身仍是接口设计,应区分方便调试与面向读者的稳定展示,不能默认把任何新增字段都公开输出。

显示字段清单也是维护契约保存独立卡片。

原书依据 · 1 处
特殊类属性

内省可取得动态类型名称与实例自身字段,二者与继承属性范围不同。

命名空间字典只是部分对象视图关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
一种通用显示工具

AttrDisplay把基于实例字典的显示机制集中为可继承工具。

通用显示工具须限定适用对象

AttrDisplay.gatherAttrs按sorted(self.dict)取得名称,再通过getattr读取并拼接;str使用self.class.name和收集结果。它避免写死子类名和字段清单,但要求对象具备可用的实例字典以及相应属性访问,不能保证适用所有slots对象、任意混合类型键或存在副作用的访问逻辑。

结构图:

classDiagram
class AttrDisplay {
  gatherAttrs(self)
  __str__(self)
}
class TopTest {
  count
  __init__(self)
}
class SubTest
AttrDisplay <|-- TopTest
TopTest <|-- SubTest

本图来自classtools.py实际自测类型,count是TopTest共享类属性,attr1/attr2在实例初始化中建立。排序提供名称顺序,不等于定义完整或稳定的对外序列化协议。

ListInstance与ListTree依赖实例字典扫描,不能仅由通用工具名称保证包含slot实例值。ListTree即使显示基类的slot描述符,也不等于已经显示实例中保存的值;若扩展支持,需明确继承层次中的名称收集与getattr取值政策。dir列出名称也不自动保证任意属性读取成功或没有副作用。

通用显示工具须限定适用对象保存独立卡片。

原书依据 · 2 处
实例与类属性的关系

实例字典不会向下复制继承属性,dir则提供另一种名称清单。

命名空间字典只是部分对象视图关联本项背景,实质主要讲解在对应位置。

属性清单不等于接口说明关联本项背景,实质主要讲解在对应位置。

原书依据 · 10 处
工具类的命名考虑

复用工具的内部方法名可能意外与客户子类冲突,需要明确扩展边界。

内部名称约定不等于访问隔离

AttrDisplay.str调用self.gatherAttrs,如果子类无意定义同名方法,实际调用会取得子类版本。单下划线_gatherAttrs表达内部使用惯例,并不阻止访问或碰撞;双前导下划线的__gatherAttrs可触发类名改写以减少子类意外冲突,但不是加密、绝对私有或全局唯一保证。是否允许客户覆写,应在工具接口中明确,而非所有方法都机械隐藏。

单下划线表达非公开接口惯例,双前导名称可按定义类作名称改写,主要防止多层或混入类无意使用同名字段和方法。它不是对调用方授权的强制检查,知道改写后名称仍可访问;也不能据“默认公开”断言任意属性都必可写,描述符等可约束访问。

三个工具使用__attrnames等双前导名称来减少与客户子类的意外冲突;若定义类名相同、显式访问改写后名字或碰到其他共享状态,仍可能冲突。原文“确保任何名称不冲突”应限定为此命名机制的预期用途,不当强制访问隔离。

890明确可通过改写后的包装字段绕过访问控制。类名经过装饰后绑定代理类,因此isinstance结果必须说明拿哪个类作第二参数:与原主体类相比类型改变,与装饰后名称指向的代理类相比可能匹配。不能笼统写成所有isinstance检查都失败;这种代理不是防恶意访问的隔离机制。

内部名称约定不等于访问隔离保存独立卡片。

原书依据 · 4 处
类的最终形式

Person继承独立显示工具,Manager继续经Person共享该实现。

跨模块继承可集中公共工具

person.py导入classtools.AttrDisplay,让Person继承它并删除旧的专用str,Manager再继承Person。显示实现因而只有一份,读取实际实例类名与实例字典,所以可显示Manager和job;以后公共工具变化会影响其使用者,需要保持相关显示契约。

结构图:

classDiagram
class AttrDisplay {
  gatherAttrs(self)
  __str__(self)
}
class Person {
  __init__(self, name, job=None, pay=0)
  lastName(self)
  giveRaise(self, percent)
}
class Manager {
  __init__(self, name, pay)
  giveRaise(self, percent, bonus=.10)
}
AttrDisplay <|-- Person
Person <|-- Manager

图按本节实际两模块实现整理,没有把str再次列为Person自己的定义;工具适用范围仍受实例字典等前提限制。

跨模块继承可集中公共工具保存独立卡片。

原书依据 · 1 处

步骤7(最后一步):把对象存储到数据库中

内存对象生命周期与跨程序运行的数据保存是两个层次。

对象持久化与数据库查询分工关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
Pickle和Shelve

pickle负责对象序列化,shelve在键值存储上提供对象级存取。

对象持久化与数据库查询分工关联本项背景,实质主要讲解在对应位置。

对象序列化需要格式与版本约定关联本项背景,实质主要讲解在对应位置。

pickle加载仍需可信输入关联本项背景,实质主要讲解在对应位置。

原书依据 · 11 处
在shelve数据库中存储对象

存储脚本导入可定位的类,建立实例后按键赋值到shelve并关闭资源。

持久化键须表达记录身份

makedb.py用object.name作shelve键,是为了演示方便;真实姓名并不天然唯一,重复键赋值会覆盖先前值。应根据记录身份选择稳定且在目标范围唯一的字符串键;时间戳或其他生成值是否唯一仍需保证,不能因使用了某个工具就自动认定唯一。

持久化键须表达记录身份保存独立卡片。

原书依据 · 1 处
存储无输出不是写入验收

原脚本依次导入Person/Manager、构造三个实例、shelve.open、按键赋值、close。关闭用于完成资源处理,但“没有打印输出”只说明脚本本来没有输出语句,不能证明写入内容正确;实际验收需检查成功结束并用明确的读取与内容核对验证持久结果。此处只阅读这些步骤,未运行makedb.py或建立任何人员存储。

存储无输出不是写入验收保存独立卡片。

原书依据 · 1 处
交互地探索shelve

重建实例依赖可找到的类定义,序列化数据并非自带全部方法实现。

重建实例依赖可定位类定义

原例从shelve读出Person实例时,调用方作用域不必先绑定Person名称,但pickle需要按保存的模块与类位置找到相应定义。实例状态重建后可使用当前类提供的方法,而不是在存储中保存了一份每个方法的旧代码。重命名模块、删除类或不兼容地改变状态布局,都可能影响加载,不能把以后修改自动生效当成无条件兼容保证。

本章解答中的自动重新连接以pickle能定位类并恢复状态为前提,调用方无需先显式导入名称不等于无需类模块存在。自定义序列化与重建可能改变具体流程,不能把本例步骤当作全部对象的唯一机制。

重建实例依赖可定位类定义保存独立卡片。

原书依据 · 2 处
持久化文件集合依赖存储后端

shelve.open使用的相对路径以当前工作目录为基准,底层后端可能创建一份或多份文件。迁移与备份应识别实际文件集合和兼容环境,不能把原书persondb.bak/dat/dir三文件当作所有平台固定格式;也不应把原始二进制内容当作通用可读导出。

持久化文件集合依赖存储后端保存独立卡片。

原书依据 · 1 处
更新shelve中的对象

默认shelve使用中,修改取出的对象后需明确写回才能保存新状态。

修改取出对象后需要明确写回

updatedb.py先取sue=db[“Sue Jones”],在内存中调用giveRaise,再执行db[“Sue Jones”]=sue并关闭。默认shelve并不能观察任意取出对象的原地修改;显式赋回键是本例保存更新的关键。脚本先打印旧值再更新,因此下一次运行的显示才反映上次写回;不能把同一次打印看成更新后的验收。

修改取出对象后需要明确写回保存独立卡片。

原书依据 · 1 处

未来方向

教程提示把人员对象模型扩展到不同界面和更强存储,但这些方案并未在本章实现。

界面存储与领域对象可分层演进

同一人员对象模型可以在不同界面中使用,也可随着持久化需求变化考虑新的存储层。要分别判断交互方式、对象行为、查询/并发/事务与映射责任,不能因为原型用shelve就默认满足多用户服务要求。ORM解决对象与关系数据映射的一部分问题,并不因此让关系数据库等同对象数据库,或免除事务与模型设计。

界面存储与领域对象可分层演进保存独立卡片。

原书依据 · 1 处

本章小结

全章以一个递进原型连接实例、封装、继承、组合、内省和持久化。

本章习题

八题要求按显示继承、重建行为和设计取舍解释整套示例。

习题解答

解答再次将方法集中、子类定制与组合控制联系到维护成本。

重建实例依赖可定位类定义关联本项背景,实质主要讲解在对应位置。

继承与组合表达不同关系关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处

第28章 类代码编写细节

类的实现细节围绕何处放扩展、怎样引用超类行为、何时使用工具性属性展开。抽象接口、实例化约束与继承复用并非同一问题;每类/每实例状态也要按真实更新目标分析。好的对象模型需要让调用者能理解可用操作及失败语义。

第28章转向类语句、方法、继承和命名空间的正式细节。

class语句

class定义通过运行建立对象和名称绑定,而非提前存在的静态声明。

执行类体建立类属性关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
一般形式

class头可指定基类,类体顶层与方法内赋值承担不同绑定责任。

执行类体建立类属性关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
例子

类体执行建立共享名称,实例赋值可在不同对象上建立同名绑定。

实例赋值可遮蔽共享类属性关联本项背景,实质主要讲解在对应位置。

执行类体建立类属性关联本项背景,实质主要讲解在对应位置。

原书依据 · 8 处
同名属性可分别存在类与实例

MixedNames在类体绑定data=“spam”,初始化又给self.data赋传入值,因此实例与类能各自保存同名属性。display中的self.data取得当前实例版本,MixedNames.data则明确取得类属性;这并不是同一个变量自动同步到两个位置。

结构图:

classDiagram
class MixedNames {
  data
  __init__(self, value)
  display(self)
}

图中data标示原书类体的共享属性;各实例的data由init建立,未误标成类体定义的每实例字段。对普通数据属性,实例绑定会遮蔽类值;描述符等可改变优先级。

同名属性可分别存在类与实例保存独立卡片。

原书依据 · 1 处

方法

普通方法通过接收实例,明确其处理的对象状态。

普通方法绑定实例作为首参关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处
例子

NextClass.printer接收目标对象后保存message,再打印对应属性。

普通方法绑定实例作为首参关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处
调用超类构造函数

子类覆盖初始化后,可显式调用所需基类初始化步骤。

覆写初始化需明确状态建立责任关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
其他方法调用的可能性

静态方法与类方法是与普通实例方法不同的调用选择。

方法种类决定自动绑定对象

普通实例方法经实例访问时绑定实例;staticmethod不自动绑定实例,可作为组织在类中的函数使用;classmethod自动接收类,适合与实际接收类相关的行为。它们都不意味着数据自动按每个类独立复制,也不让函数体里的裸名称自动变成类属性访问;应按职责和预期调用契约选择。

Selfless.selfless(arg1,arg2)通过类访问时是普通函数,可直接接两个参数;通过实例访问仍会自动带入实例,因而原图同样传两个值会参数过多。normal(self,arg1,arg2)通过类则要显式给出满足方法体需要的self。staticmethod可明确声明不做实例绑定,并支持经实例访问,不能因只通过类调用可行就说它完全多余。

静态方法经类或实例取用均不自动加入实例;类方法经两种入口都按适用规则取得类。若只是想把函数组织在类中而不需接收者,可选静态方法;需要按实际接收类定制行为时,类方法保留这一信息。函数不必处理类数据才能声明静态,类方法也不自动把类状态复制为每子类独立存储。

本例printNumInstances()没有参数,Python3经Spam.printNumInstances取出普通函数可零参调用,而a.printNumInstances会绑定a而使参数过多。能经类调用只说明这一取用路径,不会自动把函数声明成静态方法,也不能省略对目标真实签名的确认。

01979的Methods同时给出imeth(self,x)、smeth(x)和cmeth(cls,x)。在类体把smeth重绑为staticmethod(smeth)、cmeth重绑为classmethod(cmeth),便改变后续访问时的自动绑定。两种包装都不自动运行原函数体。

结构图:

classDiagram
class Methods {
 imeth(self, x)
 smeth(x)$
 cmeth(cls, x)
}

smeth标为静态,cmeth为自动接收类的方法,不能把它们当同一种静态函数。Methods.imeth(obj,2)显式传实例,obj.imeth(1)自动传实例;smeth经两入口都不加接收者,cmeth经两入口都加适用的类。原图末两行缩进显示与正文的类体重绑定说明不一致,本笔记按正文所指的类体位置解释,不将截图照录成已运行脚本。

方法种类决定自动绑定对象保存独立卡片。

原书依据 · 5 处

继承

继承使较具体定义有机会替换默认属性,但查找机制有不同层次。

继承查找应按解析顺序理解关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
属性树的构造

对象、类与基类的连接来自不同建立操作,实例归属与类继承不可混为一条关系。

实例所属关系不同于类继承关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
继承方法的专有化

覆写可在基类行为前后加入步骤,而非只能彻底替换实现。

扩展方法可委托共有实现关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
类接口技术

一个共同父类可以被原样沿用、覆写、扩展,或由子类补齐其调用的动作。

子类定制有不同扩展位置

specialize.py展示四条路径:Inheritor原样继承method,Replacer替换method,Extender在父类method前后加入步骤,Provider提供父类delegate将调用的action。最后一条把稳定流程与变化动作分开,而不仅是在同名入口上覆写。

结构图:

classDiagram
class Super {
  method(self)
  delegate(self)
}
class Inheritor
class Replacer {
  method(self)
}
class Extender {
  method(self)
}
class Provider {
  action(self)
}
Super <|-- Inheritor
Super <|-- Replacer
Super <|-- Extender
Super <|-- Provider

Super.delegate实际执行self.action(),因此调用时的实例类型仍决定动作实现。图只列各类实际定义的方法,不把继承方法重复标作子类自己实现。

子类定制有不同扩展位置保存独立卡片。

原书依据 · 1 处
抽象超类

非正式抽象接口可在动作被调用时报告缺失,正式实例化约束属于另一层机制。

抽象动作缺失可在调用时报错

Super.delegate调用self.action,Provider可补齐action;若完全不存在该属性,普通查找失败是AttributeError。也可在默认action中明确raise NotImplementedError表达“子类应实现”;它与特殊返回值NotImplemented不同,后者不是要raise的异常类型。这种默认报错不阻止创建对象,而是在调用未实现动作时失败。

结构图:

classDiagram
class Super {
  delegate(self)
  action(self)
}
class Sub {
  action(self)
}
Super <|-- Sub

图对应本节显式默认报错版与其已补齐动作的子类;未补齐的Sub版本仍可创建,失败发生在调用delegate。

章末将“抽象超类”用于由子类补齐动作的非正式设计。应与ABCMeta的正式抽象标记区分:前者可能直到调用缺失动作才失败,后者可以在实例化时阻止未完成类;抽象方法也不一定毫无实现。

抽象动作缺失可在调用时报错保存独立卡片。

原书依据 · 2 处
断言不宜承担必需接口阻断

原例action使用assert False表达未实现。断言可帮助开发时表达假设,但可随优化选项被移除,不适合作为必须持续生效的接口缺失保障;若需要调用时明确失败,可显式抛出NotImplementedError,若需实例化时阻断,则使用相应抽象基类机制。

746与02082-02083给assert test,data及debug条件展开。-O下断言可移除,所以测试表达式和消息不应承载程序必须执行的副作用,必需校验应显式实现。未使用-O时,消息仅在条件失败的路径构造;AssertionError按普通异常传播/捕获。

747及02084-02085对照x自定约束与1/x前重复assert x!=0。约束失败与内置运算异常各有含义,不能简单说断言只检查“非错误”或Python已覆盖所有设计错误。脚注说明长时间/不可恢复动作前可能需预检;若它是必须保障的前提,不能依赖可优化掉的assert。类型检查也不应过窄而破坏可用接口。

895的rangetest并非只在检查体用assert,而是在装饰阶段按debug直接选择是否返回原函数。优化模式既取消检查也取消整个包装入口;这更明确说明调试工具不能承担始终必须执行的契约阻断。

断言不宜承担必需接口阻断保存独立卡片。

原书依据 · 4 处
Python 2.6和Python 3.0的抽象超类

ABCMeta与abstractmethod可把抽象方法缺失前移为实例化约束。

抽象方法限制实例化而非派生

结合ABCMeta与abstractmethod定义的抽象方法尚未被具体实现时,类仍可被继承,但不能实例化。原书把这一点写成“不能继承”不准确,其括号里的创建实例才是实际限制;Sub只pass仍然抽象,提供action后才可构造。

结构图:

classDiagram
class Super {
  <<abstract>>
  delegate(self)
  action(self)
}
class Sub {
  action(self)
}
Super <|-- Sub

图对应本节最后一个实际ABCMeta示例的已实现Sub版本;action是被标记的抽象方法。ABC检查的是抽象标记是否仍待满足,不自动证明实现签名及业务行为正确。

抽象方法限制实例化而非派生保存独立卡片。

原书依据 · 1 处
抽象基类声明须区分版本语法

原书Python3版在class头使用metaclass=ABCMeta,Python2.6版在类体绑定metaclass,二者不能跨版本机械照抄为等价声明。Python3也可继承abc.ABC辅助基类来使用相同抽象机制;仅写一个名为metaclass的普通类属性并不会因此启用Python2的元类声明语义。抽象方法可带实现并由子类调用,不等同必须完全没有代码。

抽象基类声明须区分版本语法保存独立卡片。

原书依据 · 1 处

命名空间:完整的内容

裸名称解析与点号属性访问属于不同路径。

属性查找不同于裸名称解析关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
简单变量名:如果赋值就不是全局变量

普通函数名称绑定影响局部归属,声明和特殊作用域须另行考虑。

作用域规则关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
属性名称:对象命名空间

属性访问针对对象执行,而非套用裸名称作用域规则。

属性查找不同于裸名称解析关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
Python命名空间的“禅”:赋值将变量名分类

相同拼写可在模块、函数、类、方法局部与实例中表示不同绑定。

词法位置决定名称所属作用域关联本项背景,实质主要讲解在对应位置。

闭包可在外层返回后保留绑定关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
赋值位置区分同名绑定

manynames.py分别将X绑定为模块值11、g的局部值22、C的类属性33、m的局部值44和self.X实例属性55。拼写相同不让它们成为同一个变量:f读取本模块11,C.X仍为33,obj.m执行后obj.X才改为55。

位置 例中绑定 访问要点
模块顶层 X=11 模块全局或模块属性
g函数内 X=22 该调用局部
C类体 X=33 C.X,实例可继承取得
m方法内 X=44 方法调用局部
实例属性 self.X=55 赋值后该实例具有自身绑定

global/nonlocal会改变某些裸名称的绑定目标,需结合声明理解,不可只按视觉缩进机械判断。

赋值位置区分同名绑定保存独立卡片。

原书依据 · 1 处
命名空间字典

字典可观察普通实例自有状态,但不足以代表完整的属性语义。

命名空间字典只是部分对象视图关联本项背景,实质主要讲解在对应位置。

属性清单不等于接口说明关联本项背景,实质主要讲解在对应位置。

原书依据 · 10 处
直接字典访问不等同属性协议

原例X.hello经类继承找到方法,而X.dict[“hello”]因实例自身未存该键而无法读取。普通数据在简单实例中可同时用点号与自身字典观察,但字典访问通常绕过描述符和定制属性钩子,不能一般替代属性读写;slots对象也可能不具备同样实例字典。

结构图:

classDiagram
class super {
  hello(self)
}
class sub {
  hola(self)
}
super <|-- sub

原例hello写self.data1,hola写self.data2;X调用后具有字段,未调用的Y仍无这些字段。类名super是本示例自定义名称,不是调用内置super工具。

直接字典访问不等同属性协议保存独立卡片。

原书依据 · 1 处
命名空间链接

沿直接基类链接递归可展示结构,但不代表真实方法解析顺序。

每次普通调用有独立局部绑定关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
继承图遍历不同于解析顺序

classtree(cls,indent)打印类名,再对cls.bases逐个递归;instancetree(inst)从实例所属类启动。自测的F经D再经B/C抵达共同祖先A,所以同一祖先可重复显示。这是图的深度展开,不是C3方法解析顺序,也不是去重后的祖先集合。

结构图:

classDiagram
class A
class B
class C
class D
class E
class F
A <|-- B
A <|-- C
B <|-- D
C <|-- D
D <|-- F
E <|-- F

图为原书selftest实际继承关系,类型没有方法声明,未虚构签名。工具真实函数签名为classtree(cls,indent)、instancetree(inst)、selftest(),它们都是独立函数,未画成类方法。

继承图遍历不同于解析顺序保存独立卡片。

原书依据 · 1 处

回顾文档字符串

文档字符串随定义对象提供运行时说明,帮助工具把它们组织成报表。

文档字符串依赖定义中的位置关联本项背景,实质主要讲解在对应位置。

文档内容约定不同于语法标准关联本项背景,实质主要讲解在对应位置。

帮助报表结合文档与对象结构关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处

类与模块的关系

模块提供导入组织单位,类提供类型和实例行为,两者可协作但不是同一结构。

模块名与类名应分清绑定关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处

本章小结

章末汇总抽象接口、名称绑定与对象内省,为运算符协议铺垫。

本章习题

四道题回顾抽象父类、共享数据与基类初始化/方法扩展。

习题解答

四题解答串联抽象扩展点与明确复用父类的路径。

抽象动作缺失可在调用时报错关联本项背景,实质主要讲解在对应位置。

覆写初始化需明确状态建立责任关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处

第29章 运算符重载

特殊方法把对象接入运算符、索引、调用和显示等协议,通常由类型层参与查找。普通属性钩子只管理特定访问路径,不能保证所有隐式操作都会转发。包装器若要像主体一样使用,必须逐项检查协议、返回类型和失败信号,而不只看几个正常输出。

第29章集中解释特殊方法与语言操作的对应关系。

基础知识

特殊方法为对象定义具体操作行为,是否缺省可用依协议判断。

特殊方法协议查找有类型层规则关联本项背景,实质主要讲解在对应位置。

原书依据 · 15 处
构造函数和表达式:init和sub

Number用减法钩子构造并返回计算结果的新实例。

算术钩子决定结果对象

Number.sub(self,other)计算self.data-other并返回Number(…),所以Y=X-2得到包装后的新对象,而非直接返回裸数字或修改X.data。是否返回同类型、是否修改原对象,都应由操作契约明确;本例没有实现反射减法或类型不兼容的处理,不能推断任何操作数都支持。

结构图:

classDiagram
class Number {
  __init__(self, start)
  __sub__(self, other)
}

这是number.py实际签名;data由初始化写在实例上,原书展示Number(5)-2得到新实例data为3,未在本轮执行。

算术钩子决定结果对象保存独立卡片。

原书依据 · 1 处
常见的运算符重载方法

特殊方法表把操作类别映射到钩子,须连同协议优先级和版本阅读。

特殊方法协议查找有类型层规则关联本项背景,实质主要讲解在对应位置。

原书依据 · 15 处
特殊方法表是协议入口地图

特殊方法可按用途查找:算术用add/radd/iadd,索引用getitem/setitem/delitem,迭代用iter/next,真值用bool/len,调用用call,显示用str/repr。属性访问、上下文管理、描述符和对象创建还有各自协议;这些是理解入口的地图,不代表任何方法可在所有上下文互换。表中Python2的next、nonzero、cmp等旧名称应按版本区分。

特殊方法表是协议入口地图保存独立卡片。

原书依据 · 1 处

索引和分片:getitem和setitem

索引钩子收到方括号内的键,具体含义由对象定义。

索引协议并不保证序列语义

Indexer.getitem(self,index)直接返回index**2,展示X[2]会把2作为键交给钩子。这不自动提供长度、有限边界、负索引标准化或所有切片能力,也不能因接受某些数字就认定它是有穷列表。真正序列应定义合法范围和越界行为,映射还可能接受其他类型的键。

结构图:

classDiagram
class Indexer {
  __getitem__(self, index)
}

这里对应仅平方计算版Indexer,与下一节转发内部列表的同名替代实现分开理解。

MyList.getitem(self,offset)把offset减1后交给list.getitem,所以教材的1与3读取演示能工作,但0会变成-1,负数也改变原意;现代切片传入slice对象,不能直接减整数。仅改变这一入口也不使所有列表行为采用一基索引,继承身份不能代替替换契约。

结构图:

classDiagram
class list
class MyList {
  __getitem__(self, offset)
}
list <|-- MyList

本图是685的真实类型,区别于本卡639的平方Indexer。原图只执行1与3索引及append/reverse,没有展示负数或切片通过;这些边界由方法体与官方索引协议推导。

索引协议并不保证序列语义保存独立卡片。

原书依据 · 2 处
拦截分片

切片语法把slice对象交给索引钩子,而整数转换钩子承担另一职责。

特殊方法协议查找有类型层规则关联本项背景,实质主要讲解在对应位置。

原书依据 · 15 处
切片对象可沿索引接口转发

X[a:b:c]把slice(a,b,c)交给getitem,省略部分可能保留None;包装对象可把该键直接交给内部列表,复用其索引和切片规则。setitem(self,index,value)也可转发索引或切片赋值,但应留意内部可变对象是否被多实例共享,不能仅靠钩子存在保证隔离。

结构图:

classDiagram
class Indexer {
  data
  __getitem__(self, index)
}

这是本节完整展示的读取版:data=[5,6,7,8,9]在类体中。另示意的setitem(self,index,value)是可添加写入的片段,不伪称已加入上图的完整类实现。

切片对象可沿索引接口转发保存独立卡片。

原书依据 · 1 处
整数索引转换不同于取项

index(self)返回无损的整数表示,可用于需要整数的上下文,例如内置序列的索引/切片边界或hex/bin/oct。它让对象充当某处的整数,而非拦截该对象自身的X[i];后者由getitem负责。int等转换也不自动等同于实现index。

结构图:

classDiagram
class C {
  __index__(self)
}

本节C返回255,原图以其作字符串索引和切片边界;本轮未执行这些操作。

整数索引转换不同于取项保存独立卡片。

原书依据 · 1 处

索引迭代:getitem

没有迭代入口时,传统序列协议可通过连续索引进行遍历。

索引迭代需要越界终止

在没有适用iter入口的序列式回退中,Python从0开始请求getitem,直至IndexError表示结束。stepper把请求转交给字符串self.data,由字符串越界提供终止;仅返回index平方的Indexer却没有这一边界,不应直接当有穷序列消费。任意接受键的映射也不因此满足这种从0递增的序列约定。

结构图:

classDiagram
class stepper {
  __getitem__(self, i)
}

本例data由类外给实例赋字符串”Spam”,不是类体共享属性。in、推导式、map、解包及构造函数在相应回退路径可消费它,实际是否全部消费仍取决于操作。

索引迭代需要越界终止保存独立卡片。

原书依据 · 1 处

迭代器对象:iter和next

现代迭代优先请求迭代器,再由该对象推进并报告结束。

迭代协议关联本项背景,实质主要讲解在对应位置。

原书依据 · 13 处
用户定义的迭代器

Squares将推进状态保存在实例上,是单次消费的迭代器实现。

重复遍历能力取决于迭代器归属关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
自迭代对象共享同一推进状态

Squares.iter返回self,next保存并递增self.value,超过设定终点后raise StopIteration。第二次遍历同一对象不会自动从头开始;要重新开始需新建对象或提供明确重置接口。支持迭代也不意味着支持X[i]随机访问。

结构图:

classDiagram
class Squares {
  __init__(self, start, stop)
  __iter__(self)
  __next__(self)
}

图对应原书start到stop含终点的平方迭代代码;原图索引报错的错误类型是旧环境显示,不能保证现代版本文本相同。

自迭代对象共享同一推进状态保存独立卡片。

原书依据 · 1 处
有多个迭代器的对象

可迭代对象每次产生独立状态,使嵌套循环不互相抢占位置。

跳步遍历可在索引与切片间权衡关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
容器与迭代状态可分开保存

SkipObject持有wrapped数据,iter每次创建SkipIterator;每个SkipIterator有自己的offset并按2推进,因此外层与内层可分别遍历同一数据。独立位置不代表底层数据被复制,若wrapped可变,修改仍可能影响多个遍历。

结构图:

classDiagram
class SkipObject {
  __init__(self, wrapped)
  __iter__(self)
}
class SkipIterator {
  __init__(self, wrapped)
  __next__(self)
}
SkipObject ..> SkipIterator : 每次iter创建

原书SkipIterator未定义iter,图如实保留这一缺项;完整可复用的迭代器协议应让iter(iterator)返回自身,不能把本片段当已满足所有迭代使用方式。

容器与迭代状态可分开保存保存独立卡片。

原书依据 · 1 处

成员关系:contains、iter和getitem

成员关系可用专门入口,普通迭代与显式取项各有独立入口。

成员测试按专用入口优先

Iters同时提供contains、iter/next和getitem。in先采用适用的contains,没有时可通过迭代搜索,再无迭代入口才用序列索引回退;显式X[i]与X[a:b]仍由getitem处理。这里说缺失不是指入口出错时必然回退,不能吞掉任意异常改走下个路径。

结构图:

classDiagram
class Iters {
  __init__(self, value)
  __getitem__(self, i)
  __iter__(self)
  __next__(self)
  __contains__(self, x)
}

本例iter重置self.ix再返回self,可重启顺序遍历但嵌套遍历共享位置,不是独立迭代器容器;contains直接查询self.data,不必消费这份迭代位置。

成员测试按专用入口优先保存独立卡片。

原书依据 · 1 处

属性引用:getattr和setattr

缺失属性回退与赋值拦截是不同范围的钩子,并应避免自触发递归。

缺失属性钩子应保留失败信号

empty.getattr对age返回40,对其他名称抛AttributeError,让计算值看起来像属性。它通常在常规属性访问以AttributeError失败时触发,不是无条件拦截所有读取,也不自动为对象真正存入age字段。无法处理的名称应保留正确失败信号,而非任意返回None掩盖拼写错误。

结构图:

classDiagram
class empty {
  __getattr__(self, attrname)
}

原代码raise AttributeError,attrname是旧版语法;现代写法应按当前异常语法解释,本轮未执行。

845的Catcher只打印读取/设置名称,既没有存入设置值也没有为未知名抛AttributeError,因此它是跟踪钩子调度的最小示意,不是已完成通用属性存储。

结构图:

classDiagram
class Catcher {
 __getattr__(self, name)
 __setattr__(self, name, value)
}

图取02287,两个方法均隐式返回None。访问job/pay打印不等于字段真实存在;在需要按缺失名判定的工具中,返回None会改变失败信号。

846以Person通过属性名分支管理name:getattr只处理未存储的name,其余失败抛AttributeError;setattr/delattr将name映到_name,再用实例字典处理。

结构图:

classDiagram
class Person {
 _name
 __init__(self, name)
 __getattr__(self, attr)
 __setattr__(self, attr, value)
 __delattr__(self, attr)
}

图对应02295-02296,构造写_name也会经过setattr。02298-02299的替代读取方法为getattribute(self,attr),对name换成_name后委托object.getattribute,其他名不能直接都视为不存在。两版是替代实现,未同时装入同一类;这里没有类上的name管理对象,不能照搬Person.name.doc访问特性文档的用法。

缺失属性钩子应保留失败信号保存独立卡片。

原书依据 · 3 处
属性写入钩子需避免自递归

accesscontrol.setattr(self,attr,value)只接受age,并用self.dict[attr]=value避免再次走自身。若在同一钩子里直接self.age=value通常会再次触发它;但直接写字典也绕过部分正常属性机制且要求可用字典。现代可委托object.setattr等基础实现,不应把直接字典写入当唯一方案。

结构图:

classDiagram
class accesscontrol {
  __setattr__(self, attr, value)
}

图为原例实际实现;拦截赋值不等于拦截原地修改已引用的可变值、所有显式绕行或隐式特殊方法操作。

844提醒通用读写/删除钩子中的自递归。将访问委托到适当基类方法是避免再进入自身的一条路径,不是“调用超类必导致循环”;字典法受对象是否有dict及是否需要保留描述符语义等条件约束,后续845具体展开。

845的02291-02293对照在setattr里self.other=value导致再次进入、直接写实例字典避免该次赋值调度,以及object.setattr基础委托。后者保留基础描述符/slot等语义,字典法须有可用dict并可能绕过这些机制。删除也须按相同职责分析;不把常规Python递归一概称直到内存耗尽,通常可先受递归限制。

888中onInstance用自己的dict保存wrapped以避开本类setattr递归,却用setattr(wrapped,attr,value)写主体、getattr(wrapped,attr)读主体。不能为省事把它们全部改成主体.dict,否则可能绕过描述符或遗漏继承属性,也不适用于无实例字典的主体。slots不必然排除实例字典:继承的字典或显式加入dict均可能存在;本例只要求代理层有字典,并未要求主体有字典。

属性写入钩子需避免自递归保存独立卡片。

原书依据 · 4 处
其他属性管理工具

属性管理可在全局读取入口或指定字段协议上实施。

属性管理入口有不同粒度

getattribute负责普通属性读取的统一入口,getattr是失败后的回退;property把特定属性与获取/设置逻辑关联,描述符以get/set等参与指定属性访问。选择粒度取决于要管理全部读取还是某个字段;这些机制也不保证截获所有隐式特殊操作,内部实现需避免再进入自身。

已知字段可用property分别接入get/set/del;属性名集合在运行期才确定或需代理任意字段时,通用钩子可能更合适。原例只说明不同拦截范围,没有提供性能基准或证明property对所有任务更简单。

描述符对象置于类属性位置,通过get/set等协议参与特定字段访问;property是面向处理函数的一种描述符接口,slots也利用类级描述符。getattribute的范围是普通属性访问,仍不能覆盖语言语法触发的所有隐式特殊方法;本段没有具体自定义描述符类,不补造其成员或执行链。

832列getattr/setattr、getattribute、property和描述符。前者处理普通查找失败与赋值,getattribute处理一般读取,后两者管理类上指定字段;语言隐式特殊操作仍须按协议另判。复杂度/优雅程度应按实际接口和任务判断,不从列举次序推导统一性能或可靠性排名。

838说明property是描述符的一种简化接口,描述符实例存为类属性并管理特定字段。独立类可以有自己的状态/辅助方法/继承或组合,不代表每次访问都创建新管理器,或管理器状态会自动按主体实例隔离。后续实际例将明确两种状态位置。

844区分获取与设置:getattr/getattribute不负责写入,要实现setattr;原文后段误称后者针对获取运行,应按每次普通属性赋值理解。getattr的失败包括正常属性路径以AttributeError失败,不仅静态不存在的字段;通用钩子适合运行期名称/代理,指定字段可用property/描述符。

848以相同attr1/attr2/attr3对照读取入口。

结构图:

classDiagram
class GetAttr {
 attr1$
 attr2
 __init__(self)
 __getattr__(self, attr)
}
class GetAttribute {
 attr1$
 attr2
 __init__(self)
 __getattribute__(self, attr)
}

GetAttr的attr1从类取得、attr2从实例取得,只有缺失attr3走回退;GetAttribute三种普通读取都会经过统一钩子,非attr3委托object.getattribute。但图中GetAttr对任何未知名称都返回3,没有保留AttributeError,因此示例相同的三项值不代表任意未知名行为也一致。这两个类只作读取入口对照,不与850同名的另一组测试类混同。

属性管理入口有不同粒度保存独立卡片。

原书依据 · 7 处
模拟实例属性的私有性:第一部分

原例按子类名称列表限制写入,但不构成通用私有性保护。

写入拦截不等于私有字段

Privacy.setattr查看self.privates,命中则抛PrivateExc,否则直接写实例字典;Test1禁age,Test2禁name/pay。它不区分类内外赋值,也不阻止读取,Test2的初始化正是直接写字典绕过限制。因此它是演示写入策略,不是可靠的访问隔离或安全边界。

结构图:

classDiagram
class Exception
class PrivateExc
class Privacy {
  __setattr__(self, attrname, value)
}
class Test1 {
  privates
}
class Test2 {
  privates
  __init__(self)
}
Exception <|-- PrivateExc
Privacy <|-- Test1
Privacy <|-- Test2
Privacy ..> PrivateExc : 拒绝指定写入

privates在子类体声明,为类属性列表;完整代码中的失败赋值是作者演示,未执行。

写入拦截不等于私有字段保存独立卡片。

原书依据 · 1 处

repr和str会返回字符串表达形式

str和repr用于不同显示目标,容器对元素的表示也有自身规则。

字符串表示区分使用目标关联本项背景,实质主要讲解在对应位置。

字符串表示区分使用目标关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
显示实现与算术副作用应分开

原例adder.add执行self.data+=other却不返回值,x+1因而修改x并得到None;随后单独求值x才显示新状态。addrepr、addstr、addboth各自定制表示,却不会修复这一算术契约。读运行记录应区分表达式结果、对象被修改后的值,以及交互环境是否显示None。

结构图:

classDiagram
class adder {
  __init__(self, value=0)
  __add__(self, other)
}
class addrepr {
  __repr__(self)
}
class addstr {
  __str__(self)
}
class addboth {
  __str__(self)
  __repr__(self)
}
adder <|-- addrepr
adder <|-- addstr
adder <|-- addboth

这是原书的演示设计,其代码自己把加法原处修改标成bad,不能把它推广为通常加法应有的行为。

显示实现与算术副作用应分开保存独立卡片。

原书依据 · 1 处

右侧加法和原处加法:radd和iadd

反射加法处理另一方向的操作数,结果包装与类型兼容需分别设计。

反射算术不是简单交换律

radd(self,other)中的self位于原表达式右侧,other位于左侧;它支持反射分派,不保证数学交换律。是否调用取决于操作数类型、左方法是否支持以及右侧严格子类的优先规则,不能以“左边不是类实例”作为唯一条件。对不支持的操作数组合,返回NotImplemented可让协议继续分派,直接抛错则不等于同样回退。

反射算术不是简单交换律保存独立卡片。

原书依据 · 1 处
结果包装应避免重复嵌套

第二版Commuter.add在other也是Commuter时先取other.val,再构造单层Commuter结果,避免包装数据里又嵌套Commuter。这个类型判断只表达本例的兼容策略,不能保证处理所有子类型或任意数据类型。

结构图:

classDiagram
class Commuter {
  __init__(self, val)
  __add__(self, other)
  __radd__(self, other)
  __str__(self)
}

图为第二版实际定义;第一版返回裸算术结果且没有str,不将两种结果契约混用。

结果包装应避免重复嵌套保存独立卡片。

原书依据 · 1 处
原处加法

增强赋值先尝试原处协议,再将返回结果绑定回目标。

增强赋值返回值决定新绑定

第一版Number.iadd更新self.val并返回self,其他引用可看到同一对象改变;第二版只有add,构造新Number,增强赋值将结果重新绑定给x。原处方法也可返回不同对象,故+=并不普遍保证身份不变。

结构图:

classDiagram
class Number {
  __init__(self, val)
  __iadd__(self, other)
}
classDiagram
class Number {
  __init__(self, val)
  __add__(self, other)
}

两图是原书替代实现。缺少iadd或返回NotImplemented可回到普通算术分派,也可能考虑反射方法,不只是单一步骤调用add。

章末将增强赋值简化为iadd再add,应连同可能的NotImplemented和反射分派理解。并非所有二元关系都有相应增强赋值语法,操作失败时也不能随意吞错再转用其他入口。

增强赋值返回值决定新绑定保存独立卡片。

原书依据 · 2 处

Call表达式:call

实例调用钩子让对象按函数接口接受参数,同时保存显式状态。

实例调用可映射到调用方法关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
可调用实例保存操作配置

Prod.init(self,value)保存乘数,call(self,other)返回self.value*other,让同一对象在多次调用间复用状态。也可用命名方法comp(self,other)达到相同计算;call的价值在需要把它交给接受可调用对象的接口时。

结构图:

classDiagram
class Prod {
  __init__(self, value)
  __call__(self, other)
}

这是可调用版本;原书另一个替代Prod定义comp而不定义call,不能视为同一对象同时具备两个入口。

可调用实例保存操作配置保存独立卡片。

原书依据 · 1 处
函数接口和回调代码

回调应注册可调用引用,状态可由对象、绑定方法或默认参数携带。

普通方法绑定实例作为首参关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处
注册回调应传引用而非先调用

Callback实例可通过无额外参数的call访问self.color,或把cb.changeColor绑定方法注册为按钮command。注册时传cb或cb.changeColor,表示稍后再执行;写成cb.changeColor()则会立即调用并传入它的返回值,含义不同。

结构图:

classDiagram
class Callback {
  __init__(self, color)
  __call__(self)
}
class Button
Button ..> Callback : command保存可调用实例
classDiagram
class Callback {
  __init__(self, color)
  changeColor(self)
}
class Button
Button ..> Callback : command保存绑定方法

两图是替代版本,Button为外部工具类型,原文未提供其真实定义签名,未虚构构造器。例中回调只是print,并非实际设置按钮颜色。

注册回调应传引用而非先调用保存独立卡片。

原书依据 · 1 处

比较:lt、gt和其他方法

富比较有成对反射与默认行为,但不会从一个顺序关系自动推导全部关系。

比较协议需明确每种关系

lt与gt互为反射,le与ge互为反射;比较没有单独的rlt。不支持某组合时可返回NotImplemented,让分派或默认行为处理。默认ne通常委托eq再反转其结果,NotImplemented例外,因此原书称eq/ne毫无隐含联系须按现代规则限定;但定义小于和等于并不自动实现小于等于等全部排序。

结构图:

classDiagram
class C {
  data
  __gt__(self, other)
  __lt__(self, other)
}

这是本节实际代码,类体data=“spam”;它将比较委托给该字符串,不是任意对象的通用排序。

比较协议需明确每种关系保存独立卡片。

原书依据 · 1 处
Python 2.6的cmp方法(已经从Python 3.0中移除了)

Python2的cmp入口即使手写替代数值算法,也不会重新成为Python3特殊协议。

移除协议不能靠同名函数复原

Python3不再以cmp处理比较,写回cmp函数或在cmp里用(a>b)-(a)计算三态结果,也不会让比较表达式自动调用它。迁移需实现适用的富比较方法并规定兼容类型与关系,而非只修复旧函数找不到的错误。原书两种C.cmp(self,other)替代实现均只作历史对照。

移除协议不能靠同名函数复原保存独立卡片。

原书依据 · 1 处

布尔测试:bool和len

真值协议区分明确布尔入口、长度回退及二者均无时的默认真。

真值协议回退取决于方法是否存在关联本项背景,实质主要讲解在对应位置。

真值协议回退取决于方法是否存在关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处

对象析构函数:del

终结方法可参与对象回收,但不应承担必须按时执行的资源释放。

资源释放不应依赖终结时机

Life.del打印告别消息,原书通过重新绑定brian移除旧引用来演示回收。但重新绑定或del名称不等于无条件立即执行del,其他引用、实现与运行阶段均会影响时机;解释器退出时也不保证所有存留对象的终结方法都执行。需要可靠关闭文件或连接时,应采用明确关闭、上下文管理或try/finally等已约定路径。

结构图:

classDiagram
class Life {
  __init__(self, name="unknown")
  __del__(self)
}

图中unknown表示原签名的字符串默认值’unknown’,不表示裸名称;方法体演示打印和name绑定,不是实际服务器连接实现。

资源释放不应依赖终结时机保存独立卡片。

原书依据 · 1 处
循环终结语义须按版本判断

原书描述带del的循环对象不能由循环检测器回收,反映旧版限制。CPython在Python3.4的PEP442更新了这类对象的终结与回收流程,不能据旧书断言现代带终结方法的循环必然无法回收。对象复活、扩展类型及具体实现仍有细节边界,这项变化也不让清理时机变得可预测。

循环终结语义须按版本判断保存独立卡片。

原书依据 · 1 处
终结错误不能当普通调用异常

del可能在难以控制的环境中被触发,异常通常被忽略并向标准错误流报告,而不按普通业务调用的异常路径交给原调用者处理;退出阶段依赖的全局对象还可能已经不可用。不要把打印警告理解为异常本身,也不要让必须完成的业务提交依赖终结成功。

终结错误不能当普通调用异常保存独立卡片。

原书依据 · 1 处

本章小结

本章的钩子地图将继续连接上下文管理、描述符与对象创建。

本章习题

五题复习迭代、显示、切片、增强赋值及何时重载。

习题解答

章末解答连接各协议入口,但具体回退仍以所用协议为准。

运算符接口应符合领域语义关联本项背景,实质主要讲解在对应位置。

增强赋值返回值决定新绑定关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处

第30章 类的设计

这一章从较大设计模式回看继承与组合:超类可提供模板,成员对象可承担具体工作,控制器再安排协作。多态让共同入口在不同接收对象上选择实现;名称改写则主要减少类之间的意外冲突,不是安全访问隔离。模式的价值在于澄清职责与依赖。

第30章从语法机制转向继承、组合、委托与工厂等设计关系。

Python和OOP

继承、多态、封装分别描述查找、可替换操作及接口后实现组织。

封装集中实现仍需维护契约关联本项背景,实质主要讲解在对应位置。

多态调用分派按接收对象解析关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
通过调用标记进行重载(或不要)

重复定义同名方法只更新名称绑定,不会自动保留按签名选择的多个版本。

重复方法定义不会自动重载

class C中先def meth(self,x)再def meth(self,x,y,z),普通类体执行后meth通常只保留后一个绑定;Python不会因此按参数数量自动选择旧版本。可用默认参数、收集参数或明确分派表达接口,但不同职责应优先用清楚名称;现代显式分派机制也不改变重复def本身的含义。

原文三个片段是替代示意:重复定义、*args分支、单一meth(self,x)调用x.operation()。分支图还写arg[0],但签名为args,这是原图拼写不一致;有省略号的代码不作为已实现可执行方案。

重复方法定义不会自动重载保存独立卡片。

原书依据 · 1 处

OOP和继承:“是一个”关系

employees.py用is-a层次集中员工共有行为,并由具体角色覆写work。

继承模型应表达可替换角色

Employee提供name/salary初始化、giveRaise、work和repr;Chef与Server定制初始化及work,PizzaRobot再继承Chef并覆写work。原书用它表达机器人属于厨师、厨师属于员工的领域模型,而不仅是为了借用若干方法。

结构图:

classDiagram
class Employee {
  __init__(self, name, salary=0)
  giveRaise(self, percent)
  work(self)
  __repr__(self)
}
class Chef {
  __init__(self, name)
  work(self)
}
class Server {
  __init__(self, name)
  work(self)
}
class PizzaRobot {
  __init__(self, name)
  work(self)
}
Employee <|-- Chef
Employee <|-- Server
Chef <|-- PizzaRobot

这是本节真实类型和签名。work目前仅打印消息,类图不声称已经实现制作食品或服务客户;普通非抽象基类也可直接实例化,不限定只能创建叶子节点。

继承模型应表达可替换角色保存独立卡片。

原书依据 · 1 处

OOP和组合:“有一个”关系

组合控制器持有组件,按流程调度协作者,并可同时使用成员类的继承关系。

继承与组合表达不同关系关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
组合控制器组织协作流程

PizzaShop初始化创建Server、PizzaRobot与Oven并保存为组件。order(self,name)为本次订单建立Customer,再依次让顾客下单、厨师work、烤炉bake和顾客pay;顾客是单次请求对象,员工与烤炉是商店持有的组件,两种关系不应混成商店继承顾客。

结构图:

classDiagram
class PizzaShop {
  __init__(self)
  order(self, name)
}
class Customer {
  __init__(self, name)
  order(self, server)
  pay(self, server)
}
class Oven {
  bake(self)
}
class Server
class PizzaRobot
PizzaShop *-- Server : 构建并持有 server
PizzaShop *-- PizzaRobot : 构建并持有 chef
PizzaShop *-- Oven : 构建并持有 oven
PizzaShop ..> Customer : 每次order创建
Customer ..> Server : 方法协作

Server与PizzaRobot来自employees模块,其内部继承结构在前卡保留。这里全部动作只打印模拟消息,没有实际食品制作、支付或订单持久化。

练习7给出Lunch控制器的接口规格:其构造创建并持有Customer/Employee,order把foodName经Customer.placeOrder交给Employee.takeOrder,后者返回Food,顾客保存它;result请求顾客输出收到的食物。

结构图:

classDiagram
class Lunch {
 __init__(self)
 order(self, foodName)
 result(self)
}
class Customer {
 __init__(self)
 placeOrder(self, foodName, employee)
 printFood(self)
}
class Employee {
 takeOrder(self, foodName)
}
class Food {
 __init__(self, name)
}
Lunch *-- Customer : 构造并持有
Lunch *-- Employee : 构造并持有
Customer ..> Employee : 参数协作
Employee ..> Food : 按规格返回新对象
Customer --> Food : 接收并保存

这是02021-02022提供的练习签名和流程要求,不是已给实现或本次执行;与前面的PizzaShop/Customer替代模型分开,不合并同名类的方法或推导真实支付/食品流程。

组合控制器组织协作流程保存独立卡片。

原书依据 · 2 处
重访流处理器

Processor固定扫描流程,以继承定制转换,以组合接入读写器。

对象序列化需要格式与版本约定关联本项背景,实质主要讲解在对应位置。

pickle加载仍需可信输入关联本项背景,实质主要讲解在对应位置。

原书依据 · 8 处
稳定流程可组合不同变化点

Processor.process读取reader.readline(),假值时结束,调用self.converter(data)再交给writer.write(data)。Uppercase只覆写converter返回大写值;HTMLize提供write(self,line)来给输出加标签。变化分别来自子类方法和传入协作对象,而扫描流程只写一份。

结构图:

classDiagram
class Processor {
  __init__(self, reader, writer)
  process(self)
  converter(self, data)
}
class Uppercase {
  converter(self, data)
}
class HTMLize {
  write(self, line)
}
Processor <|-- Uppercase
Processor ..> HTMLize : writer可选协作者

reader/writer由外部传入,因此没有把其类型或生命周期伪造为Processor独占。原文叙述出现convert,但实际方法名为converter;默认实现assert False只是教学占位。HTMLize直接插值并rstrip,不是完整HTML转义器,也可能删除尾部空白。

稳定流程可组合不同变化点保存独立卡片。

原书依据 · 1 处

OOP和委托:“包装”对象

包装器可对缺失普通属性转发加日志,但不自动增强全部对象接口。

特殊方法协议查找有类型层规则关联本项背景,实质主要讲解在对应位置。

原书依据 · 15 处
包装追踪发生在属性取得时

wrapper保存wrapped,getattr(self,attrname)打印名称,再用getattr(self.wrapped,attrname)取真实属性。x.append(4)先取得被包装列表的绑定方法,再调用它;若先保存method=x.append,后续多次method(…)不会因此重复经过包装器的读取日志。钩子追踪的时机与每次方法执行不同。

结构图:

classDiagram
class wrapper {
  __init__(self, object)
  __getattr__(self, attrname)
}

实例传入的是列表或字典,保存于self.wrapped;未虚构协作者类型或其方法签名。

845的02288以大写Wrapper重述30章小写wrapper的同一委托模式,实例保存wrapped,缺失读取时打印Trace再getattr真实对象。

结构图:

classDiagram
class Wrapper {
 __init__(self, object)
 __getattr__(self, attrname)
}

保留本节实际类名大小写,不把两个定义当同一运行时类型。钩子仅接收包装器常规查找未满足的名称,所以不能把文字“每次属性读取”扩成包括包装器已有wrapped字段或所有隐式协议操作。

880的类装饰函数Tracer(aClass)返回内部Wrapper,每次构造都有独立fetches和wrapped主体:

结构图:

classDiagram
class Wrapper {
 fetches
 wrapped
 __init__(self, *args, **kargs)
 __getattr__(self, attrname)
}
class Spam {
 display(self)
}
class Person {
 name
 hours
 rate
 __init__(self, name, hours, rate)
 pay(self)
}
Wrapper *-- Person : 按所装饰原类创建主体
Wrapper *-- Spam : 另一装饰目标的对应包装类

这是02411-02412的方案,不是2410接收预创建对象的另一Wrapper定义;每次Tracer调用都形成各自内部Wrapper类。fetches只在未被包装器自身满足的属性获取时递增,绑定方法执行内部读取self.hours/rate在Person主体上进行,不再次经过代理。打印fetches/wrapped等代理字段也不计数,方法执行次数与获取次数不同。 可对MyList(list)使用@Tracer或手动Tracer(list)保留常规构造入口,但所得对象是Wrapper,不自动保持list的类型/全部协议;Python3直接显示x不经普通回退转发repr。

922的02519-02521给Tracer(aClass)返回Wrapper,init建立主体、getattr打印并转发;02522-02523改为Tracer(classname,supers,classdict),先type(…)建立主体aClass,再返回同样Wrapper。Person名在后一版本绑定Wrapper,Bob仍为代理;两个版本追踪name和pay取得,pay内部hours/rate读取不追踪。它没有要求所有元类只能管理类,也没有解决隐式特殊方法/身份保持等代理边界。

包装追踪发生在属性取得时保存独立卡片。

原书依据 · 4 处

类的伪私有属性

伪私有名称用于减少意外冲突,无法阻止知道真实名称的外部访问。

内部名称约定不等于访问隔离关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
变量名压缩概览

双下划线名称按定义类文本改写,以把内部名称与其他类区分。

名称改写取决于定义类

在Spam类定义中,X可被改写为_SpamX,self.X也据该定义类处理,不按运行时实例的最具体类名随时重写。规则针对至少两个前导、至多一个尾随下划线的标识符,init等两尾下划线协议名称不因此同样改写。类名本身的前导下划线会被剥离;getattr(obj,”X”)等字符串也不会按调用类自动改写,须明确实际名称。

890中self.wrapped在onInstance类体内被改写为_onInstancewrapped;setattr收到的是改写后的字符串,因此比较字符串要显式写完整名称,字符串不会自动按所在类改写。它减少与主体wrapped字段冲突,却不能阻止外部显式读取改写字段后取出主体。

名称改写取决于定义类保存独立卡片。

原书依据 · 2 处
为什么使用伪私有属性

多个类对同一实例写普通同名字段会碰撞,定义类改写可分开这些绑定。

混入类状态可能在实例上碰撞

未改写版本中C1.meth1与C2.metha都写self.X,C3继承两者后,最后一次赋值覆盖同一实例上的X。改为各类内部self.X后,分别写_C1X和_C2__X,两个读方法各取对应字段;字段仍存在同一个实例上,只是名称不同。

结构图:

classDiagram
class C1 {
  meth1(self)
  meth2(self)
}
class C2 {
  metha(self)
  methb(self)
}
class C3
C1 <|-- C3
C2 <|-- C3

原书两个版本具有相同真实方法签名,差异在方法体中X与X的使用;图不伪称实例字段是类体共享属性。外部显式写I._C1X仍可改变值,名称改写不是访问隔离。

混入类状态可能在实例上碰撞保存独立卡片。

原书依据 · 1 处
内部方法改写减少意外覆写

Tool定义method(self)并由other(self)调用self.method();改写使它与Super.method及Sub2实例的method分开。Sub1.actions(self)仍可调用正常method接口,而Tool内部调用不易被无意的同名定义替换。

结构图:

classDiagram
class Super {
  method(self)
}
class Tool {
  __method(self)
  other(self)
}
class Sub1 {
  actions(self)
}
class Sub2 {
  __init__(self)
}
Tool <|-- Sub1
Super <|-- Sub1
Tool <|-- Sub2

图取自原书实际代码,方法体省略号处不补造行为。Sub2设置self.method=99,并未覆盖Tool的改写后__method;这不保证不同但改写结果相同的类名永远不冲突。

内部方法改写减少意外覆写保存独立卡片。

原书依据 · 1 处

方法是对象:绑定或无绑定

方法取出与调用可分为两步,保存的绑定方法会携带原接收实例。

普通方法绑定实例作为首参关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处
绑定方法保留原接收对象

绑定方法保存接收实例与函数配对,适合延迟调用和传入接受可调用对象的接口。它仍指向取出时的那个实例,之后把原变量重新绑定到别处,不会自动改配对;保留方法引用也可能延长实例生命周期。等效普通函数式调用的前提是正确传入它所需的对象和参数,不能把任意方法与任何函数无条件互换。

绑定方法保留原接收对象保存独立卡片。

原书依据 · 1 处
在Python 3.0中,无绑定方法是函数

Python3通过类取得普通函数,不再附带Python2的未绑定方法类型检查。

方法种类决定自动绑定对象关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
绑定方法和其他可调用对象

共享调用语法可以统一调度不同可调用对象,但签名和结果契约仍不同。

统一调用语法不统一业务结果

同一actions列表可保存函数square(arg)、可调用Sum实例、Product.method绑定方法和类Negate,均用act(5)调用;前三种分别返回计算值,Negate则创建具有显示方法的新实例。共同语法不意味着相同返回类型、无副作用或所有签名兼容。

原书对象 真实定义接口 调用说明
square square(arg) 返回平方
Sum实例 init(self,val)、call(self,arg) 保存val后返回相加结果
Product绑定方法 init(self,val)、method(self,arg) 绑定实例后调用乘法逻辑
Negate类 init(self,val)、repr(self) 构造实例,显示负值

Number的double(self)/triple(self)也可先保存到列表再执行;bound.self和bound.func可观察普通绑定方法配对。

本节脚注明确factory也能调用函数和方法,而不只类;aClass是参数名,不是运行时类型保证。返回值和异常仍由实际目标决定,不能把统一入口的结果一律当某种新实例。

统一调用语法不统一业务结果保存独立卡片。

原书依据 · 2 处
界面回调用实例属性保留状态

本节图中MyWidget.makewidgets(self)把self.handler交给Button的command,handler(self)稍后经绑定实例读取状态。回调引用保留接收对象,不要求借助全局变量;但函数也可通过闭包等机制保留状态,不能以是否使用类作绝对排序。

结构图:

classDiagram
class MyWidget {
  handler(self)
  makewidgets(self)
}
class Button
MyWidget ..> Button : command传入self.handler

这是图片里的真实类名MyWidget,叙述中的MyGui并非该段代码定义。handler体用省略号说明状态用途,未补造具体GUI行为或Button签名。

界面回调用实例属性保留状态保存独立卡片。

原书依据 · 1 处

多重继承:“混合”类

混合类以继承加入通用能力,名称与初始化约定仍需协调。

混合能力仍需协调继承契约

混合类把通用方法加入应用类型,方法可通过self使用客户实例的状态。组合多个能力时,应考虑名称冲突、状态假设与初始化协作,不是把模块里的函数任意拼接就自动正确。Python3继承查找按C3线性化方法解析顺序,原书称更广度优先仅是粗略对比,不能当作真正的广度优先遍历。

MyButton把ListTree放在Button前是为了在适用MRO中优先选择其str;testmixin的三种Sub版本则把Super与一个显示混合类组合。这些是替代示例,不应拼成所有工具同时继承的一份类定义,也不能从列出整棵bases图推导真正的方法解析顺序。

原文用先横向再纵向/先宽度后深度概括新式类查找,不能作为真实算法。Python2.3以后的新式类及Python3使用C3线性化,既保留局部基类顺序又要求单调性;实际MRO不是简单的广度或深度遍历。官方历史MRO文档2026-11-06核验:https://docs.python.org/3/howto/mro.html 。

本例Sub(ListTree,Super)优先取得ListTree.str,再以other=Super.other显式选另一侧的other。这样逐成员表达取舍,而不是期望一个基类排列同时满足所有名称来源。双前导名称可减少混入类内部名冲突,但不能代替公共接口的明确选择。图2014的Lister未在本片段定义,叙述所指为ListTree,本笔记按已给类型解释意图,不把它当可直接运行代码。

混合能力仍需协调继承契约保存独立卡片。

原书依据 · 4 处
编写混合显示类

三种显示混合类逐步扩大观测范围:实例自有属性、可见继承属性、按定义类分组的继承图。显示方法通过self应用于客户实例,与继承选择、表示递归、名称改写、slots与访问副作用相互约束。ListTree的访问表避免共同祖先重复展开,但不是MRO或对象快照的完整实现。

通用显示工具须限定适用对象关联本项背景,实质主要讲解在对应位置。

默认对象显示不保证物理地址关联本项背景,实质主要讲解在对应位置。

访问集合可防止循环重复处理关联本项背景,实质主要讲解在对应位置。

混合能力仍需协调继承契约关联本项背景,实质主要讲解在对应位置。

内部名称约定不等于访问隔离关联本项背景,实质主要讲解在对应位置。

原书依据 · 15 处
属性枚举要区分可见与归属

ListInstance扫描self.dict,回答实例自己存了什么;ListInherited通过dir列名称再getattr取值,回答按它的访问规则能看到什么;ListTree沿class与bases遍历,并逐类扫描dict,回答名称定义在哪个类。三个问题不同,不能把一份名称列表当成完整对象状态或属性归属证明。

结构图: 类图列出原书三种替代混合工具的真实接口,不表示三者互相继承。

classDiagram
class ListInstance {
  __str__(self)
  __attrnames(self)
}
class ListInherited {
  __str__(self)
  __attrnames(self)
}
class ListTree {
  __str__(self)
  __listclass(self, aClass, indent)
  __attrnames(self, obj, indent)
}

dict扫描可能漏掉slot存储;dir结果可受定制影响,getattr还可能执行描述符或用户属性逻辑。ListInherited只隐藏双下划线名称的值,名称仍会显示。归属图的遍历也不是Python实际MRO的证明。

691的E声明slots c/d,D继承E并另声明a/dict;D实例能保存父slot的c、自己的a与字典中的b。X.slots只按普通属性查找取得较低层清单,不会自动合并父slot,所以只拼X.dict与X.slots仍会漏掉c/d。dir可帮助列可见名,读取值仍需getattr并处理未赋值/描述符行为;不能把可见名称当完整状态快照。

结构图:

classDiagram
class E {
 __slots__$
}
class D {
 __slots__$
}
E <|-- D

这是01966的E/D,与同单元前面另一个D的定义是替代片段,不能合并。继承普通基类的字典会保留动态字段能力,不代表子类声明的slot完全没有存储作用。

属性枚举要区分可见与归属保存独立卡片。

原书依据 · 2 处
表示对象可能触发递归显示

如果通用repr枚举并显示实例的绑定方法,方法的表示又可能引用并表示该实例,从而重新进入同一repr。原书ListInherited选择str,让方法表示可借用另一条默认实例表示路径,并提出识别MethodType后省略的方案。问题在于显示链路会再次进入自身,不只是函数名字选错。

这只解释教材所示方法值的循环,不证明改用str就能安全显示任意对象图:自引用属性、描述符或自定义值表示仍可能递归或产生副作用。可按工具目标限制被展示的值、建立访问记录或使用受控摘要;本次没有运行递归样例。

表示对象可能触发递归显示保存独立卡片。

原书依据 · 1 处

类是对象:通用对象的工厂

工厂把可调用目标与调用参数作为数据接收,再按真实签名执行;类能够被传递使统一构造成为普通函数调用的一种用法。

参数收集与调用展开方向相反关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
工厂可转发不同构造参数

factory(aClass,*args)把位置参数收集后展开给传入目标;扩展版本factory(aClass,*args,**kwargs)还转发关键字。类对象只是可调用目标的一类,函数和绑定方法也可接受这种调用,返回结果取决于目标自身。它统一调用入口,不会替目标修正参数、保证任何类都能接受任意参数,或保证非类目标返回实例。

结构图:

flowchart TD
 A[传入类或其他可调用对象] --> B[factory收集位置参数和关键字]
 B --> C[按目标真实签名展开调用]
 C --> D[返回目标结果或传播调用失败]

原书用以下两个真实类作构造例子;它们没有相互继承关系,Spam没有显式定义init。

classDiagram
class Spam {
  doit(self, message)
}
class Person {
  __init__(self, name, job)
}

示例factory(Spam)可以传零个位置参数;factory(Person,“Guido”,“guru”)则按Person要求传两个,不能将原文“一个或多个”理解为所有目标至少需要一个。

工厂可转发不同构造参数保存独立卡片。

原书依据 · 1 处
为什么有工厂

工厂的收益在于隔离动态构造选择及参数细节,而不是让所有创建都必须多一个包装层。

统一调用语法不统一业务结果关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
构造选择与构造调用可分离

动态配置可先决定从哪个模块取得哪个类,再把选定目标与参数交给构造调用。通用工厂能集中参数转发与创建入口,但配置选择本身仍需有明确范围;仅将名称交给getattr,不证明属性一定存在、可调用或符合Processor需要的reader接口。只有单个已知参数时,aclass(classarg)也可直接调用,无需为模式名称增加一层。

构造选择与构造调用可分离保存独立卡片。

原书依据 · 1 处

与设计相关的其他话题

本项回顾已读组合模式,并把抽象超类、装饰器、类型子类、方法种类、管理属性和元类指向其他章;它的作用是学习导航,没有新展开的设计机制。

本章小结

第30章小结把委托、组合、继承、伪私有名称、绑定方法与工厂回收到代码复用这一共同目标:各手段组织协作的方式不同,不能仅凭用了类就认为设计已改善。下一章转向工具作者常用的高级机制。

本章习题

五道自测问题分别要求辨认多重继承、委托、组合、绑定方法与伪私有属性;它们检查能否说清已经学习的关系,不增加第六种机制。

习题解答

答案区分多基类组合代码、代理包装后委托、控制器嵌入协作对象、实例与函数绑定,以及按定义类改写名称。它们解释了几种机制的基本分工;代理具备多少接口、混入能否兼容、伪私有名称是否冲突,仍依具体协议与已说明的边界判断。

第31章 类的高级主题

高级类主题展示内置类型派生、包装、静态与类级行为、特性及装饰等扩展位置。直接继承会开放基类接口,包装可以选择暴露范围;两者在可替代性和状态处理上需要不同约束。类也是对象,这个事实最终连接到装饰器和元类。

第31章将从内置类型扩展转向新式类、方法绑定与装饰器等高级主题,最后以陷阱和练习收束。这里先说明学习范围,特性、描述符与元类的更完整机制要到后续章节才展开。

扩展内置类型

扩展现有容器可包装并委托给内部对象,也可在具体类型允许时继承并定制;这两条路线会让客户看见不同的接口范围。

包装委托与继承是不同关系关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
通过嵌入扩展类型

setwrapper.py把列表作为内部数据,显式决定对外导出哪些操作,并用新实例返回交并结果。

容器包装控制暴露的操作

包装版Set把元素保存在新建的self.data列表,通过concat只加入尚不存在的元素,再显式提供长度、取项、交并与表示接口。它利用列表存储,却不会自动开放list的全部方法;有getitem可支持相应索引访问,也不等于对象本身就是list。

结构图:

classDiagram
class Set {
  __init__(self, value=[])
  intersect(self, other)
  union(self, other)
  concat(self, value)
  __len__(self)
  __getitem__(self, key)
  __and__(self, other)
  __or__(self, other)
  __repr__(self)
}
class list
Set *-- list : 新建并持有data

这是setwrapper.py的包装版本,与后面的同名list子类是替代实现。交并返回新的Set,concat原处修改内部列表;成员判断仍作线性扫描,不能因类叫Set就推断采用散列或具备内置set的所有契约。

948的02615 MyList以for x in start逐项append到新列表,故字符串输入变为字符列表,外层复制仍共享元素。其getitem(self,offset)直接返回wrapped[offset],旧getslice返回MyList;在Python3切片经前者,可能返回原生list,不能从旧方法存在推断新版本切片保持包装类型。

结构图:

classDiagram
class MyList {
 wrapped
 __init__(self, start)
 __add__(self, other)
 __mul__(self, time)
 __getitem__(self, offset)
 __len__(self)
 __getslice__(self, low, high)
 append(self, node)
 __getattr__(self, name)
 __repr__(self)
}

MyList.add/mul显式构造MyList,而getattr仅把普通未找到方法转给wrapped;返回类型及隐式协议各自需检查。

容器包装控制暴露的操作保存独立卡片。

原书依据 · 2 处
通过子类扩展类型

子类可以覆写内置类型行为,也会继承其余公共能力;本节的MyList改索引与Set继承列表分别展示语义替换与修改入口的边界。并非所有内置类型都允许继续继承,不能把原文概括当作无限制规则。

索引协议并不保证序列语义关联本项背景,实质主要讲解在对应位置。

可变默认参数会跨调用共享关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
继承会开放其他修改入口

Set(list)只在构造与concat中去重,其他列表操作由继承取得。若调用继承的append、extend或索引赋值,元素可能重复;构造时去重不能保证整个对象生命周期都保持唯一。选择继承时应检查全部可修改入口,或明确该对象仅演示列表扩展,并不承诺完整集合不变量。

结构图:

classDiagram
class list
class Set {
  __init__(self, value=[])
  intersect(self, other)
  union(self, other)
  concat(self, value)
  __and__(self, other)
  __or__(self, other)
  __repr__(self)
}
list <|-- Set

图仅列setsubclass.py实际声明的方法;长度、索引与其他操作来自list。它与包装版Set是同名的替代定义,不应拼接成一个同时包装并继承的实现。

继承会开放其他修改入口保存独立卡片。

原书依据 · 1 处

新式类

“新式类”是为兼容Python2历史类模型而保留的说法;Python3的普通类已采用该模型。相似class语法在不同版本的继承查找、类型观测与隐式协议上可能不同,不能只看语法相同就假定完全兼容。

精确类型与子类判断回答不同问题关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处

新式类变化

变化概览分别连接类型模型、MRO、隐式特殊方法查找与高级属性工具。这些是不同层面的规则:一个规定对象的类型,一个规定基类线性化,一个规定特定语法怎样取得协议方法,不能混成同一次普通点号查找。

混合能力仍需协调继承契约关联本项背景,实质主要讲解在对应位置。

特殊方法协议查找有类型层规则关联本项背景,实质主要讲解在对应位置。

原书依据 · 19 处
类型模式变化

类型模型把类也放进对象体系:实例具有所属类,类由元类生成,而所有普通类的继承最终通向object。理解时必须区分“是什么类型的实例”与“继承哪个基类”,并将类型检查用于明确的接口或数据契约。

精确类型与子类判断回答不同问题关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
类是类型与元类的实例

在原书普通类C的例子中,调用C产生实例X,type(X)为C,而type©通常是type。类本身也是对象,可以由元类生成;使用自定义元类时,类对象的类型可为该元类,不能把所有类的确切类型都固定成type。

结构图: 类图中的实线三角表示子类继承,虚线箭头单独标明“类型为”,两种关系不能互换。C是原书普通类,类体为空,未添加方法。

classDiagram
class object
class type
class C
object <|-- type
object <|-- C
C ..> type : 类型为
object ..> type : 类型为
type ..> type : 类型为
note for C "X等于C的调用结果时,普通实例X的类型为C"

object是type的实例,type继承object且也是自身的实例;这不表示object继承type。原书末尾“object派生自type”混用了实例与继承。类/类型统一也不抹去内置类型在可变性、可继承性或实现方式上的具体差异。

元类可在类创建层面提供管理/扩展钩子,本节讨论的是type子类这一常见形式,而不是要求每个应用类都自定义元类。Python元类入口也可由其他可调用对象提供,不能把此处的type子类介绍当作所有允许形式的穷尽定义;具体创建协议待第39章。

910的02480-02484用type([])、type(list)、type(type)、C与C(object)及传统类做历史对照。Python3普通类C的type©是type,X=C()的type(X)是C,type(type)仍是type。继承object与作为type实例是不同关系;原文2.6传统类段有混乱,应以图示type©为classobj、C.class报AttributeError区分,不把传统类说成type子类。自定义元类的类则以该元类为直接类型,后续正文会展开。

911把类的bases所列继承超类与class所指创建它的元类分开。类可从某个业务超类继承,同时作为另一个元类的实例;普通对象再作为该业务类的实例。这里描述type子类式元类,不宣称所有可用的类创建可调用对象都必须是type子类,后文另有函数工厂。

类是类型与元类的实例保存独立卡片。

原书依据 · 4 处
钻石继承变动

菱形例子把查找顺序的语义差异落到共享祖先:新式类用C3线性化保持局部顺序与单调性,C可以在共同祖先A之前参与查找。冲突可在混合点明确处理,但别名、调用与未来修改之间仍有绑定边界。

子类覆写不改写基类定义关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
菱形继承按线性顺序查找

原例D继承B和C,B与C又都继承A;A.attr为1,C.attr为2。Python3按C3得到D、B、C、A、object的线性顺序,所以未在D/B找到attr时会先采用C的2,而不是先沿B走到A。经典类的深度优先结果不同,不能把这一特例概括成任意新式继承都作宽度优先。

结构图: 类图取原书新式版本;A/C的attr都是类属性,箭头表示继承。

classDiagram
class object
class A {
 attr$
}
class B
class C {
 attr$
}
class D
object <|-- A
A <|-- B
A <|-- C
B <|-- D
C <|-- D

C对A的覆盖在这份合法线性化中保持,但实际取值仍可能受更近的定义、描述符和后续修改影响。原文“D是B和C的超类”方向写反,代码显示D是子类。多继承需满足一致的线性化约束,不能由避免重复访问推出任意基类排列都合法。

菱形继承按线性顺序查找保存独立卡片。

原书依据 · 1 处

新式类的扩展

本节从历史查找差异转到slots等扩展工具,说明下文将按具体机制解释;读者需要区分Python2新式类的可选变化与Python3已有类行为。

slots实例

slots把名称声明与实例存储联系起来;通用工具必须区分预留名称、已赋的值、继承slot和实例字典,不能只读一个slots清单就声称遍历全部状态。

属性枚举要区分可见与归属关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
声明slot不等于已有实例值

slots声明实例可采用的特定存储名称,不会替每个名称初始化值。原例limiter声明age/name/job,创建x后直接读age仍失败,赋x.age=40后才可读取;无实例字典时给未声明的ape赋值也会失败。声明范围、是否已有值和当前值是什么,是三个问题。

结构图:

classDiagram
class object
class limiter {
 __slots__$
}
object <|-- limiter
note for limiter "类属性__slots__声明age/name/job,实例值仍需各自赋予"

这是01960的真实空方法类,未补造init。若继承链保留dict或显式把它纳入slots,仍可增加其他动态属性;slots不是所有继承环境下的封闭字段保证。可能节省某些布局成本,但具体内存与速度需测量,不能由声明推导必然更快。

声明slot不等于已有实例值保存独立卡片。

原书依据 · 1 处
类特性

property在类上为特定字段安排处理函数,使普通实例属性语法与计算逻辑连接。它和通用属性钩子的分工在于管理范围,读写函数是否共同使用同一存储也必须从真实实现判断。

属性管理入口有不同粒度关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处
特性将指定属性交给处理器

property把某个类属性名绑定到读取、设置和删除处理器。原书newprops的age读调用getage,写调用setage,而job仍按普通属性赋值;未提供setter的只读版本不支持age写入。通过类取得property对象,与通过实例触发getter是不同访问。

结构图:

classDiagram
class object
class newprops {
 getage(self)
 setage(self, value)
 age$
}
object <|-- newprops

图对应01970可读写版本,age是类上创建的property,不是自动存储值。getage固定返回40,setage只写self._age,所以写age=42并不自动使下一次age读取返回42;读写一致性由处理器自己的逻辑决定,_age可另行读到42。与getattr处理缺失名、setattr处理一般赋值相比,property更适合预先明确的字段,不能由短例推导总更快或替代任意代理。

833解释property被分配为类属性,可沿继承取得,访问器通过self访问实际主体状态。它是特定形式描述符,管理单名而非对任意属性的通用代理;保留点号语法不要求真实值也存成同名实例字段。

834及02250给property参数顺序,fget计算读取结果,fset/fdel处理写删,doc可继承getter文档。参数可全省并成功创建property对象,不能将原文解释成创建property()本身就异常;无getter/setter/deleter时尝试对应操作才会失败。类访问通常取得property对象本身,实例访问才触发相应管理。

835完整Person将name=property(getName,setName,delName,doc)放在类上,实际存self._name。getName返回_name,setName修改它,delName删除它;Bob和Sue各自状态分开,Person.name.doc读取的是管理对象文档。

结构图:

classDiagram
class Person {
 _name
 name$
 __init__(self, name)
 getName(self)
 setName(self, value)
 delName(self)
}

图对应02251原始Person,不与31章newprops混为同一类。后续02254把同一实现移到Super,Person(Super)类体pass,说明继承复用:

classDiagram
class Super {
 name$
}
class Person
Super <|-- Person

第二图仅显示移入实现的继承关系,省略号处不新增其他方法;删除Bob的_name后再读其name会受缺失状态影响,不应以仍有property就认为必有值。

特性将指定属性交给处理器保存独立卡片。

原书依据 · 4 处
getattribute和描述符

getattribute面向普通属性读取入口,描述符则把读取/写入逻辑放在特定类属性对象上;property和slots借助描述符参与访问。此处是机制定位,完整实现仍在第37章。

属性管理入口有不同粒度关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处
元类

元类参与类对象的创建与管理,这与普通类生成实例处在不同层次。本节说明常见type子类形式的用途,尚未给出创建钩子的具体实现。

类是类型与元类的实例关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处

静态方法和类方法

本节预告静态方法不自动绑定实例,类方法自动取得类;与通过类读取普通函数的Python3行为需要区分。这些绑定方式既可用于新式类,也不能因原文一句“只对经典类有效”就限制到旧类模型。

为什么使用特殊方法

类级数据可能在没有实例时就需要访问,例如读取累计创建次数。把相关行为放进类命名空间可明确组织归属,但是否自动取得实例/类由方法绑定方式决定;这里的“特殊方法”不是双下划线运算符协议。

方法种类决定自动绑定对象关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
Python 2.6和Python 3.0中的静态方法

无self普通函数能否调用取决于从类还是实例取出,以及历史类模型。Spam例将这个绑定差别与实际需求连接:读取类级累计计数不应迫使调用者先增加一次计数。

方法种类决定自动绑定对象关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
类级计数不要求创建实例

Spam.numInstances放在类上,init每次执行就把它加1,因此为读取这份计数再创建一个Spam,会先改变所要观察的数值。类级观测应能经适当的类级入口完成,不必制造无用实例。该数值记录执行构造器所累积的次数,原例没有析构扣减,不能直接叫当前存活实例数。

结构图:

classDiagram
class Spam {
 numInstances$
 __init__(self)
 printNumInstances()
}

图对应01972最初尝试,printNumInstances尚未包装为staticmethod:Python3经类取得它可作为无参函数调用,经实例取得仍会加入一个实例而与零参签名冲突;原图Python2.6还受未绑定方法规则影响。后续静态方法版本是对该调用契约的明确表达,不能把本图假装成已经装饰的最终代码。

模块级printNumInstances可直接读Spam计数;普通方法printNumInstances(self)则需已有实例。01978最后的Spam().printNumInstances()先执行构造,把累计数从3加到4,再打印4。模块函数本身不参与类方法继承,子类仅定义同名方法不会自动替换原模块函数引用;但这不等于外部函数永远不能参数化或重新绑定。

静态版本把printNumInstances包装后,Spam和已有实例都可零参调用;Sub可覆写并在函数体显式调用Spam版本,Other可直接继承。原构造器与显示函数仍硬编码Spam.numInstances,所以这份设计累计在Spam上,不因Sub/Other调用就自动形成各自计数。原静态Spam版本与697普通无参尝试是替代代码,不能将两种声明混成同一原始类。

类级计数不要求创建实例保存独立卡片。

原书依据 · 3 处
静态方法替代方案

模块函数可不带实例访问类名,普通实例方法则要求一个已有实例;选择取决于所需命名空间、继承参与及是否会改变被观测状态。

类级计数不要求创建实例关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
使用静态和类方法

同一类中的三种方法在取用时采用不同绑定规则;staticmethod/classmethod包装通过类体名称重绑定生效,随后调用仍须满足真实参数契约。

方法种类决定自动绑定对象关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
使用静态方法统计实例

将计数显示函数明确包装为静态方法,可同时支持经类和实例取用而不自动传入实例;方法也能被继承或覆写,数据更新位置仍由函数体决定。

类级计数不要求创建实例关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
用类方法统计实例

类方法保留适用接收类,能够用于按类管理状态,但显式基类取用会重新确定接收者,状态是否独立还需查看字段初始化与真正的赋值目标。

类方法接收类由取用入口决定

经Sub实例或Sub取用继承的类方法,通常将Sub作为cls;经Other实例取用继承方法,可将Other传给同一Spam定义。但Sub的重定义若显式调用Spam.printNumInstances(),这次调用就从Spam取用,基类方法收到Spam。接收类不能只由最初实例的类型一概决定。

结构图:

classDiagram
class Spam {
 numInstances$
 __init__(self)
 printNumInstances(cls)
}
class Sub {
 printNumInstances(cls)
}
class Other
Spam <|-- Sub
Spam <|-- Other

图对应01989的替代版本,两个printNumInstances均包装为classmethod。01990显示Sub入口后,显式Spam调用又收到Spam;01991直接继承路径收到Other。它们演示的是访问和委托的具体绑定,不是所有子类调用都无条件把同一个cls传到底。

类方法接收类由取用入口决定保存独立卡片。

原书依据 · 1 处
每类计数需要独立更新目标

最后版本在Spam、Sub与Other各声明numInstances=0,Spam.init调用self.count(),类方法count(cls)更新cls.numInstances。这样从不同子类创建对象时,更新落到对应类,教材得到1、2、3三个累计数。仅把显示函数改成classmethod,而构造器仍写Spam.numInstances,不会达到这一效果。

结构图:

classDiagram
class Spam {
 numInstances$
 __init__(self)
 count(cls)
}
class Sub {
 numInstances$
 __init__(self)
}
class Other {
 numInstances$
}
Spam <|-- Sub
Spam <|-- Other

count包装为classmethod。三个计数字段是各类自己的绑定;不能由classmethod关键字推导所有可变类属性都被深复制。若省略子类初始绑定,读到的可能仍是继承值,随后赋值才建立局部绑定,所以状态初始化也属于设计。原例没有递减、并发或失败计数协议,计数仍不等于实时存活数。

count(aClass)装饰器为Spam、Sub和Other各在类定义阶段设置numInstances=0,再返回原类。这可替代701中显式写在各类体内的初值,不是每次创建实例都把值清零。图中其余类体以省略号表示,具体构造与count类方法仍依前文实现,不能把这一示意当完整可执行程序。

948的02616 MyListSub直接MyListSub.calls+=1累计类计数,self.adds+=1累计实例计数;它只统计本覆写add的进入,并不因任何列表操作都增加。返回MyList.add产生的是MyList而非MyListSub,新结果不能假定继续保留子类stats接口。继承Adder的示例也有start=[]共享默认值且DictAdder第二版add仅pass,不把它视为完整可用容器。

每类计数需要独立更新目标保存独立卡片。

原书依据 · 3 处

装饰器和元类:第一部分

函数装饰器把定义得到的函数交给另一可调用对象管理,结果可能保留原函数,也可能增加包装;它不只用于静态方法,也不要求一定以类实现。类装饰器进一步把同类机制用于类对象。

函数装饰器基础

装饰语法把包装调用与函数名称重绑定放在定义旁边;原函数、装饰器返回对象和以后取得/调用该名称的行为需要分别追踪。

装饰器在定义阶段重绑名称

执行带装饰的def时,先形成函数对象,再将它交给装饰器,把返回对象绑定到原函数名。装饰器的应用与以后通过该名称调用是不同阶段:返回原函数可以保持同一对象,返回包装对象才可能在后续调用增加逻辑,不能把所有装饰器都说成每次调用自动再装饰。

结构图:

flowchart TD
 A[执行def形成函数对象] --> B[应用装饰器]
 B --> C[原名称绑定返回对象]
 C --> D[后续按返回对象的协议访问或调用]

图只区分装饰应用和后续使用,不枚举装饰表达式求值的全部步骤。@staticmethod与类体内meth=staticmethod(meth)表达同一包装意图;返回的是描述符包装,不能把它在Python2.6⁄3.0一概当普通可调用函数。官方文档把staticmethod包装本身可直接调用列为3.10变化,与从类或实例正常取得静态方法要分开。

861将函数与类统一解释为定义阶段的管理步骤。名称最终指向装饰器返回对象,返回原对象与返回包装器有不同效果;类装饰不是每次属性访问自动重新装饰,也不因名称保留就保证类型与签名不变。

862举调用追踪/计时和实例属性管理说明安装后续层:装饰器收函数/类,包装器随后收调用实参。这些是常见用途,不代表所有装饰器都插入包装对象或都保持原对象身份/接口。

867及02337-02343列def前语法与装饰后手动重绑、staticmethod/property、返回原函数和返回其他对象。原文从Python2.5起可用不准确,PEP318指定函数/方法装饰语法在2.4引入。装饰器调用与所得对象后续调用分开,所得对象不保证可调用或与原参数数目相同,property便需经属性访问协议使用。

871及02367给处理对象O后return O的后创建骨架。图里定义decorate却使用@decorator,名称不一致,按意图解释协议而不称原样已可运行;函数/类返回原对象时不凭装饰语法自动增加每次调用的包装层。

装饰器在定义阶段重绑名称保存独立卡片。

原书依据 · 5 处
装饰器例子

tracer把原函数与计数保存在可调用实例中,说明装饰可以增加状态与额外动作;这种实现仍会改变返回值、可接受参数和方法绑定,需要按预期契约明确处理。

可调用包装不自动保持契约

tracer在init保存原函数和calls,在call先加计数、打印,再用*args调用原函数。它没有return,正常结束只返回None;没有**kwargs,也没有让包装实例像普通函数描述符那样自动为方法绑定self。调用语法相似不证明包装透明。

结构图:

classDiagram
class tracer {
 __init__(self, func)
 __call__(self, *args)
 calls
 func
}

图对应01996-01997实际实现,spam是被装饰的函数,不把它画成类。计数发生在目标调用之前,目标失败也可能已被计入;打印还依赖func.name。该例只演示匹配的位置参数调用,原spam本来不返回业务值,不能由三次打印推断返回值或关键字参数契约已经保留。

873的02368-02369复用tracer(init/call):只接*args、不接**kwargs,也没有return目标结果,故不能从spam打印正常就断定可透明包装任意函数。calls统计经过包装入口的调用尝试,递增在目标执行前,失败尝试也会计数;直接拿到原函数的其他引用仍可绕过。

874的02371增强tracer把call扩为(self,*args,kwargs),并return self.func(*args,kwargs),补上前版遗漏的关键字和返回值转发。这个改动仍不自动补方法绑定/元数据等全部契约;完整类和状态图另见本节计数状态卡。

可调用包装不自动保持契约保存独立卡片。

原书依据 · 3 处
类装饰器和元类

类装饰把已创建类交给管理逻辑,元类则参与创建;count例用前者初始化每类计数,Meta例只勾勒后者的入口,必须保留两层时机与实现完整性的区别。

每类计数需要独立更新目标关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
类装饰与元类作用阶段不同

类装饰器接收已经创建的类对象,返回值再绑定到类名;元类则参与该类对象的创建协议。两者都能管理类,却不处在同一阶段,也不意味着每次实例化都会重新执行装饰器。类装饰器可返回原类或替代对象,后续是否仍能像原类那样构造实例,取决于返回对象的契约。

原例count(aClass)把numInstances设为0后返回aClass自身,是定义类时的状态初始化,不是代理或每次构造时清零。Meta(type)的new(meta,classname,supers,classdict)只给省略体,属于创建钩子的示意,不能当作已经实现返回有效类的完整程序。Python2的metaclass写法与Python3类头关键字也须分版本理解。

863明确返回原函数可作注册/属性设置,返回原类可作方法扩展等后创建步骤。类装饰接受已创建类,不能因此说它与元类创建过程完全同义;直接管理对象与安装实例创建包装器是两种不同职责。

906按内省、运算符、属性钩子、property、描述符、装饰器回顾自动插入入口。类装饰器可以直接增强原类并返回它,不必包实例;元类也可安装影响实例行为的代码,阶段不同不等于应用目的互斥。描述符的调度仍遵循既有优先级,正文“常规查找之后”不扩成所有描述符都在实例字典之后运行。

908的02477-02479将extras(Class)末尾return Class,再把Client=extras(Client)改为@extras。该方案原地加方法并返回原类,实例仍直接由原类构造,没有独立实例包装器。它说明特定扩展可替代,不说明装饰器具有元类所有创建钩子或继承传播性质。图为简化骨架,required和extra函数体未实现,extra调用也未补所需arg。

922的02517-02518用Extender(aClass)赋eggs/ham再return aClass,对照元类先改classdict再创建。两版都无实例代理,但装饰器已接收完成的类,而元类new参与其构建。前者不会仅因子类继承就重新运行同一个装饰器。

类装饰与元类作用阶段不同保存独立卡片。

原书依据 · 5 处
更多详细信息

本项把property装饰写法、完整装饰器实现和元类分别指向第37、38、39章,作用是标记后续深入位置;前述小例并不替代这些章节的完整机制。

类陷阱

陷阱节以命名空间为线索,提醒类和实例的状态、继承与名称选择会影响程序含义;以下各项有的是错误风险,有的是需要明确政策的正常用法。

修改类属性的副作用

在运行期改变类对象的属性,会影响仍从该类取得这一值的实例;给实例另建绑定、给类重绑值及用类临时存放命名空间,是不同操作。

实例赋值可遮蔽共享类属性关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
修改可变的类属性也可能产生副作用

共享对象的原处修改会沿多条引用可见,实例属性重绑定则改变本实例的名称指向。类列表与每次构造新建列表让这两种边界同时可观察。

实例赋值可遮蔽共享类属性关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
多重继承:顺序很重要

多继承的基类顺序影响默认成员选择,但若要从两侧分别选择不同同名成员,单纯交换顺序不够;需要在混合点明确绑定或实现对应成员,并保留其后续变化政策。

混合能力仍需协调继承契约关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
类、方法以及嵌套作用域

嵌套函数作用域可以让方法访问外层函数绑定,但类体命名空间不是普通方法的闭包外层。旧版全局声明与移动到模块的替代方案改变了名称归属,需与实例属性查找分清。

类体不是方法的闭包外层

generate中定义Spam,Spam.method使用Spam.count;普通方法可经所在函数的词法绑定找到Spam,却不会把所在类体的count自动当闭包变量。裸count仍沿函数的普通名称规则查找,self.count或Spam.count才明确进行属性访问。函数词法作用域与对象属性命名空间不能混用。

结构图:

classDiagram
class Spam {
 count$
 method(self)
}
note for Spam "此类定义在generate函数内;方法可捕获外层函数绑定的Spam"

图取02015的实际类,generate是函数而非父类。Python2.2以前缺嵌套函数作用域的失败是历史边界,不当当前异常。self.class.count改为从实际实例类型访问,和捕获词法Spam并非在任意子类/重绑定情形下都等价;global方案也会改变绑定范围,不能只按输出相同就混同。

类体不是方法的闭包外层保存独立卡片。

原书依据 · 1 处
Python中基于委托的类:getattr和内置函数

包装器的一般属性转发不会自动覆盖语言触发的隐式协议;需要在包装类型或其基类上提供所需特殊方法,才能明确委托那些操作。

特殊方法协议查找有类型层规则关联本项背景,实质主要讲解在对应位置。

原书依据 · 15 处
“过度包装”

抽象的收益应与追踪真实行为的成本一起衡量。过深继承或多层包装可能增加维护负担,但恰当分解和稳定接口仍是OOP的价值,不能以一个层数一刀切。

复用层次应能追踪实际行为

继承与包装能减少重复,也会增加理解一次调用所需追踪的路径。若基本操作必须跨很多层才能定位,抽象成本可能超过复用收益。作者以一个多层C++系统的经历说明这种困难,建议在有理由时才增加层次,并让接口可理解;单个轶事不提供普遍最佳层数或性能阈值。

评估时可检查维护者能否找到实际方法、状态归属与协作对象,而不只数类或追求最平的结构。必要的抽象仍可提高一致性与复用;问题是层次是否清楚承载职责,不是OOP天然有害。

复用层次应能追踪实际行为保存独立卡片。

原书依据 · 1 处

本章小结

本章收束内置类型扩展、类模型、方法绑定和装饰器,指出后续高级章还会展开属性管理与元类;下一部分转向以类表达的异常与错误传播。

本章习题

五问要求回忆包装/子类两种扩展、装饰目的、新式类定义与差别、实例/静态方法绑定,都是对本章机制的自测。

习题解答

五条答案回连扩展路线、定义后包装、新式类模型、类型/隐式协议与方法绑定;答案中的简写仍需按已读实现与官方规则限定。

第六部分 练习题

第六部分练习把继承/协议/计数/属性转发/集合/内省重新应用到具体规格;Lunch、Zoo和Scene明确给出协作和类型结构,其余多为要求读者实现的任务,尚不能视为已有可执行解答。

组合控制器组织协作流程关联本项背景,实质主要讲解在对应位置。

继承与组合表达不同关系关联本项背景,实质主要讲解在对应位置。

多态调用分派按接收对象解析关联本项背景,实质主要讲解在对应位置。

原书依据 · 11 处

第七部分 异常和工具

这一来源项仅写“第七部分 异常和工具”,标记下部分起点;没有独立正文知识。沿既有计划保留这个分隔项,下一719才进入第32章实质讲解。

第32章 异常基础

异常让失败跳离当前正常语句并沿调用栈寻找处理器。raise产生或重新发出异常,try为可能失败的范围安排处理;是否恢复应由能决定后续动作的层级负责。资源清理与异常被处理是独立问题,finally执行后错误仍可能继续传播。

本章以异常改变控制流为入口,分别介绍捕获、清理、主动触发和上下文管理;这些工具承担不同职责,后续单元用代码明确区分。

为什么使用异常

异常把罕见失败路径从正常工作流程中分离:深层步骤可中止正常调用链,将处理交给外层已设的匹配处理器。它不是任意goto,也不会替程序补偿已经做完的动作。

异常沿调用栈转移控制

执行中的某一步发生异常时,控制流沿仍在活动的调用栈寻找匹配处理器,放弃从失败点继续的正常路径;中间函数不必逐层返回错误码。制作比萨的烤炉故障比喻说明可以从深层步骤直接转入外层处理,而不是继续准备成功结果。

这种转移不是倒退执行:已经发生的赋值或外部动作不会自动撤销,异常本身也不会提供事务回滚。未匹配的异常继续向外传播,处理器只在其保护的动态执行范围内有作用;比喻不意味着任意跳到程序中的标签。

721脚注明确:Python异常的控制转移不会把进入try以来的赋值重置,和真正的反向跟踪不同。错误/事件通知/特殊情况等用途是可选设计角色,不表示普通失败必须用异常,也不证明程序自带回滚;反向跟踪未展开算法,不补造实现。

771图35-1/02123显示func2抛异常,最近的func1处理器先处理,正常处理完继续func1,外层同类处理器不再自动被逐个调用;图35-2/02124对照多个活动finally在传播经过各范围时先内后外收尾。决定去向的是运行时尚未离开的保护范围,不只是文件里谁写在谁旁边。

772及02125显示action2、action1、模块三层,预期仅inner try。两个激活的匹配try不表示要执行两次恢复;内层处理后不再传播,外层不会凭匹配类型主动接收到同一已处理事件。

异常沿调用栈转移控制保存独立卡片。

原书依据 · 4 处
异常的角色

异常既可报告错误,也可表示某些事件或罕见情况;清理是另一职责。是否用异常表达搜索未找到取决于接口契约,本节只是列举用途。

异常沿调用栈转移控制关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处

异常处理:简明扼要

本节仅引出下一单元的第一个异常例子,没有独立机制或代码。

默认异常处理器

fetcher(obj,index)直接返回obj[index]。字符串spam索引3成功,索引4产生IndexError;无人捕获时异常向顶层报告,脚本通常终止,而交互环境保留提示符。

错误消息定位不等于确定根因关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
捕获异常

try只保护它实际执行的范围;fetcher越界被匹配的except IndexError处理后,不返回出错的索引操作重试,而是结束该try语句并继续后面的代码。

异常捕获要匹配预期失败范围关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处
引发异常

异常可由运行中的内置操作检测触发,也可由raise主动触发;两者进入相同的传播与匹配流程。assert是表达调试假设的条件触发工具,与必需的业务校验分开。

触发来源不改变捕获规则

解释器检测到索引越界与程序显式raise IndexError都可把同类异常交给匹配的except IndexError。捕获依据异常类型及执行中的处理范围,不要求先区分它是内置操作检测出来还是业务代码主动报告。没有匹配处理器时,手动触发的异常也会继续向外传播。

raise是主动报告失败的语句;assert条件为假可触发AssertionError,主要用于开发时检查假设,不能承担必须始终执行的输入校验或接口阻断。异常发生不代表错误已修复。

触发来源不改变捕获规则保存独立卡片。

原书依据 · 1 处
用户定义的异常

Bad(Exception)示范以异常类命名本程序的失败;raise Bad()产生实例,except Bad捕获这一类。类的潜力不等于示例已实现状态和继承行为。

自定义异常建立专用类型

程序可以定义继承Exception的异常类,为本程序提供可单独捕获的失败类型。原例Bad没有新增方法:doomed通过raise Bad()触发实例,外层except Bad按类型捕获。类继承还可支持附加状态或分组,但这段例子并未实现这些扩展。

结构图:

classDiagram
class Exception
class Bad
Exception <|-- Bad

原图Bad的类体只有pass,因此图中不捏造构造器、状态或方法签名。doomed是模块函数,不是Bad的方法。一般应用异常通常从Exception派生,不能把任何普通类实例都直接raise。

自定义异常建立专用类型保存独立卡片。

原书依据 · 1 处
终止行为

finally负责退出时收尾,except负责匹配异常处理;无异常/有异常两条路径都可能清理,但能否正常执行try之后的语句取决于异常是否仍在传播。with则要求对象支持上下文协议。

上下文管理让文件退出时关闭关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
清理结束不等于异常消失

finally为受保护代码退出时安排收尾,正常完成和异常离开都会经过它;这和except捕获失败是不同职责。原例after调用fetcher(x,4)越界,先打印finally中的after fetch,再把IndexError向外传播,因此try之后的after try不会正常执行。改用合法索引3时,清理仍发生,之后才可继续。

仅将print写在函数调用后面不能替代finally:异常会跳过普通后续语句。清理路径也不等于清理必然成功、错误被吞掉或外部修改被回滚。这里描述正常语言执行中的退出语义,不把它扩大为强制终止进程、断电等情形的保证。

737及02060再次明确finally的正常与异常两条路径,清理后若仍有异常就不正常进入try之后。2.5前不能在同一语句混合except/else/finally是历史语法边界;如今可组合职责,不能据此将清理等同匹配恢复。

771的嵌套finally图显示异常向外经过多个清理层。这里假定这些清理正常结束且没有return等覆盖传播;finally本身失败或主动改变离开路径时,不能无限定声称原异常必到所有外层。处理器正常捕获后,未被离开的外层范围也不会仅因这次异常立即清理。

783脚注明确os._exit立即终止可跳过清理,不能由try/except或finally拦住;sys.exit则抛SystemExit,可被捕获并经过正常清理。这为finally保证限定在正常语言控制流提供具体反例,不是要求执行任一退出调用。

清理结束不等于异常消失保存独立卡片。

原书依据 · 4 处

本章小结

本章将异常收束为可触发、可捕获或继续向外传播的控制流机制,并将异常处理和最终清理分开;下一章会展开这些语句的细节。

本章习题

五问围绕用途、未捕获默认路径、捕获恢复、显式触发与清理方式,均属本章回忆自测。

习题解答

五条解答重申异常用途、默认报告、try/except、raise/assert和finally/with。恢复指处理完成后继续外层正常路径,不是回到失败点。

第33章 异常编码细节

异常语句的各分句分工不同:except匹配失败,else限定成功路径,finally承担离开范围时的清理。异常对象可携带上下文,异常链也可保留原始原因。with把进入和退出约定交给上下文管理器,退出协议的返回值决定是否抑制相应异常。

本章从上章异常基础进入try、raise、assert和with的具体语法与控制流;2.5统一finally、2.6⁄3.0上下文管理与异常语法变化只是历史背景。

try/except/else语句

try主体是被保护的执行范围;异常按类型寻找第一个匹配的except,没有异常并正常完成才走else。被调用函数虽在别处定义,其运行时异常仍可能由这一范围捕获。

处理器按顺序选择首个匹配

同一try可以提供多个except分句。try主体或它调用的函数抛出异常时,按书写顺序寻找首个匹配的处理器,只执行那个处理器;没有匹配则向外传播。except (E1,E2)表示任一所列类型共享一份处理代码,而不是依次执行多个处理器。

保护范围是try主体的动态执行过程,不是这些分句在文本上的整个范围。同一try的其他except不会接手某个处理器中新发生的异常;else中的新异常也不归这组except处理。处理结束通常在整个try之后继续,不回到失败点。

处理器按顺序选择首个匹配保存独立卡片。

原书依据 · 1 处
try语句分句

except可对单类、多类或广泛范围匹配;用as获取实例。宽捕获虽省列表,却可能遮住意外错误或中断;Exception与裸except的范围也不同。

异常捕获要匹配预期失败范围关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处
异常绑定名在处理后删除

except E as V让处理器通过V访问本次异常实例及其数据。在Python3中,该异常目标名称会在处理块结束时被清除;不能依赖它在try之后仍然保留,或期待同名的先前值自动恢复。若确需保留,应在处理器中显式保存所需信息到另一个名称,并考虑保存完整异常对象的生命周期成本。

except (E1,E2)指定多个候选类型,except E as V则是将一个匹配实例绑定到V,两者语义不同。Python2曾支持except E,V旧写法,不能直接当作Python3语法;逗号不能用来把类型列表和目标名称混写。

异常绑定名在处理后删除保存独立卡片。

原书依据 · 1 处
try/else分句

else把成功后操作放在受保护主体之外,使成功路径的异常不会被误判为原操作的预期失败;仅在try后直接写代码则不能区分正常完成与已捕获异常。

try的else限定成功路径关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
例子:默认行为

bad.py中gosouth调用gobad(x,0),实际除零处触发异常,未捕获时Traceback依活动调用由外向内列出位置。可用它定位调用路径,消息文字随版本/宿主变化。

错误消息定位不等于确定根因关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
例子:捕捉内置异常

kaboom用列表加字符串引发TypeError,外层处理器打印后继续try之后;失败函数不因此被恢复到出错语句继续执行。

异常捕获要匹配预期失败范围关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处

try/finally语句

try/finally在受保护主体离开时清理:正常完成后继续,异常离开时清理后仍向外传播。with增加进入操作但要求相应对象协议。

清理结束不等于异常消失关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
例子:利用try/finally编写终止行为

文件先成功open,try中调用stuff,finally显式close,即使stuff抛MyError也会尝试关闭。关闭责任不依赖垃圾回收何时发生,清理之后异常仍可继续向外。

上下文管理让文件退出时关闭关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处

统一try/except/finally语句

统一形式把异常处理和清理组合,却不混同职责:except或else中新发生的异常仍会经过finally,之后继续传播;被成功处理的异常与没有异常可进入正常后续。

按职责组合异常语句分句

统一try可把正常主体、类型匹配、成功后动作和最终清理放在一处表达。先运行try主体;其异常走首个匹配except,正常完成则可走else;最后finally在离开该结构时执行。因此finally也覆盖except或else中新抛出异常的离开路径,而不是仅覆盖原主体。

顺序为try、except、else、finally;至少要有except或finally,else依赖至少一个except。只有finally时也可成立,不要求凑齐所有分句。把try/except/else整体嵌在外层try/finally中,可表达同样的职责组合;统一写法减少额外缩进。异常还在传播时,不能把最终清理完成当整个操作正常成功。

740与02064-02065给try→except→else→finally顺序、带可选else/finally的处理形式、单独try/finally形式。0个except仅在有finally且无else时可行;不能省掉所有分句,不能写try/else而无except。违反语法约束会在执行此代码前被解析拒绝。

741的02066-02067把整套内层try/except及可选else放进外层finally保护范围,说明统一写法的语义对等。不是将finally放在某一个except内部,否则覆盖范围就变了;选统一形式是表达清晰和少缩进的取舍,不是新增加自动恢复或回滚。

742及02068-02070预期输出:索引99触发并捕获IndexError,顺序except/finally/after;索引3正常时finally/after;索引3带else时else/finally/after;1/0只配IndexError则finally/Traceback而无after。四路对照来自原书展示,不是本次运行或对现实程序的覆盖测试;finally的出现不等于所有路径都正常完成。

773及02126-02130先把action2保护层直接嵌套,后展示内外finally的spam/SPAM/Traceback,再以raise1(IndexError)、noraise(return)、raise2(SyntaxError)三次调用置于内except IndexError、外finally。第一项处理后清理,第二项正常清理,第三项未匹配也清理后向外报告;输出中的SyntaxError是显式raise,并非这段脚本自身语法不能解析。统一try能简化部分嵌套但不取消动态嵌套能力。

按职责组合异常语句分句保存独立卡片。

原书依据 · 5 处
统一try语句语法

try后必须有处理器或最终清理;else需要至少一个except,finally在最后。图中箭头表示合法书写顺序,不代表每次运行都会逐项进入。

按职责组合异常语句分句关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
通过嵌套合并finally和except

在外层try/finally内包住try/except/else,可让清理覆盖内部主体、处理器和成功分支;这解释统一结构的组合意义。

按职责组合异常语句分句关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
合并try的例子

四个独立片段对照被捕获异常、无异常、无异常加else、不匹配异常,观察except/else/finally和正常后续的区别;最后片段未捕获除零仍会先清理再报告。

按职责组合异常语句分句关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处

raise语句

raise以异常实例承载本次失败;类形式隐式无参构造,as让处理器拿到实例,构造参数可由args读取。类、实例和承载数据的名称不是同一件事。

异常实例携带构造参数

raise可以接收异常实例,也可接收可无参数实例化的异常类。传类时会创建一个实例;若类构造必须要参数,则不能期望裸类形式自动补齐。except E as X将匹配的异常实例绑定给X,处理器由此读取数据或调用异常对象方法。

原例MyExc继承Exception且类体只有pass,通过MyExc(“spam”)构造后,其继承的args保存构造参数;不是把字符串本身作为异常类型。

结构图:

classDiagram
class Exception
class MyExc
Exception <|-- MyExc

没有给MyExc自定义方法,因此不补造init签名。args行为来自基类;处理块结束时as目标清除,需与实例本身的存在分开。

762的02113展示IndexError无参/带spam与args;02114的E(Exception):pass用一参数和三参数对照。默认零参数显示空串,一参数显示其文本,多参数通常按参数元组显示;通用说明不覆盖各内置子类自定义的显示格式。args中的数据与对象的字符串呈现分开,不能直接把异常实例当字符串连接。

结构图:

classDiagram
class Exception
class E
Exception <|-- E

E类体只有pass,无自定义构造器/显示方法;不造签名。

异常实例携带构造参数保存独立卡片。

原书依据 · 2 处
利用raise传递异常

捕获可以是传递链上的一个中间动作;裸raise让当前异常继续向外,而不是在本层处理器正常结束后被吞掉。

处理之后仍可重新抛出

在处理器内完成必要的记录或局部动作后,使用不带对象的raise,可继续传播当前正在处理的异常,让更外层决定最终恢复策略。这样既执行本层动作,也不会把失败伪装成成功。

原例捕获IndexError(“spam”)后打印propagating,再裸raise,最终仍报告IndexError及其参数。裸raise需要存在正在处理的异常;它不是无条件重跑最近失败的操作,也不是把处理器之后所有代码都执行完。

处理之后仍可重新抛出保存独立卡片。

原书依据 · 1 处
Python 3.0异常链:raise from

显式异常链记录转换原因,隐式上下文保留处理时遇到的新失败背景;默认报告可同时展示前后异常,方便理解传播路径。

异常链区分原因与上下文

在处理低层失败时改抛另一异常,可以用raise 新异常 from 原异常明确表达原因关系。新异常的cause指向指定原因;若只是处理器内又发生异常,先前异常通常作为context保留。两者帮助读者区分主动转换与处理期间发生的新失败。

原例捕获除零异常E后raise TypeError(“Bad!”) from E,默认报告先显示除零,再说明它是后一个异常的直接原因。真正传播给外层的是新异常,旧原因并不是第二个独立处理结果;这也不会恢复除法或撤销副作用。

异常链区分原因与上下文保存独立卡片。

原书依据 · 1 处

assert语句

assert把调试假设的失败表示为AssertionError,可带消息;其语义受debug约束,优化编译可移除整条断言。

断言不宜承担必需接口阻断关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
例子:收集约束条件(但不是错误)

断言适合表达程序员的开发期约束,如此函数期望负数;解释器已会拒绝内置除零,但它不会发现一切语义设计错误。不可恢复动作之前的必需验证应明确执行。

断言不宜承担必需接口阻断关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处

with/as环境管理器

with通过对象协议把进入与退出行为包围代码块。文件关闭与锁释放是例子;2.5的future import和2.6⁄3.0默认支持是书中历史版本背景。

基本使用

with的通用机制是协议,不是文件专用语法:as从进入方法接值,实际进入/离开动作由对象定义。文件关闭、锁范围和临时小数配置各是这一机制的应用。

上下文管理让文件退出时关闭关联本项背景,实质主要讲解在对应位置。

局部小数上下文限制精度影响关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处
进入结果才绑定as目标

with先求值表达式得到管理器,再调用其enter;可选as接收的是enter返回值,不必是管理器本身。文件管理器恰好返回文件本身,但不能由这个例子推断所有管理器都相同。省去as仍会执行进入与退出协议。

同一语法可管理不同的块级状态:文件用退出动作关闭,锁在进入时取得、退出时释放,decimal.localcontext在退出时恢复配置。各对象协议决定具体动作,with不会自动创造事务、修复代码错误或保证所有共享数据都被正确保护;只有在进入成功后,退出协议才有对应的保护承诺。

进入结果才绑定as目标保存独立卡片。

原书依据 · 1 处
环境管理协议

协议分离进入、as值、代码块与退出。TraceBlock显示退出返回False只观察而不吞异常;多个管理器的合写按逐层嵌套工作,故退出顺序与成功进入范围有关。

退出协议决定异常是否传播

管理器的enter成功后,with运行代码块;离开时调用exit(self,exc_type,exc_value,exc_tb)。异常退出传三项异常信息,非异常退出传三个None。异常退出时,返回真值表示抑制该异常,假值表示不抑制;不是把真假解释成清理操作成功与否。

结构图:

classDiagram
class TraceBlock {
 message(self, arg)
 __enter__(self)
 __exit__(self, exc_type, exc_value, exc_tb)
}

原例enter打印并返回self,message打印参数;exit区分正常/异常并return False。因此TypeError经它观察后仍传播,代码块中异常之后的not reached不会执行;删去return隐式None仍是假。

退出方法可能自己失败;非异常的return/break等离开,其返回值不负责改写为正常落到with之后。进入失败也不由同一个with自动调用该管理器的退出方法来补救。

退出协议决定异常是否传播保存独立卡片。

原书依据 · 1 处
多个管理器按嵌套顺序退出

with A() as a, B() as b等价于先进入外层A,再进入内层B。正常或异常离开时,先调用已进入的B退出,再处理A退出,因此多个资源的包围关系可由嵌套形式理解。

若第二个管理器的求值或进入失败,先前已进入的A仍按外层协议退出;不能宣称所有列出的管理器都成功取得资源。内层若抑制异常,外层接收到的退出情形也会变化。原书用输入/输出文件展示此形式,并未提供事务回滚、多资源原子取得或全部退出动作必成功的保证。

多个管理器按嵌套顺序退出保存独立卡片。

原书依据 · 1 处

本章小结

本章以try组织保护与处理、raise主动触发、assert调试断言、with对象协议四组工具收束;下一章转向异常类本身的层次和状态。

本章习题

五道自测分别回忆try用途/两变体、raise、assert和with/as,指向本章已经保留的机制。

习题解答

答案将捕获恢复和清理分开,说明raise主动触发、assert条件触发及with进入/退出协议;统一try是历史语法演进的结果。

第34章 异常对象

把异常组织成类层级,调用者可以按共同超类捕获一组相关失败,而不用枚举每个具体子类。基类选择又决定捕获范围,不能把所有终止信号都当普通业务错误。异常的构造参数、字符串显示和附加上下文帮助诊断,但不应把打印内容当结构化错误协议。

异常类同时支持分类、实例状态和行为继承,本章将分别解释它们对处理器和程序演进的作用。一般应用异常从Exception派生,合法异常最终属于BaseException层次。

异常:回到未来

这一短导语说明先回顾早期字符串异常,再解释现代异常类机制。

字符串异常很简单

早期Python曾允许字符串异常,按对象身份而非字符串值匹配;2.5图仅为历史演示,本书明确2.6⁄3.0已删除这一形式。

基于类的异常

异常匹配从旧字符串身份规则转为类的继承关系;处理器可以描述一个分类,而不必把它的成员逐个列举。类还给状态和行为提供承载处。

超类处理器匹配异常子类

except列出某个异常超类,可匹配该类及其任意下层子类的实例,因而超类可表示一个失败分类,子类区分具体种类。这个方向不能颠倒:仅捕获某子类不会接住它的父类实例或无关的兄弟类。

结构图:

classDiagram
class Exception
class General
class Specific1
class Specific2
Exception <|-- General
General <|-- Specific1
General <|-- Specific2

后续classexc.py的三个类均只有pass;except General捕获General、Specific1和Specific2各自的实例。按首个匹配分句的规则,若先放过宽超类处理器,更具体的后续分句可能没有机会执行;分类关系不是按类名字符串相等判断。

758和02098-02100给完整General/Specific1/Specific2定义及raiser0/1/2三个模块函数。except General配sys.exc_info()[0],或except General as X配X.class,在所示处理器内都可辨认实际类型;匹配超类不会将对象改成超类实例。实际代码常可调用异常对象行为而不逐类分支。sys.exc_info描述当前正在处理的异常,不当全局永久记住最近失败的接口。

超类处理器匹配异常子类保存独立卡片。

原书依据 · 2 处
类异常例子

classexc.py将General作为分类根,两个Specific类作为子类,外层General处理器捕获三种实例;捕获分类并不抹去实例的实际类型。

超类处理器匹配异常子类关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处

为什么使用类异常

分类使库失败集的演进与客户端的分类处理解耦;裸except虽然省去枚举,却会同时遮住不属于库公开失败契约的异常。演进仍需维持恢复语义。

异常捕获要匹配预期失败范围关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处
库异常分类减少枚举耦合

库若要求用户逐一列出所有失败类型,每新增一类都可能迫使调用处修改。给库的可处理失败建立共同异常根,客户端捕获这个分类,新增子类便可沿既有分类边界进入处理器,同时保留让无关错误继续传播的机会。

结构图:

classDiagram
class Exception
class NumErr
class Divzero
class Oflow
class Uflow
Exception <|-- NumErr
NumErr <|-- Divzero
NumErr <|-- Oflow
NumErr <|-- Uflow

mathlib示例从分别继承Exception改为NumErr统一分类,再增加Uflow(NumErr)。这是库内教学类名,不是Python内置异常层次。

稳定的是客户端所承诺处理的分类语义,并非任意新增、删除或修改异常都天然兼容;新失败若需要不同恢复策略,客户端仍可能需要调整。导出异常元组也能集中维护成员,但仍需更新列表,且不替代类的状态/行为能力。

784及02146-02147以MyExcept1/MyExcept2枚举和SuccessCategoryName分类对照:新子类可进入既有分类处理,不必逐个加名单。图中异常代表某种约定的成功事件,else反而表示未出现该事件,因此不能按except/else位置机械判断业务成败。分类只能保留原契约内的兼容,不担保任意新增恢复方式均无须修改客户端。

库异常分类减少枚举耦合保存独立卡片。

原书依据 · 2 处

内置Exception类

内置异常同样按类组织。根类保证共同的异常行为,Exception分支给一般应用失败的捕获范围,数值分类则可更具体;默认显示和args提供基础状态能力。

异常根类划分捕获边界

BaseException是合法异常的共同根;一般应用异常通常从其子类Exception派生。SystemExit、KeyboardInterrupt、GeneratorExit不属于Exception分支,故except Exception不会像裸except那样匹配它们。这里是推荐的职责边界,不是Python禁止用户直接继承BaseException。

结构图:

classDiagram
class BaseException
class Exception
class SystemExit
class KeyboardInterrupt
class GeneratorExit
class ArithmeticError
class OverflowError
class ZeroDivisionError
BaseException <|-- Exception
BaseException <|-- SystemExit
BaseException <|-- KeyboardInterrupt
BaseException <|-- GeneratorExit
Exception <|-- ArithmeticError
ArithmeticError <|-- OverflowError
ArithmeticError <|-- ZeroDivisionError

图仅列本节及下一节实际讨论的部分层次,不是完整内置异常清单。ArithmeticError捕获这一分支,而非所有可称数值问题的事件;Exception仍宽到可能遮住编程错误,不因排除退出就自动安全。

761明确ArithmeticError是OverflowError和ZeroDivisionError的超类,捕获其中一个兄弟类不会覆盖另一个。except Exception示例不能保护所有合法异常,因为用户也可直接派生BaseException;普通应用遵循Exception惯例后才有相应分类覆盖。文中“3.0不会更可靠”的措辞不推翻前后类层次规则。

异常根类划分捕获边界保存独立卡片。

原书依据 · 2 处
内置异常分类

处理器可按ArithmeticError分类捕获多个数值异常,或缩小到OverflowError;Exception仅排除自己的层次之外的控制性异常,仍可能太宽。

异常根类划分捕获边界关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
默认打印和状态

异常基类提供args和字符串显示;自定义类若保留相应默认行为,也继承这些能力。异常实例本身并不是字符串,拼接前需显式str转换。

异常实例携带构造参数关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处

定制打印显示

默认显示往往足够;需要统一异常消息时,可定制str并保留类的类型语义。继承已有str时只改repr不会达到同样打印效果。

异常显示应定制字符串协议

print异常实例、str转换和默认异常报告会用它的字符串表示。若要定制这些场景,通常应定义str:异常基类已提供这一方法,仅覆盖repr不会让print自动绕开继承来的str。

结构图:

classDiagram
class Exception
class MyBad {
 __str__(self)
}
Exception <|-- MyBad

原例先用只有pass的MyBad继承默认消息,再重定义str返回固定字符串;捕获打印与未捕获报告都反映新文本。定制显示不会改变异常匹配类型或自动保存诊断状态;实际消息可再按已有状态构造。

异常显示应定制字符串协议保存独立卡片。

原书依据 · 1 处

定制数据和行为

异常可在构造时保存专用实例状态,并提供供处理器调用的方法;args只是默认方案,并不要求所有应用都用下标解释上下文。

提供异常细节

异常实例把当前失败的专用信息随控制流传给远处处理器。命名字段比默认args下标更能表达应用语义,具体选择仍按复杂度。

异常对象随失败传递上下文

raise位置和处理器可能跨模块,若细节藏在某模块的全局变量中,调用者未必知道去哪里取。将文件名和行号放在这次抛出的异常实例上,处理器通过except FormatError as X即可访问同一次失败的上下文,不需另找全局状态。

结构图:

classDiagram
class Exception
class FormatError {
 line
 file
 __init__(self, line, file)
}
Exception <|-- FormatError

原例构造器绑定line/file,parser抛FormatError(42,file=“spam.txt”),处理器读X.file/X.line。另一个仅pass的变体用args[0]/args[1]也可传值,但失去这些有意义的字段名且所示基类构造不接受该关键字形式。

这里是异常数据表达,不保证解析器完整实现或文件已被实际读取;parser是模块函数,不是异常方法。

766进一步在FormatError类上增加logfile及logger(self),方法利用本实例file/line向追加打开的日志写消息,表明对象还可携带复用行为。

结构图:

classDiagram
class Exception
class FormatError {
 logfile$
 line
 file
 __init__(self, line, file)
 logger(self)
}
Exception <|-- FormatError

这是02121中的增强变体,图取真实定义名logger;同图处理器却写exc.logerror(),与定义不一致,按原样不能把它当成功可运行程序。02122给书中意图的日志内容,不代表本次运行;不补造一个不存在的logerror定义。方法内open也没有显式close/with,不能据其短例声称日志可靠关闭或持久化。方法调用具有文件写入副作用,继承可复用行为不等于日志一定成功。

异常对象随失败传递上下文保存独立卡片。

原书依据 · 2 处
提供异常方法

带状态的异常还可提供处理器调用的行为;原文想用日志方法说明这一点,但方法定义与调用名不一致,须明确这一代码证据边界。

异常对象随失败传递上下文关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处

本章小结

本章收束类异常的分类、状态和继承:超类描述处理范围,实例承载本次失败的信息,方法可统一显示或行为。

本章习题

五问分别自测异常类合法性、继承匹配、附加状态、显示消息和字符串异常历史。

习题解答

五条答案回连BaseException约束、超类匹配、命名属性/args、str/默认显示及历史字符串的维护局限。

第35章 异常的设计

错误处理策略要同时考虑失败位置、恢复能力和进程是否继续。静态检查、单元测试、示例测试、调试与剖析各自提供不同证据,任何一种都不能单独证明整个系统正确。记录失败不等于已经恢复,测试框架继续下一项也不意味着被测操作成功。

本章转入异常设计:嵌套传播、日常使用、捕获范围取舍及开发工具。它收束基础内容,但不是本书所有高级内容已经读完。

嵌套异常处理器

嵌套既可由文本中的try包try形成,也可由调用进入其他try形成。异常沿当前活动范围找最近的匹配处理器;finally则在离开相应范围时执行,不自行吞掉异常。

异常沿调用栈转移控制关联本项背景,实质主要讲解在对应位置。

清理结束不等于异常消失关联本项背景,实质主要讲解在对应位置。

原书依据 · 8 处
例子:控制流程嵌套

action2的1+[]触发TypeError,action1中最近的匹配处理器先接住;外层同类处理器只有异常继续传出时才可能运行。

异常沿调用栈转移控制关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
例子:语法嵌套化

语法内嵌与跨函数调用可以形成相同的保护层次;逐层finally和内except外finally的示例,分别说明清理传播和职责组合。

按职责组合异常语句分句关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处

异常的习惯用法

此短句从异常机制过渡到常见用途。

异常不总是错误

异常还可表达输入结束等控制事件。input的空字符串代表读取了空行,输入流结束则触发EOFError;读取文件行的接口采用另一组信号,不能混用。

文件结束与空白行返回不同关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
函数信号条件和raise

信号与数据可走不同通道。Found/Failure两套示范说明异常名和约定决定含义,不能只从except分支位置推断业务成败。

异常可作为独立结果通道

当普通返回值都可能是合法结果时,另用其中一个值表示特殊状态会造成歧义。异常提供独立的信号通道,调用方可把正常返回值留给结果数据;是否采用仍由接口契约决定,而非动态语言必然要求异常。

结构图:

classDiagram
class Exception
class Found
class Failure
Exception <|-- Found
Exception <|-- Failure

原书给两个不同searcher方案:一个在找到时抛Found,正常返回表示没找到;另一个正常返回找到对象,找不到抛Failure。两个类均pass,分别属于替代方案,不是同一次搜索必然抛出的两种失败。searcher是模块函数,未提供实际搜索算法。

调用者应根据找到/未找到的业务结果决定后续行为,不能把异常路径一律理解为失败、正常返回一律理解为成功;也可用明确的复合结果表达不同状态,不能用合法空值偷偷代替未找到。

异常可作为独立结果通道保存独立卡片。

原书依据 · 1 处
关闭文件和服务器连接

资源收尾可由try/finally显式表达,已有管理器时也可用with减少管理代码。二者取舍取决于对象是否有协议及是否需要复用进入/退出行为。

上下文管理让文件退出时关闭关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
在try外进行调试

顶层外层try可以替代通常未捕获异常的报告/终止路径,并在处理器中用sys.exc_info辨认异常。开发观察用途与生产恢复策略必须分开。

异常捕获要匹配预期失败范围关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处
异常信息依赖当前处理范围

处理器内调用sys.exc_info()可取当前处理异常的(type,value,traceback):分别为实际异常类型、实例和追踪对象。若调用栈上没有正在处理的异常,结果是三个None;它不是一个随时可读的全局“最近错误记录”。

即使except捕获的是分类超类,type仍反映实际异常;except General as instance也可从实例取class。需要差异化行为时可优先调用统一的异常实例方法,而不是为每种类型硬编码分支。顶层裸except可用这个接口观察漏出的异常,但观察之后继续运行,并不证明业务状态已恢复或测试已成功。

780明确无处理器时(type,value,traceback)均None;在处理器中返回当前异常而非永远最近一次失败。02138裸except取信息、02139捕获分类后取实例实际类、02140调用实例method三个方案对照。旧sys.exc_type/sys.exc_value是已删除的Python2历史接口;sys.exc_info按当前线程处理范围工作,不能当跨线程全局历史记录。

异常信息依赖当前处理范围保存独立卡片。

原书依据 · 2 处
运行进程中的测试

测试驱动可把每次测试包在处理范围内,失败记录和后续测试调度相分离;跨进程测试必须按启动接口检查结果,测试通过也需要可判断的预期。

测试失败与进程继续分离

同一进程循环运行测试时,可在每次测试调用的边界捕获未处理异常,记录失败后再进行下一项;else只记录该次正常返回。这样将单项失败与测试驱动的存活分离,但正常返回还不足以证明结果符合预期,真正测试需要明确比较或断言。

原例testdriver依次使用moreTests、runNextTest和testName,将异常信息写入日志;testapi为抽象接口,原文没有其实现。裸except可能连退出/中断一起吞掉,实际边界应按需要的失败类型和中断策略设计。日志写入自己也可能失败,测试之间的共享状态不会因捕获而自动隔离或重置。

外部程序运行是另一边界:子进程中的错误通常需要检查退出状态或输出,不能指望其Python异常自动跨进程进入这个处理器。

949的02635输出回归示例以os.popen读结果,首次不存在基准就写结果文件,以后对比文本。首次收录不是正确性证明;示例没有完整捕获退出状态与标准错误,也不保证命令字符串的路径/参数处理可靠。02634-02635列求和用split逗号和int转换,并非支持引用/转义等完整CSV解析;zip累加还可截断不等长列,不把静默产出当验证通过。

测试失败与进程继续分离保存独立卡片。

原书依据 · 2 处
关于sys.exc_info

异常信息接口报告当前处理上下文,实例接口还允许统一的多态行为。类型检查可用于诊断,但不必把每个具体异常都写成分支。

异常信息依赖当前处理范围关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处

与异常有关的技巧

异常设计需要同时决定处理器覆盖哪些类型,以及try保护多少执行范围;下面从范围再到类型边界逐项讨论。

应该包装什么

处理范围按恢复职责设计:环境操作可捕获,脚本也可选择失败即退出;收尾与恢复分开,必要时在外层集中处理多个调用的异常。

捕获位置应能决定恢复

异常处理边界应结合程序目的选择。文件打开、网络调用等受环境影响的操作常需要明确失败路径;但一次性脚本也可能应直接保留错误报告并退出,持续服务或测试驱动才更常需要恢复后继续。不能只因某操作会失败就无条件吞掉它。

可把多个调用的失败交给外层一个有足够上下文的处理器,减少内部重复处理;资源退出责任则用finally或已有上下文协议表达。选择应同时看能否作出正确恢复、应保护的实际范围,以及未预期错误如何保留可见性;try覆盖得大不等于恢复能力更强。

949的02632 safe(entry,*args)裸except打印traceback和sys.exc_info,未return成功调用结果,也未报告结构化成功/失败;它是演示顶层处理边界,不是通用恢复封装。图中的输出hello:world与前图MyError/Spam示例不一致,只当不同运行片段,不能伪称本轮复现。02634文件大小统计异常后仍在except之外append(pysize,pypath),可能使用未赋值或旧值;打印skipping不等于控制流已跳过,不能照抄为稳健文件扫描。

捕获位置应能决定恢复保存独立卡片。

原书依据 · 2 处
捕捉太多:避免空except语句

过宽捕获会遮住外层需要的事件或掩盖编程错误:sys.exit本可触发清理后离开,却可被裸except吞掉;拼写造成NameError也可被错误当成缺键。

异常捕获要匹配预期失败范围关联本项背景,实质主要讲解在对应位置。

清理结束不等于异常消失关联本项背景,实质主要讲解在对应位置。

原书依据 · 11 处
捕捉过少:使用基于类的分类

逐一枚举过窄类型也可能使新加入的预期事件被误分类;共同分类根支持扩展,但仍需定义这个分类的稳定业务含义。

库异常分类减少枚举耦合关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处

核心语言总结

本节回顾已经学习的类型、语句、异常和函数/模块/类组织工具,是基础部分的里程标。

Python工具集

工具可以从内置对象和操作,到自写Python函数/模块/类,再到编译语言扩展分层选择。任务决定需要深入哪一层,不是每个程序都应同时使用所有层。

语言生态扩展应用能力关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
大型项目的开发工具

大型项目工具按任务分工:文档与内省解释接口,静态检查提前反馈部分问题,测试比较行为与预期,剖析定位成本,调试观察状态,打包解决分发。历史工具名称、版本和普及率不能直接作为今天的选择依据。

帮助报表结合文档与对象结构关联本项背景,实质主要讲解在对应位置。

调试观察要对应待解问题关联本项背景,实质主要讲解在对应位置。

异常后调试利用现场信息关联本项背景,实质主要讲解在对应位置。

打包独立程序不等于编译加速关联本项背景,实质主要讲解在对应位置。

隐藏源文件不等于保密保证关联本项背景,实质主要讲解在对应位置。

先确认瓶颈再选择优化写法关联本项背景,实质主要讲解在对应位置。

原书依据 · 14 处
静态检查与运行测试互补

动态程序有些错误只在相关路径运行时出现,但静态检查仍可提前发现一部分未定义名称、可疑调用或规则违规。PyChecker/Pylint在原书中用来说明这种提前反馈角色;它们补充测试,不替代运行结果与业务预期的核验。

没有检查告警不能证明无错误,具体能力也依工具、配置与可分析信息。书中关于某工具当时被标准库使用或Python不会崩溃的断言,不当当前流程保证;解释器仍可受原生扩展等因素影响。

静态检查与运行测试互补保存独立卡片。

原书依据 · 1 处
测试框架组织用例与预期

测试框架把输入情形及期望响应组织成可反复执行的用例,而不是只在脚本末尾跑一次并看它没有异常。unittest在原书中以面向对象框架出现,用例可定制,测试结果与预期作比较;这补足简单驱动将正常返回当PASSED的局限。

框架只提供组织和判断工具,实际边界、输入和断言仍需由测试设计者决定;一个用例通过并不覆盖未纳入的行为。原书只概述框架,没有在这一段给完整TestCase子类实现,所以不补造类图或方法签名。

测试框架组织用例与预期保存独立卡片。

原书依据 · 1 处
示例可重放为文档测试

在文档字符串中保存交互式输入及期望输出,doctest可提取并重放这些片段,将实际输出与展示结果比较。这样同一示例既说明使用方式,又可在代码演进后检查它是否仍符合展示的行为。

预期输出必须有意义且适合稳定比较;仅复制一段交互历史不会自动验证未出现的分支、内部状态或业务正确性。它更适合示例和回归检查的一部分,不能以少量文档例子替代全面测试设计。原书提供机制概述而非这里已执行的测试记录。

示例可重放为文档测试保存独立卡片。

原书依据 · 1 处
剖析定位调用成本分布

性能剖析运行目标程序并按函数整理调用次数和耗时,用来发现实际成本集中在哪里;这和只测一段代码总耗时承担不同职责。先定位瓶颈,再对候选替代写法计时,避免靠其他语言经验猜测Python程序的热点。

原书给profile.run(“code”)和python -m profile main.py args形式,以及保存统计后用pstats分析的途径;这些入口会真的执行给定代码,不能把它们当无副作用的静态查询。书中以cProfile说明相近接口下较低开销的实现,具体模块状态应按目标Python版本核对。

剖析本身增加开销,结果需要与测量边界和输入一起解释,不能直接拿它当不同语言/实现之间公平基准,也不能只凭调用次数就定优化顺序。

剖析定位调用成本分布保存独立卡片。

原书依据 · 1 处

本章小结

本章结束基础内容,后续仍有Unicode、字节数据、属性管理、装饰器和元类等实质章节。是否用于某个程序可选择,但本次全文阅读继续覆盖后续范围。

第七部分 练习题

四项练习要求重建异常触发/捕获、专用异常数据、safe包装与traceback打印,并自学附录例子;本节给任务而未给实现。

第八部分 高级话题

本项只有“第八部分 高级话题”,标记下一部分。

第36章 Unicode和字节字符串

文本是字符或码点层面的内容,bytes是字节序列,编码与解码负责二者之间的转换。文件接口还可能处理换行,因而字符数不等于文件字节数。处理XML等结构化文本时,编码解决表示问题,解析器解决结构问题,两层都不能由显示正常推断已经正确处理。

本章把此前字符串基础扩展到非ASCII文本与二进制数据,围绕Unicode、编码和文件边界展开;这些是表示方式与接口语义,而不是两类可随意互换的字符串外观。

Python 3.0中的字符串修改

Python3将文本str与原始字节bytes分开,并提供可变bytearray。只处理简单ASCII也仍须遵循接口类型约定,默认编码不能在所有场景混用。

文本与字节需要明确转换关联本项背景,实质主要讲解在对应位置。

原书依据 · 15 处

字符串基础知识

此导语将字符串模型讨论转入字符在计算机中的表示方式。

字符编码方法

字符码点与字节表示分属两个层次:ASCII/Latin-1给出有限映射,UTF-8用可变长表示更大范围。编码名是转换规则,ASCII兼容只说明共同范围的字节相同。

字符码点不同于数字字符值关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
编码映射区分码点与字节

Unicode码点为字符提供编码身份,字符编码则规定码点如何表示为字节。编码从文本到字节,解码从字节到文本;Python3的ord/chr处理码点,并不是执行任意文件编码。相同字符可按不同编码得到不同字节和长度,不能从str的字符数量直接推出字节数。

ASCII只覆盖0到127,Latin-1把0到255映射为单字节;UTF-8对ASCII仍用相同单字节,对其他可编码字符用多字节。因此ASCII字节在这三者的共同范围兼容,但不代表Latin-1的所有非ASCII字节也都是有效UTF-8,更不代表UTF-16/32同样每字符一字节。

UTF-8按码点范围使用1到4字节,0x7ff仍属两字节范围,0x800起进入三字节范围。它不为非空码点额外引入零字节,但U+0000自身会编码为零,所以“UTF-8没有零字节”需保留这个边界。Unicode也不是ASCII、Latin-1和UTF-8这些编码名称的别名。

801及02157-02159用XYZ对照len=3、码点88/89/90、三种编码均bXYZ、list编码结果得到整数。这个单字节等价只适用于所示三种编码的ASCII范围;不能据正文“每种Unicode编码”推导UTF-16/32同样为三字节或没有BOM。

803的02161-02162用Äè对照:ASCII无法编码;Latin-1为C4 E8两字节,UTF-8为C3 84 C3 A8四字节,均用相应编码解码得长度2文本。两字节UTF-8是本例每个码点的结果,不是全部非ASCII字符都占两字节。原始字节块可能切在多字节序列中间,不能把每块当完整文本独立解码;文本IO可管理这种解码边界。

804的02163-02165用AÄBèC说明Latin-1长度5、UTF-8长度7,CP500/CP850又给不同字节。spam在CP500下也不是ASCII字节,因此ASCII兼容只能对具体编码作判断,不是“任何编码都会保留ASCII”。chr可构建同一码点文本,得到的字符身份与选择何种输出编码分开。

编码映射区分码点与字节保存独立卡片。

原书依据 · 4 处
Python的字符串类型

Python2用str兼顾字节和简单文本、unicode表达Unicode文本;Python3用str表达文本,bytes/bytearray表达原始字节,后者区别在可变性。操作相似不意味着表示相同。

文本与字节需要明确转换关联本项背景,实质主要讲解在对应位置。

原书依据 · 15 处
文本和二进制文件

文本模式让str与文件字节按编码转换,二进制模式保留字节;模式还影响换行处理。BOM是特定编码策略的一部分,不是任意文件普遍存在的属性。

文本与字节需要明确转换关联本项背景,实质主要讲解在对应位置。

原书依据 · 15 处
编码名称决定标记处理

文本文件的BOM处理依所选编码,而不是看到“文本”就统一忽略开头字节。通用utf-16用BOM处理字节序;明确utf-16-le指定小端表示,不应把它与通用utf-16的标记策略混同。

UTF-8没有字节序选择,所谓BOM主要作签名。utf-8-sig编码会加签名,解码会跳过开头可选签名;普通utf-8不采用这套自动签名处理。UTF-8文件可以没有签名,不能从无BOM推断不是UTF-8,或把有BOM当所有文本接口自动识别编码的保证。

820的02214-02221完整对照:ASCII例没有BOM;旧Notepad UTF8带EF BB BF,普通utf8读取保留U+FEFF,utf8-sig跳过;UTF16大端带FE FF,用utf16读取消费标记,用utf16-be会保留对应U+FEFF。utf8-sig写入签名且读取无签名UTF8也可行,普通utf8写入不主动加签名。通用utf16文件流读取依赖BOM,明确utf16-le/be可读对应无标记内容。原文说输出“忽略”BOM不准确,应区分写出/省略和读取消费;也不是所有UTF16数据必含BOM。02220写temp.txt后某次读spam.txt,故不把该混用文件名的片段按原样说成单文件可复现实验。

编码名称决定标记处理保存独立卡片。

原书依据 · 2 处

Python 3.0中的字符串应用

后续代码主要采用Python3模型;Python2.6的bytes只是str别名,b字面量也不带来Python3独立字节类型的全部行为。

常量和基本属性

b/B前缀产生bytes,普通引号形式产生str,三引号不改变这个区分。索引、切片和不可变性按对象类型处理,不能凭打印像文本就混同。

文本与字节需要明确转换关联本项背景,实质主要讲解在对应位置。

字符串前缀需要结合语言版本关联本项背景,实质主要讲解在对应位置。

原书依据 · 17 处
转换

encode/decode在文本和字节边界转换,str(bytes)无编码时只得到显示形式。方法默认UTF-8和文件接口的默认编码必须区分。

文本与字节需要明确转换关联本项背景,实质主要讲解在对应位置。

原书依据 · 15 处
对象显示不能代替文本解码

对bytes调用str(B)且不提供编码/错误参数,得到它的可打印表示,常包含b前缀、引号或转义;这不是按某种编码读出原来的文本。原例B=b”spam”,显示文本的长度为7,而按ASCII解码得到spam长度为4。

要取得文本应明确调用B.decode(encoding)或str(B,encoding);反向编码用S.encode(encoding)或bytes(S,encoding)。从str构造bytes需要给编码,不能由bytes(S)自动猜测。即使内容全部为ASCII,显示与解码仍是不同操作,诊断输出不应直接冒充文件/协议载荷。

对象显示不能代替文本解码保存独立卡片。

原书依据 · 1 处

编码Unicode字符串

Unicode转义让源代码能写出键盘难输入的字符;它指定码点,不是直接选择UTF-16/32等文件编码。

Unicode转义表达码点

在str字面量中,\u后跟四个十六进制位、\U后跟八个十六进制位,用来按码点写出字符;\x后跟两个十六进制位表达较小范围的转义。这是源代码中表示字符的语法,并不表示最终输出文件必须分别采用2字节、4字节或1字节存储。

例如写出一个码点后,仍需选择UTF-8等编码才能得到字节。转义位数不是Unicode字符、屏幕字形或str内存占用宽度的通用定义;raw字符串的转义处理、bytes字面量可用的转义也需按其自身规则区分。

802的02160实际用chr(0xC4)/chr(0xE8),以及十六进制和Unicode转义构造Äè,len=2。正文0xCD与图的0xC4不一致,按图记录具体例子,未把它们说成同一字符;转义位数仍不决定字节储存宽度。

804及02166-02168对照chr构造、str的x/u/U转义、bytes的x转义及不解释为Unicode的u/U序列。bytes字面量中大于127的值须用合适转义表达,不能直接放非ASCII源码字符。原书3.0示例保留未识别转义字面序列,不把它当支持Unicode转义的合法转换办法;后续版本可对未识别转义告警。要把字节内容当文本显示,应decode,原文“bytes必须编码为str”方向相反。

Unicode转义表达码点保存独立卡片。

原书依据 · 3 处
编码ASCII文本

XYZ在ASCII、Latin-1和UTF-8下恰好得到相同的三个字节,是共同范围的例子;ord/chr取得码点、编码得到bytes,两种运算仍需区分。

编码映射区分码点与字节关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
编码非ASCII文本

同一非ASCII文本可用十六进制或Unicode转义写在str里;图中两个码点构成长度2的文本,不能把这个长度当编码后的字节长度。

Unicode转义表达码点关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
编码和解码非ASCII文本

对同一非ASCII文本,ASCII编码会失败,Latin-1与UTF-8可得不同长度字节;相应解码可回到原文本。按块读取原始字节时还需处理字符可能跨块的边界。

编码映射区分码点与字节关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
其他Unicode编码技术

更长文本和CP500示例说明即使字符相同,字节格式也未必ASCII兼容。字面量转义还依str/bytes类型区分,不能把Unicode转义写在bytes中就期待得到字符。

编码映射区分码点与字节关联本项背景,实质主要讲解在对应位置。

Unicode转义表达码点关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处
转换编码

转码通过Unicode文本这个中间表示连接两种字节编码;运行时编码选择独立于源码是如何保存的。

转码先解码再编码

已有字节需要改成另一编码时,先用真实源编码解码为Unicode文本,再用目标编码重新编码;仅改变变量名、显示形式或编码标签都不改变原字节。已有str文本则可直接选择目标编码得到字节,不需要先假设它在内存中属于某个文件编码。

原例把AÄBèC编码为CP500字节T,再按CP500解码为U,最后按默认UTF-8编码,得到另一组字节。成功往返需要源解释正确、目标能表示这些码点,并选择合适错误策略;没有自动猜测任意未知编码的保证。

文本文件读取时解码、写入时编码。源码本身的编码、运行时str的字符身份和文件读写编码是不同阶段,不能把源文件声明当作所有运行期输出的默认编码。

819的02208-02212用AÄBèC对照5字符、Latin1五字节、UTF8七字节。open(…,w,encoding=…)写入同一str均返回5字符,二进制读取显出不同原始字节;按正确编码文本读取或二进制再decode还原对应文本。文本IO处理字符可能跨读取块的解码状态,不等于所有数据都可文本打开。

转码先解码再编码保存独立卡片。

原书依据 · 2 处
在Python 2.6中编码Unicode字符串

Python2.6的普通str承载字节、unicode承载文本,兼容时会隐式升级;含非ASCII的字节若不能按默认规则解码,自动混合也会失败。旧代码的迁移不能靠只换类型名完成。

文本与字节需要明确转换关联本项背景,实质主要讲解在对应位置。

原书依据 · 15 处
源文件字符集编码声明

coding注释指定解释器如何解码源码,须配合编辑器实际保存格式;转换成字节时仍按运行期明确的编码选择。

源码编码与运行编码分开

Python3解析源码时默认按UTF-8解码,首行或次行的coding声明可指定源码实际编码。它告诉解释器如何读.py中的字节,不会把已有文件自动转为该编码,也不替所有运行时encode、decode或open设置统一默认值。

原书text.py以Latin-1保存含重音字符的字面量,并声明coding: latin-1;直接字符、Unicode转义和chr构造可得到对应文本。运行时再按UTF-8或Latin-1编码,就分别得到不同字节长度;sys.getdefaultencoding仍显示utf-8,说明源码声明与运行期转换是两个环节。

声明要与真实保存的字节一致;写在第二行时第一行也须满足注释行条件。不能只改声明成另一个编码而不改文件内容,就期望字符不变;源文件编码也不会决定外部数据流的编码。

源码编码与运行编码分开保存独立卡片。

原书依据 · 1 处

使用Python 3.0 Bytes对象

此导语转入bytes操作集合:它是0..255整数序列,显示像ASCII片段;相似方法仍保持字节语义。

方法调用

同名方法不表示跨类型自动互换。bytes方法按字节参数运算,返回值或新对象要按该方法语义接收;格式化能力应按具体版本和接口区分。

字节操作保留字节语义

bytes与str可有同名查找、替换、分割方法,但bytes操作接受相应的字节参数并按字节序列处理,不会替调用者猜测文本编码。原例b”spam”.find(b”pa”)得偏移1,replace得到新bytes,split得到bytes元素列表;原对象不随replace原地改变,也不允许元素赋值。

可用dir集合差观察某版本API,但它不是固定跨版本清单或完整接口契约。原书3.0中bytes缺少百分号格式化;Python3.5已加入bytes/bytearray百分号格式化,不能把旧例扩成今天不支持。bytes没有str.format这一方法,且百分号转换项也须按字节格式化规则选参数,不能用旧例b”%s” % 99的失败判断所有格式化均不可用。

810的02185显示B=bspam:索引得115/109,切片得bytes,list得整数,拼接和重复得到字节序列。chr(B[0])在此得到s,因为这个字节恰属于相同ASCII范围;不能由此按字节逐个chr替代任意UTF-8等多字节解码,字节偏移也不保证是文本字符边界。

812的02187-02188对照replace用str失败、用bytes成功、bytes(text)无encoding失败、bytes(text,encoding)成功;拼接b与str失败,而decode后文本拼接或encode后字节拼接分别得到str/bytes。转换方向由所需结果决定,不是所有情况都强迫转换为文本。

字节操作保留字节语义保存独立卡片。

原书依据 · 3 处
序列操作

bytes支持索引、切片、拼接和重复,但其单个元素是整数。用chr解释一个整数与按完整编码解码字节序列是两种操作。

字节操作保留字节语义关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
创建bytes对象的其他方式

字节构造的入口取决于输入含义:文本要编码,整数序列提供原始字节值,已有字节字面量无需先假扮文本。

构造字节须区分参数含义

创建bytes有不同入口:b字面量直接给字节,bytes(文本,编码)按规则编码文本,bytes(整数可迭代对象)则将0到255的各整数作为字节值。后者的整数不是待自动转换为十进制文本的数字,也不要求先经过某种字符编码。

原例bytes([97,98,99])得到b”abc”,与bytes(“abc”,“ascii”)在这组数据下相同,但表达的输入契约不同。str.encode也创建字节,bytes.decode创建文本;转换不改变原有不可变对象。选择入口要先确认手中的是文本、已知字节还是整数值,不能靠打印看起来像字母来猜。

构造字节须区分参数含义保存独立卡片。

原书依据 · 1 处
混合字符串类型

str/bytes混合的表达式和参数通常需要先明确转换到同一接口类型。把str直接传入bytes构造器也不能代替提供编码。

字节操作保留字节语义关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处

使用Python 3.0(和Python 2.6)bytearray对象

bytearray将字节序列的类型约束与列表式可修改操作结合;对象可变、单字节参数和多字节参数、方法是否原地修改仍是独立规则。

可变字节仍以整数为元素

bytearray可原地修改,但单个元素仍是0到255整数。原例给C[0]赋普通str或单字节bytes都失败,赋ord(“x”)或取b”Y”[0]所得整数才符合单项赋值接口。可变性不意味着文本字符可不经编码随意塞入字节位置。

append添加一个字节整数,extend添加一组字节值:原例append(b”LMN”)失败,append(ord(“L”))成功,再extend(b”MNO”)扩展。切片得到bytearray,list得到整数;replace虽是可变对象上的方法,仍返回新对象而不改原C,不能把所有方法都看成原地修改。

文本应保留str,原始字节用bytes,需要原地改字节时再选bytearray;修改多字节编码的一部分可能破坏可解码性。Python3从str构造bytearray也需编码,已有bytes则可直接构造,和Python2.6历史宽松方式区分。

可变字节仍以整数为元素保存独立卡片。

原书依据 · 1 处

使用文本文件和二进制文件

文件模式既决定对象类型,也决定是否解码及转换换行:文本用str,二进制用bytes并保留原始内容。

文本与字节需要明确转换关联本项背景,实质主要讲解在对应位置。

原书依据 · 15 处
文本文件基础

最小文本写入/关闭/读取例说明文本接口收发str;默认r为读取,成功close与write返回值各有自己的语义。

文本与字节需要明确转换关联本项背景,实质主要讲解在对应位置。

原书依据 · 15 处
Python 3.0中的文本和二进制模式

模式按数据处理意图选择,而不是文件被谁写过。文本转换包括编码和换行,二进制保留字节;类型约束不要求所有二进制字节都必然无法解码。

文本换行转换与解码分开

文本IO可同时做字符编码转换和换行转换,这是两个独立维度。原书Windows默认配置中,文本写入换行会成为CRLF,文本读取再归一化为换行;二进制模式原样保留这些字节。选择rb不是单纯换一个打印前缀,还改变是否采用文本处理。

同一文件按不同模式读取可得str或bytes;由wb写入的ASCII字节也可能被文本接口成功解码,不是“曾用二进制写入”就永久变成无法文本读取的文件。实际换行行为可由open参数控制,原书Windows输出不能照搬成所有平台或配置的固定结果。

二进制内容可能含零字节或控制值;文本是否能解码取决于编码规则,能解码也不代表这些值拥有所需文本含义。

文本换行转换与解码分开保存独立卡片。

原书依据 · 1 处
类型和内容错误匹配

文件处理既有对象类型要求,也有编码和数据语义要求。不能把类型匹配、解码成功和“这是正确文本”三个判断混成一个。

可解码不等于有文本语义

处理文件要区分两层约束:接口是否接收这种对象类型,以及内容能否按选定编码解释。文本write要求str,二进制write要求字节类对象,提供错误类型会失败;即使类型正确,选择错误编码也可能导致解码错误或把字节解释成不合意的字符。

反过来,原始二进制字节也可能恰好可解码,甚至包含合法的零字符或控制码点,不能据解码成功就认定它是业务所需文本。应依据数据格式与真实编码选择模式,保留字节时用二进制接口;未知编码不可靠尝试无错就宣称正确。

原书把chr(0xFE)显示时的UnicodeEncodeError作为无效字符证据并不成立:U+00FE是合法码点,编码输出失败与解码读取失败是不同阶段。图中的编码异常只说明某次字符向外部编码表示失败,不能单凭截图断定输入内容无法读为str。

819的02213以python.exe文本读取产生UnicodeDecodeError、二进制读取保留MZ开头字节,说明选定字符编码未必适合可执行文件。这里是真正解码失败,与817截图显示的UnicodeEncodeError阶段不同;二进制文件的某些片段可能恰好可解码,不能把失败扩为任何二进制字节都必然不可解码。

可解码不等于有文本语义保存独立卡片。

原书依据 · 2 处

使用Unicode文件

指定open的encoding后,文本IO在输入时解码、输出时编码,从而让脚本内部处理Unicode文本,而不必对每次传输手动转换。

在Python 3.0中读取和写入Unicode

显式文本编码与二进制读写加手工转换可得到对应的结果,区别在谁承担流式解码边界。文本write返回的字符数与磁盘字节长度不一定相同。

转码先解码再编码关联本项背景,实质主要讲解在对应位置。

可解码不等于有文本语义关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
在Python 3.0中处理BOM

BOM的读写由编码策略决定:UTF8签名与UTF16字节序用途不同,普通/带签名/明确大小端的编码名不能混用。图中的Notepad行为是当时版本示例。

编码名称决定标记处理关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
Python 2.6中的Unicode文件

Python2.6可用unicode对象配codecs.open指定编码读写,达成与Python3文本IO相近的转换职责,但普通str仍是字节模型。

文本与字节需要明确转换关联本项背景,实质主要讲解在对应位置。

原书依据 · 15 处

Python 3.0中其他字符串工具的变化

最后四个工具小节观察文本/字节区分对re、struct、pickle和XML的影响。

re模式匹配模块

正则以模式描述子串结构,成功匹配后可取捕获组;str与字节模式须匹配相应目标类型,不能自动混合。

模式匹配须核对起点和分组关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
Struct二进制数据模块

struct把按布局排列的字节与Python值相互转换,二进制文件提供对应字节接口。解包后整数与字节字段还可进行单独位运算,但它不是文本解码。

二进制布局需明确字节序与宽度关联本项背景,实质主要讲解在对应位置。

位掩码在一个整数中组合标志关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
pickle对象序列化模块

pickle在Python3输出字节流,协议0即使可读也不变成str。因此文件dump/load应使用二进制模式,模式正确与协议兼容、载入信任是不同约束。

对象序列化需要格式与版本约定关联本项背景,实质主要讲解在对应位置。

pickle加载仍需可信输入关联本项背景,实质主要讲解在对应位置。

原书依据 · 8 处
XML解析工具

四种提取方式表达不同抽象:正则适合受约束文本,DOM/ElementTree提供树结构,SAX回调交出事件和应用状态。相同简单样例的标题输出不能证明它们对所有XML都等价。

结构化文本需要结构解析

字符串模式可以从受约束的示例中提取文本,却不自动理解完整文档结构。原例用(.*)读取一行一个title的简单XML可以得到三项标题,但遇到同一行多个标签、跨行内容、嵌套或其他有效写法就可能失去正确边界;匹配示例成功不是通用XML解析器。

DOM把XML组织为节点树,示例getElementsByTagName后再从TEXT_NODE取data;ElementTree例通过findall(“title”)找根的直接子节点,再取E.text。两种树API都表达结构,但查询范围和文本模型不同:DOM的此查找可取后代,所示ElementTree路径只取对应层次,不能无条件等价为任意嵌套title提取。

复杂文档还需明确命名空间、子元素文本等需求;这段样例只给简单结构,不覆盖所有XML变体。Python2的unicode与Python3的str显示差别不改变按解析结构取值的任务。

结构化文本需要结构解析保存独立卡片。

原书依据 · 1 处
事件回调用状态筛选内容

SAX把解析过程中的事件交给处理器,应用用状态决定哪些文本片段属于当前需要的元素。BookHandler在遇到title开始时将inTitle设真,characters在真时打印数据,title结束再设假;不需要由这段应用代码先建完整DOM树。

结构图:

classDiagram
class ContentHandler
class BookHandler {
 inTitle
 __init__(self)
 startElement(self, name, attributes)
 characters(self, data)
 endElement(self, name)
}
ContentHandler <|-- BookHandler

真实基类全名是xml.sax.handler.ContentHandler。处理器实例经parser.setContentHandler注册,parse才驱动回调,应用不应把它误当自己逐次直接调用的流程。

原例只用一个布尔标志且收到片段就print;characters回调可能把同一段内容拆成多块,因此不能保证一标题恰好一次回调或一行输出。要产出完整标题,需按实际需求累积片段并在结束处处理;这是对该简例的边界说明,不是原书已提供的完整改良实现。

事件回调用状态筛选内容保存独立卡片。

原书依据 · 1 处

本章小结

本章将文本码点、字节表示、可变性、文件转换及库接口连接起来,说明类型/编码边界如何影响实际数据处理。下一章改讲属性访问的管理。

本章习题

十问回顾2/3字符串类型、对应关系、操作差异、非ASCII表达、文本/二进制文件、指定编码和ASCII兼容范围。

习题解答

十条答案收束类型角色和编码读写,并以Latin1/UTF8的ASCII共同范围解释兼容;这些规则需按版本与实际数据边界应用。

第37章 管理属性

属性看似字段读取,背后可以触发property、描述符或更广的属性钩子。选择机制先看要管理特定名称还是普遍请求,再看状态存于主体、描述符还是代理。CardHolder比较说明,输出相同不意味着赋值、只读和实例隔离契约都相同。

属性管理把读写属性的外部语法与内部实现联系起来。使用普通属性通常足够,工具构建者在需要验证、转换或计算时可选择拦截机制。

为什么管理属性

管理属性的动机是保持使用接口与内部表示之间的弹性:原来是字段,后来可计算或验证;直接换成方法调用则需要改动客户端。

属性接口可隐藏实现变化

若调用者已普遍使用person.name,后来改为getName()/setName()就要求修改访问点。属性管理可以在保留点号读写接口的同时插入计算或验证,让内部从直接存储演进为受管理值;需要维持的仍是调用方依赖的可观察语义,而非只保留拼写。

结构图:

classDiagram
class Person {
 getName(self)
 setName(self, value)
}

这是原文用来说明显式方法接口替代成本的示意类,valid/transform都是抽象占位,不是已给可运行的验证实现。电子表格单元从离散值变成计算结果的例子说明同样的演进动机。保持属性语法也不保证任意新增检查、异常或副作用都与旧行为兼容。

属性接口可隐藏实现变化保存独立卡片。

原书依据 · 1 处
插入在属性访问时运行的代码

四条路线在拦截粒度上不同:缺失读取回退、一般读写钩子、指定property和指定描述符。需要代理任意属性还是管理已知字段,影响选择。

属性管理入口有不同粒度关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处

特性

property在类上管理一个指定属性,将读、写、删和可选文档交给访问器;继承可复用同一管理接口,但实际状态由接收实例和访问器逻辑决定。

特性将指定属性交给处理器关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
基础知识

property(fget,fset,fdel,doc)用独立访问器定义所支持操作。创建对象与执行某个访问动作是不同时间;缺某访问器会使相应操作不被支持。

特性将指定属性交给处理器关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
第一个例子

完整Person示例把接口name与存储_name分开:管理器可继承,实际数据各实例独立;删除执行的是访问器指定动作。

特性将指定属性交给处理器关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
计算的属性

被管理属性可以是计算结果:同一property对不同实例分别读取其状态,而不是将所有实例连到一个默认共享值。

属性计算沿实例状态取值

property可让点号读取在当次访问时计算结果,而不是直接返回存储同名值。PropSquare用self.value保存原值,getX每次返回value的平方,setX只更新原值;X的表面属性语法隐藏了这一步计算。

结构图:

classDiagram
class PropSquare {
 value
 X$
 __init__(self, start)
 getX(self)
 setX(self, value)
}

原例P初值3,P.X显示9,赋P.X=4后显示16,Q初值32显示1024。管理器放在类上并不表示value也共享,访问器的self分别指向P/Q。这里没有缓存,读取也不把原值自动替换成平方;是否返回新计算值、如何保存仍由访问器实现。

847用通用钩子实现同一平方接口,原值仍归每个主体实例。

结构图:

classDiagram
class AttrSquare {
 value
 __init__(self, start)
 __getattr__(self, attr)
 __setattr__(self, attr, value)
}

图取02300版本,X只在缺失读取时计算value平方,赋X映到value后写字典。02302替代类保留同一构造器,以getattribute(self,attr)替换读取,setattr改用object.setattr;二者不是同一类同时定义的两条读取分支。替代版读取X时内部self.value可再次经过钩子,但对value的else委托基础查找,所以是有限再进入而非无穷递归;02303直接object.getattribute(self,“value”)避免这一额外再进入。原文末段说value未定义不准确,它在构造后实际存在,因此不会触发旧版getattr。

属性计算沿实例状态取值保存独立卡片。

原书依据 · 2 处
使用装饰器编写特性

装饰器只是创建与安装访问器的一种语法。理解名称重绑定和返回新property,可以解释为何三次def name没有简单地丢掉此前getter。

访问器装饰会重绑特性对象

@property把getter函数交给property并将同名类属性绑定为特性。后续@name.setter和@name.deleter分别创建替换对应访问器的property副本,并将同名name重新绑定;不是就地把原来的普通函数变成三个同名可独立调用的方法。

结构图:

classDiagram
class Person {
 _name
 name$
 __init__(self, name)
}
note for Person "name为property,内部持有读取、写入、删除三个访问器"

02262-02263的原始函数定义名都为name:getter为name(self),setter为name(self,value),deleter为name(self)。这些函数由property持有,不在图里虚构getName/setName/delName命名。

它与手动property(fget,fset,fdel,doc)表达相同管理职责;装饰器形式不要求多写一套存储,也不自动改变读写逻辑。保持装饰与重绑定的目标名一致,才会把新property安装回需要的类属性。

访问器装饰会重绑特性对象保存独立卡片。

原书依据 · 1 处

描述符

描述符把指定属性的访问交给另一个类的实例。与property相近,却可把管理器状态、继承和辅助行为组织到独立对象中;主体状态和管理器状态应分清。

属性管理入口有不同粒度关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处
基础知识

协议需要区分谁在管理、谁被访问和通过哪一个类访问;支持读取的管理器也不一定阻止同名实例赋值,真正只读需按写入协议处理。

描述符区分主体与管理器

描述符实例放在客户类的属性上,访问该字段时由协议调度它的方法。get中的self是管理器,instance是访问该字段的主体实例,owner是主体所属类;直接经类访问时instance为None,不是再给一个主体实例。

结构图:

classDiagram
class Descriptor {
 __get__(self, instance, owner)
}
class Subject {
 attr$
}
Subject --> Descriptor : attr持有管理器实例

图取02266实际示例,Descriptor只有打印三参数的get,未显式返回值所以结果为None。原02265三方法一般框架另给set(self,instance,value)、delete(self,instance),不把占位协议当本图已实现的额外方法。

类访问同样可能触发get,若希望在instance为None时返回管理器自身,需要在实现里明确处理,并非自动保证。书中用Subject.attr演示底层展开时不可按字面再求一次它而不触发协议;若要直接取原始管理器,可从类字典按名称取得,再描述调度。

840把主体的name交给Name管理器:self指Name实例,instance指Person实例,owner指Person类而非原文误写的“Person类实例”。实际状态_name保存在主体,故Bob与Sue不共享名字。

结构图:

classDiagram
class Name {
 __get__(self, instance, owner)
 __set__(self, instance, value)
 __delete__(self, instance)
}
class Person {
 _name
 name$
 __init__(self, name)
}
Person --> Name : 类属性name持有管理器

Name.get直接访问instance._name,没有instance为None的保护,所以不能说它已支持Person.name这种类访问;Name.doc读取的是管理类文档。后续将Person实现移到Super再由Person(Super)继承,关系为Super父类/Person子类,name仍持有Name实例。把Name定义嵌入Person只改变访问命名空间:类文档从Person.Name.doc取得,不表示嵌套定义自动拥有外部实例或改变管理器放在类属性的要求。

描述符区分主体与管理器保存独立卡片。

原书依据 · 2 处
只读描述符须明确拒绝写入

仅实现get而没有set或delete的非数据描述符,在主体有实例字典的常规查找中可被同名实例字段遮住;省略setter不自动等于只读。原例X.a=99在X上创建a,之后读X.a得99,而另一个Y仍走类上的D。

结构图:

classDiagram
class D {
 __get__(*args)
 __set__(*args)
}
class C {
 a$
}
C --> D : a持有D实例

图取02270只读变体:D.set(*args)直接抛AttributeError来拒绝赋值,get(*args)打印get。02268-02269最初D仅有get,两版本不能混同;星号参数保持原定义,不虚构更具体签名。

数据描述符的赋值优先级避免该种普通实例遮蔽,但不是不可被任何代码修改的安全边界。也要把删除管理字段的delete与实例终结del、通用属性删除delattr分开。

只读描述符须明确拒绝写入保存独立卡片。

原书依据 · 1 处
第一个示例

完整Name描述符把读写删除映射到主体的_name,而管理器本身通过Person.name类属性安装。继承和嵌套类定义可以重组代码,不能混淆对象上下文。

描述符区分主体与管理器关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
计算的属性

描述符计算结果与property看起来相同,也可能把状态放在不同对象里。DescSquare例用不同管理器实例隔离两个客户类,而非按每个客户实例隔离。

状态放置决定共享范围

描述符既可访问主体实例,也可保存管理器自己的状态。DescSquare把value保存在描述符self中,get返回该值平方,set改这个管理器的值;一个类上安装的同一管理器会被该类多个实例共同访问,因此这不是逐主体自动隔离的存储。

结构图:

classDiagram
class DescSquare {
 value
 __init__(self, start)
 __get__(self, instance, owner)
 __set__(self, instance, value)
}
class Client1 {
 X$
}
class Client2 {
 X$
}
Client1 --> DescSquare : X持有初值3的实例
Client2 --> DescSquare : X持有初值32的另一实例

原例c1和c2来自不同客户类,分别持有不同DescSquare,故显示9、c1赋4后16、c2仍1024。这只能证明两个管理器状态分开,不能证明同一Client1的两个主体也各有独立value。若状态应归每个主体,则要通过instance访问或采用对应分离存储,放置位置是职责决定而非语法自动保证。

842进一步对照管理器与主体状态。DescState.get返回self.value*10,InstState.get则返回instance._Y*100,赋值也分别写这两个位置。

结构图:

classDiagram
class DescState {
 value
 __init__(self, value)
 __get__(self, instance, owner)
 __set__(self, instance, value)
}
class InstState {
 __get__(self, instance, owner)
 __set__(self, instance, value)
}
class CalcAttrs {
 X$
 Y$
 _Y
 Z
 __init__(self)
}
CalcAttrs --> DescState : X持有描述符
CalcAttrs --> InstState : Y持有描述符

图对应02281-02282增强版本。X状态在DescState实例,Y依赖每个CalcAttrs的_Y,Z是普通实例字段。原02279第一版Y仅为普通类值3,obj.Y=6会在obj上遮蔽,而非修改类Y;其X计算20→50。第二版_Y初始3使Y为300,赋Y=6后为600,X仍20→50,Z4→7。两个版本的相似输出不能混淆存储位置;描述符有自身value可避开主体同名字段,却也改变共享范围,不能只宣传避免名称冲突而忽略状态归属。

854将name/age/acct存到各自的描述符self,而不是CardHolder instance,构造新主体时setter会覆盖同一类级管理器的字段。

结构图:

classDiagram
class CardHolder {
 acctlen$
 retireage$
 name$
 age$
 acct$
 remain$
 addr
 __init__(self, acct, name, age, addr)
}
class Name {
 name
 __get__(self, instance, owner)
 __set__(self, instance, value)
}
class Age {
 age
 __get__(self, instance, owner)
 __set__(self, instance, value)
}
class Acct {
 acct
 __get__(self, instance, owner)
 __set__(self, instance, value)
}
class Remain {
 __get__(self, instance, owner)
 __set__(self, instance, value)
}
CardHolder --> Name : name持有共享管理器
CardHolder --> Age : age持有共享管理器
CardHolder --> Acct : acct持有共享管理器
CardHolder --> Remain : remain持有管理器

四管理类实际嵌套在CardHolder体内,各Name()/Age()/Acct()/Remain()只在类定义时创建一次。Name/Age/Acct读取自身字段,所以Sue构造后,原Bob再读也会取得最近写入管理器的数据;addr仍按各主体分开,可能形成混合信息。Remain读取instance.age,也会间接取得共享Age数据。原测试在构造Sue前已打印Bob,没有再次核对Bob,不能据相同示例输出证明实例隔离。修正方向是把应归主体的值写到instance对应状态,而不是只强调省去下划线命名。Remain.set主动拒绝普通写入,避免被实例字段遮住,这与状态共享问题是不同职责。

状态放置决定共享范围保存独立卡片。

原书依据 · 3 处
在描述符中使用状态信息

管理器可用自己的状态,也可依主体状态计算;应根据数据属于谁决定存储位置。同一段代码里,指定描述符字段与普通类/实例字段还会采用不同访问路径。

状态放置决定共享范围关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
特性和描述符是如何相关的

property与描述符的关系可由简化Property实现看清:前者把指定字段操作转发给已保存函数,描述符协议提供这一层调度。

特性把描述符调度到访问器

可用一个描述符对象保存fget/fset/fdel,然后在get/set/delete中把主体实例传给相应函数,这解释property如何把属性访问桥接到普通访问器。管理器self与访问器将接收的主体self是不同对象,调用时必须传对上下文。

结构图:

classDiagram
class Property {
 fget
 fset
 fdel
 __doc__
 __init__(self, fget=None, fset=None, fdel=None, doc=None)
 __get__(self, instance, instancetype=None)
 __set__(self, instance, value)
 __delete__(self, instance)
}
class Person {
 name$
 getName(self)
 setName(self, value)
}
Person --> Property : name保存管理对象
Property ..> Person : 将instance传给访问器

原示意Property在类访问instance为None时返回self,访问器缺失时分别抛AttributeError,否则调用已保存函数。Person的getName/setName体是省略号,不补造内容。

这只是基本行为模拟,没有内置property完整功能:没有getter/setter/deleter装饰器辅助方法,也未自动复制fget文档。作者提出可继续扩展但未实现;若扩展要匹配内置访问器装饰的副本语义,不能把直接返回同一self误说成完全等价。

特性把描述符调度到访问器保存独立卡片。

原书依据 · 1 处

getattr和getattribute

通用属性钩子把任意名称的普通访问交给统一方法。getattr在常规查找失败后回退,getattribute管理一般读取;设置和删除分别由另外两个协议承担。

属性管理入口有不同粒度关联本项背景,实质主要讲解在对应位置。

属性写入钩子需避免自递归关联本项背景,实质主要讲解在对应位置。

原书依据 · 11 处
基础知识

通用钩子接收名称和值,可做追踪或委托,但实现必须区分读取、写入和删除各自的再进入路径。打印跟踪与真正存储是两种结果。

缺失属性钩子应保留失败信号关联本项背景,实质主要讲解在对应位置。

包装追踪发生在属性取得时关联本项背景,实质主要讲解在对应位置。

属性写入钩子需避免自递归关联本项背景,实质主要讲解在对应位置。

原书依据 · 11 处
读取钩子内访问须分层

getattribute会经过普通属性读取入口,在其内部再写self.other,仍会调用本方法;即便写self.dict[“other”],取得dict这一步也会先再次进入自身。单纯把点号写成字典下标不能避开这个入口。

可用object.getattribute(self,“other”)委托基础查找,避免为了读取other先无条件再调用当前钩子。它仍执行基础属性协议,不等于任意描述符内部都不会产生后续读取;要分析实际访问链,而不是宣称一次基础调用能阻止所有递归。

getattr只在常规读取失败后回退,因此读取已存在字段不会再进入此回退;若内部引用字段本身也缺失,仍可能循环。写入/删除用基础方法或合适的实例字典路径另行处理,不能把写入字典技巧不加区分移植到读取钩子。

读取钩子内访问须分层保存独立卡片。

原书依据 · 1 处
第一个示例

以通用钩子实现单个name属性也可获得前面相似的外观,但要自行处理名称映射、未知名称、构造写入和类文档接口差异。

缺失属性钩子应保留失败信号关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
计算属性

不同拦截工具可形成相同计算接口,但内部访问次数和路径不同。getattribute里有限地读取基础字段,不一定形成无限循环;分支和基础委托决定能否终止。

属性计算沿实例状态取值关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处

getattr和getattribute比较

存储在类、存储在实例和未实际存储的计算名,会经过不同的普通查找路径。getattribute的入口更广,但接管范围大并不自动保证所有失败语义也相同。

属性管理入口有不同粒度关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处
管理技术比较

四种管理工具可表达相似计算接口,代码组织各不相同;示例只演示部分路径,写入cube和未知名称等未测路径的语义事实上并不一致。

同样输出不证明属性契约相同

四种实现都能让示例读取square/cube并修改square,输出9、64、25;这只覆盖给出的路径。更换属性实现前,还需检查写入、未知名称和失败路径,不能把几行相同输出当完整替代性证明。

结构图: 特性版Powers(02308):

classDiagram
class Powers {
 _square
 _cube
 square$
 cube$
 __init__(self, square, cube)
 getSquare(self)
 setSquare(self, value)
 getCube(self)
}

描述符版(02309):

classDiagram
class DescSquare {
 __get__(self, instance, owner)
 __set__(self, instance, value)
}
class DescCube {
 __get__(self, instance, owner)
}
class Powers {
 _square
 _cube
 square$
 cube$
 __init__(self, square, cube)
}
Powers --> DescSquare : square持有管理器
Powers --> DescCube : cube持有管理器

通用回退版(02310)和统一读取版(02311-02312)各自重新定义Powers,分别具init(self,square,cube)、getattr(self,name)/getattribute(self,name)、setattr(self,name,value),不是这两个读取方法同时存在的一份实现。

按代码推导,特性版cube无setter会拒绝普通赋值;DescCube仅get可被实例同名字段遮蔽;回退版setattr也允许直接存cube,从而遮住虚拟读取;统一读取版仍按_cube计算cube,即使普通赋值存入同名字段也不按该字段取值。回退版未知名抛TypeError,其他默认查找通常是AttributeError,失败契约也不同。这些不是本次运行结果,而是已读源码的分支分析;若要保持只读/失败一致,应明确补齐相应协议。

同样输出不证明属性契约相同保存独立卡片。

原书依据 · 1 处
拦截内置操作属性

对语法或内置操作的隐式特殊方法查找,通常绕过普通实例属性钩子。因此“几乎所有读取”须限定为普通读取,包装器的协议支持需要在类型层明确提供。

特殊方法协议查找有类型层规则关联本项背景,实质主要讲解在对应位置。

原书依据 · 15 处
重访基于委托的Manager

Manager的普通委托和打印协议属于不同路径。改用统一读取钩子可以控制普通方法取得过程,却仍须在类型层提供所需特殊协议;减少钩子调用也可能改变可见接口。

包装委托与继承是不同关系关联本项背景,实质主要讲解在对应位置。

特殊方法协议查找有类型层规则关联本项背景,实质主要讲解在对应位置。

原书依据 · 18 处

示例:属性验证

CardHolder以同一组示例输入比较四种属性管理方法,验证/转换针对特定字段,未管理字段继续普通存储。相同测试输出不意味着完整契约或存储隔离一定相同。

使用特性来验证

构造期间也会走管理协议。特性版按字段区分转换、范围检查、遮蔽读取、普通存储和只读计算;后备字段与公开属性名分开。

构造赋值也经过属性验证

init中的普通属性赋值也遵循属性访问协议。CardHolder先给acct/name/age/addr赋值,前三者触发property setter进行转换或检查,不需要等对象建成后外部再次赋值才生效。若某一步拒绝值,初始化不会自动完成后面的全部赋值。

结构图:

classDiagram
class CardHolder {
 acctlen$
 retireage$
 name$
 age$
 acct$
 remain$
 addr
 __name
 __age
 __acct
 __init__(self, acct, name, age, addr)
 getName(self)
 setName(self, value)
 getAge(self)
 setAge(self, value)
 getAcct(self)
 setAcct(self, value)
 remainGet(self)
}

图取02328-02329特性版。name转小写并将空格换下划线;age只检查0到150范围;acct去掉连字符后要求长度8,读取只返回前5位加三颗星;addr直接存储;remain是59.5减age的只读计算值。四个property含一个虚拟remain,不能因正文说三个受管属性就漏掉它。

双下划线后备字段避免在访问器里再次读写同名property,但这不是隐藏原始数据的安全边界;遮蔽显示与账号语义验证是不同职责,原例仅检查长度,并未验证数字、身份或真实账户。规则是教学例的接口,不当作通用姓名/年龄/账号业务标准。

855改用getattr/setattr:name与age按原名存实例,读取已定义字段不触发回退;acct存为_acct,因此读acct时进入回退做显示遮蔽;remain不存数据,每次从年龄计算。

结构图:

classDiagram
class CardHolder {
 acctlen$
 retireage$
 name
 age
 addr
 _acct
 __init__(self, acct, name, age, addr)
 __getattr__(self, name)
 __setattr__(self, name, value)
}

图取02334。所有构造赋值同样先进入setattr,未管理addr也经过这个入口;普通读取则不都进入回退。未知名抛AttributeError,给remain赋值抛TypeError;具体异常类型与property无setter的错误不完全相同。统一写入规则不意味着绕过实例字典的显式操作也有同样验证。

856以getattribute替代缺失回退,acct可按原名存实例,但读取acct时显式调用基础获取原值再遮蔽;remain也用基础获取retireage/age来计算。

结构图:

classDiagram
class CardHolder {
 acctlen$
 retireage$
 name
 age
 acct
 addr
 __init__(self, acct, name, age, addr)
 __getattribute__(self, name)
 __setattr__(self, name, value)
}

图取02335独立替代版,不与855同时定义两个读取钩子。superget只是局部变量绑定object.getattribute,不是调用一次无参super();非受管字段也需通过它返回基础读取以避免无条件再进入。setter仍按字段验证再写实例字典,并非每条写入都调用getattribute;只有其内部实际读取acctlen等字段才会进入读取钩子。

构造赋值也经过属性验证保存独立卡片。

原书依据 · 3 处
使用描述符验证

描述符可拥有状态,但状态放在哪里决定共享行为。本版把三个主体数据字段存到类级管理器,不能当作与特性版具有同样实例隔离;只读remain另由setter拒绝写入。

状态放置决定共享范围关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
使用getattr来验证

写入时转换或验证,可以与读取时拦截分开。数据按原名真实存下后,缺失读取钩子不会为每次正常读取重复运行;只对虚拟/换名字段处理。

构造赋值也经过属性验证关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
使用getattribute验证

统一读取入口需要明确哪些名计算、哪些名交回基础查找;原始acct可用同名存储,但普通读取仍按管理策略展示。

构造赋值也经过属性验证关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处

本章小结

本章以四种属性管理路线收束:选择拦截粒度,明确状态归属,处理递归和隐式协议边界。下一章转向定义时运行的装饰器。

本章习题

五问回忆两种读取钩子、property/descriptor、装饰器绑定及通用/指定粒度差别,并以争论引文作结。

习题解答

解答回连读取范围、描述符的状态能力、property装饰器绑定与读写钩子职责。工具比较的价值在于能说明行为和取舍,而不是只相互否定。

第38章 装饰器

装饰器在定义边界接收函数或类并重绑定名称;它可以返回包装器,也可以登记或修改对象后返回原对象。包装使调用、构造和属性访问更易统一扩展,但状态生命周期、方法绑定和返回值必须分别保留。私有代理和范围检查两个大例子也揭示了普通属性、隐式协议及有效调用假设的限制。

本章承接前面的静态/类方法、property与抽象接口,转向装饰器的内部机制、状态保存和较完整工具。

什么是装饰器

装饰器在定义函数或类时接收已形成的对象,并把返回值绑定到相应名称;它可以安装后续调用逻辑,但装饰应用和后续使用须分开。

装饰器在定义阶段重绑名称关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
管理调用和实例

安装包装对象可以让函数调用、实例创建或属性访问的额外逻辑在以后运行。定义时安装与每次调用执行是不同次数和不同参数。

装饰器在定义阶段重绑名称关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
管理函数和类

装饰也可仅注册、修改函数或类对象,然后返回原对象;它不必为每次调用增加一层。类的后创建管理与元类有重叠用途,但作用阶段仍不同。

类装饰与元类作用阶段不同关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
使用和定义装饰器

使用内置或框架装饰器只需理解其契约,编写自己的装饰器则要处理目标范围和状态。函数级包装和类实例接口包装适合不同职责。

为什么使用装饰器

装饰器将管理意图放到定义边界,使安装步骤集中可见;收益是维护和一致使用,成本可能是额外层与对象变化。

定义边界集中安装扩展

把扩展放在函数或类定义旁边,可让读者直接看到它的管理意图,并集中安装逻辑,避免每个调用点重复加同一套操作。需要改变扩展策略时,可在这一处维护,而不是追踪所有调用方是否记得执行辅助步骤。

这是一种表达和维护取舍,不是必须使用新能力:显式辅助函数和手动重绑定也能实现许多相同功能。一次定义执行时应用装饰,不表示整个程序生命周期只可能定义一次;包装器仍可能为每次调用增加成本或改变对象类型,必须连同接口与状态契约一起判断。

873的02370将计数移到显式tracer(func,*args)辅助函数,需要每个调用点自选是否经过;装饰版重绑入口后普通按名调用经过包装,可减少忘记附加逻辑的机会。两者都可用手动重绑达到相近安装效果,语法本身不是不可绕过的控制边界。

882的02422-02425分别对照显式Wrapper(Spam())/装饰后Spam()、getInstance(类,*args)/装饰构造、getInstance(已建对象)和显式tracer调用。语法负担从每个调用点移到定义处;最后的显式tracer参数形态要与其具体辅助函数签名一致,不能拿一个装饰器原样当任意管理函数。

883逐项说明类型变化/额外调用,以及显式语法/维护/一致性三收益。单例保留返回实例的原类类型,只说明没有用额外代理包住它,不等于缓存构造入口完全没有函数调用;追踪代理则改变外部对象类型。是否影响性能或依赖类型判断的代码需按任务评估,不把作者“大多不显著”当测量结论,也不能只为提速移除承载必需行为的装饰。

894的02444-02446比较giveRaise(self,percent)内部if/assert和@rangetest(percent=(0.0,1.0))。统一检查可减少重复规则的维护位置;参数验证仅覆盖经过该入口的调用,不等于pay或其他属性本身已获得赋值验证。前两段是历史片段,包含Python2形式raise和省略类体,不当当前完整代码执行。

907的02473-02476逐步比较Extras继承、类后逐个赋extra、extras(Class)辅助函数、Extras(type)元类的init(Class,classname,superclasses,attributedict)。元类内按required()条件给Class.extra赋普通函数,客户声明metaclass=Extras。required与函数体均为示意,extra(self,arg)与X.extra()缺少arg也未补齐,不能当可运行演示。自动接入只对已纳入该机制的类生效,不会自动发现所有客户类。

定义边界集中安装扩展保存独立卡片。

原书依据 · 6 处

基础知识

先理解装饰的自动重绑定映射,再读实际包装实现,有助于分清每层执行时机。

函数装饰器

函数装饰的基本映射是把新函数交给装饰器并绑定返回值;闭包可保存目标函数,可调用实例可在字段保存它。用到方法时,包装对象还须按所需协议取得主体实例。

装饰器在定义阶段重绑名称关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
方法包装还需绑定主体实例

把普通函数放在类属性上,经实例取出时会得到绑定方法,主体实例进入调用参数。若装饰器返回一个只有call而没有相应绑定协议的可调用实例,这一自动主体绑定不再按普通函数发生:call的self是包装器自己,原方法所需的C实例并不会因此自动出现。

结构图:

classDiagram
class decorator {
 func
 __init__(self, func)
 __call__(self, *args)
}
class C {
 method$
}
C --> decorator : method绑定可调用实例

02346原方法定义method(self,x,y)在装饰时传给decorator并存func;图中method表示类上最后安装的对象,不将它误画成仍自动绑定的普通方法。

嵌套wrapper(*args)作为函数返回并安装时,仍有函数的绑定行为,X.method(6,7)可将X放入args,再传给原方法。描述符也是可实现绑定的另一条路,不能说所有可调用对象都永远无法用作方法包装。书中框架有省略号/注释调用,未提供完整返回值和关键字转发,不能把它当透明包装已实现。

875完整tracer再次展示失败:bob.giveRaise(.25)进入的是tracer.call,*args只有.25,缺少原Person主体;跟踪计数/返回值/kwargs已经转发正确,也不能弥补缺失绑定。嵌套onCall函数返回后保留函数绑定,原Person能作为首项传入。另一种真实修复使用描述符:

结构图:

classDiagram
class tracer {
 calls
 func
 __init__(self, func)
 __call__(self, *args, **kwargs)
 __get__(self, instance, owner)
}
class wrapper {
 desc
 subj
 __init__(self, desc, subj)
 __call__(self, *args, **kwargs)
}
class Person {
 giveRaise$
}
Person --> tracer : 类字段保存装饰描述符
tracer ..> wrapper : 属性取得时创建
wrapper --> tracer : desc
wrapper --> Person : subj

图取02390完整两类,Person方法定义沿前文省略引用,不补造额外方法。tracer.get返回wrapper(self,instance),它同时保存管理器和主体,调用时通过self.desc(self.subj,*args,**kwargs)回到管理器,再进入原函数。02392则在get内返回保存相同两对象的嵌套wrapper函数,职责相同而存储方式不同。 本例get未特殊处理instance为None,故不能据此保证通过Person.giveRaise显式取类方法后,所有未绑定调用形式都正确。装饰方法计数属于类上每个tracer,多个Person调用同一方法共享它;不是每个Person独立计数。原文提描述符del属于笔误,删除协议是delete,这里两者都未实现。

903的02469-02470给timer(label,trace)→onDecorator(func)→onCall(*args,**kargs)完整替代,onCall.alltime=0并累计成功返回后的耗时。函数作为类属性保留方法绑定,Person.giveRaise和lastName各有自己的包装函数,但所有Person实例共用该方法的alltime,并非每个实例一份。time.clock是历史接口,非当前可运行保证;失败路径无finally,仍不累计抛异常调用。

方法包装还需绑定主体实例保存独立卡片。

原书依据 · 3 处
类装饰器

类装饰管理已形成的类或其后续构造入口。若要保留多实例语义,必须明确每次构造分配的代理与主体,不能只在装饰阶段建立单个存储槽。

类包装须按构造调用分配

类装饰器可在定义时记住原类,并返回一个包装类;以后每次调用包装类,都创建新的包装实例和新的被包主体。这样同一装饰类的多个对象有各自存储,而不是不断覆盖一个装饰器实例的wrapped字段。

结构图:

classDiagram
class Wrapper {
 wrapped
 __init__(self, *args)
 __getattr__(self, name)
}
class C {
 attr
 __init__(self, x, y)
}
Wrapper *-- C : 每次构造建立独立主体

图取02352:外层decorator(cls)闭包记住原类,返回Wrapper;C构造只设attr=spam。另一个02353替代类为:

classDiagram
class Decorator {
 C
 wrapped
 __init__(self, C)
 __call__(self, *args)
 __getattr__(self, attrname)
}

它在装饰时只建一个Decorator,调用时改self.wrapped,因此主体槽会覆盖。原图call还没有return,按原样x=C()、y=C()都得到None,不能直接声称x/y已是可用代理;即使补return self,也会让两者指向同一包装对象,仍未解决多主体隔离。

每个装饰类一份外层状态与每次实例化一份主体状态是不同生命周期,装饰器写成函数还是类本身不能替你决定它。

881的Tracer与前868缺return的骨架不同,这次call明确return self,别名覆盖问题可直接从完整实现推导:

结构图:

classDiagram
class Tracer {
 aClass
 wrapped
 __init__(self, aClass)
 __call__(self, *args)
 __getattr__(self, attrname)
}
class Person {
 name
 __init__(self, name)
}
Tracer --> Person : wrapped只保存最新主体

02418-02421中Person名指向一个Tracer实例,bob=Person(Bob)和sue=Person(Sue)都返回同一管理器,第二次替换wrapped后,bob.name也转向Sue。前版每次建立独立Wrapper避免这个单槽覆盖;并非类实现装饰器必然失败,关键是call返回何种对象及主体存在哪里。

类包装须按构造调用分配保存独立卡片。

原书依据 · 2 处
装饰器嵌套

多个装饰器处理前一层所得对象,按靠近定义的层向外应用。是否安装包装器以及层间是否兼容,决定实际后续行为。

装饰嵌套按内层结果组合

在函数上依次写@A、@B、@C,应用关系为A(B(C(原函数))):靠近def的C先接收原函数,B接收C的结果,A最后接收B的结果。每层可返回原对象或新的包装对象,因此层数也不保证等于实际后续调用层数。

原例d1/d2/d3仅return F时,最后仍直接取得原函数;另例分别包装并给返回字符串加X/Y/Z前缀,形成XYZspam。这个结果来自函数组合,而不是装饰器每次调用重新应用。若包装器都有调用前动作,调用会从外层开始进入,结果再由内层返回,不能把应用顺序误当所有调用时动作都从内到外发生。

类装饰同样按嵌套应用,但每层可能保留原类或替换构造入口;各层仍须满足下一层的输入/调用契约。这里描述应用关系,不将它冒充包含装饰表达式求值的全部时间顺序。

装饰嵌套按内层结果组合保存独立卡片。

原书依据 · 1 处
装饰器参数

带参数语法实际先调用装饰工厂,再用所得装饰器处理目标。理解配置、目标和后续实参三种不同输入,才能决定状态如何保存。

装饰参数先由工厂接收

@decorator(A,B)先取得decorator(A,B)的结果,把它作为真正接收函数F的装饰器,关系为F=decorator(A,B)(原F)。A/B是配置这层装饰的参数,不是随后F(99)的调用参数。

常见包装形式有三种时机:工厂接配置,实际装饰器接目标函数,包装器接以后的调用实参。闭包或对象字段可在层间保存各自需要的配置/目标,但这些状态不应混成一份随每次调用覆盖的全局数据。

原图decorator(A,B)返回actualDecorator(F),后者返回callable占位;没有给出具体包装体,不能虚构它已执行转发。实际装饰器也可返回原函数而不增加包装,所以三层是这种常见包装模式的结构,不是所有带参装饰器必须增加第三层。

877把Timer类定义放入timer(label=“”,trace=True)工厂,每次工厂返回一个Timer类,装饰目标时新建其实例保存func/alltime,label/trace由外层函数作用域保存供以后调用。

结构图:

classDiagram
class Timer {
 func
 alltime
 __init__(self, func)
 __call__(self, *args, **kwargs)
}

图取02398-02399,label/trace不是图中类体字段。trace=False仅跳过打印,目标仍运行、耗时仍计算并累加;标签改变展示,不改变实际工作量。每次装饰建立的Timer实例状态独立,而重复调用同一实例累计alltime。 函数装饰器返回的是Timer实例,尚未提供方法绑定协议,因此不能直接声称也透明支持普通实例方法;time.clock同样是旧接口。2397是带省略号的标签语法骨架,不是完整计时实现,2400-2403为书中2.6客户端和交互展示,未在本次运行。

899对照中带参数版的规则在argchecks闭包,注解版在目标函数的annotations,所以省去接收规则的最外层工厂。配置来源变化而调用包装仍在;两者都未在该骨架里填完检查逻辑。

装饰参数先由工厂接收保存独立卡片。

原书依据 · 3 处
装饰器管理函数和类

装饰协议可仅在创建后处理目标,再返回原对象;包装后续调用只是用途之一。后面注册API和函数属性例会展开直接管理。

装饰器在定义阶段重绑名称关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处

编写函数装饰器

接下来以真实示例学习函数装饰器,再转向类装饰器和较大型工具。

跟踪调用

tracer按每个装饰函数创建包装实例,保存函数和计数,call在目标前递增并打印;这种最小实现的通用性只覆盖所示位置参数场景。

可调用包装不自动保持契约关联本项背景,实质主要讲解在对应位置。

定义边界集中安装扩展关联本项背景,实质主要讲解在对应位置。

原书依据 · 9 处
状态信息保持选项

保存状态有多种载体,重要的是它们的共享范围和修改语义。类实例、每次装饰的闭包和新函数属性可分别隔离目标,全局变量则汇总所有经过该模块入口的目标。

可调用包装不自动保持契约关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
计数状态应按装饰目标隔离

计数器该属于一个被装饰目标,还是多个目标的共同集合,必须由放置位置表达。每次装饰新建tracer实例时,func与calls分别归该包装器;若将calls放到模块全局,spam和eggs的调用就累计到同一个计数,不再是各函数独立统计。

结构图:

classDiagram
class tracer {
 func
 calls
 __init__(self, func)
 __call__(self, *args, **kwargs)
}

02371-02373的完整增强版接收关键字参数并return目标结果,分别显示两个函数计数1/2;02374-02376全局版则连续计数1/2/3/4。是否错误取决于想统计哪个集合,不把全局汇总本身一律判错。

闭包版在每次tracer(func)调用中建立calls=0,wrapper用nonlocal更新该绑定,也可隔离目标;函数属性版在每个新wrapper上保存wrapper.calls,更新的是对象属性而非重新绑定wrapper,所以不需nonlocal。属性版还允许外部读取/修改状态,和只在闭包内部可见不同。所有版本递增在目标之前,统计调用尝试而非成功完成次数,未处理并发一致性。

875的nonlocal方法版与描述符版将计数保存在每个被装饰方法的闭包/管理器上。Bob与Sue调用同一lastName方法时累计到同一方法计数,原输出1/2对应这一含义;实例绑定代理只携带主体,并不自动新建独立方法计数器。

924的02524-02527重列tracer(func)的nonlocal calls和timer工厂的onCall.alltime,Person的init/giveRaise/lastName分别手工装饰。每个方法独立累计,但同一方法的Bob/Sue调用共享累计;tracer计数在目标前增加,timer耗时在目标成功返回后累计,失败语义不同。正常返回值均return传回;time.clock旧接口限制沿用前卡,不据旧输出比较当前速度。

计数状态应按装饰目标隔离保存独立卡片。

原书依据 · 3 处
类错误之一:装饰类方法

方法装饰同时需要装饰器状态和主体实例。闭包函数可借函数绑定拿到主体,描述符也可在属性取得时创建持有主体的代理,之后再转发调用。

方法包装还需绑定主体实例关联本项背景,实质主要讲解在对应位置。

计数状态应按装饰目标隔离关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
计时调用

计时包装给函数入口增加单次与累计耗时,但必须明确工作量和统计路径。比较map与列表解析时,Python3需让惰性结果真正产出,否则只是测迭代器构造。

计时区间应明确包括哪些工作关联本项背景,实质主要讲解在对应位置。

迭代形式性能须按具体工作比较关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
添加装饰器参数

参数工厂使每个目标的标签/打印配置可明确指定,计时统计与是否打印分离。配置在外层作用域,目标与累计值在Timer实例,职责各有位置。

装饰参数先由工厂接收关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处

编写类装饰器

下一组示例把装饰管理目标从函数调用转到类和实例创建,语法映射仍是定义后重绑。

单体类

类装饰可改变实例创建入口的复用策略。单例缓存保存首次结果,后续请求的不同参数不会自动重建或更新;共享行为在这里是设计意图,而非普通多实例类默认语义。

单例入口复用首次构造结果

单例入口在首次请求时构造并保存目标,随后请求返回缓存对象。原例第一次Person(“Bob”,40,10)建立值,第二次请求Sue及另一组参数仍取Bob对象;后续参数并不重新初始化它。每个被管理目标类各有缓存,不是Person和Spam共用一个实例。

结构图:

classDiagram
class singleton {
 aClass
 instance
 __init__(self, aClass)
 __call__(self, *args)
}
class Person {
 name
 hours
 rate
 __init__(self, name, hours, rate)
 pay(self)
}
class Spam {
 attr
 __init__(self, val)
}
singleton ..> Person : 可管理目标之一
singleton ..> Spam : 另一目标各有管理器

图取02405-02409,singleton类是第三种替代;第一种用全局字典以原类为键,第二种用每次singleton(aClass)形成的nonlocal instance闭包。状态载体可不同,但缓存范围必须明确。

“最多一个”只限所示入口和缓存管理的顺序调用语义,不是对所有原类引用、重入或并发构造的全局唯一性保证。例子只转发位置参数,关键字转发尚未实现;缓存建立后也没有按新参数更新对象的逻辑。

882的02424先执行Person(Bob,40,10)再传入getInstance(object),函数才以object.class取缓存键。这可能返回已有对象,却无法避免本次参数表达式中那个新对象已经构造过;因此缓存返回同一对象不等于避免所有构造或副作用。直接接类与参数的版本则能在缓存命中时不调用原类。

单例入口复用首次构造结果保存独立卡片。

原书依据 · 2 处
跟踪对象接口

装饰代理把主体创建放入包装器,但追踪范围仍由普通属性回退决定:外部经过代理的访问与主体内部的访问是两条路径,实例间计数也需分开。

包装追踪发生在属性取得时关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
类错误之二:保持多个实例

每个被装饰类只建一个管理器,不等于给该类每次构造都建立独立代理。完整Tracer的return self让两个外部名称实际指向同一包装器,后建主体覆盖前一个。

类包装须按构造调用分配关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
装饰器与管理器函数的关系

管理器函数可把扩展显式放在调用处,装饰器则把安装放在定义处。两者可能共享底层逻辑,但已创建实例再交给缓存的形式会有不同构造成本。

定义边界集中安装扩展关联本项背景,实质主要讲解在对应位置。

单例入口复用首次构造结果关联本项背景,实质主要讲解在对应位置。

原书依据 · 8 处
为什么使用装饰器(重访)

装饰和显式管理器都可实现扩展,选择应权衡定义处的可见性/一致安装与包装引入的类型/调用变化,不能从语法便利推断无代价。

定义边界集中安装扩展关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处

直接管理函数和类

直接管理对象不必包装调用:注册表保存目标引用,字段标记保存元信息,返回原对象保留它的原调用路径。

注册与标记可保留原对象

装饰器可在定义时登记对象或给它附加元数据,然后return原对象。注册例将obj存到registry[obj.name],之后既可由原名称调用,也可从表中取得同一函数/类再调用;没有额外代理自动拦截每次运行。

结构图:

classDiagram
class Eggs {
 data
 __init__(self, x)
 __str__(self)
}

图取02426实际被注册类,构造将x的四次方保存在data,str负责显示;spam/ham是模块函数,分别返回平方/立方,不画为Eggs方法。registry本身是普通字典而非自定义API类,按同一键登记会替换已有值,示例未提供同名冲突检测或命名空间策略。

另一个decorate把func.marked=True,annotate(text)工厂的decorate把func.label=text,均返回原函数。这里的“annotate”是自定义元数据装饰器,不是Python自动读取的类型注解。保留对象身份不代表对象从未被修改,只代表后续调用不因本例额外经过包装层。

注册与标记可保留原对象保存独立卡片。

原书依据 · 1 处

示例:“私有”和“公有”属性

接下来两个较大装饰器案例展示属性访问管理和参数检查,说明比前面骨架更完整的工具如何组合。

实现私有属性

Private用代理把外部访问与主体内部访问分开。公开方法仍可管理主体的私有字段;检查只覆盖所实现的代理路径,不能据此承诺安全隔离。

代理隔开外部与内部访问

属性访问控制可以把外部调用者放在代理一侧,把主体方法的self留在另一侧。Private(*privates)返回类装饰器,后者返回onInstance;外部读取经过getattr,外部赋值经过setattr,命中私有名时抛TypeError。主体方法经getattr取得后仍绑定原主体,因此内部self.data及self.size()不经过代理检查。

结构图:

classDiagram
class onInstance {
 wrapped
 __init__(self, *args, **kargs)
 __getattr__(self, attr)
 __setattr__(self, attr, value)
}
class Doubler {
 label
 data
 __init__(self, label, start)
 size(self)
 double(self)
 display(self)
}
onInstance *-- Doubler : wrapped保存主体

图取02430-02433。Private(data,size)拒绝外部直接读取/修改这两个名称,但允许外部调用double,由它在主体内部读取size和修改data。测试的成功输出说明公开入口的转发;源码把违规访问示例放在三引号字符串内,没有实际执行这些失败调用。

这是普通属性访问路径的教学代理,不是安全隔离。第一版的wrapped本身公开,能取出主体绕过检查;没有删除拦截,也不自动委托隐式特殊方法。

887比较继承钩子和委托:继承把内外访问都放在同一self路径,代理则让主体方法保留自己的self。Private调用的privates配置、onDecorator调用捕获的aClass、onInstance实例的wrapped分属配置/装饰/构造三个时机。前两者可在对应装饰目标的实例间共享,wrapped必须按实例分开。

891的02442-02443改为accessControl在原aClass上安装getattributes,再return aClass;getattributes(self,attr)先判failIf,再用object.getattribute读取。没有代理改变主体类型,但主体方法自己的self读取也会被拒绝;仅添加读取钩子也没有拦截写入。隐式协议可运行是因为特殊方法仍在原类上,并不意味着隐式查找经过此钩子得到验证。覆盖既有钩子和slots兼容亦未解决;调用栈检查只作为未实现的探索方向。

代理隔开外部与内部访问保存独立卡片。

原书依据 · 3 处
实现细节之一

访问路径的区分来自对象分层;配置与实例也位于不同生命周期:最外层保存私有名称,中层保存目标类,最内层每次构造保存不同主体。

代理隔开外部与内部访问关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
使用dict和slots

代理自己的内部存储和对主体的属性操作应分开处理。前者可用自身字典避开递归;后者通过标准属性接口保留主体自己的查找及存储规则。

属性写入钩子需避免自递归关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
公有声明的泛化

把拒绝条件抽成failIf,便可复用代理机制实现黑名单和白名单。Private与Public在示例字段上结果相同,但对未声明名称的默认策略相反。

公私声明可共用拒绝谓词

Private与Public可以共用同一访问代理,只把“何时拒绝”的判断作为failIf传入。Private(*attributes)在attr属于集合时拒绝,未列出的名称允许;Public(*attributes)在attr不属于集合时拒绝,只有列出的名称允许。区别也影响新属性:Private允许未列名的新增写入,Public拒绝未列名的写入。

结构图:

classDiagram
class onInstance {
 __wrapped
 __init__(self, *args, **kargs)
 __getattr__(self, attr)
 __setattr__(self, attr, value)
}
class Person {
 name
 age
 __init__(self, name, age)
}
onInstance *-- Person : 装饰时保存原类

02434-02436中的accessControl(failIf)返回onDecorator(aClass),再返回onInstance。两个Person定义是替代示例:Private(age)与Public(name)都允许外部读写name,拒绝age;不能因此认为两种策略对所有其他名称都相同。wrapped是单侧双下划线名称,被改写为_onInstancewrapped,不是标准双侧名称wrapped。

该实现仍是可绕过的普通属性代理。代理自己已有的字段不必经过getattr,因此Public白名单也不是对对象所有可能操作的完整安全契约。

903的02471-02472在onDecorator内加if not debug: return aClass,否则建立原onInstance代理。两种模式的访问行为与外部对象类型均可能不同;被注释的age失败示例不是本轮执行证据。仍没有给包装类补全部隐式协议,不能据此宣称通用代理完成。

公私声明可共用拒绝谓词保存独立卡片。

原书依据 · 2 处
实现细节之二

双下划线把代理内部字段与主体字段区分开,但改写名仍可从外部访问。代理还改变外部对象身份和类型,应按具体绑定分析类型判断。

名称改写取决于定义类关联本项背景,实质主要讲解在对应位置。

内部名称约定不等于访问隔离关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
开放问题

普通属性代理不会自动支持隐式协议。可以在包装类显式实现所需特殊方法来委托;直接给主体类插入读取钩子虽保留类型,却失去内外访问的分层。

特殊方法协议查找有类型层规则关联本项背景,实质主要讲解在对应位置。

代理隔开外部与内部访问关联本项背景,实质主要讲解在对应位置。

原书依据 · 18 处
Python不是关于控制

作者把访问控制例定位为装饰器与属性机制的演示,是否添加这类限制应依应用需求决定。

示例:验证函数参数

下一案例转向验证函数或方法实参的数值范围,检查对象由属性写入改为函数调用。

目标

把参数范围验证移到可复用的装饰器,可以减少每个方法中的重复检查。它控制的是调用实参,不是之后所有属性赋值。

定义边界集中安装扩展关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
针对位置参数的一个基本范围测试装饰器

第一版范围装饰器先检查位置实参,再调用目标。方法绑定带来self偏移;调试关闭分支会移除检查及包装,必须与必需业务校验区分。

断言不宜承担必需接口阻断关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
范围包装可在调用前拒绝

rangetest(*argchecks)把每项(index,low,high)保存到闭包。onCall(*args)按指定位置取值,若小于low或大于high便抛TypeError;端点允许,通过后才return func(*args)。因此正常返回值保留,失败检查阻止目标函数本次执行。它没有类型专用分支,也不是完整调用签名验证器。

02447-02451的初版只接受位置实参,没有**kargs;越界索引、不可比较对象或缺失实参可能在检查自身失败。装饰普通实例方法时,函数包装仍参与方法绑定,args[0]是self,percent须检查索引1;同一配置不能不加分析地照搬给自由函数。

装饰发生时若debug为False,直接return func,不安装onCall。本例把验证定位为可关闭的调试工具,-O分支会允许原先拒绝的调用。不能把这种可关闭检查当业务必需不变量或输入边界。原书输出是教学运行记录,本轮未执行。

范围包装可在调用前拒绝保存独立卡片。

原书依据 · 1 处
针对关键字和默认泛化

第二版用名称规则连接位置或关键字实参。省略参数不验证,原函数继续承担真正的调用匹配;工具能力仍由其简化的名称定位算法限定。

按形参名定位实际传入值

改进版rangetest(**argchecks)让规则按参数名指定,例如percent=(0.0,1.0)。装饰时取func.code.co_varnames[:co_argcount]作为该旧例的预期位置形参表;调用时取其前len(pargs)项作为本次按位置提供的名称表。

对每条规则依次判断:名称在kargs中则读关键字值;否则在该位置名称表中则用其索引读pargs;两者都不在时按省略默认处理,跳过范围检查。通过后调用func(*pargs,**kargs)。规则不需要为实例方法手工写self偏移,因为位置表本身包括self;percent的名字索引会落到正确位置。

省略检查不等于证明默认值在范围内,也不等于完整验证了调用:初版算法假设常见调用本来合法,缺少必需参数和重复提供等仍可在目标调用时失败。额外**kwargs名称若提供并配置规则可检查;额外*args没有签名内名称,无法由这套规则定位。它也不是涵盖所有后续语言签名形式的通用绑定算法。

897的02459展示func(a,b,c,d)中co_varnames还包括x/y局部名,须用co_argcount截断,不能把所有局部名当形参。02460为旧2.x func_code与3.x code写法比较;所示major版本分支是历史兼容示例。正文按N个位置实参、关键字表、剩余默认名解释三个分支。调用无效时仍可留给目标函数失败,不承诺检查之前必已绑定。

898的02461列omitargs()及omitargs(d=8,c=7,b=6)两种缺少a的调用:省略分支可能先略过检查,最终原函数仍因缺必需参数失败。任意关键字参数有名称且出现时可按配置检查;未传入不检查,额外位置参数没有形参名可映射而被忽略。把规则扩展为对尾部*args逐项检查只是建议练习,未实现。

按形参名定位实际传入值保存独立卡片。

原书依据 · 3 处
实现细节

内省提供预期名称,切片提供本次位置名称;这个简化算法依赖原书时期的常见形参形式及有效调用假设,并非重建Python全部匹配规则。

按形参名定位实际传入值关联本项背景,实质主要讲解在对应位置。

调用顺序限制须区分版本关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
开放问题

这个工具负责命名参数的范围检查,剩余签名错误与无法命名的额外位置实参是明确边界。

按形参名定位实际传入值关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
装饰器参数VS函数注解

验证规范既可从装饰器配置读取,也可从函数注解读取;换存放位置不会自动产生验证行为,也不免除实参名称匹配。

函数注解不自动执行类型校验关联本项背景,实质主要讲解在对应位置。

装饰参数先由工厂接收关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
其他应用程序:类型测试

范围检查模式可以换成类型谓词,但限制具体类型会缩小可接受对象范围,应区别接口所需能力和工具规则。

接口优先于过窄的类型筛选关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处

本章小结

本章以定义时重绑定为共同骨架,逐步讨论函数调用、实例构造与对象元数据管理;下一章转向类本身的创建。

本章习题

两道练习分别要求修复计时包装的方法绑定,以及为属性代理增加按调试开关禁用的分支。

习题解答

答案将类式计时包装改为函数,使方法绑定可用;累计状态附在包装函数上。另一个答案在优化模式直接返回原类,取消属性代理。

方法包装还需绑定主体实例关联本项背景,实质主要讲解在对应位置。

公私声明可共用拒绝谓词关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处

第39章 元类

元类让逻辑参与类对象的创建,接收类名、基类与命名空间,再构建和初始化结果。业务类从超类继承,与它作为元类的实例是不同关系。类装饰器能在类已产生后扩展它,元类则还有构建钩子与选择传播;批量装饰示例将二者组合,也显示集中机制并不会自动覆盖所有成员形态。

本章将自动扩展的入口移到类对象创建过程,介绍元类怎样参与工具和API的类管理。

要么是元类,要么不是元类

是否引入元类应由明确的类管理需求决定。验证接口、批量装饰或注册等是潜在用途,原书这里尚未给这些用途的实现。

提高魔力层次

各种自动钩子作用时机不同。元类进入类创建过程,装饰器在定义后重绑定;但两者都可能通过修改类影响后续实例,不能按用途作绝对分割。

类装饰与元类作用阶段不同关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
“辅助”函数的缺点

集中扩展逻辑可减少每个客户类重复决策;元类把明确声明后的扩展接入类创建,而辅助函数仍要求类定义者记得调用。

定义边界集中安装扩展关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处
元类与类装饰器的关系:第一回合

若辅助函数返回增强后的原类,装饰器可自动完成重绑定,类装饰器因此也能管理类本身。这个扩展目的与元类初始化类的用途有交集。

类装饰与元类作用阶段不同关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处

元类模型

理解元类要先区分类型实例关系与类创建协议。

类是类型的实例

类对象也有自己的类型。普通实例指向它的类,普通类指向type;自定义元类会替换默认类类型,因此不能把所有用户类都说成type的直接实例。

类是类型与元类的实例关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
元类是Type的子类

从type派生的元类让用户定制类创建;类与元类的实例关系不能与类从超类继承混为一谈。

类是类型与元类的实例关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
Class语句协议

class语句先执行类体形成名称空间,再调用类创建入口。元类接入这个过程,管理的是类对象,不是本章示例后来建立的X实例。

类体命名空间交给创建入口

类体先执行以准备名称空间,类创建入口再接收类名、基类元组和属性映射,产生类对象。原书用Spam = type(名字,基类,字典)概括默认路径;有定制元类时入口换成选定的Meta。类体中的def先产生函数,再随命名空间成为方法属性,并不是等首个实例创建才执行类体。

02485-02488的Spam有data=1和meth(self,arg),继承Eggs。字典示意包括data、meth与module;它用于说明输入结构,不是逐字复现现代class语句全部隐含状态和准备步骤。类体失败或创建入口失败都不会得到所期待的新类。

在通常type调用协议下,new负责产生对象,符合条件后init初始化它;不能把两者都叫“创建实例之后运行的方法”,这里产生的是类对象。元类自身与普通业务类的构造处在不同层级。

913的02489-02495给class Spam(Eggs,metaclass=Meta)与旧2.6 class spam(object): metaclass=Meta。3中旧类体写法只保留普通属性而不选择元类;旧模块级metaclass也不是3的替代配置。Spam继承Eggs同时作为Meta实例,传Meta的三项输入仍为名称、基类、命名空间;new接收Meta本身,init接收已经创建的Spam。

类体命名空间交给创建入口保存独立卡片。

原书依据 · 2 处

声明元类

元类声明选择类创建入口,基类列表仍独立表达继承关系。新旧Python声明语法不同,旧类体字段不能直接当Python3元类配置。

类体命名空间交给创建入口关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处

编写元类

元类可以用常规class语法编写,type子类式实现通过协议方法参与类的构建和初始化。

基本元类

最小type子类先截取创建请求,再委托type.new,从而保留类对象的正常构造路径。输出时序把建类和建实例分开。

元类构建钩子先于实例创建

MetaOne(type)可以在new里处理类定义,再把参数交给type.new真正建立类。Spam继承Eggs,同时以MetaOne为元类;X=Spam()是另一次调用,才产生普通业务实例。不能把Spam类的创建打印当X初始化打印。

结构图:

classDiagram
class type
class MetaOne {
 __new__(meta, classname, supers, classdict)
}
class Eggs
class Spam {
 data
 meth(self, arg)
}
type <|-- MetaOne
Eggs <|-- Spam
MetaOne ..> Spam : 创建其类对象

图取02497-02499的实际类与签名:Eggs为空类,Spam.data=1,meth体为pass。MetaOne先输出收到的信息,随后return type.new(meta,classname,supers,classdict),使Spam确实成为该元类实例。普通类型创建钩子也可在此失败;图示的成功输出不等于所有输入都能创建。

916的02500-02502是MetaOne的另一版,增加init(Class,classname,supers,classdict),输出Class.dict的键而不返回新类;new仍return type.new(meta,…)。

结构图:

classDiagram
class MetaOne {
 __new__(meta, classname, supers, classdict)
 __init__(Class, classname, supers, classdict)
}

Class是新Spam类对象,不是元类本身;meta才是MetaOne。init的职责是初始化,不拿其返回值替代new生成的类。它输出的字典还含type创建时生成的条目,因此不能要求其键集合逐字等于传入classdict。

元类构建钩子先于实例创建保存独立卡片。

原书依据 · 2 处
定制构建和初始化

new返回类对象后,元类init可初始化这个已有类。二者位于同一次建类流程,仍早于示例的普通实例构造。

元类构建钩子先于实例创建关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
其他元类编程技巧

同样的类创建入口可以由函数工厂、元类的元类或普通可调用实例提供。关键是明确正被调用的对象及其类型,不能把不同层级的call混作同一钩子。

调用钩子随对象层级上移

调用某个对象时,调用钩子来自它的类型。要截获SubMeta(…)创建业务类,需让SubMeta的元类SuperMeta定义call;直接给SubMeta定义call通常截获的是它所创建业务类的调用,即构造普通实例,层级不同。

结构图:

classDiagram
class SuperMeta {
 __call__(meta, classname, supers, classdict)
}
class SubMeta {
 __new__(meta, classname, supers, classdict)
 __init__(Class, classname, supers, classdict)
}
class type
class Eggs
class Spam {
 data
 meth(self, arg)
}
type <|-- SuperMeta
type <|-- SubMeta
SuperMeta ..> SubMeta : 是其元类
SubMeta ..> Spam : 是其元类
Eggs <|-- Spam

图取02505-02507。SuperMeta.call先输出,再委托type.call,于是依次进入SubMeta.new和init。这里SubMeta与SuperMeta不是继承链,二者各从type继承;虚线表示实例关系。

02503-02504还给更简单的MetaFunc(classname,supers,classdict)工厂,直接return type(…),所以元类位置不一定必须是type子类。02508的另一种替代是普通SuperMeta/SubMeta及可调用的SubMeta()实例;辅助方法特意叫New和Init,由普通call手动调度,避免与创建工厂实例自身的构造钩子混淆。它创建的业务类由普通type(…)产生,不应误说成SubMeta的类型实例。

调用钩子随对象层级上移保存独立卡片。

原书依据 · 1 处
实例与继承的关系

元类可以继续参与子类创建,但普通实例不会把元类当业务超类搜索。把创建时使用某机制与继承该机制的属性分开理解。

元类声明传播不等于属性继承

一个类的子类通常会沿基类关系继续使用兼容的元类,因此元类可处理后续子类的创建;这不等于普通实例会从元类继承属性。实例查找走自己的类及超类,元类层的属性是给类对象使用的。

结构图:

classDiagram
class MetaOne {
 __new__(meta, classname, supers, classdict)
 toast(self)
}
class Super {
 spam(self)
}
class C {
 eggs(self)
}
Super <|-- C
MetaOne ..> Super : 创建类
MetaOne ..> C : 子类继续选用该元类

02509-02510中X=C()可调用eggs与继承来的spam,X.toast()却报AttributeError。MetaOne处理Super和C两次创建,不是在X上安装toast;若想给实例提供该方法,需显式添加到业务类或其超类。

这种传播还受实际元类选择和兼容性约束,不能扩成任意继承组合都无冲突。更新元类逻辑影响之后的构造,也不保证已存在的全部类会自动重新执行扩展。

元类声明传播不等于属性继承保存独立卡片。

原书依据 · 1 处

示例:向类添加方法

后面用添加方法和批量装饰两个实例对照元类与类装饰器,展示它们既可替代也可组合。

手动扩展

类对象可在创建后增加普通函数属性,随后实例访问仍会按方法协议绑定。手动做法有效,但每个客户类都需重复安装相同扩展。

类后赋函数仍能绑定实例

独立定义的函数赋给类属性后,仍可通过实例作为方法调用。函数的首参数接收该实例,名称叫obj或self均不改变绑定语义。它可读取主体字段,不要求函数原本就写在类体内;把函数赋给单个实例则是另一种情况,不能直接套用该结论。

结构图:

classDiagram
class Client1 {
 value
 __init__(self, value)
 spam(self)
 eggs(obj)
 ham(obj, value)
}
class Client2 {
 value
 eggs(obj)
 ham(obj, value)
}

图取02511-02513的扩展后接口:eggs由eggsfunc(obj)赋入,读取obj.value并乘4;ham由hamfunc(obj,value)赋入,返回参数value加ham,不读取主体value。Client1的spam读取其value乘2;Client2的value为类字段。两个类各要重复两次赋值,是本例后续集中扩展要减少的重复。

921的02514-02515定义Extender(type).new(meta,classname,supers,classdict),先把eggsfunc/hamfunc填到classdict的eggs/ham键,再return type.new。Client1/Client2只声明metaclass=Extender,结果接口与920相同。写入同名键会替换原定义,示例没有冲突处理。02516的MetaExtend分支用sometest/someothertest选择实现,属于未完整定义的动态配置骨架,不是已运行的新能力;未来修改影响以后建类,不意味着现有所有类自动重建。

类后赋函数仍能绑定实例保存独立卡片。

原书依据 · 2 处
基于元类的扩展

把共同安装步骤移入元类new,可在构造类对象前统一修改其命名空间。固定添加同样两方法也可用继承完成,元类的额外价值要由实际动态需求说明。

类后赋函数仍能绑定实例关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处
元类与类装饰器的关系:第二回合

类装饰器可修改已创建原类,也可返回包装类。函数式元类入口亦能先创建主体类再返回包装类,但这说明构造模式可组合,不代表二者所有行为完全等价。

类装饰与元类作用阶段不同关联本项背景,实质主要讲解在对应位置。

包装追踪发生在属性取得时关联本项背景,实质主要讲解在对应位置。

原书依据 · 9 处

示例:对方法应用装饰器

把函数装饰器的调用管理与元类的类创建管理组合,可集中安装方法扩展。

用装饰器手动跟踪

手动给各方法装饰仍是有效方案,包装函数保留方法绑定,计数与耗时状态按被包装方法保存。

计数状态应按装饰目标隔离关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
用元类和装饰器跟踪

元类在类创建时扫描并替换符合条件的函数,再由包装器管理实际调用。集中安装并不会自动扩大可支持的成员类型。

批量装饰受扫描范围限制

MetaTrace(type)在new遍历本次classdict,对type(attrval) is FunctionType的成员替换为tracer(attrval),随后type.new创建类。它集中安装调用包装,但“每个方法”必须按实际扫描条件理解。

结构图:

classDiagram
class MetaTrace {
 __new__(meta, classname, supers, classdict)
}
class Person {
 name
 pay
 __init__(self, name, pay)
 giveRaise(self, percent)
 lastName(self)
}
MetaTrace ..> Person : 替换类体函数再建类

图取02528-02529。本例三种方法都是本次类体中的普通函数,因此都会被替换,连init也包括。继承而未在本次字典出现的方法不在扫描范围;staticmethod、classmethod、property等描述符对象也不满足该精确FunctionType条件,不能宣称已按相同方式包装。

元类负责安装时机,tracer负责之后的调用计数与转发。包装器要能保持方法绑定及目标契约,否则批量安装会把错误扩散到所有命中成员。

926的02530-02534定义decorateAll(decorator),返回嵌套MetaDecorate(type),其new仍只替换FunctionType成员。可以传tracer或timer()、timer(label=…)。每次decorator(attrval)产生对应方法包装,因此各方法累计状态独立,配置label等共享外层参数,不是整类所有方法共用一个总耗时字段。原书末尾读取Person各方法.alltime,计时数字只为旧例输出。

927的02535-02540改为decorateAll(decorator)→DecoDecorate(aClass),遍历aClass.dict.items(),用setattr(aClass,attr,decorator(attrval))替换已有函数,最后return aClass。类的字典视图不能直接赋值,所以用setattr;没有新实例代理层,方法函数本身却已替换。扫描仍不遍历继承成员,也不直接处理描述符。timer配置同样统一,累计按方法;装饰器不会因子类化自动重新执行。

批量装饰受扫描范围限制保存独立卡片。

原书依据 · 3 处
把任何装饰器应用于方法

外层工厂可以把要批量应用的装饰器保存到闭包,使跟踪与计时复用同一安装逻辑。配置统一用于所有命中方法,单个方法并没有独立配置接口。

批量装饰受扫描范围限制关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
元类与类装饰器的关系:第三回合

类装饰器也可集中改原类方法并返回原类,从而保留主体类型。扩展机制可互补,但采用高级工具还需考虑读者和维护者的理解成本。

批量装饰受扫描范围限制关联本项背景,实质主要讲解在对应位置。

原书依据 · 3 处
高级机制也增加协作成本

一种语言机制对作者可选,对维护使用它的代码的人却可能成为必要知识。引入元类、描述符或复杂装饰链时,局部代码减少的重复,应和阅读、排错及团队交接所增加的理解成本一起评估。

原书并非要求禁止高级工具:它们可封装重复规则并形成有用API。选择应由实际问题与维护者需求解释,而不是只因作者熟悉或觉得技巧有趣;同样,也不能要求每个用户都掌握库的所有内部实现,理解深度随使用和修改任务而异。

高级机制也增加协作成本保存独立卡片。

原书依据 · 1 处

本章小结

本章收束类创建协议、集中扩展与装饰器组合,接下来是基础习题与安装配置附录。

本章习题

四题要求解释元类、声明语法及两类工具管理类/实例的交集。

习题解答

答案回顾元类创建入口及装饰器重绑定。元类不只可在创建后扩展,也能在new中先改变命名空间,前面的完整示例已展示这一点。

第九部分 附录

本部分为安装配置与练习答案附录。

附录A 安装和配置

安装配置附录解释如何取得解释器、区分PATH与模块搜索路径、用环境或启动选项调整行为。它的大量平台细节针对旧Windows与早期Python,适合识别配置层次而不是照抄命令。排查运行差异时,应先确认解释器、入口、继承环境与配置作用范围。

附录A补充安装和配置背景。

安装Python解释器

运行源码通常需要合适解释器;随冻结或自包含应用交付的运行环境可能由发行包处理。

Python已经存在了吗

检查是否已有解释器还需确认其版本和项目兼容性,旧书的2.6⁄3.0建议只反映其写作时期。

从哪里获取Python

作者列出官方发行入口、平台移植和打包发行版,说明解释器实现与发行形式可以不同。

安装步骤

安装方式随平台和发行包改变,应按对应版本说明处理。本文是旧Windows/MSI、Linux包及UNIX源码安装的历史背景。

配置Python

环境变量和启动选项可以影响解释器行为,基础运行未必需要额外系统配置。

Python环境变量

环境变量各有职责:PATH找程序,PYTHONPATH扩充模块路径,PYTHONSTARTUP用于交互准备,GUI库另有自身配置。

模块搜索路径不同于程序搜索路径关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处
交互启动文件不同于脚本入口

PYTHONSTARTUP可指向一个Python代码文件,在常规交互解释器启动时执行,用于预先导入工具等交互准备。它与运行某个脚本的顶层代码不是同一入口,不能把所有脚本启动或所有IDE界面都推断为必经该文件。

这类配置来自Python进程之外,要在对应启动前让该进程获得所需值。环境中的路径是将被解释器执行的代码位置,迁移环境时应明确文件归属和作用范围;本例没有设置变量或实际执行启动文件。

交互启动文件不同于脚本入口保存独立卡片。

原书依据 · 1 处
如何设定配置选项

配置的语法、持久性与被哪个启动进程继承是不同问题。PYTHONPATH与站点路径文件也有各自格式和生效位置。

路径配置作用范围要明确关联本项背景,实质主要讲解在对应位置。

路径配置文件由站点机制处理关联本项背景,实质主要讲解在对应位置。

原书依据 · 8 处
Python命令行选项

解释器先消费自己的启动选项,再把程序参数交给脚本;-c、-m、文件和标准输入是不同的代码入口,sys.argv首项随入口而不同。

命令行字符串须解析并校验关联本项背景,实质主要讲解在对应位置。

主程序保护区分入口与导入关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处

寻求更多帮助

平台配置细节应查对应解释器版本的Using Python文档;图书中的平台细节会随时间失效。

附录B 各部分练习题的解答

答案附录把基本类型、控制流、函数、模块、类和异常重新放入可观察例子。它既帮助核对正常结果,也暴露教学代码的简化前提,例如空输入、浮点质数、包装返回类型和错误后的继续执行。后半应用示例展示组合能力,但旧接口与外部副作用使它们不能直接成为现实部署方案。

附录B提供前面各部分习题答案。

第一部分 使用入门

入门答案对照交互、脚本、导入与可执行文件入口,并用自引用列表说明对象引用与遍历的区别。

循环显示被省略不代表遍历安全关联本项背景,实质主要讲解在对应位置。

原书依据 · 2 处

第二部分 类型和运算

类型习题通过索引/切片、赋值、字典、不可变字符串与文件操作复习已有规则;具体容器协议和边界决定结果。

字典按键映射而非按位置数组关联本项背景,实质主要讲解在对应位置。

切片默认边界随步长方向变化关联本项背景,实质主要讲解在对应位置。

原书依据 · 5 处

第三部分 语句和语法

语法习题用循环收集字符码、排序字典键、查找列表中的幂值,比较多种等价写法。

原地修改不同于返回新容器关联本项背景,实质主要讲解在对应位置。

原书依据 · 7 处

第四部分 函数

函数答案复习多态、参数匹配、归约、字典复制合并、质数边界和计时比较。返回值及输入前提比某一组正常输出更能说明可复用契约。

归约初始值决定输入边界关联本项背景,实质主要讲解在对应位置。

质数示例需先限定整数与下界关联本项背景,实质主要讲解在对应位置。

比较惰性方案须消费相同结果关联本项背景,实质主要讲解在对应位置。

原书依据 · 8 处

第五部分 模块

模块练习把文件统计函数、入口保护、名称再导出、普通包与循环导入组合起来。读同一文件对象的两轮统计还需处理其当前位置。

读取方式决定物化范围关联本项背景,实质主要讲解在对应位置。

文本流位置不直接等同字节偏移关联本项背景,实质主要讲解在对应位置。

循环导入可见未完成的模块关联本项背景,实质主要讲解在对应位置。

原书依据 · 6 处

第六部分 类和OOP

OOP答案比较继承分派、容器包装、计数、可变参数集合和对象组合。同样显示结果不保证返回类型、协议覆盖及状态共享都符合预期。

容器包装控制暴露的操作关联本项背景,实质主要讲解在对应位置。

每类计数需要独立更新目标关联本项背景,实质主要讲解在对应位置。

多态调用分派按接收对象解析关联本项背景,实质主要讲解在对应位置。

继承与组合表达不同关系关联本项背景,实质主要讲解在对应位置。

原书依据 · 14 处

第七部分 异常和工具

异常答案复习匹配、异常对象与调用边界;后半给文件统计、回归输出、GUI、邮箱、CGI和持久化的小型应用,适合观察组合机制但不构成完整可靠工具。

捕获位置应能决定恢复关联本项背景,实质主要讲解在对应位置。

测试失败与进程继续分离关联本项背景,实质主要讲解在对应位置。

原书依据 · 4 处
定时回调以状态决定续约

GUI定时回调可先检查状态,再决定本次更新以及是否安排下一次调用。MyGui.grow把growing置True并立即调用grower;grower仅在growing为真时增大字体、更新标签,再通过lab.after(500,self.grower)安排下一轮;stop只把状态置False。

结构图:

classDiagram
class MyGui {
 colors
 growing
 fontsize
 lab
 __init__(self, parent, title)
 reply(self)
 grow(self)
 grower(self)
 stop(self)
}
class MySubGui {
 colors
}
MyGui <|-- MySubGui

图取02636-02637的实际类式版本,title默认popup;它与02635-02636的全局timer/grow版本是替代定义。每个MyGui实例的growing/fontsize/lab独立,colors可由子类覆写;绑定回调带回相应实例。

stop没有显式取消队列里的任务,已排回调到来时会因状态为假而不再更新/续约。反复点击Grow会再次立即调用grower并安排任务,本例没有保存任务标识或去重,因此不能承诺任何时刻只存在一条定时链,也不构成生产级任务生命周期管理。

定时回调以状态决定续约保存独立卡片。

原书依据 · 1 处

作者介绍

本节介绍Mark Lutz的写作、培训与工作背景,数字截止原书时期。

封面介绍

封面文字介绍林鼠及版画来源。

跨章综合

对象引用是第一条跨章主线。名称赋值、容器元素、函数参数、模块导入和实例字段都可能指向同一对象;是否共享取决于对象归属和修改方式,而非名称看起来是否不同。浅复制只复制一层容器,闭包保留绑定访问,装饰器又可能把共享状态移到包装函数或管理器上。这些现象可用同一问题追踪:状态在哪里,谁持有引用,什么时候新建一份。

协议是第二条主线。迭代、调用、属性、显示、索引和上下文退出都把某种操作交给指定入口;实现某个入口不会自动实现其他协议。一个对象能在示例里打印或遍历,不等于能安全替代完整主体类型。类层的特殊方法、实例普通字段与描述符的优先级一起决定真实分派路径。

边界与失败是第三条主线。文本跨到字节需要编码契约,函数调用需要参数契约,模块导入需要初始化状态,类构建需要元类协议。异常能把失败带到合适位置,但捕获、清理和恢复必须分别解释。只有把成功、失败和未执行的分支都交代清楚,包装和自动化才不会把局部错误扩大。

最后,简洁的语法不等于没有成本。生成器可以推迟工作,计时可能把工作漏掉;元类可以减少重复,也可能提高维护者的理解门槛。先选择任务真正需要的机制,再用证据检查其边界,比追求最短代码或最复杂工具更可靠。

发散与实践

以下是读者延伸,交付的是有限范围阅读计划及已初读的一手材料,没有执行完整实验或业务动作。

第一条路线以CPython固定提交核对描述符、property与函数绑定的实际分派,回答同名实例字段何时能覆盖类属性。描述符读取计划包含90分钟顺序、代码入口和待完成对照。

第二条路线追踪importlib在缓存、执行和失败清理之间的状态变化,回答为何取得模块对象不等于其字段全部就绪。导入状态计划列出固定源码、缓存测试与未覆盖的并发问题。

两条路线优先阅读成熟实现,避免为演示重建解释器或修改真实项目。计时排名、旧版安装、邮箱维护与数据库操作等候选没有扩成现实行动;它们或缺明确需求,或受时代与副作用限制。

生成进度与管理记录

Python学习手册(原书第4版)

类别:编程语言类

四象限结论:经典原理(高浓度 + 高稳定性)

阶段一:整体评级

四象限结论:经典原理 判断理由:虽然覆盖 Python 2.6⁄3.0 时代差异,但主体讲的是对象模型、动态类型、作用域、函数、模块、类、异常、迭代和元编程等语言基础,信息浓度高且稳定性强。

阶段二:章节重点确认

章节号 章节标题 精读/略读 状态(pending/done) 卡片数
01 第1章 问答环节 精读 done 17
02 第2章 Python如何运行程序 精读 done 12
03 第3章 如何运行程序 精读 done 31
04 第4章 介绍Python对象类型 精读 done 44
05 第5章 数字 精读 done 27
06 第6章 动态类型简介 精读 done 4
07 第7章 字符串 精读 done 27
08 第8章 列表与字典 精读 done 19
09 第9章 元组、文件及其他 精读 done 18
10 第10章 Python语句简介 精读 done 12
11 第11章 赋值、表达式和打印 精读 done 18
12 第12章 if测试和语法规则 精读 done 8
13 第13章 while和for循环 精读 done 16
14 第14章 迭代器和解析,第一部分 精读 done 11
15 第15章 文档 精读 done 10
16 第16章 函数基础 精读 done 10
17 第17章 作用域 精读 done 16
18 第18章 参数 精读 done 18
19 第19章 函数的高级话题 精读 done 17
20 第20章 迭代和解析,第二部分 精读 done 21
21 第21章 模块:宏伟蓝图 精读 done 8
22 第22章 模块代码编写基础 精读 done 4
23 第23章 模块包 精读 done 7
24 第24章 高级模块话题 精读 done 12
25 第25章 OOP:宏伟蓝图 精读 done 9
26 第26章 类代码编写基础 精读 done 10
27 第27章 更多实例 精读 done 27
28 第28章 类代码编写细节 精读 done 10
29 第29章 运算符重载 精读 done 24
30 第30章 类的设计 精读 done 16
31 第31章 类的高级主题 精读 done 14
32 第32章 异常基础 精读 done 4
33 第33章 异常编码细节 精读 done 9
34 第34章 异常对象 精读 done 5
35 第35章 异常的设计 精读 done 8
36 第36章 Unicode和字节字符串 精读 done 13
37 第37章 管理属性 精读 done 10
38 第38章 装饰器 精读 done 12
39 第39章 元类 精读 done 7
40 附录A 安装和配置 略读 done 1
41 附录B 各部分练习题的解答 略读 done 1

来源说明

本书来自合集 EPUB《OReilly精品图书系列共21册(《Javascript权威指南》、《机器学习:实用案例解析》、《编写可读代码的艺术》、《算法精解》等)》;合集实际 one-based spine 范围为 416–1162(历史 415..1161 为 zero-based 下标),已按单本书独立建目录与卡片。

类别清单核对(编程语言类)

维度 覆盖状态(已覆盖/补充生成/未覆盖) 关联卡片标题或未覆盖理由
类型系统 已覆盖 动态对象、接口与类型判断、数值/容器协议均有卡片。
内存管理模型 已覆盖 引用共享、循环回收、浅复制与文件上下文;不声称涵盖解释器全部内存优化。
并发/并行模型 未覆盖 本书未系统展开线程/协程/内存可见性;生成器及单例缓存不当并发模型。
错误处理机制 已覆盖 第32–35章异常传播、层级、清理、恢复与测试工具。
编译/执行模型 已覆盖 解释器、字节码缓存、实现差异及入口语义。
模块/包与命名空间设计 已覆盖 作用域、import/from、包入口、缓存与循环导入。
语言设计哲学与取舍 已覆盖 《动态类型》《可变性边界》说明灵活性、约定和状态边界的取舍。
元编程/反射/宏能力 已覆盖 描述符/特性/钩子、装饰器与元类;不扩成文本宏能力。
性能特性与其代价 已覆盖 《迭代协议》说明惰性计算节省内存及一次性迭代器边界。

2026-10-28 本批恢复

执行模式:light

本次实际执行版本:book-workflow v4 / book-notes v23,保留历史首次版本、5张旧卡路径与数据库身份。

继承原经典原理评级:对象模型、名称绑定、函数作用域、模块、类与异常等实质机制浓度高且可迁移;Python2.6⁄3.0接口与历史工具不能当现行版本保证。默认概念解析型,局部操作条目按实际手册结构取材。旧精读/略读和零卡done不构成本轮有效阅读证据。

建档进度:done

实践候选筛选:done(2张实现深读计划,首轮源码映射已准备;完整实践未执行)

当前章节进度
章节号 章节标题 状态 卡片数
spine-420 译者序 done 0
spine-421 前言 done 0
spine-422 关于第4版 done 1
spine-423 新增章 done 0
spine-424 已有内容的修改 done 1
spine-425 Python 2.6和Python 3.0中的特定语言扩展 done 0
spine-426 Python 3.0中特定的语言删除 done 2
spine-427 关于本书 done 0
spine-428 本书的范围和其他书籍 done 0
spine-429 本书的风格和结构 done 0
spine-430 书籍更新 done 0
spine-431 关于本书的程序 done 0
spine-432 使用代码示例 done 0
spine-433 体例 done 1
spine-434 联系我们 done 0
spine-435 致谢 done 0
spine-436 第一部分 使用入门 done 5
spine-437 开发效率 done 0
spine-438 Python是“脚本语言”吗 done 1
spine-439 好吧,Python的缺点是什么呢 done 2
spine-440 如今谁在使用Python done 1
spine-441 使用Python可以做些什么 done 0
spine-442 用户图形接口 done 0
spine-443 Internet脚本 done 0
spine-444 组件集成 done 0
spine-445 数据库编程 done 2
spine-446 快速原型 done 0
spine-447 数值计算和科学计算编程 done 0
spine-448 游戏、图像、人工智能、XML、机器人等 done 0
spine-449 Python如何获得支持 done 1
spine-450 Python有哪些技术上的优点 done 1
spine-451 免费 done 1
spine-452 可移植 done 0
spine-453 功能强大 done 3
spine-454 可混合 done 0
spine-455 简单易用 done 0
spine-456 简单易学 done 0
spine-457 Python和其他语言比较起来怎么样 done 0
spine-458 本章小结 done 0
spine-459 本章习题 done 0
spine-460 习题解答 done 1
spine-461 第2章 Python如何运行程序 done 1
spine-462 程序执行 done 1
spine-463 Python的视角 done 3
spine-464 执行模块的变体 done 1
spine-465 执行优化工具 done 2
spine-466 冻结二进制文件 done 2
spine-467 其他执行选项 done 2
spine-468 未来的可能性 done 0
spine-469 本章小结 done 0
spine-470 本章习题 done 0
spine-471 习题解答 done 0
spine-472 第3章 如何运行程序 done 2
spine-473 为什么使用交互提示模式 done 2
spine-474 使用交互提示模式 done 2
spine-475 系统命令行和文件 done 1
spine-476 使用命令行运行文件 done 2
spine-477 使用命令行和文件 done 2
spine-478 UNIX可执行脚本(#!) done 2
spine-479 点击文件图标 done 0
spine-480 input的技巧 done 2
spine-481 图标点击的其他限制 done 0
spine-482 模块导入和重载 done 5
spine-483 import和reload的使用注意事项 done 1
spine-484 使用exec运行模块文件 done 1
spine-485 IDLE用户界面 done 2
spine-486 使用IDLE done 2
spine-487 高级IDLE工具 done 1
spine-488 其他的IDE done 1
spine-489 其他启动选项 done 0
spine-490 冻结二进制的可执行性 done 0
spine-491 文本编辑器启动的选择 done 0
spine-492 其他的启动选择 done 0
spine-493 未来的可能 done 0
spine-494 我应该选用哪种 done 2
spine-495 本章小结 done 0
spine-496 本章习题 done 0
spine-497 习题解答 done 0
spine-498 第一部分 练习题 done 1
spine-499 第二部分 类型和运算 done 6
spine-500 数字 done 3
spine-501 字符串 done 4
spine-502 不可变性 done 1
spine-503 类型特定的方法 done 3
spine-504 寻求帮助 done 1
spine-505 编写字符串的其他方法 done 3
spine-506 模式匹配 done 1
spine-507 列表 done 0
spine-508 类型特定的操作 done 2
spine-509 边界检查 done 1
spine-510 嵌套 done 1
spine-511 列表解析 done 4
spine-512 字典 done 1
spine-513 重访嵌套 done 0
spine-514 键的排序:for循环 done 2
spine-515 迭代和优化 done 2
spine-516 不存在的键:if测试 done 2
spine-517 元组 done 1
spine-518 文件 done 3
spine-519 其他核心类型 done 4
spine-520 用户定义的类 done 1
spine-521 剩余的内容 done 0
spine-522 本章小结 done 0
spine-523 本章习题 done 0
spine-524 习题解答 done 0
spine-525 第5章 数字 done 3
spine-526 内置数学工具和扩展 done 1
spine-527 Python表达式操作符 done 5
spine-528 在实际应用中的数字 done 1
spine-529 数字显示的格式 done 0
spine-530 比较:一般的和连续的 done 1
spine-531 除法:传统除法、Floor除法和真除法 done 2
spine-532 整数精度 done 0
spine-533 复数 done 0
spine-534 十六进制、八进制和二进制记数 done 1
spine-535 位操作 done 2
spine-536 其他的内置数学工具 done 2
spine-537 其他数字类型 done 2
spine-538 分数类型 done 2
spine-539 集合 done 4
spine-540 布尔型 done 1
spine-541 数字扩展 done 0
spine-542 本章小结 done 0
spine-543 本章习题 done 0
spine-544 习题解答 done 0
spine-545 第6章 动态类型简介 done 1
spine-546 类型属于对象,而不是变量 done 0
spine-547 对象的垃圾收集 done 1
spine-548 共享引用 done 1
spine-549 共享引用和相等 done 0
spine-550 动态类型随处可见 done 0
spine-551 本章小结 done 0
spine-552 本章习题 done 0
spine-553 习题解答 done 0
spine-554 第7章 字符串 done 3
spine-555 用转义序列代表特殊字节 done 1
spine-556 raw字符串抑制转义 done 0
spine-557 三重引号编写多行字符串块 done 1
spine-558 实际应用中的字符串 done 1
spine-559 索引和分片 done 2
spine-560 字符串转换工具 done 2
spine-561 修改字符串 done 0
spine-562 字符串方法 done 2
spine-563 字符串方法实例:文本解析 done 2
spine-564 实际应用中的其他常见字符串方法 done 1
spine-565 最初的字符串模块(在Python 3.0中删除) done 1
spine-566 字符串格式化表达式 done 3
spine-567 基于字典的字符串格式化 done 1
spine-568 字符串格式化调用方法 done 1
spine-569 添加键、属性和偏移量 done 1
spine-570 添加具体格式化 done 3
spine-571 与%格式化表达式比较 done 1
spine-572 为什么用新的格式化方法 done 1
spine-573 通常意义下的类型分类 done 0
spine-574 可变类型能够在原处修改 done 0
spine-575 本章小结 done 0
spine-576 本章习题 done 0
spine-577 习题解答 done 0
spine-578 第8章 列表与字典 done 1
spine-579 实际应用中的列表 done 1
spine-580 列表迭代和解析 done 0
spine-581 索引、分片和矩阵 done 0
spine-582 原处修改列表 done 5
spine-583 字典 done 1
spine-584 实际应用中的字典 done 1
spine-585 原处修改字典 done 0
spine-586 其他字典方法 done 1
spine-587 语言表 done 1
spine-588 字典用法注意事项 done 2
spine-589 创建字典的其他方法 done 2
spine-590 Python 3.0中的字典变化 done 3
spine-591 本章小结 done 0
spine-592 本章习题 done 0
spine-593 习题解答 done 0
spine-594 第9章 元组、文件及其他 done 1
spine-595 为什么有了列表还要元组 done 0
spine-596 文件 done 2
spine-597 使用文件 done 2
spine-598 实际应用中的文件 done 5
spine-599 其他文件工具 done 1
spine-600 重访类型分类 done 1
spine-601 对象灵活性 done 0
spine-602 引用VS拷贝 done 0
spine-603 比较、相等性和真值 done 1
spine-604 Python中真和假的含义 done 1
spine-605 Python的类型层次 done 1
spine-606 Type对象 done 1
spine-607 Python中的其他类型 done 0
spine-608 赋值生成引用,而不是拷贝 done 0
spine-609 重复能够增加层次深度 done 0
spine-610 留意循环数据结构 done 1
spine-611 不可变类型不可以在原处改变 done 0
spine-612 本章小结 done 0
spine-613 本章习题 done 0
spine-614 习题解答 done 0
spine-615 第二部分 练习题 done 1
spine-616 第三部分 语句和语法 done 2
spine-617 两个if的故事 done 1
spine-618 Python删除了什么 done 2
spine-619 为什么使用缩进语法 done 1
spine-620 几个特殊实例 done 2
spine-621 简短实例:交互循环 done 1
spine-622 对用户输入数据做数学运算 done 0
spine-623 用测试输入数据来处理错误 done 1
spine-624 用try语句处理错误 done 2
spine-625 嵌套代码三层 done 0
spine-626 本章小结 done 0
spine-627 本章习题 done 0
spine-628 习题解答 done 0
spine-629 第11章 赋值、表达式和打印 done 1
spine-630 序列赋值 done 1
spine-631 Python 3.0中的扩展序列解包 done 2
spine-632 多目标赋值语句 done 1
spine-633 增强赋值语句 done 1
spine-634 变量命名规则 done 3
spine-635 表达式语句 done 1
spine-636 打印操作 done 3
spine-637 Python 2.6 print语句 done 1
spine-638 打印流重定向 done 2
spine-639 版本独立的打印 done 2
spine-640 本章小结 done 0
spine-641 本章习题 done 0
spine-642 习题解答 done 0
spine-643 第12章 if测试和语法规则 done 0
spine-644 基本例子 done 0
spine-645 多路分支 done 1
spine-646 Python语法规则 done 0
spine-647 语句的分隔符 done 0
spine-648 一些特殊情况 done 1
spine-649 真值测试 done 1
spine-650 if/else三元表达式 done 5
spine-651 本章小结 done 0
spine-652 本章习题 done 0
spine-653 习题解答 done 0
spine-654 第13章 while和for循环 done 1
spine-655 例子 done 1
spine-656 break、continue、pass和循环else done 1
spine-657 一般循环格式 done 0
spine-658 pass done 2
spine-659 continue done 0
spine-660 break done 0
spine-661 循环else done 1
spine-662 for循环 done 0
spine-663 一般格式 done 1
spine-664 例子 done 2
spine-665 编写循环的技巧 done 2
spine-666 非完备遍历:range和分片 done 1
spine-667 修改列表:range done 1
spine-668 并行遍历:zip和map done 2
spine-669 产生偏移和元素:enumerate done 1
spine-670 本章小结 done 0
spine-671 本章习题 done 0
spine-672 习题解答 done 0
spine-673 第14章 迭代器和解析,第一部分 done 1
spine-674 手动迭代:iter和next done 2
spine-675 其他内置类型迭代器 done 0
spine-676 列表解析:初探 done 0
spine-677 在文件上使用列表解析 done 1
spine-678 扩展的列表解析语法 done 2
spine-679 其他迭代环境 done 3
spine-680 Python 3.0中的新的可迭代对象 done 0
spine-681 map、zip和filter迭代器 done 1
spine-682 多个迭代器VS单个迭代器 done 0
spine-683 字典视图迭代器 done 0
spine-684 其他迭代器主题 done 0
spine-685 本章小结 done 0
spine-686 本章习题 done 0
spine-687 习题解答 done 0
spine-688 第15章 文档 done 2
spine-689 dir函数 done 1
spine-690 文档字符串:doc done 2
spine-691 PyDoc:help函数 done 1
spine-692 PyDoc:HTML报表 done 2
spine-693 标准手册集 done 0
spine-694 网络资源 done 0
spine-695 已出版的书籍 done 1
spine-696 常见编写代码的陷阱 done 0
spine-697 本章小结 done 0
spine-698 本章习题 done 0
spine-699 习题解答 done 0
spine-700 第三部分 练习题 done 1
spine-701 第四部分 函数 done 2
spine-702 编写函数 done 3
spine-703 def语句是实时执行的 done 2
spine-704 第一个例子:定义和调用 done 0
spine-705 调用 done 0
spine-706 Python中的多态 done 1
spine-707 第二个例子:寻找序列的交集 done 0
spine-708 调用 done 0
spine-709 重访多态 done 1
spine-710 本地变量 done 1
spine-711 本章小结 done 0
spine-712 本章习题 done 0
spine-713 习题解答 done 0
spine-714 第17章 作用域 done 3
spine-715 变量名解析:LEGB原则 done 2
spine-716 作用域实例 done 0
spine-717 内置作用域 done 2
spine-718 global语句 done 1
spine-719 最小化文件间的修改 done 1
spine-720 其他访问全局变量的方法 done 0
spine-721 作用域和嵌套函数 done 0
spine-722 嵌套作用域举例 done 4
spine-723 nonlocal语句 done 0
spine-724 nonlocal应用 done 1
spine-725 为什么使用nonlocal done 2
spine-726 本章小结 done 0
spine-727 本章习题 done 0
spine-728 习题解答 done 0
spine-729 第18章 参数 done 0
spine-730 避免可变参数的修改 done 1
spine-731 对参数输出进行模拟 done 1
spine-732 特定的参数匹配模型 done 3
spine-733 匹配语法 done 2
spine-734 细节 done 2
spine-735 关键字参数和默认参数的实例 done 0
spine-736 任意参数的实例 done 2
spine-737 Python 3.0 Keyword-Only参数 done 0
spine-738 min调用 done 1
spine-739 满分 done 3
spine-740 加分点 done 1
spine-741 结论 done 0
spine-742 一个更有用的例子:通用set函数 done 0
spine-743 模拟Python 3.0 print函数 done 2
spine-744 本章小结 done 0
spine-745 本章习题 done 0
spine-746 习题解答 done 0
spine-747 第19章 函数的高级话题 done 1
spine-748 递归函数 done 2
spine-749 编码替代方案 done 2
spine-750 循环语句VS递归 done 1
spine-751 处理任意结构 done 2
spine-752 函数对象:属性和注解 done 0
spine-753 函数内省 done 1
spine-754 函数属性 done 0
spine-755 Python 3.0中的函数注解 done 2
spine-756 匿名函数:lambda done 2
spine-757 为什么使用lambda done 1
spine-758 如何(不要)让Python代码变得晦涩难懂 done 0
spine-759 嵌套lambda和作用域 done 1
spine-760 在序列中映射函数:map done 1
spine-761 函数式编程工具:filter和reduce done 1
spine-762 本章小结 done 0
spine-763 本章习题 done 0
spine-764 习题解答 done 0
spine-765 第20章 迭代和解析,第二部分 done 0
spine-766 增加测试和嵌套循环 done 0
spine-767 列表解析和矩阵 done 2
spine-768 理解列表解析 done 1
spine-769 重访迭代器:生成器 done 5
spine-770 生成器表达式:迭代器遇到列表解析 done 1
spine-771 生成器函数VS生成器表达式 done 0
spine-772 生成器是单迭代器对象 done 0
spine-773 用迭代工具模拟zip和map done 4
spine-774 内置类型和类中的值生成 done 0
spine-775 Python 3.0解析语法概括 done 0
spine-776 针对集合和字典的扩展的解析语法 done 0
spine-777 对迭代的各种方法进行计时 done 2
spine-778 计时脚本 done 1
spine-779 计时结果 done 0
spine-780 计时模块替代方案 done 3
spine-781 其他建议 done 1
spine-782 函数陷阱 done 0
spine-783 默认和可变对象 done 1
spine-784 没有return语句的函数 done 0
spine-785 嵌套作用域的循环变量 done 0
spine-786 本章小结 done 0
spine-787 本章习题 done 0
spine-788 习题解答 done 0
spine-789 第四部分 练习题 done 0
spine-790 第五部分 模块 done 0
spine-791 Python程序架构 done 1
spine-792 导入和属性 done 1
spine-793 标准库模块 done 1
spine-794 import如何工作 done 0
spine-795 2.编译(可选) done 0
spine-796 3.运行 done 0
spine-797 模块搜索路径 done 3
spine-798 搜索路径的变动 done 0
spine-799 sys.path列表 done 0
spine-800 模块文件选择 done 1
spine-801 高级的模块选择概念 done 1
spine-802 本章小结 done 0
spine-803 本章习题 done 0
spine-804 习题解答 done 0
spine-805 第22章 模块代码编写基础 done 0
spine-806 模块的使用 done 0
spine-807 from语句 done 0
spine-808 from*语句 done 1
spine-809 导入只发生一次 done 0
spine-810 import和from是赋值语句 done 0
spine-811 文件间变量名的改变 done 0
spine-812 import和from的对等性 done 0
spine-813 from语句潜在的陷阱 done 1
spine-814 模块命名空间 done 0
spine-815 属性名的点号运算 done 0
spine-816 导入和作用域 done 0
spine-817 命名空间的嵌套 done 1
spine-818 重载模块 done 1
spine-819 reload实例 done 0
spine-820 本章小结 done 0
spine-821 本章习题 done 0
spine-822 习题解答 done 0
spine-823 第23章 模块包 done 1
spine-824 init.py包文件 done 2
spine-825 包导入实例 done 0
spine-826 为什么要使用包导入 done 1
spine-827 包相对导入 done 2
spine-828 相对导入基础知识 done 0
spine-829 为什么使用相对导入 done 0
spine-830 相对导入的作用域 done 0
spine-831 模块查找规则总结 done 0
spine-832 相对导入的应用 done 1
spine-833 本章小结 done 0
spine-834 本章习题 done 0
spine-835 习题解答 done 0
spine-836 第24章 高级模块话题 done 0
spine-837 启用以后的语言特性 done 1
spine-838 混合用法模式:name和main done 1
spine-839 使用带有name的命令行参数 done 3
spine-840 修改模块搜索路径 done 0
spine-841 Import语句和from语句的as扩展 done 0
spine-842 模块是对象:元程序 done 2
spine-843 用名称字符串导入模块 done 1
spine-844 过渡性模块重载 done 2
spine-845 模块设计理念 done 1
spine-846 模块陷阱 done 0
spine-847 from复制变量名,而不是连接 done 0
spine-848 from*会让变量语义模糊 done 0
spine-849 reload不会影响from导入 done 0
spine-850 reload、from以及交互模式测试 done 0
spine-851 递归形式的from导入无法工作 done 1
spine-852 本章小结 done 0
spine-853 本章习题 done 0
spine-854 习题解答 done 0
spine-855 第五部分 练习题 done 0
spine-856 第六部分 类和OOP done 2
spine-857 概览OOP done 2
spine-858 类和实例 done 0
spine-859 类方法调用 done 1
spine-860 编写类树 done 1
spine-861 OOP是为了代码重用 done 3
spine-862 本章小结 done 0
spine-863 本章习题 done 0
spine-864 习题解答 done 0
spine-865 第26章 类代码编写基础 done 1
spine-866 实例对象是具体的元素 done 0
spine-867 第一个例子 done 1
spine-868 类通过继承进行定制 done 2
spine-869 类是模块内的属性 done 1
spine-870 类可以截获Python运算符 done 2
spine-871 为什么要使用运算符重载 done 0
spine-872 世界上最简单的Python类 done 3
spine-873 本章小结 done 0
spine-874 本章习题 done 0
spine-875 习题解答 done 0
spine-876 第27章 更多实例 done 1
spine-877 在进行中测试 done 1
spine-878 以两种方式使用代码 done 0
spine-879 步骤2:添加行为方法 done 5
spine-880 步骤3:运算符重载 done 2
spine-881 步骤4:通过子类定制行为 done 1
spine-882 扩展方法:不好的方式 done 0
spine-883 扩展方法:好的方式 done 2
spine-884 多态的作用 done 1
spine-885 继承、定制和扩展 done 1
spine-886 OOP:大思路 done 0
spine-887 步骤5:定制构造函数 done 1
spine-888 组合类的其他方式 done 2
spine-889 步骤6:使用内省工具 done 1
spine-890 一种通用显示工具 done 1
spine-891 实例与类属性的关系 done 0
spine-892 工具类的命名考虑 done 1
spine-893 类的最终形式 done 1
spine-894 步骤7(最后一步):把对象存储到数据库中 done 0
spine-895 在shelve数据库中存储对象 done 2
spine-896 交互地探索shelve done 2
spine-897 更新shelve中的对象 done 1
spine-898 未来方向 done 1
spine-899 本章小结 done 0
spine-900 本章习题 done 0
spine-901 习题解答 done 0
spine-902 第28章 类代码编写细节 done 0
spine-903 例子 done 1
spine-904 方法 done 0
spine-905 调用超类构造函数 done 0
spine-906 其他方法调用的可能性 done 1
spine-907 继承 done 0
spine-908 继承方法的专有化 done 0
spine-909 类接口技术 done 1
spine-910 抽象超类 done 2
spine-911 Python 2.6和Python 3.0的抽象超类 done 2
spine-912 命名空间:完整的内容 done 0
spine-913 属性名称:对象命名空间 done 0
spine-914 Python命名空间的“禅”:赋值将变量名分类 done 1
spine-915 命名空间字典 done 1
spine-916 命名空间链接 done 1
spine-917 回顾文档字符串 done 0
spine-918 类与模块的关系 done 0
spine-919 本章小结 done 0
spine-920 本章习题 done 0
spine-921 习题解答 done 0
spine-922 第29章 运算符重载 done 1
spine-923 常见的运算符重载方法 done 1
spine-924 索引和分片:getitem和setitem done 3
spine-925 索引迭代:getitem done 1
spine-926 迭代器对象:iter和next done 1
spine-927 有多个迭代器的对象 done 1
spine-928 成员关系:contains、iter和getitem done 1
spine-929 属性引用:getattr和setattr done 3
spine-930 模拟实例属性的私有性:第一部分 done 1
spine-931 repr和str会返回字符串表达形式 done 1
spine-932 右侧加法和原处加法:radd和iadd done 3
spine-933 Call表达式:call done 2
spine-934 比较:lt、gt和其他方法 done 2
spine-935 布尔测试:bool和len done 0
spine-936 对象析构函数:del done 3
spine-937 本章小结 done 0
spine-938 本章习题 done 0
spine-939 习题解答 done 0
spine-940 第30章 类的设计 done 1
spine-941 OOP和继承:“是一个”关系 done 1
spine-942 OOP和组合:“有一个”关系 done 2
spine-943 OOP和委托:“包装”对象 done 1
spine-944 类的伪私有属性 done 1
spine-945 为什么使用伪私有属性 done 2
spine-946 方法是对象:绑定或无绑定 done 1
spine-947 绑定方法和其他可调用对象 done 2
spine-948 多重继承:“混合”类 done 3
spine-949 类是对象:通用对象的工厂 done 2
spine-950 与设计相关的其他话题 done 0
spine-951 本章小结 done 0
spine-952 本章习题 done 0
spine-953 习题解答 done 0
spine-954 第31章 类的高级主题 done 1
spine-955 通过子类扩展类型 done 1
spine-956 新式类 done 0
spine-957 新式类变化 done 1
spine-958 钻石继承变动 done 1
spine-959 新式类的扩展 done 1
spine-960 类特性 done 1
spine-961 getattribute和描述符 done 0
spine-962 元类 done 0
spine-963 静态方法和类方法 done 0
spine-964 Python 2.6和Python 3.0中的静态方法 done 1
spine-965 静态方法替代方案 done 0
spine-966 使用静态和类方法 done 0
spine-967 使用静态方法统计实例 done 0
spine-968 用类方法统计实例 done 2
spine-969 装饰器和元类:第一部分 done 1
spine-970 装饰器例子 done 1
spine-971 类装饰器和元类 done 1
spine-972 更多详细信息 done 0
spine-973 类陷阱 done 0
spine-974 修改可变的类属性也可能产生副作用 done 0
spine-975 多重继承:顺序很重要 done 0
spine-976 类、方法以及嵌套作用域 done 1
spine-977 Python中基于委托的类:getattr和内置函数 done 0
spine-978 “过度包装” done 1
spine-979 本章小结 done 0
spine-980 本章习题 done 0
spine-981 习题解答 done 0
spine-982 第六部分 练习题 done 0
spine-983 第七部分 异常和工具 done 1
spine-984 异常处理:简明扼要 done 0
spine-985 捕获异常 done 0
spine-986 引发异常 done 1
spine-987 用户定义的异常 done 1
spine-988 终止行为 done 1
spine-989 本章小结 done 0
spine-990 本章习题 done 0
spine-991 习题解答 done 0
spine-992 第33章 异常编码细节 done 2
spine-993 try/else分句 done 0
spine-994 例子:默认行为 done 0
spine-995 例子:捕捉内置异常 done 0
spine-996 try/finally语句 done 0
spine-997 统一try/except/finally语句 done 1
spine-998 通过嵌套合并finally和except done 0
spine-999 合并try的例子 done 0
spine-1000 raise语句 done 2
spine-1001 Python 3.0异常链:raise from done 1
spine-1002 assert语句 done 0
spine-1003 with/as环境管理器 done 1
spine-1004 环境管理协议 done 2
spine-1005 本章小结 done 0
spine-1006 本章习题 done 0
spine-1007 习题解答 done 0
spine-1008 第34章 异常对象 done 0
spine-1009 基于类的异常 done 1
spine-1010 类异常例子 done 0
spine-1011 为什么使用类异常 done 1
spine-1012 内置Exception类 done 1
spine-1013 默认打印和状态 done 0
spine-1014 定制打印显示 done 1
spine-1015 定制数据和行为 done 1
spine-1016 提供异常方法 done 0
spine-1017 本章小结 done 0
spine-1018 本章习题 done 0
spine-1019 习题解答 done 0
spine-1020 第35章 异常的设计 done 0
spine-1021 例子:语法嵌套化 done 0
spine-1022 异常的习惯用法 done 0
spine-1023 函数信号条件和raise done 1
spine-1024 关闭文件和服务器连接 done 0
spine-1025 在try外进行调试 done 1
spine-1026 运行进程中的测试 done 1
spine-1027 关于sys.exc_info done 0
spine-1028 与异常有关的技巧 done 0
spine-1029 应该包装什么 done 1
spine-1030 捕捉过少:使用基于类的分类 done 0
spine-1031 核心语言总结 done 0
spine-1032 大型项目的开发工具 done 4
spine-1033 本章小结 done 0
spine-1034 第七部分 练习题 done 0
spine-1035 第八部分 高级话题 done 0
spine-1036 字符串基础知识 done 1
spine-1037 Python的字符串类型 done 0
spine-1038 文本和二进制文件 done 1
spine-1039 Python 3.0中的字符串应用 done 0
spine-1040 转换 done 1
spine-1041 编码Unicode字符串 done 1
spine-1042 编码非ASCII文本 done 0
spine-1043 编码和解码非ASCII文本 done 0
spine-1044 其他Unicode编码技术 done 0
spine-1045 转换编码 done 1
spine-1046 在Python 2.6中编码Unicode字符串 done 0
spine-1047 源文件字符集编码声明 done 1
spine-1048 使用Python 3.0 Bytes对象 done 1
spine-1049 序列操作 done 0
spine-1050 创建bytes对象的其他方式 done 1
spine-1051 混合字符串类型 done 0
spine-1052 使用Python 3.0(和Python 2.6)bytearray对象 done 1
spine-1053 使用文本文件和二进制文件 done 0
spine-1054 Python 3.0中的文本和二进制模式 done 1
spine-1055 类型和内容错误匹配 done 1
spine-1056 使用Unicode文件 done 0
spine-1057 在Python 3.0中处理BOM done 0
spine-1058 Python 2.6中的Unicode文件 done 0
spine-1059 Python 3.0中其他字符串工具的变化 done 0
spine-1060 Struct二进制数据模块 done 0
spine-1061 pickle对象序列化模块 done 0
spine-1062 XML解析工具 done 2
spine-1063 本章小结 done 0
spine-1064 本章习题 done 0
spine-1065 习题解答 done 0
spine-1066 第37章 管理属性 done 1
spine-1067 特性 done 0
spine-1068 第一个例子 done 0
spine-1069 计算的属性 done 1
spine-1070 使用装饰器编写特性 done 1
spine-1071 描述符 done 2
spine-1072 第一个示例 done 0
spine-1073 计算的属性 done 1
spine-1074 在描述符中使用状态信息 done 0
spine-1075 特性和描述符是如何相关的 done 1
spine-1076 getattr和getattribute done 1
spine-1077 第一个示例 done 0
spine-1078 计算属性 done 0
spine-1079 getattr和getattribute比较 done 1
spine-1080 拦截内置操作属性 done 0
spine-1081 重访基于委托的Manager done 0
spine-1082 示例:属性验证 done 1
spine-1083 使用描述符验证 done 0
spine-1084 使用getattr来验证 done 0
spine-1085 使用getattribute验证 done 0
spine-1086 本章小结 done 0
spine-1087 本章习题 done 0
spine-1088 习题解答 done 0
spine-1089 第38章 装饰器 done 0
spine-1090 管理函数和类 done 0
spine-1091 使用和定义装饰器 done 0
spine-1092 为什么使用装饰器 done 1
spine-1093 基础知识 done 1
spine-1094 类装饰器 done 1
spine-1095 装饰器嵌套 done 1
spine-1096 装饰器参数 done 1
spine-1097 装饰器管理函数和类 done 0
spine-1098 编写函数装饰器 done 0
spine-1099 状态信息保持选项 done 1
spine-1100 类错误之一:装饰类方法 done 0
spine-1101 计时调用 done 0
spine-1102 添加装饰器参数 done 0
spine-1103 编写类装饰器 done 1
spine-1104 跟踪对象接口 done 0
spine-1105 类错误之二:保持多个实例 done 0
spine-1106 装饰器与管理器函数的关系 done 0
spine-1107 为什么使用装饰器(重访) done 0
spine-1108 直接管理函数和类 done 1
spine-1109 示例:“私有”和“公有”属性 done 1
spine-1110 实现细节之一 done 0
spine-1111 使用dict和slots done 0
spine-1112 公有声明的泛化 done 1
spine-1113 实现细节之二 done 0
spine-1114 开放问题 done 0
spine-1115 Python不是关于控制 done 0
spine-1116 示例:验证函数参数 done 0
spine-1117 针对位置参数的一个基本范围测试装饰器 done 1
spine-1118 针对关键字和默认泛化 done 1
spine-1119 实现细节 done 0
spine-1120 开放问题 done 0
spine-1121 装饰器参数VS函数注解 done 0
spine-1122 其他应用程序:类型测试 done 0
spine-1123 本章小结 done 0
spine-1124 本章习题 done 0
spine-1125 习题解答 done 0
spine-1126 第39章 元类 done 0
spine-1127 “辅助”函数的缺点 done 0
spine-1128 元类与类装饰器的关系:第一回合 done 0
spine-1129 元类模型 done 0
spine-1130 元类是Type的子类 done 0
spine-1131 Class语句协议 done 1
spine-1132 声明元类 done 0
spine-1133 编写元类 done 1
spine-1134 定制构建和初始化 done 0
spine-1135 其他元类编程技巧 done 1
spine-1136 实例与继承的关系 done 1
spine-1137 示例:向类添加方法 done 1
spine-1138 基于元类的扩展 done 0
spine-1139 元类与类装饰器的关系:第二回合 done 0
spine-1140 示例:对方法应用装饰器 done 0
spine-1141 用元类和装饰器跟踪 done 1
spine-1142 把任何装饰器应用于方法 done 0
spine-1143 元类与类装饰器的关系:第三回合 done 1
spine-1144 本章小结 done 0
spine-1145 本章习题 done 0
spine-1146 习题解答 done 0
spine-1147 第九部分 附录 done 0
spine-1148 从哪里获取Python done 0
spine-1149 安装步骤 done 0
spine-1150 配置Python done 1
spine-1151 如何设定配置选项 done 0
spine-1152 Python命令行选项 done 0
spine-1153 寻求更多帮助 done 0
spine-1154 附录B 各部分练习题的解答 done 0
spine-1155 第二部分 类型和运算 done 0
spine-1156 第三部分 语句和语法 done 0
spine-1157 第四部分 函数 done 0
spine-1158 第五部分 模块 done 0
spine-1159 第六部分 类和OOP done 0
spine-1160 第七部分 异常和工具 done 1
spine-1161 作者介绍 done 0
spine-1162 封面介绍 done 0
当前非正文排除候选
spine项 类型 排除理由
416 封面 待完整读取确认,不预标排除完成
417 书名与版权页 待完整读取确认,不预标排除完成
418 纯目录 待完整读取确认,不预标排除完成
419 出版商介绍 待完整读取确认,不预标排除完成
当前待关联术语
术语名 出现章节 一句话语境
super协作式调用 31 菱形共同祖先初始化冲突的进一步入口,本项仅提示,具体用法以后展开。
管理属性 30 仅导航第37章,不把章节清单当实现。
静态方法/类方法 30 仅导航第31章,区分两类绑定机制待后续。
类型子类 30 仅导航第31章,后续展开。
抽象超类 30 仅导航第28章,本项未新增抽象机制。
XML-RPC 27 远程接口提名,未展开协议。
SOAP 27 结构化远程接口提名,未展开协议。
设计模式 25 用于归类常见OOP设计结构,未展开具体模式。
pexpect 9 原文仅列交互程序控制工具入口
PySerial 9 原文仅列串口通信扩展作为文件类工具入口
setdefault 8 本章答案列为另一个可修改字典的方法,未在此展开
SciPy 5 科学计算扩展进一步学习入口
NumPy 5 另行安装的数组/向量数值扩展,本节仅作功能入口
FIFO 4 系统先进先出通信工具,仅提名。
Fraction 4 有理数类提名,后文具体解释。
Decimal 4 十进制数字类提名,后文具体解释。
random 4 示例random与choice,未执行。
math 4 标准数学模块,实际示例pi和sqrt。
sys.platform 3 运行平台标记,当前示例只读取并打印。
CPython 1 语言标准实现背景,第2章运行细节说明。
OSCON 1 原书开源会议背景。
PyCon 1 Python会议背景。
PSF 1 Python Software Foundation,原书组织背景。
PEP 1 Python Enhancement Proposal,原书变更提议机制。
PyPI 1 Python包索引入口提名。
pickle 1 对象序列化模块,已有持久化分工卡。
Python DB-API 1 数据库统一接口提名,具体契约本段未展开。
COM 1 Windows组件接口提名。
CPython 1 本段实现名称提名,运行章展开。
MVC 1 框架架构方式,仅提名未展开。
ORM 1 对象关系映射,当前仅框架功能提名。
CGI 1 服务器脚本协议提名。
POSIX 1 常见操作系统接口标准,当前段只应用清单。
EIBTI 1 Explicit is better than implicit的社区缩写,语义已在卡中说明。
CORBA 1 组件通信机制提名。
XML-RPC 1 跨系统通信接口提名。
SOAP 1 跨系统通信接口提名。
Jython 前言 基于Java的Python实现提名,后文运行章展开。
Python3.0删除替代表 前言 57项历史映射,实际语义需相应章节说明和当前规范核对。
Python2.6⁄3.0语言扩展表 前言 27项扩展与对应章节的导航,后文逐机制说明。
元类 前言 高级章比较工具,当前只课程介绍。
装饰器 前言 高级核心语言主题,稍后实质取材。
描述符 前言 高级章将介绍属性管理,本段仅提名。
当前引用文献
标题 类型 出现章节 一句话语境
Python官方MRO历史说明与数据模型 规范 31 2026-11-06核对C3、特殊方法查找和type/object关系;未运行代码。
Programming Python 书 31 内置类型子类与集合实现的进一步阅读入口,本项未读被引全书。
SQLAlchemy 框架 27 ORM选项提名,未实现映射。
SQLObject 框架 27 ORM历史选项提名。
SQLite 源码项目 27 嵌入关系存储候选,未实现迁移。
PostgreSQL 源码项目 27 关系存储候选,未实现迁移。
Oracle 框架 27 关系存储候选,仅提名。
MySQL 源码项目 27 关系存储候选,未实现迁移。
Google’s App Engine 框架 27 历史服务平台提名,不核验现今产品状态。
Zope 框架 27 历史Web框架提名。
web2Py 框架 27 历史Web框架提名。
Pylons 框架 27 历史Web框架提名。
TurboGears 框架 27 历史Web框架提名。
Django 框架 27 Web框架候选,未选择或部署。
PyQt 框架 27 历史GUI选项,仅提名。
WxPython 框架 27 历史GUI选项,仅提名。
tkinter 框架 27 候选GUI入口,本章未实现界面。
Programming Python 书 27 推荐了解应用持久化细节;本书此处未展开该书内容。
ZODB 源码项目 25 脚注提及对象数据库系统,未核验现今产品能力。
eggs 源码项目 21 原文仅简提发行系统与依赖检查,未补造成卡
distutils 源码项目 21 旧标准库构建安装工具,已核验3.12移除
timeit 源码项目 20 标准库小代码片段计时工具,官方接口补充核验
PyDoc 源码项目 15 标准库文档生成器和help所用工具
PEP257 论文 15 官方文档字符串约定,非强制语言语法;补充核验
PEP 8 论文 11 原文提出命名惯例的进一步阅读,具体项目风格仍依上下文
profile 框架 4 性能剖析工具提名,未执行。
timeit 框架 4 计时工具提名,未执行。
shelve 框架 4 对象持久化进一步阅读提名,未访问数据库。
re 框架 4 标准正则模块,原例match/group/groups。
PyDoc 框架 4 从对象文档提供帮助的工具,当前机制引介。
Winpdb 框架 3 原书专用调试工具例,当前状态未核验。
pdb 框架 3 标准库调试工具,当前保留接口角色未运行。
Programming Python 书 3 嵌入Python的进一步阅读,非当前全文。
Vim 框架 3 编辑器支持提名。
Emacs 框架 3 编辑器支持提名。
PythonCard 框架 3 原书工具提名。
Wing IDE 框架 3 原书IDE提名。
PythonWin 框架 3 原书Windows开发环境。
NetBeans 框架 3 原书Python IDE支持背景。
Komodo 框架 3 原书多语言IDE,价格/功能未核验当前状态。
Eclipse/PyDev 框架 3 原书通用IDE加Python插件方案。
Tkinter 框架 3 IDLE的GUI依赖,原书历史名称。
IDLE 框架 3 Python编辑运行与调试界面,当前段引入,下面具体取材。
Parrot 框架 2 原书多语言虚拟机探索背景,未核验当前状态。
Pyrex 框架 2 Cython历史背景提名。
Cython 框架 2 生成C扩展的混合语言机制。
Stackless Python 框架 2 状态管理变体,当前实现细节待核验。
freeze 框架 2 原书早期冻结工具例。
PyInstaller 框架 2 打包工具例,未核验当前平台范围。
py2exe 框架 2 历史冻结工具例。
PyPy 框架 2 原书新实现项目背景,当前状态未核验。
Shedskin 框架 2 原书Python到C++转换示例。
Psyco 框架 2 历史JIT特化示例,非当前推荐。
Mono 框架 2 .NET相关宿主实现背景提名。
ActivePython 框架 2 原书分发包提名。
JPype 框架 2 CPython调用Java的另一途径,仅提名。
IronPython 框架 2 .NET宿主集成实现,未核验当前版本。
Jython 框架 2 Java宿主集成实现,固定历史说明非当前版本核验。
PySol 框架 1 原书应用举例,未核验当前版本。
NLTK 框架 1 自然语言工具提名。
PyRo 框架 1 原书机器人控制工具包提名,不混同同名项目。
Maya 框架 1 图形工具提名。
Blender 框架 1 图形工具提名。
PyOpenGL 框架 1 图形接口提名。
PIL 框架 1 原书图像库提名。
PySerial 框架 1 串口工具提名。
pygame 框架 1 游戏图形工具提名。
ScientificPython 框架 1 历史科学工具提名,当前维护未核验。
SciPy 框架 1 科学计算扩展提名。
SQLite 框架 1 原书标准库数据库背景,未连接。
SQLObject 框架 1 关系映射工具提名。
ZODB 框架 1 对象数据库提名。
SIP 框架 1 绑定代码生成工具。
SWIG 框架 1 跨语言绑定生成工具。
WebWare 框架 1 Web框架提名。
Zope 框架 1 Web框架提名。
Pylons 框架 1 Web框架提名。
web2py 框架 1 Web框架提名。
TurboGears 框架 1 Web框架提名。
Django 框架 1 Web框架提名。
mod_python 框架 1 历史Apache集成工具。
HTMLGen 框架 1 从描述生成HTML的历史工具。
Jython 框架 1 Java上的Python实现及Swing接口提名。
IronPython 框架 1 .NET上的Python实现提名。
PyWin32 框架 1 Windows接口提名。
PyGTK 框架 1 GTK接口提名。
PyQt 框架 1 Qt接口提名。
Dabo 框架 1 历史GUI工具包。
PythonCard 框架 1 历史高级GUI工具包。
wxPython 框架 1 C++界面库的Python接口。
PMW 框架 1 Tkinter高级组件扩展。
Tkinter 框架 1 Python对Tk的GUI接口提名。
Stackless Python 框架 1 历史并发扩展实现提名,未展开机制。
NumPy 框架 1 数值计算扩展示例,后文混编机制补充。
Python Cookbook 书 前言 为已有基础读者提供独立案例,非本段实质知识。
Python Essential Reference 书 前言 参考资料,未读全文。
Python in a Nutshell 书 前言 参考资料,未读全文。
Python Pocket Reference 书 前言 核心语法与工具快速查找。
Programming Python 书 前言 本书之后的应用级专题教程。
What’s New in Python 3.0 框架 前言 官方版本差异文档,原书延伸参考。
Python Pocket Reference 书 前言 补充速查参考,未读该书全文。
Programming Python 书 前言 应用专题续读,与当前语言核心教程分工。
当前资金安全问题案例
问题标题 问题卡 解决方案卡(如有) 出现章节 一句话说明

整书笔记为本轮正文与来源真源,全文讲解已生成;整书主线与实践入口已收束,生成放行版本有效;导入归档结果见_workflow.md。

2026-11-06 全文生成收束

实际执行book-notes v24 / book-workflow v4,light;首次历史版本保留。951/951单元及其代码/图表全文阅读完成,572卡/572唯一primary/1247出处;39章与两附录讲解、全书主线和跨章综合已生成。实践筛选done,2张计划与固定CPython提交首轮映射已交付,未执行完整实践。阶段2已放行;本轮恢复导入对账与归档,进度见_workflow.md。轻量模式:未执行复核、审查及审查结果优化。

实践卡进度

序号 实践标题 实践方式 状态(pending/done) 关联章节 产出
001 追踪描述符的读取优先级 实现深读 done 37、38 ideas/idea-001-追踪描述符的读取优先级.md;CPython固定提交源码清单与首轮映射已准备,完整实践未执行。
002 追踪模块导入的状态变化 实现深读 done 21–24、附录B ideas/idea-002-追踪模块导入的状态变化.md;固定提交importlib/缓存测试映射已准备,完整实践未执行。

实践候选筛选:done;采用/合并/未采用理由见_practice_selection.md。

相关主题

从本书的主题进入跨书阅读,对照其他书籍的讲解。下方数量包含主题关联的全部卡片与书籍。

暂无公开主题。