builtins

• filter(iterable, func)：过滤func返回布尔否值元素
• enumerate(iterable)：添加索引迭代
• zip(*iterables)：打包迭代元素
• map(func, *iterables)：func接受各迭代器中元素作为 参数调用（类似zip）
• iter：两种产生迭代器的模式
  • iter(iterable)：返回迭代器
  • iter(callable, sentinel)：调用callable直到返回 sentinel停止迭代（不包括）
    • 可用于替代while循环

itertools

itertools：包含为高效循环而创建迭代器的函数

• 参考https://docs.python.org/zh-cn/3/library/itertools.html

无穷迭代器

• count(start, step=1)：步长累加
• cycle(p)：循环p中元素
• repeat(elem, n=None)：重复elem

迭代元素处理

• accumulate(p, func=None)：累加p中元素
• chain(*iters)：链接迭代器
• chain.from_iterable(iterable)：链接可迭代对象中迭代器
• compress(data, selelctors)：根据selectors选取data
• dropwhile(pred, seq)：保留首个满足pred之后所有元素
• takewhile(pred, seq)：保留首个不满足pred之前元素
• filterfalse(pred, seq)：反filter
• groupby(iterable, key=None)：根据key(v)值分组迭代器
• islice(seq, start=0, stop=None, step=1)：切片
• starmap(func, seq)：迭代对seq中执行func(*elem)
• tee(iterable, n=2)：复制迭代器，默认2个
• zip_longes(*iters, fillvalue)：依最长迭代器zip，较短 循环填充或fillvalue填充

排列组合

• product(*iters, repeat=1)：笛卡尔积
• permutations(p, r=None)：r长度的排列，缺省全排列
• combinations(p, r)：r长度组合
• combinations_with_replacement(p,r)：可重复组合

functools

functools：包含高阶函数，即参数、返回值为其他函数的函数

• 参见https://docs.python.org/zh-cn/3/library/functools.html

函数转换

• cmp_to_key(func)：将旧式比较函数转换新式key function

  • 常用在以下函数key参数中转换旧式比较函数
    • sorted
    • min
    • max
    • heapq.nlargest
    • heapq.nsmallest
    • itertools.groupby

  • key function：接收参数，返回可以用于排序的值

• partial(func, *args, **kwargs)：返回partial对象，其 调用时类似使用args、kwargs调用func

• partial.method(func, *args, **kwargs)：适合类命名空间 中函数、描述器

• update_wrapper(wrapper, wrapped, assigned=WRAPPER_ASSIGNMENTS, udpated=WRAPPER_UPDATES)： 更新wrapper函数信息为wrapped函数信息

函数应用

• reduce(func, iterable[, initializer])：使用func接受 两个参数，reduce处理iterable

函数装饰器

• @lru_cache(maxsize=128, typed=False)：缓存函数执行结果

  • 字典存储缓存：函数固定参数、关键字参数必须可哈希
  • 不同参数调用模式（如仅参数顺序不同）可能被视为不同 ，从而产生多个缓存项

  • 可以用于方便实现动态规划

• @singledispatch：转换函数为单分派范型函数，实现python 的重载（接口多态）

  • single dispatch：单分派，基于单个参数类型分派的 范型函数分派形式

• @wraps(wrapped, assigned=WRAPPER_ASSIGNMENTS, updated=WRAPPER_UPDATES)： 等价于partial(update_wrapper, wrapped, assigned, updated)

类装饰器

• @total_ordering：根据类中已定义比较方法实现剩余方法
  • 类必须实现__eq__、其他富比较方法中任意一种

operator

operator：提供与python内置运算符对应的高效率函数

• 为向后兼容，保留双下划线版本函数名（同特殊方法名）

比较运算

• lt(a,b)/__lt__(a,b)
• le(a,b)
• eq(a,b)
• ne(a,b)
• ge(a,b)
• gt(a,b)

逻辑运算

• not(obj)
• truth(obj)：等价于使用bool构造器
• is_(a,b)
• is_not(a,b)

数值运算

• add(a,b)
• sub(a,b)
• mul(a,b)
• div(a,b)
• pow(a,b)
• mod(a,b)
• floordiv(a,b)
• truediv(a,b)
• matmul(a,b)
• abs(obj)
• neg(obj)
• pos(obj)

在位赋值

• 在位运算对可变数据类型才会更新参数，否则只返回结果

• iadd(a,b)：等价于a += b
• isub(a,b)
• imul(a,b)
• idiv(a,b)
• ipow(a,b)
• imod(a,b)
• ifloordiv(a,b)
• itruediv(a,b)
• imatmul(a,b)

位运算

• and_(a,b)
• or_(a,b)
• xor(a,b)
• inv(obj)/invert(obj)
• lshift(a,b)
• shift(a,b)

在位运算

• iand(a,b)
• ior(a,b)
• ixor(a,b)

索引

• index(a)

序列运算

• concat(a,b)
• contains(a,b)
• countOf(a,b)
• delitem(a,b)
• getitem(a,b)
• indexOf(a,b)
• setitem(a,b,c)
• length_hint(obj, default=0)

访问函数

• attrgetter(attr)/attrgetter(*attrs)：返回函数，函数 返回值为参数属性attr
• itemgetter(item)/itemgetter(*items)：类似
• methodcaller(name[, args...])：类似

collections

array

headq

bisect

weakref

datetime

calender

types

copy

pprint

reprlib

enum

综述

• 语言的具体实现可能发生改变、其他实现可能使用不同方式
• 在语言的参考文档中加入过多细节实现很危险

Python实现

python只是一种语言，其具体解释器实现有很多种

• CPython：C语言实现，最原始版本

  • 通常就被称为Python，其他实现区分时才强调为CPython
  • 新语言特性通常较早出现

• Jython：Java实现

  • 将Python代码编译为Java字节码
  • 可以左线Java应用的脚本语言、创建需要Java类库支持的 应用
  • 在JVM上运行

• Python for .NET：实际上使用CPython实现，但是属于.NET 托管应用，可以引入.NET类库

• IronPython：.NET实现

  • 生成IL的完全Python实现，将Python代码直接编译为.NET 程序集

• PyPy：RPython（Python语言子集）实现

  • JIT编译器，执行效率高于CPython
  • 非栈式支持
  • 允许方便修改解释器，鼓励对语言本身进行实验

• CPython是解释器实现版本，cython是将Python代码翻译为 C插件的项目/包

Notation说明

标注：词法、句法解析的描述使用修改过的BNF语法标注

1
2

name ::= lc_letter(lc_letter | "_")*
lc_letter ::= "a"..."z"

• ::=：声明规则，左侧为规则名称
• |：分隔可选项
• *：前一项的零次、多次重复
• +：前一项的一次、多次重复
• []：括起内容可选，即出现零次、一次
• ()：分组
• ""：固定字符串包含在引号内
• ：空格仅用于分隔token
• ...：三个点分割的本义字符表示在指定区间范围内的任意 单个字符
• <>：对所定义符号的非常描述，在必要时用于说明“控制字符” 意图

• 每条规则通常为一行，多个可选项规则可用|为界分为多行
• 词法定义：作用域输入源中的单独字符
• 句法定义：作用于词法分析生成的token stream

约定

• 实例方法：定义在类命名空间中、未因访问而绑定函数
• 绑定方法：已绑定实例方法
• 静态方法
• 类方法
• [类]实例：类实例化所得对象
• 对象：泛指所有python对象，包括类、实例

Global Intepretor Lock

全局内存锁：GIL，任何python字节码执行前必须获得的解释器锁

• 在任何时刻，只能有一个线程处于工作状态
• 避免多个线程同时操作变量导致内存泄漏、错误释放

优势

• GIL实现简单，只需要管理一把解释器锁就能保证线程内存安全

  • 当然GIL只能保证引用计数正确，避免由此导致内存问题
  • 还需要原子操作、对象锁避免并发更新问题

• GIL单线程情况下性能更好、稳定，若通过给所有对象引用计数 加锁来实现线程安全

  • 容易出现死锁
  • 性能下降很多

• 方便兼容C遗留库，这也是python得以发展的原因

  • 很多python需要的C库扩展要求线程安全的内存管理

影响

• Python线程是真正的操作系统线程

  • 在准备好之后必须获得一把共享锁才能运行
  • 每个线程都会在执行一定机器指令和后切换到无锁状态， 暂停运行
  • 事实上程序在开始时已经在运行“主线程”

  • 解释器检查线程切换频率sys.getcheckinterval()

• Python线程无法在多核CPU间分配，对CPU-Bound程序基本没有 提升效果，对于IO-Bound的程序性能仍然有巨大帮助

解决方案

• 多进程

  • 进程分支：os.fork
  • 派生进程：multiprocessing.Process、 concurrent.futures

• C语言库封装线程：ctypes、cython

  • C扩展形式实现任务线程可在python虚拟机作用域外运行 可以并行运行任意数量线程
  • 在运行时释放GIL、结束后继续运行python代码时重新获取 GIL，真正实现独立运行

• 使用其他版本Python解释器：只有原始Python版本CPython使用 GIL实现

  • Jython
  • IronPython
  • PyPy

Python最高层级组件

完整的Python程序

• 完整的python程序会在最小初始化环境中被执行

  • 所有内置、标准模块均可用，但均处于未初始化状态
  • 只有sys、builtins、__main__已经初始化
  • __main__模块为完整程序的执行提供局部、全局命名空间

• 完整程序可通过三种形式传递给解释器

  • -c命令行选项传递字符串
  • 文件作为第一个命令行参数
  • 标准输入

  • 若文件、标准输入是tty设备，解释器进入交互模式，否则 将文件当作完整程序执行

• 解释器也可以通过交互模式被发起调用

  • 每次读取执行一条语句，语句会在__main__命名空间中 被执行
  • 初始环境同完整程序

输入类型

文件输入

文件输入：从非交互式文件读取的输入，具有相同形式

1

file_input ::= (NEWLINE|statement)*

• 适合以下几种情况

  • 解析完整的python程序（从文件、字符串）
  • 解析模块
  • 解析传递给exec()函数的字符串

交互式输入

交互式输入：从tty设备读取输入

1

interactive_input ::= [stmt_list] NEWLINE | compound_stmt NEWLINE

• 注意
  • 交互模式中（最高层级）复合语句后必须带有空行，帮助 解释器确定输入的结束

表达式输入

表达式输入

1

eval_input ::= expression_list NEWLINE*

• eval被用于表达式输入
• 忽略开头空白

综述

导入方式

importing操作可以使得模块能够访问其他模块中代码

• import：结合了以下两个操作，发起导入调机制最常用方式

  • 搜索指定名称模块：对__import__()带有适当参数调用
  • 将搜索结果绑定到当前作用域中名称：__import__返回值 被用于执行名称绑定操作

• __import__()：只执行模块搜索、找到模块后创建module

  • 可能产生某些副作用
    • 导入父包
    • 更新各种缓存：sys.modules

• importlib.import_module()

  • 可能会选择绕过__import__，使用其自己的解决方案实现 导入机制
  • 用于为动态模块导入提供支持

  • importlib模块参见标准库

子模块

• 任意机制加载子模块时，父模块命名空间中会添加对子模块对象 的绑定

Packages

• python只有一种模块对象类型：所有模块都属于该类型，C、 Python语言实现均是

• 包：为帮助组织模块、并提供名称层次结构引入

  • 可将包视为文件系统中目录、模块视为目录中文件， 但包、模块不是必须来自文件系统
  • 类似文件系统，包通过层次结构进行组织：包内包括模块、 子包

• 所有包都是模块，但并非所有模块都是包

  • 包是一种特殊的模块
  • 特别的，任何具有__path__属性的模块都被当作包

• 所有模块都有自己的名字

  • 子包名与其父包名以.分隔，同python标准属性访问语法

Regular Packages

正规包：通常以包含__init__.py文件的目录形式出现

• __init__.py文件可以包含和其他模块中包含python模块相似 的代码

• 正规包被导入时

  • __init__.py文件会隐式被执行，其中定义对象被绑定到 该包命名空间中名称
  • python会为模块添加额外属性

Namespace Packages

命名空间包：由多个部分构成，每个部分为父包增加一个子包

• 包各部分可以物理不相邻，不一定直接对应到文件系统对象， 可能是无实体表示的虚拟模块

  • 可能处于文件系统不同位置
  • 可能处于zip文件、网络上，或在导入期间其他可搜索位置

• __path__属性不是普通列表，而是定制的可迭代类型

  • 若父包、或最高层级包sys.path路径发生改变，对象会 在包内的下次导入尝试时，自动执行新的对包部分的搜索

• 命名空间包中没有__init__.py文件

  • 毕竟可能有多个父目录提供包不同部分，彼此物理不相邻
  • python会在包、子包导入时为其创建命名空间包

导入相关模块属性

• 以下属性在加载时被设置，参见 cs_python/py3ref/import_system

• __name__：模块完整限定名称，唯一标识模块

• __loader__：导入系统加载模块时使用的加载器对象

  • 主要用于内省
  • 也可用于额外加载器专用功能

