Python Cookbook(第3版)中文版电子书

内容提要

O’Reilly Media, Inc. 介绍

关于作者

前言

第1章 数据结构和算法

1.1 将序列分解为单独的变量

1.1.1 问题

1.1.2 解决方案

1.1.3 讨论

1.2 从任意长度的可迭代对象中分解元素

1.2.1 问题

1.2.2 解决方案

1.2.3 讨论

1.3 保存最后N个元素

1.3.1 问题

1.3.2 解决方案

1.3.3 讨论

1.4 找到最大或最小的N个元素

1.4.1 问题

1.4.2 解决方案

1.4.3 讨论

1.5 实现优先级队列

1.5.1 问题

1.5.2 解决方案

1.5.3 讨论

1.6 在字典中将键映射到多个值上

1.6.1 问题

1.6.2 解决方案

1.6.3 讨论

1.7 让字典保持有序

1.7.1 问题

1.7.2 解决方案

1.7.3 讨论

1.8 与字典有关的计算问题

1.8.1 问题

1.8.2 解决方案

1.8.3 讨论

1.9 在两个字典中寻找相同点

1.9.1 问题

1.9.2 解决方案

1.9.3 讨论

1.10 从序列中移除重复项且保持元素间顺序不变

1.10.1 问题

1.10.2 解决方案

1.10.3 讨论

1.11 对切片命名

1.11.1 问题

1.11.2 解决方案

1.11.3 讨论

1.12 找出序列中出现次数最多的元素

1.12.1 问题

1.12.2 解决方案

1.12.3 讨论

1.13 通过公共键对字典列表排序

1.13.1 问题

1.13.2 解决方案

1.13.3 讨论

1.14 对不原生支持比较操作的对象排序

1.14.1 问题

1.14.2 解决方案

1.14.3 讨论

1.15 根据字段将记录分组

1.15.1 问题

1.15.2 解决方案

1.15.3 讨论

1.16 筛选序列中的元素

1.16.1 问题

1.16.2 解决方案

1.16.3 讨论

1.17 从字典中提取子集

1.17.1 问题

1.17.2 解决方案

1.17.3 讨论

1.18 将名称映射到序列的元素中

1.18.1 问题

1.18.2 解决方案

1.18.3 讨论

1.19 同时对数据做转换和换算

1.19.1 问题

1.19.2 解决方案

1.19.3 讨论

1.20 将多个映射合并为单个映射

1.20.1 问题

1.20.2 解决方案

1.20.3 讨论

第2章 字符串和文本

2.1 针对任意多的分隔符拆分字符串

2.1.1 问题

2.1.2 解决方案

2.1.3 讨论

2.2 在字符串的开头或结尾处做文本匹配

2.2.1 问题

2.2.2 解决方案

2.2.3 讨论

2.3 利用Shell通配符做字符串匹配

2.3.1 问题

2.3.2 解决方案

2.3.3 讨论

2.4 文本模式的匹配和查找

2.4.1 问题

2.4.2 解决方案

2.4.3 讨论

2.5 查找和替换文本

2.5.1 问题

2.5.2 解决方案

2.5.3 讨论

2.6 以不区分大小写的方式对文本做查找和替换

2.6.1 问题

2.6.2 解决方案

2.6.3 讨论

2.7 定义实现最短匹配的正则表达式

2.7.1 问题

2.7.2 解决方案

2.7.3 讨论

2.8 编写多行模式的正则表达式

2.8.1 问题

2.8.2 解决方案

2.8.3 讨论

2.9 将Unicode文本统一表示为规范形式

2.9.1 问题

2.9.2 解决方案

2.9.3 讨论

2.10 用正则表达式处理Unicode字符

2.10.1 问题

2.10.2 解决方案

2.10.3 讨论

2.11 从字符串中去掉不需要的字符

2.11.1 问题

2.11.2 解决方案

2.11.3 讨论

2.12 文本过滤和清理

2.12.1 问题

