Python面向对象编程指南

基本信息

图书简介

Python是一种面向对象、解释型的程序设计语言，它已经被成功应用于科学计算、数据分析以及游戏开发等诸多领域。

本书深入介绍Python语言的面向对象特性，全书分3个部分共18章。第1部分讲述用特殊方法实现Python风格的类，分别介绍了__init__()方法、与Python无缝集成—基本特殊方法、属性访问和特性及修饰符、抽象基类设计的一致性、可调用对象和上下文的使用、创建容器和集合、创建数值类型、装饰器和mixin—横切方面；第2部分讲述持久化和序列化，分别介绍了序列化和保存、用Shelve保存和获取对象、用SQLite保存和获取对象、传输和共享对象、配置文件和持久化；第3部分讲述测试、调试、部署和维护，分别介绍了Logging和Warning模块、可测试性的设计、使用命令行、模块和包的设计、质量和文档。

目录

第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章 与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 使用特殊方法完成属性访问 ................................................................................................. 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

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

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

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

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

第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

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

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

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

第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