• __package__：取代__name__用于主模块计算显式相对 导入

  • 模块为包：应设置为__name__
  • 模块非包：最高层级模块应设为空字符串，否则为父包名

  • 预期同__spec__.parent值相同，未定义时，以 __spec__.parent作为回退项

• python <PYSCIRPT>直接执行脚本时__name__被设置为 __main__、__package__设置为None，此时导入器无法 解释相对导入中.，相对导入报错
• python -m <PYSCIRPT>则会按模块逻辑设置__name__、 __package__，相对导入可以正常执行

__spec__

__spec__：导入模块时要使用的模块规格说明

• 对__spec__正确设置将同时作用于解释器启动期间 初始化的模块
• 仅__main__某些情况下被设置为None

__path__

• 具有该属性模块即为包：包模块必须设置__path__属性， 非包模块不应设置

• 在导入子包期间被使用，在导入机制内部功能同sys.path， 即用于提供模块搜索位置列表

  • 但受到更多限制，其必须为字符串组成可迭代对象，但若其 没有进一步用处可以设置为空
  • 适用作用于sys.path的规则
  • sys.path_hooks会在遍历包的__path__时被查询

• 可在包的__init__.py中设置、更改

  • 在PEP420引入之后，命名空间包不再需要提供仅包含操作 __path__代码的__init__.py文件，导入机制会自动为 命名空间包正确设置__path__
  • 在之前其为实现命名空间包的典型方式

__repr__

• 若模块具有__spec__，导入机制将尝试使用其中规格信息生成 repr

  • name
  • loader
  • origin
  • has_location

• 若模块具有__file__属性，将被用作repr的一部分

• 否则若模块具有__loader__属性且非None，则加载器repr 将被用作模块repr的一部分

• 其他情况下，仅在repr中适用模块的__name__

• 可以在模块规则说明中显式控制模块对象repr

__file__/__cached__

• __file__：模块对应的被加载文件的路径名
• __cached__：编译版本代码（字节码文件）路径

• __file__为可选项，须为字符串

  • 可以在其无语法意义时不设置
  • 对从共享库动态加载的扩展模块，应为共享库文件路径名

• __cached__

  • 不要求编译文件已经存在，可以表示应该存放编译文件 的位置
  • 不要求__file__已经设置
    • 有时加载器可以从缓存加载模块但是无法从文件加载
    • 加载静态链接至解释器内部的C模块

• 从.pyc文件加载缓存字节码前会检查其是否最新

  • 默认通过比较缓存文件中保存的源文件修改时间戳实现
  • 也支持基于哈希的缓冲文件，此时.pyc文件中保存源文件 哈希值
    • 检查型：求源文件哈希值再和缓存文件中哈希值比较
    • 非检查型：只要缓存文件存在就直接认为缓存文件有效

  • --check-hash-based-pycs命名行选项设置基于哈希的 .pyc文件有效性

执行相关模块属性

• __doc__：模块文档字符串
• __annotaion__：包含变量标注的字典
  • 在模块体执行时获取
• __dict__：以字典对象表示的模块命名空间

• CPython：由于CPython清理模块字典的设定，模块离开作用域时 模块字典将被清理，即使字典还有活动引用，可以复制该字典、 保持模块状态以直接使用其字典

sys.modules模块缓存

sys.modules映射：缓存之前导入的所有模块（包括中间路径） （即导入子模块会注册父模块条目）

• 其中每个键值对就是限定名称、模块对象

• 在其中查找模块名称

  • 若存在需要导入模块，则导入完成
  • 若名称对应值为None则raise ModuleNotFoundError
  • 若找不到指定模块名称，python将继续搜索

• 映射可写，可删除其中键值对

  • 不一定破坏关联模块，因为其他模块可能保留对其引用
  • 但是会使命名模块缓存条目无效，导致下次导入时重新 搜索命名模块，得到两个不同的两个模块对象

  • importlib.reload将重用相同模块对象，通过重新运行 模块代码重新初始化模块内容

Finders And Loaders

• Finders：查找器，确定能否使用所知策略找到指定名称模块
• Loaders：加载器，加载找到的指定模块
• Importer：导入器，同时实现两种接口的对象，在确定能加载 所需模块时会返回自身

• 导入机制通过import hooks实现扩展

  • 可以加入新的查找器以扩展模块搜索范围、作用域

• 工作流程：在sys.modules缓存中无法找到指定名称模块时

  • 查找器若能找到指定名称模块，返回模块规格说明spec
  • 加载器将利用查找器返回的模块规格说明加载模块

Import Path

导入路径：文件系统路径、zip文件等path term组成的位置列表

• 其中元素不局限于文件系统位置，可扩展为字符串指定的任意 可定位资源

  • URL指定资源
  • 数据库查询

• 位置条目来源

  • 通常为sys.path
  • 对次级包可能来自上级包的__path__属性

• 其中每个路径条目指定一个用于搜索模块的位置

  • path based finder将在其中查找导入目标

sys.path

sys.path：模块、包搜索位置的字符串列表

• 初始化自PYTHONPATH环境变量、特定安装和实现的默认设置、 执行脚本目录（或当前目录）

• 其中条目可以指定文件系统中目录、zip文件、可用于搜索模块 的潜在位置

• 只能出现字符串、字节串，其他数据类型被忽略

  • 字节串条目使用的编码由导入路径钩子、 path entry finder确定

• 所以可以修改sys.path值定制导入路径，CPython实现参见 cs_python/py3ref/import_system

sys.path_import_cache

sys.path_importer_cache：存放路径条目到路径条目查找器映射 的缓存

• 减少查找路径条目对应路径条目查找器的消耗，对特定路径条目 查找对应路径条目查找只需进行一次

• 可从中移除缓存条目，以强制基于路径查找器执行路径条目搜索

Import Hooks

• meta hooks：元[路径]钩子

  • 导入过程开始时被调用，此时仅sys.modules缓存查找 发生，其他导入过程未发生
  • 所以允许元钩子重载sys.path过程、冻结模块甚至内置 模块

  • 元钩子即导入器/元路径查找器
  • sys.meta_path为元路径查找器列表，可在其中注册定制 元钩子

• path[ entry] hooks：导入路径钩子

  • 是sys.path、package.__path__处理的一部分
  • 基于路径的查找器调用其处理路径条目，以获取路径条目 查找器

  • 导入路径钩子返回路径条目查找器
  • sys.path_hooks为导入路径钩子列表，可在其中注册 定制导入路径钩子

默认元路径查找器/导入器

python默认实现sys.meta_path有以下导入器（元路径查找器）

• BuiltinImporter：定位、导入内置模块
• FrozenImporter：定位、导入冻结模块
• PathFinder：定位、导入来自import path中模块

• 尝试导入模块时，内置模块、冻结模块导入器优先级较高，所以 解释器首先搜索内置模块

Finder

• 指定名称模块在sys.modules找不到时，python继续搜索 sys.meta_path，按顺序调用其中元路径查找器

• 若sys.meta_path处理到列表末尾仍未返回说明对象，则 raise ModuleNotFoundError

• 导入过程中引发的任何异常直接向上传播，并放弃导入过程
• 对非最高层级模块的导入请求可能会多次遍历元路径

Meta Path Finders

元路径查找器：

• 元路径查找器可使用任何策略确定其是否能处理给定名称模块

  • 若知道如何处理指定名称的模块，将返回模块规格说明
  • 否则返回None

• 模块规格协议：元路径查找器应实现find_spec()方法

  • 接受名称、导入路径、目标模块作为参数
  • 返回模块规格说明

Spec

• 模块规格[说明]：基于每个模块封装的模块导入相关信息

  • 模块规格中大部分信息对所有模块是公用的
  • 模块规格说明作为模块对象的__spec__属性对外公开

• 用途

  • 允许状态在导入系统各组件间传递，如：查询器和加载器
  • 允许导入机制执行加载的样板操作，否则该由加载器负责

find_spec

1
2

def finder.find_spec(fullname, path=None, target=None):
	pass

• fullname：被导入模块的完整限定名称
• path：供模块搜索使用的路径条目
  • 对最高层级模块应为None
  • 对子模块、子包应为父包__path__属性值，若 相应__path__属性无法访问将 raise ModuleNotFoundError
• target：将被作为稍后加载目标的现有模块对象
  • 导入系统仅在重加载期间传入目标模块

• 导入器的find_spec()返回模块规格说明中加载器为self
• 有些元路径查找器仅支持顶级导入，path参数不为None时 总返回None

Loaders

• 模块规格说明被找到时，导入机制将在加载该模块时使用
  • 其中包含的加载器将被使用，若存在

加载流程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

module = None

if spec.loader is not None and hasattr(spec.loader, 'create_module'):
	# 模块说明中包含加载器，使用加载器创建模块
	module = spec.loader.create_module(spec)

if module is None:
	# 否则创建空模块
	module = types.ModuleType(spec.name)

 # 设置模块导入相关属性
_init_module_attrs(spec, module)

if spec.loader is None:
	# 模块说明中不包含加载器
	# 检查模块是否为为命名空间包
	if spec.submodule_search_locations is not None:
		# 设置`sys.modules`
		sys.modules[spec.name] = module
	else:
		raise ImportError
elif not hasattr(spec.loader, "exec_module"):
	# 向下兼容现有`load_module`
	module = spec.loader.load_module(spec.name)
else:
	sys.modules[spec.name] = module
	try:
		# 模块执行
		spec.loader.exec_module(module)
	except BaseException:
		try:
			# 加载模块失败则从`sys.modules`中移除
			del sys.modules[spec.name]
		except KeyError:
			pass
		raise
return sys.modules[spec.name]

• 创建模块对象
• 设置模块导入相关属性：在执行模块代码前设置
• sys.modules注册模块
• 模块执行：模块导入关键，填充模块命名空间

create_module创建模块对象

• 模块加载器可以选择通过实现create_module方法在加载 期间创建模块对象

  • 其应接受模块规格说明作为参数

• 否则导入机制使用types.ModuleType自行创建模块对象

sys.modules注册模块

• 在加载器执行代码前注册，避免模块代码导入自身导致无限 递归、多次加载
• 若模块为命名空间包，直接注册空模块对象

exec_module模块执行

• 导入机制调用importlib.abc.Loader.exec_module()方法执行 模块对象

  • CPython：exec_module不定返回传入模块，其返回值将被 忽略

    • importlib避免直接使用返回值，而是通过在 sys.modules中查找模块名称获取模块对象
    • 可能会间接导致被导入模块可能在sys.modules中 替换其自身

• 加载器应该该满足

  • 若模块是python模块（非内置、非动态加载），加载器应该 在模块全局命名空间module.__dict__中执行模块代码

  • 若加载器无法执行指定模块，则应raise ImportError， 在exec_module期间引发的任何其他异常同样被传播

• 加载失败时作为附带影响被成功加载的模块仍然保留

  • 重新加载模块会保留加载失败模块（最近成功版本）

Path Based Finder—PathFinder

基于路径的查找器：在特定path entry中查找、加载指定的python 模块、包

• 基于路径查找器只是遍历import path中的路径条目，将其 关联至处理特定类型路径的path entry finder

• 默认路径条目查找器集合实现了在文件系统中查找模块的所有 语义，可以处理多种文件类型

  • python源码.py
  • python字节码.pyc
  • 共享库.so
  • zip包装的上述文件类型（需要zipimport模块支持）

• 作为元路径查找器

  • 实现有find_spec协议
  • 并提供额外的钩子、协议以便能扩展、定制可搜索路径条目 的类型，定制模块从import path的查找、加载

流程

导入机制调用基于路径的查找器的find_spec()迭代搜索 import path的路径条目，查找对应路径条目查找器

• 先在sys.path_impporter_cache缓存中查找对应路径条目 查找器

• 若没有在缓存中找到，则迭代调用sys.path_hooks中 Path Entry Hook

• 迭代结束后若没有返回路径条目查找器，则

  • 置sys.path_importer_cache对应值为None
  • 返回None，表示此元路径查找器无法找到该模块

当前目录

对空字符串表示的当前工作目录同sys.path中其他条目处理方式 有所不同

• 若当前工作目录不存在，则sys.path_importer_cache 中不存放任何值

• 模块查找回对当前工作目录进行全新查找

• sys.path_importer_cache使用、 importlib.machinery.PathFinder.find_spec()返回路径将是 实际当前工作目录而非空字符串

Path Entry Hook

路径条目钩子：根据路径条目查找对应路径条目查找器的可调用对象

• 参数：字符串、字节串，表示要搜索的目录条目

  • 字节串的编码由钩子自行决定
  • 若钩子无法解码参数，应raise ImportError

• 路径条目钩子返回值

  • 可处理路径条目的路径条目查找器
  • raise ImportError：表示钩子无法找到与路径条目对应 路径条目查找器
    • 该异常会被忽略，并继续对import path迭代

Path Entry Finder—PathEntryFinder

路径条目查找器：

• 元路径查找器作用于导入过程的开始，遍历sys.meta_path时
• 路径条目查找器某种意义上是基于路径查找器的实现细节

find_spec

1
2

def PathEntryFinder.find_spec(fullname, target=None):
	pass

• 路径条目查找器协议：目录条目查找器需实现find_spec方法

  • 以支持模块、已初始化包的导入
  • 给命名空间包提供组成部分