2.12.2 解决方案

2.12.3 讨论

2.13 对齐文本字符串

2.13.1 问题

2.13.2 解决方案

2.13.3 讨论

2.14 字符串连接及合并

2.14.1 问题

2.14.2 解决方案

2.14.3 讨论

2.15 给字符串中的变量名做插值处理

2.15.1 问题

2.15.2 解决方案

2.15.3 讨论

2.16 以固定的列数重新格式化文本

2.16.1 问题

2.16.2 解决方案

2.16.3 讨论

2.17 在文本中处理HTML和XML实体

2.17.1 问题

2.17.2 解决方案

2.17.3 讨论

2.18 文本分词

2.18.1 问题

2.18.2 解决方案

2.18.3 讨论

2.19 编写一个简单的递归下降解析器

2.19.1 问题

2.19.2 解决方案

2.19.3 讨论

2.20 在字节串上执行文本操作

2.20.1 问题

2.20.2 解决方案

2.20.3 讨论

第3章 数字、日期和时间

3.1 对数值进行取整

3.1.1 问题

3.1.2 解决方案

3.1.3 讨论

3.2 执行精确的小数计算

3.2.1 问题

3.2.2 解决方案

3.2.3 讨论

3.3 对数值做格式化输出

3.3.1 问题

3.3.2 解决方案

3.3.3 讨论

3.4 同二进制、八进制和十六进制数打交道

3.4.1 问题

3.4.2 解决方案

3.4.3 讨论

3.5 从字节串中打包和解包大整数

3.5.1 问题

3.5.2 解决方案

3.5.3 讨论

3.6 复数运算

3.6.1 问题

3.6.2 解决方案

3.6.3 讨论

3.7 处理无穷大和NaN

3.7.1 问题

3.7.2 解决方案

3.7.3 讨论

3.8 分数的计算

3.8.1 问题

3.8.2 解决方案

3.8.3 讨论

3.9 处理大型数组的计算

3.9.1 问题

3.9.2 解决方案

3.9.3 讨论

3.10 矩阵和线性代数的计算

3.10.1 问题

3.10.2 解决方案

3.10.3 讨论

3.11 随机选择

3.11.1 问题

3.11.2 解决方案

3.11.3 讨论

3.12 时间换算

3.12.1 问题

3.12.2 解决方案

3.12.3 讨论

3.13 计算上周5的日期

3.13.1 问题

3.13.2 解决方案

3.13.3 讨论

3.14 找出当月的日期范围

3.14.1 问题

3.14.2 解决方案

3.14.3 讨论

3.15 将字符串转换为日期

3.15.1 问题

3.15.2 解决方案

3.15.3 讨论

3.16 处理涉及到时区的日期问题

3.16.1 问题

3.16.2 解决方案

3.16.3 讨论

第4章 迭代器和生成器

4.1 手动访问迭代器中的元素

4.1.1 问题

4.1.2 解决方案

4.1.3 讨论

4.2 委托迭代

4.2.1 问题

4.2.3 解决方案

4.2.4 讨论

4.3 用生成器创建新的迭代模式

4.3.1 问题

4.3.2 解决方案

4.3.3 讨论

4.4 实现迭代协议

4.4.1 问题

4.4.2 解决方案

4.4.3 讨论

4.5 反向迭代

4.5.1 问题

4.5.2 解决方案

4.5.3 讨论

4.6 定义带有额外状态的生成器函数

4.6.1 问题

4.6.2 解决方案

4.6.3 讨论

4.7 对迭代器做切片操作

4.7.1 问题

4.7.2 解决方案

4.7.3 讨论

4.8 跳过可迭代对象中的前一部分元素

4.8.1 问题

4.8.2 解决方案

4.8.3 讨论

4.9 迭代所有可能的组合或排列

4.9.1 问题

4.9.2 解决方案

4.9.3 讨论

4.10 以索引-值对的形式迭代序列

4.10.1 问题

4.10.2 解决方案

