《Python面向对象编程指南》.([美] Steven F. Lott).[PDF]
本书介绍:
Python是一种面向对象、解释型的程序设计语言，它已经被成功应用于科学计算、数据分析以及游戏开发等诸多领域。
本书深入介绍Python语言的面向对象特性，全书分3个部分共18章。第1部分讲述用特殊方法实现Python风格的类，分别介绍了__init__()方法、与Python无缝集成—基本特殊方法、属性访问和特性及修饰符、抽象基类设计的一致性、可调用对象和上下文的使用、创建容器和集合、创建数值类型、装饰器和mixin—横切方面；第2部分讲述持久化和序列化，分别介绍了序列化和保存、用Shelve保存和获取对象、用SQLite保存和获取对象、传输和共享对象、配置文件和持久化；第3部分讲述测试、调试、部署和维护，分别介绍了Logging和Warning模块、可测试性的设计、使用命令行、模块和包的设计、质量和文档。
本书深入剖析Python，帮助读者全面掌握Python并构建出更好的应用程序，非常适合对Python语言有一定了解并想要深入学习Python的读者，也适合有一定开发经验并且想要尝试使用Python语言进行编程的IT从业人员。
作译者:
Steven F. Lott的编程生涯开始于20世纪70年代，那时候计算机体积很大、昂贵并且非常少见。作为软件工程师和架构师，他参与了100多个不同规模的项目研发。在使用Python解决业务问题方面，他已经有10多年的经验了。
Steven目前是自由职业者，居住在美国东海岸。他的技术博客是：http://slott-softwarearchitect. blogspot.com。
本书目录:
第1部分 用特殊方法实现Python风格的类 ..................................................................................... 1
第1章 __init__()方法 ............................................................................................................................ 5
1.1 隐式的基类——object .............................................................................................................. 5
1.2 基类中的__init__()方法 ........................................................................................................... 6
1.3 在基类中实现__init__()方法 ................................................................................................... 7
1.4 使用__init__()方法创建常量清单 ........................................................................................... 8
1.5 通过工厂函数调用__init__() ................................................................................................... 9
1.5.1 错误的工厂设计和模糊的else语句 ............................................................................... 10
1.5.2 使用elif简化设计来获得一致性 ................................................................................... 11
1.5.3 使用映射和类来简化设计 ............................................................................................... 11
1.6 在每个子类中实现__init__()方法 ......................................................................................... 14
1.7 简单的组合对象 ...................................................................................................................... 16
1.7.1 封装集合类 ...................................................................................................................... 16
1.7.2 扩展集合类 ...................................................................................................................... 17
1.7.3 可适应更多需求的另一种设计 ....................................................................................... 17
1.8 复合的组合对象 ...................................................................................................................... 18
1.9 不带__init__()方法的无状态对象 ......................................................................................... 19
1.10 一些其他的类定义 ................................................................................................................ 20
1.11 多策略的__init__()方法........................................................................................................ 22
1.11.1 更复杂的初始化方式 ..................................................................................................... 23
1.11.2 静态函数的初始化 ......................................................................................................... 24
1.12 更多的__init__()技术 ........................................................................................................... 24
1.12.1 带有类型验证的初始化 ................................................................................................. 26
1.12.2 初始化、封装和私有化 ................................................................................................. 28
1.13 总结 ......................................................................................................................................... 29
2 目录
第2章 与Python无缝集成——基本特殊方法 ............................................................................... 30
2.1 __repr__()和__str__()方法...................................................................................................... 30
2.1.1 非集合对象的__str__()和__repr__() ............................................................................... 31
2.1.2 集合中的__str__()和__repr__() ....................................................................................... 32
2.2 __format__()方法 ..................................................................................................................... 33
2.2.1 内嵌格式规范................................................................................................................... 34
2.2.2 集合和委托格式规范 ....................................................................................................... 35
2.3 __hash__()方法 ........................................................................................................................ 35
2.3.1 决定哈希的对象 ............................................................................................................... 36
2.3.2 有关不可变对象和继承的默认行为 ............................................................................... 37
2.3.3 重载不可变对象 ............................................................................................................... 39
2.3.4 重载可变对象................................................................................................................... 40
2.3.5 从可变的Hand类中生成一个不可变的Hand类 .......................................................... 41
2.4 __bool__()方法 ........................................................................................................................ 43
2.5 __bytes__()方法 ....................................................................................................................... 44
2.6 比较运算符方法 ...................................................................................................................... 45
2.6.1 设计比较运算................................................................................................................... 47
2.6.2 实现同一个类的对象比较 ............................................................................................... 48
2.6.3 实现不同类的对象比较 ................................................................................................... 49
2.6.4 硬总和、软总和及多态 ................................................................................................... 50
2.6.5 不同类比较的例子 ........................................................................................................... 51
2.7 __del__()方法 ........................................................................................................................... 53
2.7.1 引用计数和对象销毁 ....................................................................................................... 54
2.7.2 循环引用和垃圾回收 ....................................................................................................... 55
2.7.3 循环引用和weakref模块 ................................................................................................ 56
2.7.4 __del__()和close()方法 ................................................................................................... 58
2.8 __new__()方法和不可变对象 ................................................................................................ 58
2.9 __new__()方法和元类型 ........................................................................................................ 59
2.9.1 元类型示例1——有序的属性 ........................................................................................ 60
2.9.2 元类型示例2——自引用 ................................................................................................ 61
2.10 总结 ......................................................................................................................................... 64
第3章 属性访问、特性和修饰符 ...................................................................................................... 66
3.1 属性的基本操作 ...................................................................................................................... 66
3.2 创建特性 .................................................................................................................................. 68
3.2.1 主动计算特性................................................................................................................... 70
3.2.2 setter和deleter特性 ........................................................................................................ 71
目录 3
3.3 使用特殊方法完成属性访问 ................................................................................................. 72
3.3.1 使用__slots__创建不可变对象 ....................................................................................... 73
3.3.2 使用tuple子类创建不可变对象 ..................................................................................... 74
3.3.3 主动计算的属性 ............................................................................................................... 75
3.4 __getattribute__()方法 ............................................................................................................. 77
3.5 创建修饰符 .............................................................................................................................. 78
3.5.1 使用非数据修饰符 ........................................................................................................... 80
3.5.2 使用数据修饰符 ............................................................................................................... 81
3.6 总结、设计要素和折中方案 ................................................................................................. 83
3.6.1 特性与属性对比 ............................................................................................................... 83
3.6.2 修饰符的设计................................................................................................................... 84
3.6.3 展望 .................................................................................................................................. 84
第4章 抽象基类设计的一致性 ........................................................................................................... 85
4.1 抽象基类 .................................................................................................................................. 85
4.2 基类和多态 .............................................................................................................................. 87
4.3 可调用对象 .............................................................................................................................. 88
4.4 容器和集合 .............................................................................................................................. 88
4.5 数值类型 .................................................................................................................................. 89
4.6 其他的一些抽象基类 .............................................................................................................. 90
4.6.1 迭代器的抽象基类 ........................................................................................................... 90
4.6.2 上下文和上下文管理器 ................................................................................................... 91
4.7 abc模块 .................................................................................................................................... 92
4.8 总结、设计要素和折中方案 ................................................................................................. 93
第5章 可调用对象和上下文的使用 .................................................................................................. 95
5.1 使用ABC可调用对象来进行设计 ...................................................................................... 95
5.2 提高性能 .................................................................................................................................. 97
5.3 使用functools完成记忆化 .................................................................................................... 99
5.4 可调用API和复杂性 ........................................................................................................... 100
5.5 管理上下文和with语句 ...................................................................................................... 102
5.5.1 使用小数上下文 ............................................................................................................. 103
5.5.2 其他上下文 .................................................................................................................... 104
5.6 定义__enter__()和__exit__()方法 ....................................................................................... 104
5.7 上下文管理器工厂 ................................................................................................................ 105
5.8 总结 ......................................................................................................................................... 107
5.8.1 可调用对象的设计要素和折中方案 ............................................................................. 108
5.8.2 上下文管理器的设计要素和折中方案 ......................................................................... 108
4 目录
5.8.3 展望 ................................................................................................................................ 109
第6章 创建容器和集合 ..................................................................................................................... 110
6.1 集合的抽象基类 .................................................................................................................... 110
6.2 特殊方法示例 ........................................................................................................................ 111
6.3 使用标准库的扩展 ................................................................................................................ 112
6.3.1 namedtuple()函数 ........................................................................................................... 112
6.3.2 deque类 .......................................................................................................................... 114
6.3.3 使用ChainMap ............................................................................................................... 115
6.3.4 OrderedDict集合 ............................................................................................................ 116
6.3.5 defaultdict子类 .............................................................................................................. 118
6.3.6 counter集合.................................................................................................................... 119
6.4 创建新集合 ............................................................................................................................ 120
6.5 定义一种新的序列 ................................................................................................................ 121
6.5.1 一个用于统计的list ....................................................................................................... 122
6.5.2 主动计算和延迟计算 ..................................................................................................... 122
6.5.3 使用__getitem__()、__setitem__()、__delitem__()和slice操作 ................................ 125
6.5.4 实现__getitem__()、__setitem__()和__delitem__() ..................................................... 126
6.5.5 封装list和委托 .............................................................................................................. 127
6.5.6 用__iter__()创建迭代器 ................................................................................................. 129
6.6 创建一种新的映射 ................................................................................................................ 129
6.7 创建一种新的集合 ................................................................................................................ 131
6.7.1 一些设计原则................................................................................................................. 132
6.7.2 定义Tree类 ................................................................................................................... 132
6.7.3 定义TreeNode类 ........................................................................................................... 133
6.7.4 演示二叉树集合 ............................................................................................................. 136
6.8 总结 ......................................................................................................................................... 136
6.8.1 设计要素和折中方案 ..................................................................................................... 137
6.8.2 展望 ................................................................................................................................ 138
第7章 创建数值类型 ......................................................................................................................... 139
7.1 numbers的抽象基类 ............................................................................................................. 139
7.1.1 决定使用哪种类型 ......................................................................................................... 141
7.1.2 方法解析和运算符映射 ................................................................................................. 141
7.2 算术运算符的特殊方法 ....................................................................................................... 142
7.3 创建一个数字类 .................................................................................................................... 144
7.3.1 FixedPoint的初始化 ...................................................................................................... 144
7.3.2 定义固定小数点位数的二进制算术运算符 ................................................................. 146
目录 5
7.3.3 定义FixedPoint一元算术运算符 ................................................................................. 148
7.3.4 实现FixedPoint反向运算符 ......................................................................................... 148
7.3.5 实现FixedPoint比较运算符 ......................................................................................... 150
7.4 计算一个数字的哈希值 ....................................................................................................... 152
7.5 实现其他的特殊方法 ............................................................................................................ 153
7.6 原地运算符的优化 ................................................................................................................ 154
7.7 总结 ......................................................................................................................................... 155
7.7.1 设计要素和折中方案 ..................................................................................................... 155
7.7.2 展望 ................................................................................................................................ 155
第8章 装饰器和mixin——横切方面 ............................................................................................. 156
8.1 类和描述 ................................................................................................................................ 156
8.1.1 创建函数 ........................................................................................................................ 157
8.1.2 创建类 ............................................................................................................................ 158
8.1.3 一些类设计原则 ............................................................................................................. 159
8.1.4 面向方面编程................................................................................................................. 159
8.2 使用内置的装饰器 ................................................................................................................ 160
8.3 使用标准库中的mixin类 .................................................................................................... 161
8.3.1 使用上下文管理器的mixin类 ..................................................................................... 162
8.3.2 禁用类的一个功能 ......................................................................................................... 163
8.4 写一个简单的函数装饰器 ................................................................................................... 164
8.5 带参数的装饰器 .................................................................................................................... 166
8.6 创建方法函数装饰器 ............................................................................................................ 167
8.7 创建类装饰器 ........................................................................................................................ 169
8.8 向类中添加方法函数 ............................................................................................................ 170
8.9 将装饰器用于安全性 ............................................................................................................ 172
8.10 总结 ....................................................................................................................................... 173
8.10.1 设计要素和折中方案 ................................................................................................... 173
8.10.2 展望 .............................................................................................................................. 174
第2部分 持久化和序列化 ................................................................................................................. 175
第9章 序列化和保存——JSON、YAML、Pickle、CSV和XML ........................................ 178
9.1 持久化、类、状态以及数据表示 ....................................................................................... 179
9.2 文件系统和网络的考虑 ....................................................................................................... 180
9.3 定义用于持久化的类 ............................................................................................................ 181
9.4 使用JSON进行转储和加载................................................................................................ 184
9.4.1 在类中支持JSON .......................................................................................................... 185
6 目录
9.4.2 自定义JSON编码 ......................................................................................................... 186
9.4.3 自定义JSON解码 ......................................................................................................... 188
9.4.4 安全性和eval() .............................................................................................................. 189
9.4.5 重构编码函数................................................................................................................. 189
9.4.6 日期字符串的标准化 ..................................................................................................... 190
9.4.7 将JSON写入文件 ......................................................................................................... 191
9.5 使用YAML进行转储和加载 .............................................................................................. 192
9.5.1 YAML文件的格式化 .................................................................................................... 193
9.5.2 扩展YAML的表示 ....................................................................................................... 194
9.5.3 安全性与安全加载 ......................................................................................................... 196
9.6 使用pickle进行转储和加载........................................................................................... 196
9.6.1 针对可靠的pickle处理进行类设计 ............................................................................. 197
9.6.2 安全性和全局性问题 ..................................................................................................... 199
9.7 转储和加载CSV ................................................................................................................... 200
9.7.1 将简单的序列转储为CSV ............................................................................................ 200
9.7.2 从CSV文件中加载简单的序列 ................................................................................... 201
9.7.3 处理集合与复杂的类 ..................................................................................................... 202
9.7.4 在一个CSV文件中转储并从多类型的行中加载数据 ............................................... 203
9.7.5 使用迭代器筛选CSV中的行 ....................................................................................... 204
9.7.6 从CSV文件中转储和加载连接的行 ........................................................................... 205
9.8 使用XML转储和加载 ......................................................................................................... 207
9.8.1 使用字符串模板转储对象 ............................................................................................. 208
9.8.2 使用xml.etree.ElementTree转储对象 .......................................................................... 209
9.8.3 加载XML文档 .............................................................................................................. 210
9.9 总结 ......................................................................................................................................... 211
9.9.1 设计要素和折中方案 ..................................................................................................... 211
9.9.2 模式演化 ........................................................................................................................ 212
9.9.3 展望 ................................................................................................................................ 213
第10章 用Shelve保存和获取对象 ................................................................................................. 214
10.1 分析持久化对象用例 ......................................................................................................... 215
10.2 创建shelf.............................................................................................................................. 216
10.3 设计适于存储的对象 ......................................................................................................... 217
10.3.1 为我们的对象设计键 ................................................................................................... 217
10.3.2 为对象生成代理键 ....................................................................................................... 218
10.3.3 设计一个带有简单键的类 ........................................................................................... 218
10.3.4 为容器和集合设计类 ................................................................................................... 220
10.3.5 用外键引用对象 ........................................................................................................... 220
目录 7
10.3.6 为复杂对象设计CRUD操作 ...................................................................................... 222
10.4 搜索、扫描和查询 .............................................................................................................. 223
10.5 为shelve设计数据访问层 ................................................................................................. 224
10.6 用索引提高性能 .................................................................................................................. 227
10.7 有关更多的索引维护工作 ................................................................................................. 230
10.8 用writeback代替更新索引 ............................................................................................... 232
10.9 总结 ....................................................................................................................................... 233
10.9.1 设计要素和折中方案 ................................................................................................... 233
10.9.2 应用软件层................................................................................................................... 234
10.9.3 展望 .............................................................................................................................. 234
第11章 用SQLite保存和获取对象 ............................................................................................... 235
11.1 SQL数据库、持久化和对象 ............................................................................................. 235
11.1.1 SQL数据模型—行和表 .......................................................................................... 236
11.1.2 使用SQL的DML语句完成CRUD .......................................................................... 238
11.1.3 使用SQL中SELECT语句执行查询 ......................................................................... 240
11.1.4 SQL事务和ACID属性 .............................................................................................. 240
11.1.5 设计数据库中的主键和外键 ....................................................................................... 242
11.2 使用SQL处理程序中的数据............................................................................................ 243
11.3 从Python对象到SQLite BLOB列的映射 ...................................................................... 245
11.4 手动完成从Python对象到数据库中行的映射 ............................................................... 247
11.4.1 为SQLite设计一个访问层 ......................................................................................... 248
11.4.2 实现容器的关系 ........................................................................................................... 251
11.5 使用索引提高性能 .............................................................................................................. 252
11.6 添加ORM层 ....................................................................................................................... 252
11.6.1 设计ORM友好的类 .................................................................................................... 253
11.6.2 使用ORM层创建模型 ................................................................................................ 255
11.6.3 使用ORM层操作对象 ................................................................................................ 256
11.7 通过指定标签字符串查询文章对象 ................................................................................. 258
11.8 通过创建索引提高性能...................................................................................................... 259
11.9 总结 ....................................................................................................................................... 261
11.9.1 设计要素和折中方案 ................................................................................................... 261
11.9.2 映射的方法 ................................................................................................................... 261
11.9.3 键和键的设计 ............................................................................................................... 262
11.9.4 应用软件层 ................................................................................................................... 262
11.9.5 展望 ............................................................................................................................... 262
8 目录
第12章 传输和共享对象 ................................................................................................................... 263
12.1 类、状态和表示 .................................................................................................................. 263
12.2 用HTTP和REST传输对象 ............................................................................................. 264
12.2.1 用REST实现CRUD操作 .......................................................................................... 264
12.2.2 实现非CRUD操作 ..................................................................................................... 265
12.2.3 REST协议和ACID ..................................................................................................... 266
12.2.4 选择一种表示方法—JSON、XML或者YAML ................................................... 266
12.3 实现一个REST服务器——WSGI和mod_wsgi ........................................................... 267
12.3.1 创建简单的REST应用程序和服务器 ....................................................................... 267
12.3.2 实现REST客户端 ....................................................................................................... 270
12.3.3 演示RESTful服务并创建单元测试 ........................................................................... 271
12.4 使用可回调类创建WSGI应用程序 ................................................................................ 272
12.4.1 设计RESTful对象标识符 .......................................................................................... 274
12.4.2 多层REST服务 ........................................................................................................... 275
12.4.3 创建roulette服务器 .................................................................................................... 279
12.4.4 创建roulette客户端 .................................................................................................... 280
12.5 创建安全的REST服务 ...................................................................................................... 281
12.6 用Web应用程序框架实现REST ..................................................................................... 284
12.7 用消息队列传输对象 ......................................................................................................... 285
12.7.1 定义进程 ...................................................................................................................... 286
12.7.2 创建队列和提供数据 ................................................................................................... 287
12.8 总结 ....................................................................................................................................... 289
12.8.1 设计要素和折中方案 ................................................................................................... 289
12.8.2 模式演变 ...................................................................................................................... 289
12.8.3 应用程序软件层次 ....................................................................................................... 290
12.8.4 展望 .............................................................................................................................. 290
第13章 配置文件和持久化 ............................................................................................................... 291
13.1 配置文件的使用场景 ......................................................................................................... 291
13.2 表示、持久化、状态和可用性 ......................................................................................... 293
13.2.1 应用程序配置的设计模式 ........................................................................................... 293
13.2.2 使用对象的构造完成配置 ........................................................................................... 294
13.2.3 实现具有层次结构的配置 ........................................................................................... 295
13.3 使用INI文件保存配置 ...................................................................................................... 296
13.4 使用eval()完成更多的文字处理 ...................................................................................... 299
13.5 使用PY文件存储配置 ...................................................................................................... 299
13.5.1 使用类定义进行配置 ................................................................................................... 300
目录 9
13.5.2 通过SimpleNamespace进行配置 ............................................................................... 301
13.5.3 在配置中使用Python的exec() .................................................................................. 304
13.6 为什么执行exec()没有问题 .............................................................................................. 305
13.7 为默认值和重写使用链映射 ............................................................................................. 306
13.8 使用JSON或YAML文件存储配置 ................................................................................ 307
13.8.1 使用压平的JSON配置 ............................................................................................... 309
13.8.2 加载YAML配置 ......................................................................................................... 310
13.9 使用特性文件存储配置 ..................................................................................................... 311
13.9.1 解析特性文件............................................................................................................... 312
13.9.2 使用特性文件............................................................................................................... 314
13.10 使用XML文件——PLIST以及其他格式保存配置 ................................................... 315
13.11 总结 ..................................................................................................................................... 318
13.11.1 设计要素和折中方案 ................................................................................................. 318
13.11.2 创建共享配置 ............................................................................................................. 319
13.11.3 模式演化 ..................................................................................................................... 319
13.11.4 展望 ............................................................................................................................. 319
第3部分 测试、调试、部署和维护 ................................................................................................ 321
第14章 Logging和Warning模块 ................................................................................................. 324
14.1 创建基本日志 ...................................................................................................................... 324
14.1.1 创建共享的类级记录器 ............................................................................................... 325
14.1.2 配置日志记录器 ........................................................................................................... 326
14.1.3 开始和关闭日志记录系统 ........................................................................................... 326
14.1.4 使用命名的日志记录器 ............................................................................................... 328
14.1.5 扩展日志等级............................................................................................................... 329
14.1.6 定义指向多个目标输出的handler .............................................................................. 329
14.1.7 管理传播规则............................................................................................................... 331
14.2 理解配置 .............................................................................................................................. 332
14.3 为控制、调试、审计和安全创建专门的日志 ................................................................ 332
14.3.1 创建调试日志............................................................................................................... 334
14.3.2 创建审计和安全日志 ................................................................................................... 335
14.4 使用warnings模块 ............................................................................................................. 337
14.4.1 用警告信息显示API变化 .......................................................................................... 337
14.4.2 用警告信息显示配置问题 ........................................................................................... 338
14.4.3 用警告信息显示可能存在的软件问题 ....................................................................... 339
14.5 高级日志——最后一些信息和网络目标地址 ................................................................ 340
14.5.1 创建自动的tail缓冲区 ................................................................................................ 340
10 目录
14.5.2 发送日志消息到远程的进程 ....................................................................................... 342
14.5.3 防止队列溢出............................................................................................................... 345
14.6 总结 ....................................................................................................................................... 346
14.6.1 设计要素和折中方案 ................................................................................................... 346
14.6.2 展望 .............................................................................................................................. 347
第15章 可测试性的设计 ................................................................................................................... 348
15.1 为测试定义并隔离单元 ..................................................................................................... 348
15.1.1 最小化依赖................................................................................................................... 349
15.1.2 创建简单的单元测试 ................................................................................................... 351
15.1.3 创建一个测试组件 ....................................................................................................... 352
15.1.4 包含边界值测试 ........................................................................................................... 353
15.1.5 为测试模仿依赖 ........................................................................................................... 354
15.1.6 为更多的行为使用更多的模仿对象 ........................................................................... 357
15.2 使用doctest来定义测试用例 ............................................................................................ 357
15.2.1 将doctest与unittest相结合 ........................................................................................ 360
15.2.2 创建一个更完整的测试包 ........................................................................................... 360
15.3 使用安装和卸载 .................................................................................................................. 361
15.3.1 使用OS资源进行安装和卸载 .................................................................................... 362
15.3.2 结合数据库进行安装和卸载 ....................................................................................... 363
15.4 TestCase的类层次结构 ...................................................................................................... 366
15.5 使用外部定义的期望结果 ................................................................................................. 367
15.6 自动化集成和性能测试 ..................................................................................................... 370
15.7 总结 ....................................................................................................................................... 371
15.7.1 设计要素和折中方案 ................................................................................................... 372
15.7.2 展望 .............................................................................................................................. 372
第16章 使用命令行 ........................................................................................................................... 373
16.1 操作系统接口和命令行 ..................................................................................................... 373
16.2 用argparse解析命令行 ...................................................................................................... 375
16.2.1 简单的on/off选项 ....................................................................................................... 376
16.2.2 带参数选项................................................................................................................... 377
16.2.3 位置参数 ...................................................................................................................... 377
16.2.4 所有其他参数............................................................................................................... 377
16.2.5 --version的显示和退出 ............................................................................................... 378
16.2.6 --help的显示和退出 .................................................................................................... 378
16.3 集成命令行选项和环境变量 ............................................................................................. 378
16.3.1 提供更多的可配置默认值 ........................................................................................... 379
目录 11
16.3.2 用环境变量覆盖配置文件设置 ................................................................................... 380
16.3.3 用配置文件覆盖环境变量 ........................................................................................... 381
16.3.4 让配置文件理解None ................................................................................................. 381
16.4 自定义帮助文档的输出 ..................................................................................................... 382
16.5 创建顶层main()函数 .......................................................................................................... 383
16.5.1 确保配置遵循DRY原则 ............................................................................................ 385
16.5.2 管理嵌套的配置上下文 ............................................................................................... 385
16.6 大规模程序设计 .................................................................................................................. 386
16.6.1 设计命令类................................................................................................................... 386
16.6.2 添加用于分析的命令子类 ........................................................................................... 388
16.6.3 向应用程序中添加更多的功能 ................................................................................... 389
16.6.4 设计更高级的复合命令 ............................................................................................... 389
16.7 其他的复合命令设计模式 ................................................................................................. 391
16.8 与其他应用程序集成 ......................................................................................................... 392
16.9 总结 ....................................................................................................................................... 392
16.9.1 设计要素和折中方案 ................................................................................................... 393
16.9.2 展望 .............................................................................................................................. 393
第17章 模块和包的设计 ................................................................................................................... 394
17.1 设计一个模块 ...................................................................................................................... 394
17.1.1 一些模块设计的方法 ................................................................................................... 395
17.1.2 模块和类 ...................................................................................................................... 396
17.1.3 模块中应该包含的内容 ............................................................................................... 397
17.2 全局模块和模块项 .............................................................................................................. 398
17.3 包的设计 .............................................................................................................................. 399
17.3.1 包与模块的混合设计 ................................................................................................... 400
17.3.2 使用多种实现进行包的设计 ....................................................................................... 401
17.4 主脚本和__main__模块的设计 ......................................................................................... 402
17.4.1 创建可执行脚本文件 ................................................................................................... 402
17.4.2 创建__main__模块 ....................................................................................................... 403
17.4.3 大规模编程................................................................................................................... 403
17.5 设计长时间运行的应用 ..................................................................................................... 404
17.6 使用src、bin和test来组织代码 ..................................................................................... 406
17.7 安装Python模块 ................................................................................................................ 407
17.8 总结 ....................................................................................................................................... 408
17.8.1 设计要素和折中方案 ................................................................................................... 408
17.8.2 展望 .............................................................................................................................. 408
12 目录
第18章 质量和文档 ........................................................................................................................... 409
18.1 为help()函数编写docstrings ............................................................................................. 409
18.2 用pydoc编写文档 .............................................................................................................. 410
18.3 通过RST标记提供更好的输出 ....................................................................................... 411
18.3.1 文本块 .......................................................................................................................... 412
18.3.2 RST内联标记 .............................................................................................................. 413
18.3.3 RST指令 ...................................................................................................................... 414
18.3.4 学习RST ...................................................................................................................... 415
18.4 编写有效的文档字符串 ..................................................................................................... 415
18.5 编写文件级别的文档字符串——包括模块和包 ............................................................ 416
18.5.1 用RST标记编写详细的API文档 ............................................................................. 417
18.5.2 编写类和方法函数的文档字符串 ............................................................................... 419
18.5.3 编写函数文档字符串 ................................................................................................... 420
18.6 更复杂的标记技术 .............................................................................................................. 420
18.7 用Sphinx生成文档 ............................................................................................................ 421
18.7.1 使用Sphinx的快速启动 ............................................................................................. 421
18.7.2 编写Sphinx文档 ......................................................................................................... 423
18.7.3 在文档中加入4+1视图 .............................................................................................. 424
18.7.4 编写实现文档............................................................................................................... 425
18.7.5 用Sphinx创建交叉引用 ............................................................................................. 426
18.7.6 将Sphinx文件重构为目录 ......................................................................................... 427
18.8 编写文档 .............................................................................................................................. 427
18.9 大纲式编程 .......................................................................................................................... 428
18.9.1 大纲式编程用例 ........................................................................................................... 428
18.9.2 使用大纲式编程工具 ................................................................................................... 429
18.10 总结 ..................................................................................................................................... 432
下载地址:
**** Hidden Message ***** 有道理。。。 有道理。。。 不错不错，楼主您辛苦了。。。 不错不错，楼主您辛苦了。。。 有竞争才有进步嘛 不错不错，楼主您辛苦了。。。 谢谢楼主，共同发展 找到好贴不容易，我顶你了，谢了 有竞争才有进步嘛