• 参数

  • fullname：要导入模块的完整限定名称
  • target：目标模块

• 返回值：完全填充好的模块规格说明

  • 模块规格说明总是包含加载器集合
  • 但命名空间包的规格说明中loader会被设置为None， 并将submodule_search_locations设置为包含该部分的 列表，以告诉导入机制该规格说明为命名空间包的portion

• Portion：构成命名空间包的单个目录内文件集合
• 替代旧式find_loader()、find_module()方法

替换标准导入系统

• 替换sys.meta_path为自定义元路径钩子

  • 替换整个导入系统最可靠机制

• 替换内置__import__()函数

  • 仅改变导入语句行为而不影响访问导入系统其他接口
  • 可以在某个模块层级替换，只改变某块内部导入语句行为

• 替换find_spec()，引发ModuleNotFoundError

  • 选择性的防止在元路径钩子导入某些模块

__main__

• __main__模块是在解释器启动时直接初始化，类似sys、 builtins，但是不被归类为内置模块，因为其初始化的方式 取决于启动解释器的旗标（命令行参数）

__spec__

根据__main__被初始化的方式，__main__.__spec__被设置为 None或相应值

• -m选项启动：以脚本方式执行模块

  • 此时__spec__被设置为相应模块、包规格说明

  • __spec__会在__main__模块作为执行某个目录、zip 文件、其他sys.path条目的一部分加载时被填充

  • 此时__main__对应可导入模块和__main__被视为不同 模块

• 其余情况

  • __spec__被设置为None

  • 因为用于填充__main__的代码不直接与可导入模块相对应

    • 交互型提示
    • -c选项
    • 从stdin运行
    • 从源码、字节码文件运行

• -m执行模块时sys.path首个值为空字符串，而直接执行脚本 时首个值为脚本所在目录

Import[ Search] Path定制

动态增加路径

1
2
3

import sys
sys.path.insert(1, /path/to/fold/contains/module)
	# 临时生效，对不经常使用的模块较好

修改PYTHONPATH环境变量

1
2

 # .bashrc
export PYTHONPATH=$PYTHONPATH:/path/to/fold/contains/module

• 对许多程序都使用的模块可以采取此方式
• 会改变所有Python应用的搜索路径

增加.pth文件

在/path/to/python/site-packages（或其他查找路径目录）下 添加.pth配置文件，内容为需要添加的路径

1
2

 # extras.pth
/path/to/fold/contains/module

• 简单、推荐
• python在遍历已知库文件目录过程中，遇到.pth文件会将其中 路径加入sys.path中

Atoms

原子：表达式最基本元素

• 最简单原子

  • 标识符
  • 字面值

• 以圆括号、方括号、花括号包括的形式在语法上也被归为原子

1
2

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display | dict_display | set_display | generator_expression | yield_atom

Indentifiers/Names

名称：作为原子出现的标识符

• 名称被绑定到对象时：对原子求值将返回相应对象
• 名称未绑定时：对原子求值将raise NameError

Private Name Mangling

• 类的私有名称：文本形式出现在类定义中以两个、更多下划线 开头且不以两个、更多下划线结尾的标识符

私有名称转换：在为私有名称生成代码前，其被转换为更长形式

• 转换方式：在名称前插入类名、下划线

  • 若转换后名称太长（超过255字符），某些实现中可能 发生截断

• 转换独立于标识符使用的句法

• 若类名仅由下划线组成，则不会进行转换

Literals

字面值：

1

literal ::=  stringliteral | bytesliteral | integer | floatnumber | imagnumber

• 对字面值求值将返回改值对应类型的对象

  • 对浮点数、复数，值可能为近似值

• 所有字面值都对应不可变数据类型

  • 所以对象标识的重要性不如其实际值

• 多次对具有相同值的字面值求值，可能得到相同对象、或具有 相同值的不同对象

  • 元组是不可变对象，适用字面值规则：两次出现的空元组 产生对象可能相同、也可能不同

    todo

Parenthesized Forms

带括号形式：包含在()的可选表达式列表

1

parenth_form ::= "(" [starred_expression] ")"

• 带圆括号表达式列表将返回表达式所产生的任何东西

  • 内容为空的圆括号返回空元组对象
  • 列表包含至少一个逗号，产生元组
  • 否则，产生表达式列表对应的单一表达式

• 元组不是由圆括号构建，实际是,逗号操作符起作用

  • 空元组是例外，此时圆括号必须，因为表达式中不带圆括号 的“空”会导致歧义

List/Set/Dict/Generator-Tuple

• display：显式列出容器内容
• comprehension：推导式，通过循环、筛选指令计算

1
2
3
4

comprehension ::=  expression comp_for
comp_for      ::=  ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" expression_nocond [comp_iter]

• 推导式结构：单独表达式后加至少一个for子句以及零个、或 多个for或if子句

  • for、if子句视为代码块，按从左到右顺序嵌套 （类似for循环嵌套）
  • 每次到达最内层代码块时对表达式求值以产生元素

• 除最左边for子句中可迭代表达式，推导式在另一个隐式嵌套 作用域内执行

  • 确保赋给目标列表的名称不会“泄露”到外层作用域
  • 最左边for子句中可迭代表达式直接在外层作用域中被 求值，然后作为参数传递给隐式嵌套作用域
  • 后续for子句、最左侧for子句中任何筛选条件不能在 外层作用域中被求值，因为其可能依赖于从最左侧可迭代 对象中获得的值

• 为确保推导式总能得到类型正确的容器，隐式嵌套作用域内禁止 使用yield、yield from表达式，因为其会对外层作用域 造成附加影响

• 若推导式包含async for子句、await表达式，则为异步 推导式

List Displays

列表显式：用[]方括号括起的、可能为空的表达式系列

1

list_display ::= "[" [starred_list | comprehesion] "]"

• 列表显式会产生新的列表对象，内容通过表达式、推导式指定
• 提供逗号分隔的表达式时：元素从左至右求值，按此顺序放入 列表对象
• 提供推导式时：根据推导式产生结果元素进行构建

Set Displays

集合显式：用{}花括号标明，与字典区别在于没有冒号分隔键值

1

set_display ::=  "{" (starred_list | comprehension) "}"

• 集合显式产生可变集合对象，内容通过表达式、推导式指定
• 提供逗号分隔的表达式时：元素从左至右求值，按此顺序放入 列表对象
• 提供推导式时：根据推导式产生结果元素进行构建

• 空集合不能使用{}构建，此构建的是空字典

Dict Displays

字典显式：用{}花括号括起来的、可能为空的键值对

1
2
3
4

dict_display       ::=  "{" [key_datum_list | dict_comprehension] "}"
key_datum_list     ::=  key_datum ("," key_datum)* [","]
key_datum          ::=  expression ":" expression | "**" or_expr
dict_comprehension ::=  expression ":" expression comp_for

• **：映射拆包，操作数必须是映射

• 字典显式产生新的字典对象

• 提供,分隔键值对序列

  • 从左至右被求值以定义字典条目
  • 可多次指定相同键，最终值由最后给出键值对决定

• 提供字典推导式

  • 以冒号分隔的两个表达式，后者带上标准for、if子句
  • 作为结果键值对按产生顺序被加入新字典

• 键类型需要为hashable

Generator Expression

生成器表达式：用圆括号括起来的紧凑形式生成器（迭代器）标注

1

generator_expression ::=  "(" expression comp_for ")"

• 生成器表达式会产生新的生成器（迭代器）对象

  • 句法同推导式，但使用圆括号括起
  • 圆括号在只附带一个参数（省略expression）的调用中 可以被省略

• 生成器表达式中使用的变量在生成器对象调用__next__方法 时以惰性方式被求值，同普通生成器

  • 最左侧for子句内可迭代对象会被立即求值，则其造成的 错误会在生成器表达式被定义时被检测到

Yield Expression

yield表达式：将控制权交还给调度程序

1
2

yield_atom       ::=  "(" yield_expression ")"
yield_expression ::=  "yield" [expression_list | "from" expression]

• yield：返回其后表达式求值
• yield表达式是赋值语句右侧唯一表达式时，括号可以省略

• 在定义生成器函数、异步生成器函数时才会用到，也只能在函数 定义内部使用yield表达式，将函数变为（异步）生成器函数

• yield表达式会对外层作用域造成附带影响，不允许作为实现 推导式、生成器表达式隐式作用域的一部分

• 生成器、异步生成器参见cs_python/py3ref/dm_gfuncs

yield from

yield from：其后表达式视为子迭代器，将控制流委托给其

• 类似管道，迭代器参数、异常都被传递给子迭代器

  • 子迭代器依次迭代结果被传递给生成器方法调用者
  • .send传递值、.throw生成异常被传递给子迭代器

• .send传入值、.throw传入异常如果有适当方法将被传递给 下层迭代器，否则

  • send将raise AttributeError、raise TypeError
  • throw将立即引发传入异常

• 子迭代器完成后引发的StopIteration实例的value属性将 作为yield表达式值

  • 可以在引发StopIteration时被显式设置#todo
  • 在子迭代器是生成器时通过从子生成器返回值自动设置

• 用途

  • 展开嵌套序列

Primaries

原型：代表编程语言中最紧密绑定的操作（优先级最高）

1

primary ::= atom | attributeref | subscription | slicing | call

Attributeref

属性引用：后面带有句点加名称的原型

1

attributeref ::= primary "." identifier

• 要求值为支持属性引用类型的对象（多数对象支持）
• 对象会被要求产生以指定标识符为名称的属性
  • 产生过程可以通过重载__getattr__()方法自定义

Subscriptions

抽取：在序列（字符串、元组、列表）、映射（字典）对象中选择 一项

1

subscription ::= primary "[" expression_list "]"

• 要求值必须为支持抽取操作的对象

  • 可以定义__getitem__()方法支持抽取操作

• 映射：表达式列表求值须为键值

  • 抽取操作选择映射中键对应值
  • 表达式列表为元组，除非其中只有一项

• 序列：表达式列表求值须为整数、或切片

  • 正式句法规则没有要求实现对负标号值处理，但内置序列 __getitem__()方法结合序列长度解析负标号
  • 重载__getitem__的子类需要显式添加对负标号、切片 支持

Slicings

切片：在序列对象（字符串、元组、列表）中选择某个范围内的项

1
2
3
4
5
6
7

slicing      ::=  primary "[" slice_list "]"
slice_list   ::=  slice_item ("," slice_item)* [","]
slice_item   ::=  expression | proper_slice
proper_slice ::=  [lower_bound] ":" [upper_bound] [ ":" [stride] ]
lower_bound  ::=  expression
upper_bound  ::=  expression
stride       ::=  expression

• 可以用作表达式赋值、del语句的目标

• 形似表达式列表的东西同样形似切片列表，所以任何抽取操作 都可以被解析为切片

  • 通过定义将此情况解析为抽取优先于切片以消除歧义

• 原型使用__getitem__、根据切片列表构造的键进行索引

  • 切片列表包含逗号：键将为包含切片项转换的元组
  • 否则：键为单个切片项的转换
  • 切片项若为表达式：切片的转换即为切片对象

Calling

调用：附带可能为空的一系列参数来执行可调用对象

1
2
3
4
5
6
7
8
9
10
11

call                 ::=  primary "(" [argument_list [","] | comprehension] ")"
argument_list        ::=  positional_arguments ["," starred_and_keywords]
                            ["," keywords_arguments]
                          | starred_and_keywords ["," keywords_arguments]
                          | keywords_arguments
positional_arguments ::=  ["*"] expression ("," ["*"] expression)*
starred_and_keywords ::=  ("*" expression | keyword_item)
                          ("," "*" expression | "," keyword_item)*
keywords_arguments   ::=  (keyword_item | "**" expression)
                          ("," keyword_item | "," "**" expression)*
keyword_item         ::=  identifier "=" expression

• 要求值为可调用对象

  • 用户定义函数
  • 内置函数
  • 内置对象方法
  • 类对象
  • 类实例方法
  • 任何具有__call__()方法的对象

• 调用流程

  • 参数表达式在尝试调用前被求值
  • 所有参数表达式被转换为参数列表
  • 代码块将形参绑定到对应参数表达式值

• 除非引发异常，调用总有返回值

  • 返回值可能为None
  • 返回值计算方式取决于可调用类型
    • 用户定义函数、实例方法、类实例：函数返回值
    • 内置函数：依赖于编译器
    • 内置对象方法：类新实例

• 在位置参数、关键字参数后加上括号不影响语义

关键字实参转位置实参

若存在关键字实参，会通过以下操作被转换为位置参数

• 为正式参数创建未填充空位的列表
• 若有N个位置参数：将其放入前N个空位
• 对每个关键字参数
  • 使用标识符确定对应的空位：若标识符与第k个正式 参数名相同，使用第k个空位
  • 若空位已被填充：则raise TypeError
  • 否则将参数值放入空位进行填充
• 所有参数处理完毕后，未填充空位使用默认值填充
• 若仍有未填充空位，则raise TypeError；否则填充完毕 列表被作为调用的参数列表

多余实参