4.10.3 讨论

4.11 同时迭代多个序列

4.11.1 问题

4.11.2 解决方案

4.11.3 讨论

4.12 在不同的容器中进行迭代

4.12.1 问题

4.12.2 解决方案

4.12.3 讨论

4.13 创建处理数据的管道

4.13.1 问题

4.13.2 解决方案

4.13.3 讨论

4.14 扁平化处理嵌套型的序列

4.14.1 问题

4.14.2 解决方案

4.14.3 讨论

4.15 合并多个有序序列，再对整个有序序列进行迭代

4.15.1 问题

4.15.2 解决方案

4.15.3 讨论

4.16 用迭代器取代while循环

4.16.1 问题

4.16.2 解决方案

4.16.3 讨论

第5章 文件和I/O

5.1 读写文本数据

5.1.1 问题

5.1.2 解决方案

5.1.3 讨论

5.2 将输出重定向到文件中

5.2.1 问题

5.2.2 解决方案

5.2.3 讨论

5.3 以不同的分隔符或行结尾符完成打印

5.3.1 问题

5.3.2 解决方案

5.3.3 讨论

5.4 读写二进制数据

5.4.1 问题

5.4.2 解决方案

5.4.3 讨论

5.5 对已不存在的文件执行写入操作

5.5.1 问题

5.5.2 解决方案

5.5.3 讨论

5.6 在字符串上执行I/O操作

5.6.1 问题

5.6.2 解决方案

5.6.3 讨论

5.7 读写压缩的数据文件

5.7.1 问题

5.7.2 解决方案

5.7.3 讨论

5.8 对固定大小的记录进行迭代

5.8.1 问题

5.8.2 解决方案

5.8.3 讨论

5.9 将二进制数据读取到可变缓冲区中

5.9.1 问题

5.9.2 解决方案

5.9.3 讨论

5.10 对二进制文件做内存映射

5.10.1 问题

5.10.2 解决方案

5.10.3 讨论

5.11 处理路径名

5.11.1 问题

5.11.2 解决方案

5.11.3 讨论

5.12 检测文件是否存在

5.12.1 问题

5.12.2 解决方案

5.12.3 讨论

5.13 获取目录内容的列表

5.13.1 问题

5.13.2 解决方案

5.13.3 讨论

5.14 绕过文件名编码

5.14.1 问题

5.14.2 解决方案

5.14.3 讨论

5.15 打印无法解码的文件名

5.15.1 问题

5.15.2 解决方案

5.15.3 讨论

5.16 为已经打开的文件添加或修改编码方式

5.16.1 问题

5.16.2 解决方案

5.16.3 讨论

5.17 将字节数据写入文本文件

5.17.1 问题

5.17.2 解决方案

5.17.3 讨论

5.18 将已有的文件描述符包装为文件对象

5.18.1 问题

5.18.2 解决方案

5.18.3 讨论

5.19 创建临时文件和目录

5.19.1 问题

5.19.2 解决方案

5.19.3 讨论

5.20 同串口进行通信

5.20.1 问题

5.20.2 解决方案

5.20.3 讨论

5.21 序列化Python对象

5.21.1 问题

5.21.2 解决方案

5.21.3 讨论

第6章 数据编码与处理

6.1 读写CSV数据

6.1.1 问题

6.1.2 解决方案

6.1.3 讨论

6.2 读写JSON数据

6.2.1 问题

6.2.2 解决方案

6.2.3 讨论

6.3 解析简单的XML文档

6.3.1 问题

6.3.2 解决方案

6.3.3 讨论

6.4 以增量方式解析大型XML文件

6.4.1 问题

6.4.2 解决方案

6.4.3 讨论

6.5 将字典转换为XML

6.5.1 问题

6.5.2 解决方案

6.5.3 讨论

6.6 解析、修改和重写XML

6.6.1 问题

6.6.2 解决方案

6.6.3 讨论

6.7 用命名空间来解析XML文档

6.7.1 问题

6.7.2 解决方案

6.7.3 讨论

6.8 同关系型数据库进行交互

6.8.1 问题

6.8.2 解决方案

6.8.3 讨论

6.9 编码和解码十六进制数字

6.9.1 问题

6.9.2 解决方案

6.9.3 讨论

6.10 Base64编码和解码

6.10.1 问题

6.10.2 解决方案

6.10.3 讨论

6.11 读写二进制结构的数组

6.11.1 问题

6.11.2 解决方案

6.11.3 讨论

6.12 读取嵌套型和大小可变的二进制结构

6.12.1 问题

6.12.2 解决方案

6.12.3 讨论

6.13 数据汇总和统计

6.13.1 问题

6.13.2 解决方案

6.13.3 讨论

第7章 函数

7.1 编写可接受任意数量参数的函数

7.1.1 问题

7.1.2 解决方案

7.1.3 讨论

7.2 编写只接受关键字参数的函数

7.2.1 问题

7.2.2 解决方案

7.2.3 讨论

7.3 将元数据信息附加到函数参数上

7.3.1 问题

7.3.2 解决方案

7.3.3 讨论

7.4 从函数中返回多个值

7.4.1 问题

7.4.2 解决方案

7.4.3 讨论

7.5 定义带有默认参数的函数

7.5.1 问题

7.5.2 解决方案

7.5.3 讨论

7.6 定义匿名或内联函数

7.6.1 问题

7.6.2 解决方案

7.6.3 讨论

7.7 在匿名函数中绑定变量的值

7.7.1 问题

7.7.2 解决方案

7.7.3 讨论

7.8 让带有N个参数的可调用对象以较少的参数形式调用

7.8.1 问题

7.8.2 解决方案

7.8.3 讨论

7.9 用函数替代只有单个方法的类

7.9.1 问题

7.9.2 解决方案

7.9.3 讨论

7.10 在回调函数中携带额外的状态

7.10.1 问题

7.10.2 解决方案

7.10.3 讨论

7.11 内联回调函数

7.11.1 问题

7.11.2 解决方案

7.11.3 讨论

7.12 访问定义在闭包内的变量

7.12.1 问题

7.12.2 解决方案

7.12.3 讨论

第8章 类与对象

8.1 修改实例的字符串表示

8.1.1 问题

8.1.2 解决方案

8.1.3 讨论

8.2 自定义字符串的输出格式

8.2.1 问题

8.2.2 解决方案

8.2.3 讨论

8.3 让对象支持上下文管理协议

8.3.1 问题

8.3.2 解决方案

8.3.3 讨论

8.4 当创建大量实例时如何节省内存

8.4.1 问题

8.4.2 解决方案

8.4.3 讨论

8.5 将名称封装到类中

8.5.1 问题

8.5.2 解决方案

8.5.3 讨论

8.6 创建可管理的属性

8.6.1 问题

8.6.2 解决方案

8.6.3 讨论

8.7 调用父类中的方法

8.7.1 问题

8.7.2 解决方案

8.7.3 讨论

8.8 在子类中扩展属性

8.8.1 问题

8.8.2 解决方案

8.8.3 讨论

8.9 创建一种新形式的类属性或实例属性

8.9.1 问题

8.9.2 解决方案

8.9.3 讨论

8.10 让属性具有惰性求值的能力

8.10.1 问题

8.10.2 解决方案

8.10.3 讨论

8.11 简化数据结构的初始化过程

8.11.1 问题

8.11.2 解决方案

8.11.3 讨论

8.12 定义一个接口或抽象基类

8.12.1 问题

8.12.2 解决方案

8.12.3 讨论

8.13 实现一种数据模型或类型系统

8.13.1 问题

8.13.2 解决方案

8.13.3 讨论

8.14 实现自定义的容器

8.14.1 问题

8.14.2 解决方案

8.14.3 讨论

8.15 委托属性的访问

8.15.1 问题