• 若有关键字参数没有与之对应的正式参数名称，将 raise TypeError，除非有形参使用**indentifier句法

  • identifier将被初始化新的有序映射接收任何额外关键字 参数
  • 若没有多余关键字实参，则为相同类型空映射

• 若位置实参数目多余位置形参数目，将raise TypeError， 除非有形参使用*identifier句法

  • identifier将初始化为元组接受任何额外位置参数
  • 没有多余位置实参，则为空元组

实参解包

• 若实参中出现*expression句法

  • expression求值须为iterable
  • 来自该可迭代对象的元素被当作额外位置实参

  • *expression可以放在关键字实参后而没有语法错误

    • expression会优先被迭代，元素用于填充参数列表
    • 可能和关键字参数冲突，导致关键字参数对应空位被 填充

    • 一般位置实参必须位于关键字实参前，否则有语法错误

• 若实参中出现**expresion句法

  • expression求值须为mapping
  • 其内容被当作额外关键字参数
    • 若关键字已存在，将raise TypeError

运算符

• 运算符优先级：从低到高

  |运算符|描述| |——-|——-| |lambda|lambda表达式| |if--else|条件表达式| |or|布尔逻辑或| |and|布尔逻辑与| |not|布尔逻辑非| |in、not in、is、is not、<、<=、>、=>、!=、==|比较运算，包括成员检测、标识号检测| |||按位或| |^|按位异或| |&|按位与| |<<、>>|移位| |+、-|加、减| |*、@、/、//、%|乘、矩阵乘、除、整除、取余（字符串格式化）| |+x、-x、~x|正、负、按位取反| |**|幂次| |await|await表达式| |x[index]、x[start:end]、x(arguments...)|抽取、切片、调用、属性调用| |(expression...)、[expressions...]、{key:value}、{expressions...}|绑定或元组、列表、字典、集合显示|

• 求值顺序：从左至右对表达式求值

  • 但赋值操作时，右侧先于左侧求值

• 算术类型转换

  • 若任意参数为复数，另一参数转换为复数
  • 否则，若任意参数为浮点数，另一参数为浮点数
  • 否则，二者均为整数，不需要转换

await

await：挂起coroutine执行以等待awaitable对象

1

await_expr ::= "await" primary

• 只能在协程函数中使用

幂运算符

幂运算符

1

power ::= (await_expr | primary) ["**" u_expr]

• 优先级高于左侧一元运算符、低于右侧一元运算符

  1 2 3

  -1 ** 2 == -1 0 ** 0 == 1 # 编程语言得普遍做法

• 语义同两个参数调用内置power函数

  • 左参数进行右参数所指定的幂次乘方运算
  • 数值参数会转换为相同类型，返回转换后类型
    • int类型做负数幂次：参数转换为float
    • 0进行负数幂次：raise ZeroDivisionError
    • 负数进行分数次幂次：返回complex类型

一元算术、位运算

一元算术、位运算

1

u_expr ::= power | "-" u_expr | "+" u_expr | "~" u_expr

• 一元算数、位运算具有相同优先级
• 若参数类型不正确将raise TypeError
  • +：产生数值参数相同的值
  • -：产生数值参数的负值
  • ~：只作用于整数，对整数参数按位取反，返回-(x+1) （即负值使用补码存储）

二元算术运算符

二元算术运算符

1
2
3
4

m_expr ::=  u_expr | m_expr "*" u_expr | m_expr "@" m_expr |
            m_expr "//" u_expr | m_expr "/" u_expr |
            m_expr "%" u_expr
a_expr ::=  m_expr | a_expr "+" m_expr | a_expr "-" m_expr

• 二元算术运算符遵循传统优先级，除幂运算符外只有两个优先 级别

  • 乘法型
  • 加法型

• python支持混合算术，二元运算符可以用于不同类型操作数

  • 精度较低者会被扩展为另一个操作数类型

算符说明

• @：目标是用于矩阵乘法，没有内置类型实现此运算符

• %：模，输出第1个参数除以第2个参数的余数

  • 参数可以是浮点数
  • 结果正负总是与第2个操作数一致、或为0
  • 结果绝对值一定小于第2个操作数绝对值（数学上必然真， 但对浮点数而言由于舍入误差存在，数值上未必真）