8.15.2 解决方案

8.15.3 讨论

8.16 在类中定义多个构造函数

8.16.1 问题

8.16.2 解决方案

8.16.3 讨论

8.17 不通过调用init来创建实例

8.17.1 问题

8.17.2 解决方案

8.17.3 讨论

8.18 用Mixin技术来扩展类定义

8.18.1 问题

8.18.2 解决方法

8.18.3 讨论

8.19 实现带有状态的对象或状态机

8.19.1 问题

8.19.2 解决方案

8.19.3 讨论

8.20 调用对象上的方法，方法名以字符串形式给出

8.20.1 问题

8.20.2 解决方案

8.20.3 讨论

8.21 实现访问者模式

8.21.1 问题

8.21.2 解决方案

8.21.3 讨论

8.22 实现非递归的访问者模式

8.22.1 问题

8.22.2 解决方案

8.22.3 讨论

8.23 在环状数据结构中管理内存

8.23.1 问题

8.23.2 解决方案

8.23.3 讨论

8.24 让类支持比较操作

8.24.1 问题

8.24.2 解决方案

8.24.3 讨论

8.25 创建缓存实例

8.25.1 问题

8.25.2 解决方案

8.25.3 讨论

第9章 元编程

9.1 给函数添加一个包装

9.1.1 问题

9.1.2 解决方案

9.1.3 讨论

9.2 编写装饰器时如何保存函数的元数据

9.2.1 问题

9.2.2 解决方案

9.2.3 讨论

9.3 对装饰器进行解包装

9.3.1 问题

9.3.2 解决方案

9.3.3 讨论

9.4 定义一个可接受参数的装饰器

9.4.1 问题

9.4.2 解决方案

9.4.3 讨论

9.5 定义一个属性可由用户修改的装饰器

9.5.1 问题

9.5.2 解决方案

9.5.3 讨论

9.6 定义一个能接收可选参数的装饰器

9.6.1 问题

9.6.2 解决方案

9.6.3 讨论

9.7 利用装饰器对函数参数强制执行类型检查

9.7.1 问题

9.7.2 解决方案

9.7.3 讨论

9.8 在类中定义装饰器

9.8.1 问题

9.8.2 解决方案

9.8.3 讨论

9.9 把装饰器定义成类

9.9.1 问题

9.9.2 解决方案

9.9.3 讨论

9.10 把装饰器作用到类和静态方法上

9.10.1 问题

9.10.2 解决方案

9.10.3 讨论

9.11 编写装饰器为被包装的函数添加参数

9.11.1 问题

9.11.2 解决方案

9.11.3 讨论

9.12 利用装饰器给类定义打补丁

9.12.1 问题

9.12.2 解决方案

9.12.3 讨论

9.13 利用元类来控制实例的创建

9.13.1 问题

9.13.2 解决方案

9.13.3 讨论

9.14 获取类属性的定义顺序

9.14.1 问题

9.14.2 解决方案

9.14.3 讨论

9.15 定义一个能接受可选参数的元类

9.15.1 问题

9.15.2 解决方案

9.15.3 讨论

9.16 在*args和**kwargs上强制规定一种参数签名

9.16.1 问题

9.16.2 解决方案

9.16.3 讨论

9.17 在类中强制规定编码约定

9.17.1 问题

9.17.2 解决方案

9.17.3 讨论

9.18 通过编程的方式来定义类

9.18.1 问题

9.18.2 解决方案

9.18.3 讨论

9.19 在定义的时候初始化类成员

9.19.1 问题

9.19.2 解决方案

9.19.3 讨论

9.20 通过函数注解来实现方法重载

9.20.1 问题

9.20.2 解决方案

9.20.3 讨论

9.21 避免出现重复的属性方法

9.21.1 问题

9.21.2 解决方案

9.21.3 讨论

9.22 以简单的方式定义上下文管理器

9.22.1 问题

9.22.2 解决方案

9.22.3 讨论

9.23 执行带有局部副作用的代码

9.23.1 问题

9.23.2 解决方案

9.23.3 讨论

9.24 解析并分析Python源代码

9.24.1 问题

9.24.2 解决方案

9.24.3 讨论

9.25 将Python源码分解为字节码

9.25.1 问题

9.25.2 解决方案

9.25.3 讨论

第10章 模块和包

10.1 把模块按层次结构组织成包

10.1.1 问题

10.1.2 解决方案

10.1.3 讨论

10.2 对所有符号的导入进行精确控制

10.2.1 问题

10.2.2 解决方案

10.2.3 讨论

10.3 用相对名称来导入包中的子模块

10.3.1 问题

10.3.2 解决方案

10.3.3 讨论

10.4 将模块分解成多个文件

10.4.1 问题

10.4.2 解决方案

10.4.3 讨论

10.5 让各个目录下的代码在统一的命名空间下导入

10.5.1 问题

10.5.2 解决方案

10.5.3 讨论

10.6 重新加载模块

10.6.1 问题

10.6.2 解决方案

10.6.3 讨论

10.7 让目录或zip文件成为可运行的脚本

10.7.1 问题

10.7.2 解决方案

10.7.3 讨论

10.8 读取包中的数据文件

10.8.1 问题

10.8.2 解决方案

10.8.3 讨论

10.9 添加目录到sys.path中

10.9.1 问题

10.9.2 解决方案

10.9.3 讨论

10.10 使用字符串中给定的名称来导入模块

10.10.1 问题

10.10.2 解决方案

10.10.3 讨论

10.11 利用import钩子从远端机器上加载模块

10.11.1 问题

10.11.2 解决方案

10.11.3 讨论

10.12 在模块加载时为其打补丁

10.12.1 问题

10.12.2 解决方案

10.12.3 讨论

10.13 安装只为自己所用的包

10.13.1 问题

10.13.2 解决方案

10.13.3 讨论

10.14 创建新的Python环境

10.14.1 问题

10.14.2 解决方案

10.14.3 讨论

10.15 发布自定义的包

10.15.1 问题

10.15.2 解决方案

10.15.3 讨论

第11章 网络和Web编程

11.1 以客户端的形式同HTTP服务交互

11.1.1 问题

11.1.2 解决方案

11.1.3 讨论

11.2 创建一个TCP服务器

11.2.1 问题

11.2.2 解决方案

11.2.3 讨论

11.3 创建一个UDP服务器

11.3.1 问题

11.3.2 解决方案

11.3.3 讨论

11.4 从CIDR地址中生成IP地址的范围

11.4.1 问题

11.4.2 解决方案

11.4.3 讨论

11.5 创建基于REST风格的简单接口

11.5.1 问题

11.5.2 解决方案

11.5.3 讨论

11.6 利用XML-RPC实现简单的远端过程调用

11.6.1 问题

11.6.2 解决方案

11.6.3 讨论

11.7 在不同的解释器间进行通信

11.7.1 问题

11.7.2 解决方案

11.7.3 讨论

11.8 实现远端过程调用

11.8.1 问题

11.8.2 解决方案

11.8.3 讨论

11.9 以简单的方式验证客户端身份

11.9.1 问题

11.9.2 解决方案

11.9.3 讨论

11.10 为网络服务增加SSL支持

11.10.1 问题

11.10.2 解决方案

11.10.3 讨论

11.11 在进程间传递socket文件描述符

11.11.1 问题

11.11.2 解决方案

11.11.3 讨论

11.12 理解事件驱动型I/O

11.12.1 问题

11.12.2 解决方案

11.12.3 讨论

11.13 发送和接收大型数组

11.13.1 问题

11.13.2 解决方案

11.13.3 讨论

第12章 并发

12.1 启动和停止线程

12.1.1 问题

12.1.2 解决方案

12.1.3 讨论

12.2 判断线程是否已经启动

12.2.1 问题