• //：整除，结果就是floor函数处理算术除法/的结果

  • 整除、模语义同内置函数divmod(x,y) == (x//y, x%y)
  • 若x接近y的整数倍，由于舍入误差的存在，x//y可能 大于(x-x%y)//y，此时python返回后一个结果，保证 divmod(x,y)[0]*y + x % y尽量接近x

• 某些运算符也作用于特定非数字类型

  • *：两个参数分别为整数、序列，执行序列重复
  • %：被字符串对象重载，用于执行旧式字符串格式化/插值
  • +：两个参数为相同类型序列，执行序列拼接操作

移位运算

移位运算

1

shift_expr ::= a_expr | shift_expr ("<<" | ">>") a_expr

• 优先级低于算术运算
• 运算符接受整数参数
  • 将第一个参数左移、右移第二个参数指定的bit数
  • 右移：x >> n == x // power(2, n)
  • 左移：x << n == x * power(2, n)

二元位运算

二元位运算

1
2
3

and_expr ::=  shift_expr | and_expr "&" shift_expr
xor_expr ::=  and_expr | xor_expr "^" and_expr
or_expr  ::=  xor_expr | or_expr "|" xor_expr

• 三种位运算符具有不同的优先级

• 两个参数须为整数

  • &：对两个参数进行按位AND运算
  • ^：对两个参数进行按位XOR运算
  • |：对两个参数进行按位OR运算

比较运算

比较运算

1
2
3

comparison    ::=  or_expr (comp_operator or_expr)*
comp_operator ::=  "<" | ">" | "==" | ">=" | "<=" | "!="
                   | "is" ["not"] | ["not"] "in"

• 所有比较运算优先级相同（与C不同）

  • 低于任何算术、移位、位运算

• 比较运算可以任意串联a op1 b op2 c ... y opN z等价于 a op1 b and b op2 c and ... and y opN z

  • 只是后者中每个表达式最多只被求值一次

  • 例：a < b >= c类似表达式会被按照传统比较法则解读

    • 等价a < b and b >= c
    • 仍具有短路求值特性，a < b == false时，c不会 被求值

值比较

• >、<、==、!=、<=、>=比较两个对象值

  • 不要求两个对象为相同类型

  • 比较运算符实现了特定对象值概念，可以认为是通过 实现对象比较间接定义对象值

• 所有类型继承于object，从其继承了默认比较行为

  • =、!=：一致性比较，基于对象标识id

    • 具有相同标识的实例一致性比较结果相等
    • 此默认行为动机：希望对象都应该是自反射，即 x is y就意味着x == y

  • <、>、<=、>=：没有默认值提供

    • 尝试比较raise TypeError
    • 此默认行为动机：缺少一致性比较类似固定值

数字类型

数字类型：int、float、complex以及标准库类型 fractions.Fraction、decimal.Decimal

• 可进行类型内部、跨类型比较

  • 类型相关限制内按数学（算法）规则正确进行比较，且不会 有精度损失
  • 复数不支持次序比较

• 非数字值float('NaN')、decimal.Decimal('NaN')

  • 同任何其他数字值比较均返回False
  • 不等于自身，但是是同一个对象（标识相同）

  • 具体实现参见cs_python/py3ref/#todo

二进制码序列

二进制码序列：bytes、bytearray

• 可以进行类型内部、跨类型比较
• 使用元素数字值按字典序进行比较

字符串

字符串：str

• 使用字符的Unicode码位数字值、按字典序比较
• 字符串、二进制码序列不能直接比较

序列

序列：tuple、list、range

• 只能进行类型内部比较

  • 跨类型：一致性比较结果为否、次序比较将 raise TypeError
  • range不支持次序比较

• 序列元素通过相应元素进行字典序比较

  • 序列相等：相同类型、相同长度，每对相应元素必须 相等
  • 对支持次序比较序列：排序同第一个不相等元素排序，若 对应元素不同，较短序列排序较小

• 强制规定元素自反射性：序列元素x，x==x总为真

  • 即序列元素比较比较时：须首先比较元素标识，仅会对不同 元素执行==严格比较运算

  • 若序列元素为自反射元素，结果与严格比较相同；若序列 元素为非自反射元素，结果与严格比较不同

    1 2 3 4

    nan = float("NaN") (nan is nan) == True (nan == nan) == False ([nan] == [nan]) == True

映射

映射：dict

• 映射相等：当且进行具有相同键值对
  • 键、值一致性比较强制规定自反射性

集合

集合：set、frozenset

• 可进行类型内部、跨类型比较

• 比较运算符定义为子集、超集检测

  • 这类关系没有定义完全排序，如：{1,2}、{2,3}集合 不相等，也没有大小比较关系
  • 所以，集合不应作为依赖完全排序的函数参数，如： min、max、sorted，将产生未定义结果

• 集合强制规定其元素自反射性

自定比较行为

• 其他内置类型没有实现比较方法，继承object默认比较行为
• 可以通过实现富比较方法自定义类型的比较行为，最好 遵守一些一致性规则（不强制）

• 自反射：相同对象比较应该相等

  • x is y有x == y

• 对称性

  • x == y有y == x
  • x != y有y != x
  • x < y有y > x
  • x <= y有y >= x

• 可传递

  • x > y and y > z有x > z
  • x < y and y <= z有x < z

• 反向比较应该导致布尔取反

  • x == y有not x != y
  • x < y有not x >= y（对完全排序）
  • x > y有not x <= y（对完全排序）

• 相等对象应该具有相同hash值，或标记为不可hash

• 具体实现参见cs_python/py3ref/#todo

成员检测

in、not in：成员检测，后者为前者取反

• 对list、tuple、set、frozenset、dict、 collections.deque等内置容器类型

  • x in y同any(x is e or x == e for e in y)
  • 映射检测是否有给定键

• 对字符串、字节串

  • 当且进当x为y其子串时x in y返回True，空字符串 总被视为其他字符串子串
  • x in y等价于y.find(x) != -1

• 自定义类型可以自定义成员检测

  • __contains__方法返回值即为x in y返回值
  • 未定义__contains__方法但定义__iter__，若迭代y 得到值z == x，则x in y == True，出现异常等同于 in引发异常

  • 具体实现参见cs_python/py3ref/#todo

标识号比较

is、is not：对象标识号检测，后者为前者取反

• 当且仅当x、y为同一对象x is y == True

布尔运算

布尔运算

1
2
3

or_test  ::=  and_test | or_test "or" and_test
and_test ::=  not_test | and_test "and" not_test
not_test ::=  comparison | "not" not_test

• 执行布尔运算、表达式用于流程控制语句时，以下值被解析为 假值，其余值被解析为真值

  • False
  • None
  • 所有数值类型的数值0
  • 空字符串
  • 空容器

• and、or返回最终求值参数而不是False、True

  • x and y：首先对x求值

    • 对x求值，若为假直接返回x求值
    • 否则对y求值并返回

  • x or y：首先对x求值

    • 对x求值，若为真直接返回x求值
    • 否则对y求值并返回结果值

• not必须创建新值，无论参数为和类型均范围布尔值True、 False

• 可以通过自定义__bool__方法定制逻辑值

  • 具体实现参见cs_python/py3ref/#todo

条件表达式

条件表达式：三元运算符

1
2
3

conditional_expression ::=  or_test ["if" or_test "else" expression]
expression             ::=  conditional_expression | lambda_expr
expression_nocond      ::=  or_test | lambda_expr_nocond

• 在所有python运算中具有最低优先级
• x if C else y
  • 首先对条件C求值
  • 若C为真，x被求值并返回
  • 否则将对y求值并返回

lambda表达式

lambda表达式：创建匿名函数

1
2

lambda_expr        ::=  "lambda" [parameter_list] ":" expression
lambda_expr_nocond ::=  "lambda" [parameter_list] ":" expression_nocond

• lambda parameters: expression返回函数对象，同

  1 2	def <lambda>(parameters): return expression

• lambda表达式只是简单函数定义的简单写法

表达式列表

表达式列表：除作为列表、集合显示的一部分，包含至少一个逗号 的列表表达式将生成元组

1
2
3
4

expression_list    ::=  expression ("," expression)* [","]
starred_list       ::=  starred_item ("," starred_item)* [","]
starred_expression ::=  expression | (starred_item ",")* [starred_item]
starred_item       ::=  expression | "*" or_expr

• 末尾逗号仅在创建单独元组时需要，在其他情况下可选

• 元组长度就是列表中表达式的数量

  • 表达式将从左至右被求值

• *表示可迭代拆包：操作数必须为iterable（同实参调用）

  • 可迭代对象将被拆解为迭代项序列，并被包含于新建的元组 、列表、集合中

综述

• 内置类型相关参见cs_python/py3ref/dm_basics

常用参数说明

Functional Programming

• key=None/callable

  • 含义：key函数，接受一个参数，返回用于排序的值
  • 默认：None，不处理

• iterable=iterable

  • 含义：可迭代对象

对象、值、类型

对象：python中对数据的抽象

• python中所有数据都是由对象、对象间关系表示

  • 按冯诺依曼“存储程序计算机”，代码本身也是由对象表示

编号、类型、值

每个对象都有各自编号、类型、值

• 编号：可以视为对象在内存中地址，对象创建后不变

  • id()函数：获取代表对象编号的整形
  • is算符：比较对象编号判断是否为同一对象

• 类型：决定对象支持的操作、可能取值

  • 类型会影响对象行为几乎所有方面，甚至对象编号重要性 也受到影响，如：对于会得到新值的运算
    • 不可变类型：可能返回同类型、同取值现有对象引用
      • a = b = 1：a、b可能指向相同对象1 （取决于具体实现）
    • 可变类型：不允许返回已存在对象
      • c=[];d=[]：会保证c、d指向不同、单独 空列表（c=d=[]将同一对象赋给c、d）
  • 对象创建后保持不变
  • type：返回对象类型

  • CPython：相同整形值都引用同一个对象

• 值：通过一些特征行为表征的抽象概念

  • 对象值在python中是抽象概念

    • 对象值没有规范的访问方法
    • 不要求具有特定的构建方式，如：值由其全部数据 属性组成

  • 对象值可变性由其类型决定

    • 可变的：值可以改变的对象
    • 不可变的：值（直接包含对象编号）不可改变的对象

  • 比较运算符实现了特定对象值概念，可以认为是 通过实现对象比较间接定义对象值

• CPython：id(x)返回存放x的地址

对象销毁

对象不会被显式销毁（del仅是移除名称绑定）

• 无法访问时可能被作为垃圾回收

  • 允许具体实现推迟垃圾回收或完全省略此机制
  • 实现垃圾回收是质量问题，只要可访问对象不会被回收 即可
  • 不要依赖不可访问对象的立即终结机制，应当总是显式 关闭外部资源引用

• 以下情况下，正常应该被回收的对象可能继续存活

  • 使用实现的跟踪、调试功能
  • 通过try...except...语句捕捉异常

• CPython：使用带有（可选）延迟检测循环链接垃圾的 引用计数方案

  • 对象不可访问时立即回收其中大部分，但不保证 回收包含循环引用的垃圾

标准类型层级结构

• 以下是python内置类型的列表，扩展模块可以定义更多类型
• 以下有些类型有特殊属性，这些特殊属性不应用作通常使用， 其定义在未来可能改变

None

NoneType：只有一种取值，None是具有此值的唯一对象

• 通过内置名称None访问
• 多数情况表示空值，如
  • 未显式指明返回值函数返回None
• 逻辑值：假

NotImplemented

NotImplementedType：只有一种取值，NotImplemented是具有 此值的唯一对象

• 通过内置名称NotImplemented访问
• 数值、富比较方法在操作数没有该实现操作时应返回此值
  • 返回NotImplemented前，解释器会依据运算符尝试反射 方法、委托回退方法
• 逻辑值：真

Ellipsis

ellipsis：只有一种取值，Ellipsis是具有此值的唯一对象

• 通过字面值...、内置名称Ellipsis访问
• 逻辑值：真

numbers.Number

number.Number：由数字字面值创建，被作为算法运算符、算数 内置函数返回结果

• 不可变：一旦创建其值不再改变
• 类似数学中数字，但也受限于计算机对数字的表示方法

numbers.Integral

numbers.Integral：表示数学中整数集合

• int：整形，表示任意大小数字，仅受限于可用内存

  • 变换、掩码运算中以二进制表示
  • 负数以2的补码表示（类似符号位向左延伸补满空位）

• bool：布尔型，表示逻辑值真、假

  • True、False是唯二两个布尔对象
  • 整形子类型：在各类场合中行为类似整形1、0，仅在 转换为字符串时返回"True"、"False"

方法、函数

• int.bit_length()：不包括符号位、开头0位长
• int.to_bytes(length, byteorder, *, signed=False)
• class int.from_bytes(bytes, byteorder, *, signed=False)

• 详细说明参见https://docs.python.org/zh-cn/3/library/stdtypes.html#additional-methods-on-integer-types

numbers.Real(float)

float：表示机器级双精度浮点数

• 接受的取值返回、溢出处理取决于底层结构、python实现
• python不支持单精度浮点

• 没必要因为节省处理器、内存消耗而增加语言复杂度

特殊取值

1
2
3
4
5

infty = float("inf")
neg_infty = float("-inf")
	# 正/负无穷大
nan = float("nan")
	# Not a Number

• 特殊取值根据定义==、is肯定返回False

  • float.__eq__内部应该有做检查，保证==返回False
  • 每次会创建“新”的nan/infty

  • 连续执行id(float("nan"))返回值可能相等，这是因为 每次生成的float("nan")对象被回收，不影响

• np.nan is np.nan返回True，应该是numpy初始化的时候 创建了一个float("nan")，每次都是使用同一个nan

相关操作

• 详细参考https://docs.python.org/zh-cn/3/library/stdtypes.html#additional-methods-on-float
• 更多数字运算参考math、cmath模块

• float.as_integer_ratio()
• float.is_integer()
• float.hex()
• classmethod float.fromhex(s)
• round(f[,n])
• math.trunc(f)
• math.floor(f)
• math.ceil(f)

numbers.Complex(complex)

complex：以一对机器级双精度浮点数表示复数值

• 实部、虚部：可通过只读属性z.real、z.imag获取

Iterators

迭代器类型

• 迭代器对象需要自身支持以下两个方法，其共同组成迭代器协议
  • iterator.__iter__()
  • iterator.__next__()

• 方法详细参考cs_python/py3ref/cls_special_method

Generator

生成器类型：提供了实现迭代器协议的便捷形式

• 将容器对象的__iter__()方法实现为生成器，方便实现容器对 迭代器支持

• 创建、使用参见cs_python/py3ref/dm_gfuncs

序列

序列：表示以非负整数作为索引的有限有序集

• 不可变序列类型：对象一旦创建不能改变

  • 若包含其他可变对象引用，则可变对象“可改变”
  • 但不可变对象所直接引用的对象集是不可变的
  • 包括
    • str
    • tuple
    • bytes
    • range：非基本序列类型

• 可变序列：创建后仍可被改变值

  • list
  • bytesarray

通用序列操作

• x in s、x not in s

  • str、bytes、bytearray支持子序列检测

• s + t：拼接

  • 拼接不可变总会生成新对象
  • 重复拼接构建序列的运行时开销将基于序列总长度乘方

• s * n、n * s：s自身拼接n次

  • n<0被当作0处理
  • s中项不会被复制，而是被多次引用

• s[i]、s[i:j]、s[i:j:step]

  • i<0索引为负值：索引顺序相对于序列s末尾，等价于 对序列长度取模
  • 序列切片：与序列类型相同的新序列
    • 索引从0开始
    • 左闭右开
  • 某些序列支持a[i:j:step]扩展切片

• s.index(x[, i[, j]])

  • 仅部分序列支持
  • 类似s[i:j].index(x)，但返回值是相对序列开头

• s.count(x)：序列中元素x数目

• len(s)：返回序列条目数量

• min(s)、max(s)：序列最小、最大值

• 序列比较运算默认实现参见cs_python/py3ref/expressions
• 以上运算自定义实现参见 cs_python/py3ref/cls_special_methods

不可变序列

不可变序列普遍实现而可变序列未实现的操作

• hash()内置函数

可变序列

• s[i]=x、s[i:j]=t、s[i:j:k]=t：下标、切片被赋值
  • s[i:j:k]=t中t长度必须和被替换切片长度相同
• del s[i:j]、del s[i:j:k]：移除元素
  • 作为del语句的目标
  • 等同于s[i:j]=[]
• s.append()：添加元素
  • 等同于s[len(s):len(s)] = [x]
• s.clear()：移除所有项
  • 等同于del s[:]
• s.copy()：浅拷贝
  • 等同于s[:]
• s.extend(t)：扩展（合并）序列
  • 基本上等于s += t
• s.insert(i, x)：向序列中插入元素
  • 等同于s[i:i] = [x]
• s.pop(i=-1)：弹出序列中元素
• s.remove(x)：删除序列中首个值为x的项
• s.reverse()：反转序列
  • 反转大尺寸序列时，会原地修改序列
  • 为提醒用户此操作通过间接影响进行，不会返回反转后序列

• array、collections模块提供额外可变序列类型
• 可利用collections.abc.MutableSequence抽象类简化自定义 序列操作

tuple

元组

• 元组中条目可以是任意python对象
• 元组创建
  • 一对圆括号创建空元组
  • 逗号分隔
    • 单项元组：后缀逗号a,、(a,)
    • 多项元组：a,b,c、(a,b,c)
  • 内置构建器：tuple、tuple(iterable)

list

列表

• 列表中条目可以是任意python对象
• 构建方式
  • 方括号括起、项以逗号分隔：[]、[a]、[a,b]
  • 列表推导式：[x for x in iterable]
  • 类型构造器：list(iterable)

相关操作

.sort

1
2

def list.sort(*, key=None, reverse=False):
	pass

• 用途：对列表原地排序

  • 使用<进行各项之间比较
  • 不屏蔽异常：若有比较操作失败，整个排序操作将失败， 此时列表可能处于部分被修改状态

• 参数

  • key：带参数函数，遍历处理每个元素提取比较键
    • None：默认，直接使用列表项排序

• 说明

  • .sort保序，有利于多重排序
  • 为提醒用户此方法原地修改序列保证空间经济性，其不返回 排序后序列（可考虑使用sorted显式请求）

• CPython：列表排序期间尝试改变、检测会造成未定义影响， CPython将列表排序期间显式为空，若列表排序期间被改变将 raise ValueError

str

1
2
3
4
5

class str(object="")
	# 返回`object.__str__()`、`object.__repr__()`
class str(object=b"", encoding="utf-8", errors="strict")
	# 给出`encoding`、`errors`之一，须为bytes-like对象
	# 等价于`bytes.decode(encoding, errors)`

字符串：由Unicode码位值组成不可变序列（应该是UTF16-bl编码）

• 范围在U+0000~U+10FFFF内所有码位值均可在字符串中使用
• 不存在单个“字符”类型
  • 字符串中单个字符为长度为1字符串
• 不存在可变字符串类型
  • 可以用str.join()、io.StringIO高效连接多个字符串 片段
• 字符串构建
  • 字符串字面值：cs_python/py3ref/lexical_analysis
  • 内置构造器str()

相关操作

• 参见https://docs.python.org/zh-cn/3/library/stdtypes.html#string-methods

• ord()：转换单个字符字符串为（整形）码位
• chr()：转换（整形）码位为单个字符字符串

判断

• str.isalnum()
• str.isalpha()
• str.isascii()
• str.isdecimal()
• str.isdigit()
• str.isidentifier()
• str.islower()
• str.isnumeric()
• str.isprintable()
• str.isspace()
• str.istitle()
• str.isupper()

查找

• str.rfind(sub[, start[, end]])
• str.rindex(sub[, start[, end]])
• str.startswith(prefix[, start[, end]])
• str.endwith(suffix[, start[, end]])
• str.count(sub[, start[, end]])：子串出现次数
• str.find(sub[, start[, end]])
  • 仅检查sub是否为子串，应使用in
  • 找不到子串时返回-1
• str.index(sub[, start[, end]])
  • 类似str.find，但找不到子串时raise ValueError

分隔

• str.partition(sep)
• str.rpartition(sep)
• str.rsplit(sep=None, maxsplit=-11)
• str.split(sep=None, maxsplit=-1)
• str.splitline([keepends])

拼接

• str.join(iterable)
• str.strip([chars])
• str.lstrip([chars])
• str.rstrip([chars])
• str.rstrip([chars])

转换

• str.lower()
• str.upper()
• str.swapcase()
• str.translate(table)
• str.replace(old, new[, count])
• static str.maketrans(x[, y[, z]])
• str.encode(encoding="utf-8", errors="strict")：使用 指定编码方案编码为bytes
• str.expandtabs(tabsize=8)
• str.capitalize()：首字符大写副本
• str.casefold()：消除大小写副本
• str.center(width[, fillchar])：字符串位于中间的字符串
• str.title()

格式化

• str.ljust(width[, fillchar])
• str.rjust(width[, fillchar])
• str.zfill(width)
• str.format(*args, **kwargs)
• str.format_map(mapping)
  • 类似str.format(**mapping)，但mapping不会被复制 到dict中

    1 2 3 4

    class Default(dict): def __missing__(self, key): return key "{name} was born in {country}".format_map(Default(name="Guido"))

printf风格字符串格式化

• format % values中：format中%转换标记符将被转换 为values中条目

  • 效果类似于sprintf
  • values为与format中指定转换符数量等长元组、或映射 对象，除非format要求单个参数

• 转换标记符按以下顺序构成

  • %字符：标记转换符起始
  • 映射键：可选，圆括号()括起字符序列
    • values为映射时，映射键必须
  • 转换旗标：可选，影响某些类型转换效果
    • #：值转换使用“替代形式”
    • 0：为数字值填充0字符
    • -：转换值左对齐（覆盖0）
    • ：符号位转换产生整数（空字符串）将留出空格
    • +：符号字符显示在开头（覆盖 ）
  • 最小字段宽度：可选
    • *：从values读取下个元素
  • 精度：可选，.之后加精度值
    • *：从values读取下个元素
  • 长度修饰符：可选
  • 转换类型
    • d/u/i：十进制整形
    • o：8进制整形
      • #替代形式，前端添加0o
    • x/X：小/大写16进制整形
      • #替代形式，前端添加0x/0X
    • e/E：小/大写浮点指数
      • #替代形式，总是包含小数点
    • f/`F：浮点10进制
      • #替代形式，总是包含小数点
    • g/G：指数小于-4、不小于精度使用指数格式
      • #替代形式，总是包含小数点，末尾0不移除
    • c：单个字符（接收整数、单个字符字符串）
    • r/s/a：字符串（repr/str/ascii转换）
      • 按输出精度截断
    • %：输出%字符

技巧

• 快速字符串拼接
  • 构建包含字符串的列表，利用str.join()方法
  • 写入io.StringIO实例，结束时获取值

bytes/bytearray

1

class bytes([source[, encoding[, errors]]])

• 字节串：单个字节构成的不可变序列
• 字节数组：字节串可变对应版本，其他同不可变bytes

• 字节串构建

  • 字节串字面值：cs_python/py3ref/lexical_analysis
  • 内置构造器bytes()
    • 指定长度零值填充：bytes(10)
    • 整数组成可迭代对象：bytes(range(20))
    • 通过缓冲区协议复制现有二进制数据：bytes(obj)

• 字节数组构建

  • 字节数组没有字面值语法，只能通过构造器构造
  • 可变，构建空字节数组有意义

• 类似整数构成序列

  • 每个条目都是8位字节
  • 取值范围0~255，但只允许ASCII字符0~127
  • b[0]产生整数，切片返回bytes对象
  • 可通过list(bytes)将bytes对象转换为整数构成列表

• 由memeoryview提供支持

相关函数、方法

• bytes.decode：解码为相关字符串
• classmethod bytes.fromhex(string)
• bytes.hex()

• 其他类似字符串，包括printf风格格式化
• 参见https://docs.python.org/zh-cn/3/library/stdtypes.html#bytes-and-bytearray-operations

技巧

• 快速字节串拼接
  • 构建包含字节串的列表，利用bytes.join()方法
  • 写入io.BytesIO实例，结束时获取值
  • 使用betaarray对象进行原地拼接

memoryview

1

class memoryview(obj)

内存视图：允许python代码访问对象内部数据

• 若对象支持缓冲区协议，则无需拷贝

  • 支持缓冲区协议的内置对象包括bytes、bytesarray

• 内存视图元素：原始对象obj处理的基本内存单元

  • 对简单bytes、bytesarray对象，一个元素就是一字节
  • array.array等类型可能有更大元素

• 内存视图支持索引抽取、切片

  • 若下层对象可选，则支持赋值，但切片赋值不允许改变大小

相关操作

• 参见https://docs.python.org/zh-cn/3/library/stdtypes.html#memory-views

• mv.__eq__(exporter)
• mv.__len__()
• mv.tobyte()
• mv.hex()
• mv.tolist()
• mv.release()
• mv.cast(format[, shape])：将内存视图转换新格式形状

可用属性

以下属性均只读

• mv.obj：内存视图的下层对象
• mv.nbytes
  • == product(shape) * itemsize = len(mv.tobytes())
• mv.readonly
• mv.format：内存视图中元素格式
  • 表示为struct模块格式
• mv.itemsize
• mv.ndim
• mv.shape
• mv.strides
• mv.suboffsets
• mv.c_contiguous
• mv.f_contiguous
• mv.contiguous

Slices Object

切片对象：表示__getitem__()方法得到的切片

• 可以使用内置的slice()函数创建
• a[start: stop]形式的调用被转换为 a[slice(start, stop, None)]

• 切片对象是内部类型，参见cs_python/py3ref/dm_exec，也 不是序列类型

特殊只读属性

• start：下界
• stop：上界
• step：步长值

• 属性可以具有任意类型

方法

• .indices(self, length)：计算切片对象被应用到length 长度序列时切片相关信息
  • 返回值：(start, stop, step)三元组
  • 索引号缺失、越界按照正规连续切片方式处理

range

range：不可变数字序列类型（非不是基本序列类型）

1
2

class range(stop)
class range(start=0, stop[, step=1])

• 参数：必须均为整数（int或实现__index__方法）

  • step > 0：对range对象r[i]=start + step * i，其中 i >= 0, r[i] < stop
  • step < 0：对range对象r[i]=start + step * i，其中 i >= 0, r[i] > stop
  • step = 0：raise ValueError

• 说明

  • 允许元素绝对值大于sys.maxsize，但是某些特性如： len()可能raise OverflowError
  • range类型根据需要计算单项、切片值
    • 相较于常规list、tuple占用内存较小，且和表示 范围大小无关
    • 只能表示符合严格模式的序列
  • range类型实现了collections.abc.Sequence抽象类
    • 基本实现序列所有操作：检测、索引查找、切片等
    • 除拼接、重复：拼接、重复通常会违反严格模式
  • !=、==将range对象视为序列比较，即提供相同值即 认为相等

集合类型

• 表示不重复、不可变对象组成的无序、有限集合

  • 不能通过下标索引
  • 可以迭代
  • 可以通过内置函数len返回集合中条目数量

• 常用于

  • 快速成员检测、去除序列中重复项
  • 进行交、并、差、对称差等数学运算

公用操作

• 参见https://docs.python.org/zh-cn/3/library/stdtypes.html#set-types-set-frozenset

• len(s)
• x [not ]in s
• s.isdisjoint(other)
• s.issubset(other)/s <= other
• s < other
• s.issuperset(other)/s >= other
• s > other
• s.union(*others)/s | other |...
• s.intersection(*others)/s & other &...
• s.difference(*other)/s - other - other
• s.symmetric_difference(other)/s ^ other
• s.copy()

• 集合比较仅定义偏序，集合列表排序无意义

可变集合独有

• s.update(*others)/s |= other |...
• s.intersection_update(*others)/s &= other &...
• s.difference_udpate(*others)/s -= other |...
• s.symmetric_difference_update(other)/set ^= other
• s.add(elem)
• s.remove(elem)
• s.discard(elem)
• s.pop()
• s.clear()

set/frozenset

1
2

class set([iterable])
class frozenset([iterable])

• 集合：由具有唯一性的hashable对象组成的多项无序集
• 冻结集合：不可变集合，可哈希，可以用作集合元素、字典键

• 创建集合

  • set()内置构造器
  • 花括号包括、逗号分隔元组列表：{a, b}

• 创建冻结集合

  • frozenset()内置构造器

• python中集合类似dict通过hash实现

  • 集合元素须遵循同字典键的不可变规则
  • 数字：相等的数字1==1.0，同一集合中只能包含一个

操作说明

• .remove、.__contains__、discard等可以接收set类型 参数，其将被转换为临时frozenset对象

• 非运算符版本操作可以接受任意可迭代对象作为参数，运算符 版本只能接受集合类型作为参数

映射

映射：表示任何索引集合所索引的对象的集合

• 通过下标a[k]可在映射a中选择索引为k的条目
  • 可在表达式中使用
  • 可以作为赋值语句、del语句的目标

• dbm.ndbm、dbm.gnu、collections模块提供额外映射类型

通用操作

• 参见https://docs.python.org/zh-cn/3/library/stdtypes.html#mapping-types-dict

• len(d)
• d[key]
• key [not ]in d
• iter(d)
• d.keys()：返回字典视图对象
• d.values()：返回字典视图对象
• d.items()：返回字典视图对象
• d.get(key[, default])
• d.copy()
• classmethod fromkey(iterable[, value])

可变映射独有

• d[key]=value
• del d[key]
• d.clear()
• d.setdefault(key[, default])
• d.pop()
• d.popitem()
• d.copy()
• d.update()

dict

1
2
3

class dict(**kwargs)
class dict(mapping, **kwargs)
class dict(iterable, **kwargs)

字典：可由几乎任意值作为索引的有限个对象可变集合

• 字典的高效实现要求使用键hash值以保持一致性

  • 不可作为键的值类型
    • 包含列表、字典的值
    • 其他通过对象编号而不是值比较的可变对象
  • 数字：相等的数字1==1.0索引相同字典条目

• 创建字典

  • 花括号括起、逗号分隔键值对：{key:value,}
  • 内置字典构造器：dict()

字典视图对象

字典视图对象：提供字典条目的动态视图，随字典改变而改变

• len(dictview)
• iter(dictview)
• x in dictview

• 参见https://docs.python.org/zh-cn/3/library/stdtypes.html#dictionary-view-objects

综述

特殊方法：python类中具有特殊名称的方法，实现由特殊语法 所引发的特定操作

• python实现操作符重载的方式

  • 允许每个类自行定义基于操作符的特定行为
  • 特定操作包括python内置的钩子函数

• 钩子函数不能简单的看作直接调用特殊方法

  • 尝试调用备用实现：iter、reversed
  • 修改方法返回值：dir

• 大部分情况下，若没有定义适当方法，尝试执行操作将 raise AttributeError、raise TypeError

  • 但__hash__、__iter__、__reversed__、 __contains__等方法即使未定义，其对应钩子函数 实现会尝试调用可能的其他方法完成操作 （直接obj.__xxx__调用方法仍然报错）

  • 将特殊方法设为None表示对应操作不可用，此时即使以上 hash、iter、reversed、in等操作也不会尝试调用 备用方法

实例创建、销毁

调用类时，元属性方法执行顺序

• __prepare__()：创建命名空间
• 依次执行类定义语句
• __new__()：创建类实例
• __init__()：初始化类
  • __new__返回的新实例的__init__方法将被调用
  • 用户定义__new__返回对象不一定期望类实例，调用的 __init__随之不一定是期望方法
• 返回__new__返回类实例

__prepare__

• 在所有类定义开始执行前被调用，用于创建类命名空间
• 一般这个方法只是简单的返回一个字典或其他映射对象

__new__

1
2

classmethod object.__new__(cls[, *args, **kwargs]):
	pass

• 用途：创建、返回cls类新实例

  • super().__new__(cls[,...])调用超类方法创建类实例， 然后根据需要修改新创建实例再返回

• 参数

  • cls：待实例化类
  • 其余参数：类构造器表达式参数

• 返回值：cls类新实例

  • __new__返回值就是类构造器的返回值，有绝对控制权

说明

• __new__：builtin_function_or_method

• __new__是静态方法：以需实例化类作为第一个参数

  • __new__方法绑定当前类对象
  • 特例，不需要显式声明为静态方法

• 原生有两个__new__函数，二者C实现不同

  • type.__new__：元类继承，用于创建类对象
  • object.__new__：其他类继承，用于创建实例

__init__

1
2

def object.__init__(self[, *args, *kwargs]):
	pass

• 用途：初始化类实例

  • 类构造器中__new__返回类实例调用此方法初始化
  • 若基类有用户定义__init__方法，则其派生类__init__ 应该显式调用基类__init__保证基类部分正确初始化

• 参数

  • self：当前类实例
  • 其余参数：类构造器表达式参数

• 返回值：None，否则raise TypeError

__del__

1

def object.__del__(self)

• 用途：实例销毁时（引用计数变为0）被调用
  • 若基类有__del__方法，则其派生类__del__方法中 需要显式调用基类__del__保证基类部分正确清除
  • 对象重生：在其中创建该实例的新引用推迟其销毁
    • 不推荐
    • 重生对象被销毁时__del__是否会被再次调用取决于 具体实现
    • 当前CPython实现中只会调用一次

说明

• 解释器退出时不会确保为仍然存在的对象调用__del__方法
• “钩子函数”：del
  • del x不直接调用x.__del__()
  • del x仅将x的引用计数减一

输出属性

__repr__

1
2

def object.__repr__(self):
	pass

• 用途：输出对象的“官方”字符串表示

  • 如果可能，应类似有效的python表达式，可以用于重建具有 相同取值的对象（适当环境下）
  • 若不可能，返回形如<...some useful description...> 的字符串
  • 常用于调试，确保内容丰富、信息无歧义很重要

• 返回值：字符对象

  • 内置钩子函数：repr
  • 交互环境下直接“执行”变量的结果

__str__

1
2

def object.__str__(self):
	pass

• 用途：生成对象“非正式”、格式良好的字符串表示

  • 返回较方便、准确的描述信息

• 返回值：字符串对象

  • 内置钩子函数：str

说明

• object.__str__方法默认实现调用object.__repr__

  • 所以若未定义__str__，需要实例“非正式”字符串表示时 也会使用__repr__

• format、print函数会隐式调用对象__str__方法

  • 此时若__str__返回非字符串会raise TypeError

__bytes__

1
2

def object.__bytes__(self):
	pass

• 用途：生成对象的字节串表示

• 返回值：bytes对象

  • 内置钩子函数：bytes

__format__

1

def object.__format__(self, format_spec)

• 用途：生成对象的“格式化”字符串表示

  • 内部常调用format、str.format实现格式化
  • object.__format__(x, '')等同于str(x)

• 参数

  • fomrat_spec：包含所需格式选项描述的字符串
    • 参数解读由实现__format__的类型决定
    • 大多数类将格式化委托给内置类型、或使用相似格式化 语法

• 返回值：字符串对象

  • 内置钩子函数：format

__hash__

1
2

def object.__hash__(self):
	pass

• 用途：计算对象hash值返回

  • 相等的对象（即使类型不同）理应具有相同hash值
  • 建议把参与比较的对象的全部组件的hash值打包为元组， 对元组做hash运算

    1 2	def __hash__(self): return hash((self.name, self.nick, self.color))

• 返回值：整数

  • 内置钩子函数：hash()

说明

• hash()会从对象自定义的__hash__()方法返回值中截断为 Py_ssize_t大小

  • 64bits编译平台通常为8bytes、32bits为4bytes
  • 若对象__hash__()需要在不同位大小的平台上互操作， 需要检查支持的平台位宽

  • 查看sys.hash_info.width

• set、frozenset、dict这3个hash集类型中成员的操作 会调用相应__hash__()

• 类的__hash__方法设置为None时

  • 尝试获取实例hash值时将raise TypeError
  • isinstance(obj, collecitons.abc.Hashable)返回 False
  • 单纯在__hash__中显式raise TypeError会被错误 认为是可hash

关联__eq__

hash绝大部分应用场景是比较是否相等，所以__hash__、__eq__ 密切相关

• 类未定义__eq__

  • 也不应该定义__hash__，单独hash结果无法保证比较结果

• 类实现__eq__

  • 未定义__hash__：其实例将不可被用作hash集类型的项
  • 类中定义了可变对象：不应该实现__hash__，因为hash集 实现要求键hash值不可变

• 类重载__eq__方法

  • 默认其__hash__被隐式设为None
  • 否则须设置__has__ = <ParentClass>.__hash__显式保留 来自父类__hash__实现

默认实现

• float、integer、decimal.Decimal等数字类型hash运算 是基于为任意有理数定义的统一数学函数

  • 详细参考https://docs.python.org/zh-cn/3/library/stdtypes.html#hashing-of-numeric-types

• str、bytes、datetime对象__hash__值会使用不可预知 值随机加盐

  • 盐在单独python进程中保持不变，但在重复执行的python 进程之间是不可预测的
  • 目的是为了防止某种形式的DDos服务攻击

• 改变hash值会影响集合迭代次序

  • python也不保证次序不会改变

__bool__

1
2

def object.__bool__(self):
	pass

• 用途：返回True、False实现真值检测

  • 未定义：调用__len__返回非0值时对象逻辑为真
  • __len__、__bool__均未定义：所有实例逻辑为真

• 返回值：False、True

  • 内置构造函数：bool()

例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

class Pair:
	def __init__(self, x, y):
		self.x = x
		self.y = y

	def __repr__(self):
		# 返回实例代码表示形式
		# 通常用于重新构造实例
		return "Pair({0.x!r}, {0.y!r})".format(self)
			# 格式化代码`!r`指明输出使用`__repr__`而不是默认
				# 的`__str___`
			# 格式化代码`0.x`表示第一个参数`x`属性

	def __str__(self):
		return "({0.x!s}, {0.y!s})".format(self)
			# 格式化代码`!s`指明使用默认`__str__`

	def __format__(self):
		if self.x == 0:
			return self.y
		elif self.y == 0:
			return self.x
		return "{0.x!r}, {0.y!r}".format(self)

Rich Comparison Methods

富比较方法

1
2
3
4
5
6
7
8
9
10
11
12

def object.__lt__(self, other):
	pass
def object.__le__(self, other):
	pass
def object.__eq__(self, other):
	pass
def object.__ne__(self, other):
	pass
def object.__gt__(self, other):
	pass
def object.__ge__(self, other):
	pass

• 用途：比较运算符重载

  • x < y：调用x.__lt__(y)
  • x <= y：调用x.__le__(y)
  • x == y：调用x.__eq__(y)
  • x != y：调用x.__ne__(y)

• 返回值

  • 成功比较返回False、True
  • 若指定方法没有相应实现，富比较方法会返回单例对象 NotImplemented

• 比较运算默认实现参见cs_python/py3ref/expressions

说明

• 默认情况下，__ne__会委托给__eq__，并将结果取反，除非 结果为NotImplemented

• 比较运算符之间没有其他隐含关系

  • x < y or x == y为真不意味着x <= y
  • 要根据单个运算自动生成排序操作可以利用 functools.total_ordering()装饰器简化实现

• 以上方法没有对调参数版本（左边参数不支持该操作，右边参数 支持该操作）

  • 若两个操作数类型不同、且右操作数是左操作数直接或间接 子类，优先选择右操作数的反射方法，否则左操作数 方法（不考虑虚拟子类）
  • 反射方法
    • __lt__、__gt__互为反射
    • __le__、__ge__互为反射
    • __eq__、__ne__各为自身反射

内部信息

__dict__

• 钩子函数：vars、dir（部分）

  • vars是真正对应的钩子函数，返回键值对
  • dir执行过程中会访问__dict__、__class__，而且 只返回keys

• 对象底层字典，存储对象属性、方法

  • 注意区分开：实例属性、类属性、基类属性，__dict__ 只包括当前实例属性、方法
  • 返回结果是dir结果的子集

• 调用实例obj的属性时，按照以下顺序查找

  • obj.__dict__：当前实例的__dict__中
  • type(obj).__dict__：实例所属类的__dict__中
  • type(obj).mro().__dict__：基类的__dict__中

• 在大部分情况下__dict__会自动更新，如setattr函数时， 或说实例的属性、方法更新就是__dict__的变动

  • 一般情况下不要直接访问__dict__，除非真的清楚所有 细节，如果类使用了cls.__slots__、@property、 描述器类等高级技术时代码可能会被破坏

  • 尽量使用setattr函数，让python控制其更新

__class__

• 用途：返回实例所属类

• 返回值：实例（狭义）返回类、类返回元类

  • 钩子函数：type

__objclass__

• 用途：被inspect模块解读为指定实例所在的类
  • 合适的设置可以有助于动态类属性的运行时检查
  • 对于可调用对象：指明第一个位置参数应为特定类型的 实例、子类
    • 描述器类：instance参数

      todo

__slots__

• 用途：显式声明数据成员、特征属性，限制实例添加属性

  • 可赋值为：字符串、可迭代对象、实例使用的变量名构成的 字符串序列

    • 可迭代对象中元素可以是任何类型
    • 还可以映射类型，未来可能会分别赋给每个键特殊含义 的值

  • __slots__会为已声明变量保留空间

    • 直接访问将raise AttributeError
    • dir可以找到__slots__中声明的变量

• 阻止默认为每个实例创建__dict__、__weakref__的 行为，除非在__slots__中显式声明、或在父类中可用

  • 无__dict__属性实例无法给未在__slots__中列出 的新变量赋值

    • 但是python很多特性依赖于普通的依赖字典实现，定义 __slots__的类不再支持普通类某些特性
    • 大多数情况下，应该只在经常使用到作为数据结构的 类上定义__slots__
    • 不应该把__slots__作为防止用户给实例增加新属性 的封装工具

  • 无__weakref__属性实例不支持对实例的弱引用

• 是阻止给实例创建__dict__，类本身仍然有__dict__属性 （dir返回值中无__dict__，__dir__返回值中有）

说明

• __slots__声明的行为不只限于定义其的类

  • 父类中声明__slots__可以在子类中使用，但子类将获得 __dict__、__weakref__，除非其也定义了__slots__

  • 子类__slots__中定义的slot将覆盖父类中同名slot

    • 需要直接从基类直接获取描述器才能访问
    • 这会导致程序未定义，以后增加检查避免

  • 多重继承中只允许一个父类具有非空__slots__，否则 raise TypeError

• __slots__是在类层次上的实现：为每个变量创建描述器

  • 类属性不能被用于给在__slots__中定义变量设置默认值
  • 否则类属性会覆盖描述器赋值，变成只读属性

• 非空的__slots__不适用于派生自“可变长度”内置类型，如 int、bytes、tuple

• 定义类属性__slots__后，python会为实例属性使用紧凑内部 表示

  • 实例属性使用固定大小、很小的数组构建，而不是为每个 实例定义字典
  • 在__slots__列出的属性名在内部映射到数组指定下标上
  • 类似于R中factor类型、C中enum类型
  • 相比__dict__可以显著节省空间、提升属性查找速度

1
2
3
4
5
6

class Date:
	__slots__ = ["year", "month", "day"]
	def __init__(self, year, month, day):
		self.year = year
		self.month = month
		self.day = day

• 继承自未定义__slots__类时，实例中__dict__、 __weakref__属性将总是可访问的

• __class__赋值仅在两个类具有相同__slots__值时才有用

自定义属性访问

__getattr__

1
2

def object.__getattr__(self, name):
	pass

• 用途：.默认属性访问引发AttributeError而失败时调用

  • 如果属性通过正常机制找到，__getattr__不会被调用
    • 在__getattr__、__setattr__之间故意设置的 不对称性
    • 出于效率考虑
  • 对实例变量而言，无需在实例属性字典中插入值，就可以 模拟对其的完全控制

• 返回值：计算后的属性值、或raise AttributeError

说明

• 可能引发AttributeError

  • 调用__getattribute__时因为name不是实例属性、 或是类关系树中属性
  • 对调用__get__获取name描述器

• 调用__getattr__是.运算符中逻辑

  • __getattribute__显式调用raise AtttributeError 不会调用__getattr__

• __getattr__甚至不是object具有的 <wrapper_descriptor>

• 相较于__getattribute__其实更常用，因为修改所有对 对对象的访问逻辑没啥价值

__getattribute__

1
2
3
4
5
6

def __getattribute__(self, key):
	"Emulate type_getattro() in Objects/typeobject.c"
	v = object.__getattribute__(self, key)
	if hasattr(v, "__get__"):
		return v.__get__(None, self)
	return v

• 用途：访问对象属性时无条件被调用

  • 判断访问属性类型、做对应操作
    • 描述器：调用描述器方法
    • 实例方法：为类中函数绑定实例
    • 类方法：为类中函数绑定类
    • 静态方法：不绑定
    • 普通属性
  • 作为通过特定语法、内置函数隐式调用的结果情况下， 查找特殊方法时仍可能被跳过

• 返回值：找到的属性值、或raise AttributeError

• __getattribute__仅对继承自object的新式类实例可用

说明

• 内置类型均有各自__getattribute__函数实例

  • 其均为wrapper_descriptor类型（C实现的函数）
  • 各函数实例标识符不同，若其均“继承自object”，其 应为同一个函数实例
  • 自定义类真继承自object类，其__getattribute__同 object.__getattribute__

• 自定义实现

  • 为避免方法中无限递归，实现总应该调用具有相同名称 基类方法访问所需要的属性

钩子函数

• .运算符：首先调用__getattribute__，若无访问结果， 调用__getattr__

  • .运算符说明参见cs_python/py3ref/cls_basics

• getattr：基本同.运算符，除可捕获异常，设置默认返回值

• hasattr：内部调用getattr，根据raise Exception判断 属性是否存在

  • 可以通过@property.getter中raise AttributeError 使得属性看起来不存在
  • 内部有更多boilerplate相较于getattr更慢
  • 则按照字面意思使用不需要考虑过多

__setattr__

1
2

def object.__setattr__(self, name, value):
	pass

• 用途：属性被尝试赋值时被调用

  • 默认实现：将值保存到实例字典
  • 若__setattr__要赋值给实例属性，应该调用同名基类 方法

• 返回指：None

  • 钩子函数：setattr

__delattr__

1
2

def object.__delattr__(self, name):
	pass

• 用途：删除实例属性时被调用

  • 默认实现：从实例字典中删除对应项
  • 应该在del obj.name对该对象有意义时才实现

• 返回值：None

  • 内置钩子函数：delattr、del

__dir__

1
2

def object.__dir__(self):
	pass

• 用途：返回实例中“可访问”名称的字符串列表

  • 默认实现：返回实例、类、祖先类所有属性
  • 交互式解释器就是在__dir__/dir返回列表中进行查询 进行补全

• 返回值：序列

  • 内置钩子函数：dir
    • dir()获取__dir__返回序列，转换为列表、排序
    • dir()会剔除__dir__返回值中部分值
    • 若__dir__返回值不可迭代，报错

自定义模块属性访问

• __getattr__、__dir__可以用于自定义对模块属性的访问

  • 模块层次__getattr__类似普通类
    • 接受属性名作为参数
    • 返回计算后结果、或raise AttributeError
    • 若正常查找__getattribute__无法在模块中找到某个 属性，调用__getattr__
  • 模块层次__dir__类似普通类
    • 不接受参数
    • 返回模块中可访问名称的字符串列表

• 可以将模块的__class__属性设置为types.ModuleType子类

  1 2 3 4 5 6 7 8 9 10 11

  import sys import types import ModuleType class VersboseModule(ModuleType): def __repr__(self): return f"verbose {self.__name__}" def __setattr__(self, attr, value): print(f"settting {attr}") super().__setattr__(attr, value) sys.modules[__name__].__class__ = VerboseModule

• 设置模块__getattr__、__class__只影响使用属性访问 语法进行查找，直接访问模块全局变量（通过模块内代码、对 模块全局字典引用）不受影响

描述器类

描述器：具有“绑定行为”的对象属性

• 类中定义其中任意一个方法，则其实例被称为描述器

  • __set__
  • __get__
  • __delete__

• 所有对描述器属性的访问会被__get__、__set__、 __delete__方法捕获/重载

  • 如果只是想简单的自定义某个类的属性处理逻辑，使用 @porperty装饰器简化实现

• @property参见cs_python/py3ref/cls_basics

描述器协议

• 以下方法仅包含其的类的实例出现在类属性中才有效
  • 即以下方法必须在（祖先）类__dict__中出现，而不是 实例__dict__中
  • 即描述器只能定义为类属性，不能定义为实例属性

__get__

1
2

def object.__get__(self, instance, owner=None):
	pass

• 用途：访问描述器属性时调用，重载实例属性访问

  • 若描述器未定义__get__，则访问属性会返回描述器对象 自身，除非实例字典__dict__中有同名属性
  • 若仅仅只是从底层实例字典中获取属性值，__get__方法 不用实现

• 参数

  • instance：用于方法属性的实例
  • owner：实例所属类，若通过类获取属性则为None

• 返回值：计算后属性值、或raise AttributeError

• 示例

  1 2 3 4 5 6 7 8 9 10 11 12

  def __get__(self, instance, cls): if instance is None: # 装饰器类一般作为类属性，需要考虑通过类直接访问 # 描述器类属性，此时`instance is None` # 常用操作是返回当前实例 return self else: return instance.__dict__[self.name] # self：描述器类当前实例 # instance：定义描述器作为类属性的类的实例 # cls：定义描述器作为类属性的类

__set__

1
2

def object.__set__(self, instance, name, value):
	pass

• 用途：设置实例instance的“描述器属性”值为value，重载 实例属性赋值

  • 常用实现：操作实例instance.__dict__存储值，使得 看起来是设置普通实例属性

• 示例

  1 2 3 4 5 6 7 8 9 10

  def __set__(self, instance, name, value): if instance is None: pass else: if not instance(value, int): raise TypeError("expect an int") instance.__dict__[self.name] = value # 操作实例底层`__dict__` # `value`：赋给描述器类属性的值

__delete__

1
2

def object.__delete__(self, instance):
	pass

• 用于：“删除”实例instance的“描述器属性”，重载实例属性 删除

  • 具体实现应取决于__set__实现

• 示例

  1 2 3 4 5 6

  def __delete__(self, instance): if instance is None: pass else: del instance.__dict__[self.name] # 操作实例底层`__dict__`

__set_name__

1
2

def object.__set_name__(self, owner, name):
	pass

• 用途：类owner被创建时调用，描述器被赋给name

实现原理

• 描述器的实现依赖于object.__getattribute__()方法

  • 可以通过重写类的__getattribute__方法改变、关闭 描述器行为

• 描述器调用：描述器x定义在类A中、a = A()

  • 直接调用：x.__get__(a)
  • 实例绑定：a.x
    • 转换为：type(a).__dict__['x'].__get__(a)
  • 类绑定：A.x
    • 转换为：A.__dict__['x'].__get__(None,A)
  • 超绑定：super(a, A).x

实例绑定—资料描述器

• 资料描述器：定义了__set__、__delete__方法
• 非资料描述器：只定义了__get__方法

• 访问对象属性时，描述器调用的优先级取决于描述器定义的方法

  • 优先级：资料描述器 > 实例字典属性 > 非资料描述器
  • 实例属性会重载非资料描述器
  • 实例属性和资料描述器同名时，优先访问描述器，否则优先 访问属性

• 只读资料描述器：__set__中raise AttributeError得到

描述器调用

todo

Python设计

• function类中定义有__get__方法，则其实例（即函数） 都为非资料描述器

  • 所以实例可以覆盖、重载方法
  • __getattribute__会根据不同方法类型选择绑定对象
    • staticmethod：静态方法
    • classmethod：类方法
    • 实例方法

• super类中定义有__get__方法，则其实例也为描述器

• @property方法被实现为资料描述器

特殊描述器类

todo

• wrapper_descripter：<slot wrapper>，封装C实现的函数

  • 等价于CPython3中函数
  • 调用__get__绑定后得到<method-wrapper>
  • object的方法全是<slot wrapper>

• method-wrapper：<method-wrapper>，封装C实现的绑定方法

  • 等价于CPython3中绑定方法

function描述器类

function描述器类：实例化即得到函数

1
2
3
4
5
6
7
8
9

class function:
	function(code, globals[, name[, argdefs[, closure]]])

	def __call__(self, /, *args, **kwargs):
		# 作为一个函数调用自身

	def __get__(self, instance, owner, /):
		# 返回`owner`类型实例`instance`的属性
		# 即返回绑定方法

method描述器类

method描述器类：实例化即得到(bound )method，绑定方法

1
2
3
4
5
6
7
8

class method:
	method(function, instance)

	def __call__(self, /, *args, **kwargs):
		# 作为函数调用自身

	def __get__(self, instance, owner, /):
		# 返回自身

• (bound )method：绑定方法，（首个参数）绑定为具体实例 的函数，即实例属性

XXmethod描述类

• 代码是C实现，这里是python模拟，和help结果不同

1
2
3
4
5
6
7
8
9
10
11
12
13
14

class classmethod:
	def __init__(self, method):
		self.method = method
	def __get__(self, obj, cls):
		return lambda *args, **kw: self.method(cls,*args,**kw)

class staticmethod:
	def __init__(self, callable):
		self.f = callable
	def __get__(self, obj, cls=None):
		return self.f
	@property
	def __func__(self):
		return self.f

• 类中静态方法、类方法就是以上类型的描述器

  • 静态方法：不自动传入第一个参数
  • 类方法：默认传递类作为第一个参数
  • 描述器用途就是避免默认传入实例为第一个参数的行为

• 静态方法、类方法均是非资料描述器，所以和实例属性重名时 会被覆盖

• 所以类静态方法、类方法不能直接通过__dict__获取、调用， 需要调用__get__方法返回绑定方法才能调用

  • 直接访问属性则由__getattribute__方法代劳

例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

class Integer:
	# 描述器类
	def __init__(self, name):
		self.name = name

	def __get__(self, instance, cls):
		# 描述器的每个方法会接受一个操作实例`instance`
		if instance is None:
			# 描述器只能定义为类属性，在这里处理直接使用类
				# 访问描述器类的逻辑
			return self
		else:
			return instance.__dict__(self.name)

	def __set__(self, instance, value):
		if not instance(value, int):
			rasie TypeError("expect an int")
		instance.__dict__[self.name] = value
			# 描述器方法会操作实例底层`__dict__`属性

	def __delete__(self, instance):
		del instance.__dict__[self.name]

class Point:
	x = Integer("x")
	y = Integer("y")
		# 需要将描述器的实例作为类属性放在类的定义中使用

	def __init__(self, x, y):
		self.x = x
		self.y = y

def test():
	p = Point(2, 3)
	print(p.x)
		# 调用`Point.x.__get__(p, Point)`
	print(Point.x)
		# 调用`Point.x.__get__(None, Point)`
	p.y = 5
		# 调用`Point.y.__set__(p, 5)`

自定义类创建

__init_subclass__

1
2

classmethod object.__init_subclass__(cls):
	pass

• 用途：派生类继承父类时，基类的__init_subclas__被调用
  • 可以用于编写能够改变子类行为的类
  • 类似类装饰器，但是类装饰其影响其应用的类，而 __init_subclass__影响基类所有派生子类
  • 默认实现：无行为、只有一个参数cls
  • 方法默认、隐式为类方法，不需要classmethod封装

• 参数

  • cls：指向新的子类
  • 默认实现无参数，可以覆盖为自定义参数

  1 2 3 4 5 6 7

  class Philosopher: def __init_subclass__(self, default_name, **kwargs): super().__init_subclass__(**kwrags) cls.default_name = default_name class AstraliaPhilosopher(Philosopher, default_name="Bruce"): pass

  • 定义派生类时需要注意传递参数
  • 元类参数metaclass会被其他类型机制消耗，不会被传递 给__init_subclass__

元类

• 默认情况下，类使用type构建

  • 类体在新的命名空间中执行，类名被局部绑定到 元类创建结果type(name, bases, namespace)

• 可在类定义部分传递metaclass关键字参数，自定义类创建 过程

  • 类继承同样继承父类元类参数
  • 其他类定义过程中的其他关键字参数会在以下元类操作中 进行传递
    • 解析MRO条目
    • 确定适当元类
    • 准备类命名空间__prepare__
    • 执行类主体
    • 创建类对象

解释MRO条目

1
2

def type.__mro_entries__():
	pass

• 用途：若类定义中基类不是type的实例，则使用此方法对 基类进行搜索

  • 找到结果时，以原始基类元组作为参数进行调用

• 返回值：类的元组替代基类被使用

  • 元组可以为空，此时原始基类将被忽略

元类确定

• 若没有显式给出基类、或元类，使用type()
• 若显式给出的元类不是type()的实例，直接用其作为元类
• 若显式给出type()实例作为元类、或定义有基类，则选取 “最派生”元类
  • 最派生元类从显式指定的元类、基类中元类中选取
  • 最派生元类应为所有候选元类的子类型
  • 若没有满足条件的候选元类则raise TypeError

准备类命名空间

1
2

def type.__prepare__(name, bases, **kwds):
	pass

• 用途：确定合适的元类之后，准备类命名空间

  • 若元类没有__prepare__属性，类命名空间将被初始化为 空ordered mapping

• 参数：来自于类定义中的关键字参数

执行类定义主体

1
2

exec(body, globals(), namespace)
	# 执行类主体类似于

• 普通调用和exec()区别
  • 类定义在函数内部时
    • 词法作用域允许类主体、方法引用来自当前、外部 作用域名称
    • 但内部方法仍然无法看到在类作用域层次上名称
    • 类变量必须通过实例的第一个形参、类方法方法

创建类对象

1
2

metaclass(name, base, namespace, **kwds):
	pass

• 用途：执行类主体填充类命名空间后，将通过调用 metaclass(name, base, namespace, **kwds)创建类对象

• 参数：来自类定义中的关键字参数

说明

• 若类主体中有方法中引用__class__、super，则__class__ 将被编译器创建为隐式闭包引用

  • 这使得无参数调用super可以能基于词法作用域正确 定位类
  • 而被用于进行当前调用的类、实例则是基于传递给方法 的第一个参数来标识

自定义实例、子类检查

• 以下方法应该的定义在元类中，不能在类中定义为类方法

  • 类似于实例从类中查找方法

• 元类abc.ABCMeta实现了以下方法以便允许将抽象基类ABC 作为“虚拟基类”添加到任何类、类型（包括内置类型）中

__instancecheck__

1
2

def class.__instancecheck__(self, instance):
	pass

• 用途：若instance被视为class直接、间接实例则返回真值

  • 重载instance内置函数行为

• 返回：布尔值

  • 内置钩子函数：isintance(instance, class)

__subclasscheck__

1
2

class.__subclasscheck__(self, subclass):
	pass

• 用途：若subclass被视为class的直接、间解子类则返回 真值

  • 重载issubclass内置函数行为

• 返回：布尔值

  • 内置钩子函数：issubclass(subclass, class)

模拟范型类型

__class_getitem__

1
2

classmethod object.__class_getitem__(cls, key):
	pass

• 用途：按照key指定类型返回表示泛型类的专门化对象

  • 实现PEP 484规定的泛型类语法
  • 查找基于对象自身
  • 主要被保留用于静态类型提示，不鼓励其他尝试使用
  • 方法默认、隐式为类方法，不需要classmethod封装

• 参数

  • cls：当前类
  • key：类型

模拟可调用对象

__call__

1
2

def object.__call__(self[,args...]):
	pass

• 用途：实例作为函数被调用时被调用
  • 若定义此方法x(arg1, arg2, ...)等价于 x.__call__(arg1, args2, ...)

模拟容器类型

• collections.abc.MutableMapping为抽象基类
  • 其实现基本方法集__getitem__、__setitem__、 __delitem__、keys()
  • 可以方法继承、扩展、实现自定义映射类

__len__

1
2

def object.__len__(self):
	pass

• 用途：计算、返回实例长度

  • 若对象未定义__bool__，以__len__是否返回非0作为 布尔运算结果

• 返回值：非负整形

  • 钩子函数：len()

• CPython：要求长度最大为sys.maxsize，否则某些特征可能 会raise OverflowError

__length_hint__

1
2

def object.__length_hist__(self):
	pass

• 用途：返回对象长度估计值

  • 存粹为优化性能，不要求正确无误

• 返回值：非负整形

  • 钩子函数：operator.length_hint()

__getitem__

1
2

def object.__getitem__(self, key):
	pass

• 用途：实现根据索引取值

• 参数

  • 序列key：整数、切片对象

    • key类型不正确将raise TypeError
    • key在实例有效范围外将raise IndexError

  • 映射key：可hash对象

    • key不存在将raise KeyError

• 返回值：self[key]