12.2.2 解决方案

12.2.3 讨论

12.3 线程间通信

12.3.1 问题

12.3.2 解决方案

12.3.3 讨论

12.4 对临界区加锁

12.4.1 问题

12.4.2 解决方案

12.4.3 讨论

12.5 避免死锁

12.5.1 问题

12.5.2 解决方案

12.5.3 讨论

12.6 保存线程专有状态

12.6.1 问题

12.6.2 解决方案

12.6.3 讨论

12.7 创建线程池

12.7.1 问题

12.7.2 解决方案

12.7.3 讨论

12.8 实现简单的并行编程

12.8.1 问题

12.8.2 解决方案

12.8.3 讨论

12.9 如何规避GIL带来的限制

12.9.1 问题

12.9.2 解决方案

12.9.3 讨论

12.10 定义一个Actor任务

12.10.1 问题

12.10.2 解决方案

12.10.3 讨论

12.11 实现发布者/订阅者消息模式

12.11.1 问题

12.11.2 解决方案

12.11.3 讨论

12.12 使用生成器作为线程的替代方案

12.12.1 问题

12.12.2 解决方案

12.12.3 讨论

12.13 轮询多个线程队列

12.13.1 问题

12.13.2 解决方案

12.13.3 讨论

12.14 在UNIX上加载守护进程

12.14.1 问题

12.14.2 解决方案

12.14.3 讨论

第13章 实用脚本和系统管理

13.1 通过重定向、管道或输入文件来作为脚本的输入

13.1.1 问题

13.1.2 解决方案

13.1.3 讨论

13.2 终止程序并显示错误信息

13.2.1 问题

13.2.2 解决方案

13.2.3 讨论

13.3 解析命令行选项

13.3.1 问题

13.3.2 解决方案

13.3.3 讨论

13.4 在运行时提供密码输入提示

13.4.1 问题

13.4.2 解决方案

13.4.3 讨论

13.5 获取终端大小

13.5.1 问题

13.5.2 解决方案

13.5.3 讨论

13.6 执行外部命令并获取输出

13.6.1 问题

13.6.2 解决方案

13.6.3 讨论

13.7 拷贝或移动文件和目录

13.7.1 问题

13.7.2 解决方案

13.7.3 讨论

13.8 创建和解包归档文件

13.8.1 问题

13.8.2 解决方案

13.8.3 讨论

13.9 通过名称来查找文件

13.9.1 问题

13.9.2 解决方案

13.9.3 讨论

13.10 读取配置文件

13.10.1 问题

13.10.2 解决方案

13.10.3 讨论

13.11 给脚本添加日志记录

13.11.1 问题

13.11.2 解决方案

13.11.3 讨论

13.12 给库添加日志记录

13.12.1 问题

13.12.2 解决方案

13.12.3 讨论

13.13 创建一个秒表计时器

13.13.1 问题

13.13.2 解决方案

13.13.3 讨论

13.14 给内存和CPU使用量设定限制

13.14.1 问题

13.14.2 解决方案

13.14.3 讨论

13.15 加载Web浏览器

13.15.1 问题

13.15.2 解决方案

13.15.3 讨论

第14章 测试、调试以及异常

14.1 测试发送到stdout上的输出

14.1.1 问题

14.1.2 解决方案

14.1.3 讨论

14.2 在单元测试中为对象打补丁

14.2.1 问题

14.2.2 解决方案

14.2.3 讨论

14.3 在单元测试中检测异常情况

14.3.1 问题

14.3.2 解决方案

14.3.3 讨论

14.4 将测试结果作为日志记录到文件中

14.4.1 问题

14.4.2 解决方案

14.4.3 讨论

14.5 跳过测试，或者预计测试结果为失败

14.5.1 问题

14.5.2 解决方案

14.5.3 讨论

14.6 处理多个异常

14.6.1 问题

14.6.2 解决方案

14.6.3 讨论

14.7 捕获所有的异常

14.7.1 问题

14.7.2 解决方案

14.7.3 讨论

14.8 创建自定义的异常

14.8.1 问题

14.8.2 解决方案

14.8.3 讨论

14.9 通过引发异常来响应另一个异常

14.9.1 问题

14.9.2 解决方案

14.9.3 讨论

14.10 重新抛出上一个异常

14.10.1 问题

14.10.2 解决方案

14.10.3 讨论

14.11 发出告警信息

14.11.1 问题

14.11.2 解决方案

14.11.3 讨论

14.12 对基本的程序崩溃问题进行调试

14.12.1 问题

14.12.2 解决方案

14.12.3 讨论

14.13 对程序做性能分析以及计时统计

14.13.1 问题

14.13.2 解决方案

14.13.3 讨论

14.14 让你的程序运行得更快

14.14.1 问题

14.14.2 解决方案

使用函数

有选择性的消除属性访问

理解变量所处的位置

避免不必要的抽象

使用内建的容器

避免产生不必要的数据结构或者拷贝动作

14.14.3 讨论

第15章 C语言扩展

15.1 利用ctypes来访问C代码

15.1.1 问题

15.1.2 解决方案

15.1.3 讨论

15.2 编写简单的C语言扩展模块

15.2.1 问题

15.2.2 解决方案

15.2.3 讨论

15.3 编写一个可操作数组的扩展函数

15.3.1 问题

15.3.2 解决方案

15.3.3 讨论

15.4 在C扩展模块中管理不透明指针

15.4.1 问题

15.4.2 解决方案

15.4.3 讨论

15.5 在扩展模块中定义并导出C API

15.5.1 问题

15.5.2 解决方案

15.5.3 讨论

15.6 从C中调用Python

15.6.1 问题

15.6.2 解决方案

15.6.3 讨论

15.7 在C扩展模块中释放GIL

15.7.1 问题

15.7.2 解决方案

15.7.3 讨论

15.8 混合使用C和Python环境中的线程

15.8.1 问题

15.8.2 解决方案

15.8.3 讨论

15.9 用Swig来包装C代码

15.9.1 问题

15.9.2 解决方案

15.9.3 讨论

15.10 用Cython来包装C代码

15.10.1 问题

15.10.2 解决方案

15.10.3 讨论

15.11 用Cython来高效操作数组

15.11.1 问题

15.11.2 解决方案

15.11.3 讨论

15.12 把函数指针转换为可调用对象

15.12.1 问题

15.12.2 解决方案

15.12.3 讨论

15.13 把以NULL结尾的字符串传给C库

15.13.1 问题

15.13.2 解决方案

15.13.3 讨论

15.14 把Unicode字符串传递给C库

15.14.1 问题

15.14.2 解决方案

15.14.3 讨论

15.15 把C字符串转换到Python中

15.15.1 问题

15.15.2 解决方案

15.15.3 讨论

15.16 同编码方式不确定的C字符串打交道

15.16.1 问题

15.16.2 解决方案

15.16.3 讨论

15.17 把文件名传给C扩展模块

15.17.1 问题

15.17.2 解决方案

15.17.3 讨论

15.18 把打开的文件传给C扩展模块

15.18.1 问题

15.18.2 解决方案

15.18.3 讨论

15.19 在C中读取文件型对象

15.19.1 问题

15.19.2 解决方案

15.19.3 讨论

15.20 从C中访问可迭代对象

15.20.1 问题

15.20.2 解决方案

15.20.3 讨论

15.21 排查段错误

15.21.1 问题

15.21.2 解决方案

15.21.3 讨论

附录A 补充阅读

A.1 在线资源

A.2 学习Python的图书

A.3 高级图书

封面说明

欢迎来到异步社区！

异步社区的来历

社区里都有什么？

购买图书

下载资源

与作译者互动

灵活优惠的购书

特别优惠

纸电图书组合购买

社区里还可以做什么？

提交勘误

写作

会议活动早知道

加入异步