Python Standard Library

翻译: Python 江湖群

2008-03-28 13:11:51

Contents

  1. 1. 核心模块
    1. 1.1. 介绍
      1. 1.1.1. 内建函数和异常
      2. 1.1.2. 操作系统接口模块
      3. 1.1.3. 类型支持模块
      4. 1.1.4. 正则表达式
      5. 1.1.5. 语言支持模块
    2. 1.2. _ _builtin_ _ 模块
      1. 1.2.1. 使用元组或字典中的参数调用函数
        1. 1.2.1.1. Example 1-1. 使用 apply 函数
        2. 1.2.1.2. Example 1-2. 使用 apply 函数传递关键字参数
        3. 1.2.1.3. Example 1-3. 使用 apply 函数调用基类的构造函数
      2. 1.2.2. 加载和重载模块
        1. 1.2.2.1. Example 1-4. 使用 _ _import_ _ 函数加载模块
        2. 1.2.2.2. Example 1-5. Plug-in 例子
        3. 1.2.2.3. Example 1-6. 使用 _ _import_ _ 函数获得特定函数
        4. 1.2.2.4. Example 1-7. 使用 _ _import_ _ 函数实现 延迟导入
        5. 1.2.2.5. Example 1-8. 使用 reload 函数
      3. 1.2.3. 关于名称空间
        1. 1.2.3.1. Example 1-9. 使用 dir 函数
        2. 1.2.3.2. Example 1-10. 使用 dir 函数查找类的所有成员
        3. 1.2.3.3. Example 1-11. 使用 vars 函数
      4. 1.2.4. 检查对象类型
        1. 1.2.4.1. Example 1-12. 使用 type 函数
        2. 1.2.4.2. Example 1-13. 对文件名和文件对象使用 type 函数
        3. 1.2.4.3. Example 1-14. 使用 callable 函数
        4. 1.2.4.4. Example 1-15. 使用 isinstance 函数
        5. 1.2.4.5. Example 1-16. 使用 issubclass 函数
      5. 1.2.5. 计算 Python 表达式
        1. 1.2.5.1. Example 1-17. 使用 eval 函数
        2. 1.2.5.2. Example 1-18. 使用 eval 函数执行任意命令
        3. 1.2.5.3. Example 1-19. 安全地使用 eval 函数求值
      6. 1.2.6. 编译和执行代码
        1. 1.2.6.1. Example 1-20. 使用 compile 函数检查语法
        2. 1.2.6.2. Example 1-21. 执行已编译的代码
        3. 1.2.6.3. Example 1-22. 简单的代码生成工具
        4. 1.2.6.4. Example 1-23. 使用 execfile 函数
        5. 1.2.6.5. Example 1-24. hello.py 脚本
      7. 1.2.7. 从 _ _builtin_ _ 模块重载函数
        1. 1.2.7.1. Example 1-25. 显式地访问 _ _builtin_ _ 模块中的函数
    3. 1.3. exceptions 模块
        1. 1.3.0.1. Example 1-26. 使用 exceptions 模块
    4. 1.4. os 模块
      1. 1.4.1. 处理文件
        1. 1.4.1.1. Example 1-27. 使用 os 模块重命名和删除文件
      2. 1.4.2. 处理目录
        1. 1.4.2.1. Example 1-28. 使用 os 列出目录下的文件
        2. 1.4.2.2. Example 1-29. 使用 os 模块改变当前工作目录
        3. 1.4.2.3. Example 1-30. 使用 os 模块创建/删除多个目录级
        4. 1.4.2.4. Example 1-31. 使用 os 模块创建/删除目录
      3. 1.4.3. 处理文件属性
        1. 1.4.3.1. Example 1-32. 使用 os 模块获取文件属性
        2. 1.4.3.2. Example 1-33. 使用 os 模块修改文件的权限和时间戳
      4. 1.4.4. 处理进程
        1. 1.4.4.1. Example 1-34. 使用 os 执行操作系统命令
        2. 1.4.4.2. Example 1-35. 使用 os 模块启动新进程
        3. 1.4.4.3. Example 1-36. 使用 os 模块调用其他程序 (Unix)
        4. 1.4.4.4. Example 1-37. 使用 os 模块调用其他程序 (Windows)
        5. 1.4.4.5. Example 1-38. 使用 os 模块在后台执行程序 (Windows)
        6. 1.4.4.6. Example 1-39. 使用 spawn 或 fork/exec 调用其他程序
      5. 1.4.5. 处理守护进程(Daemon Processes)
        1. 1.4.5.1. Example 1-40. 使用 os 模块使脚本作为守护执行 (Unix)
        2. 1.4.5.2. Example 1-41. 使用 os 模块终止当前进程
    5. 1.5. os.path 模块
      1. 1.5.1. 处理文件名
        1. 1.5.1.1. Example 1-42. 使用 os.path 模块处理文件名
        2. 1.5.1.2. Example 1-43. 使用 os.path 模块检查文件名的特征
        3. 1.5.1.3. Example 1-44. 使用 os.path 模块将用户名插入到文件名
        4. 1.5.1.4. Example 1-45. 使用 os.path 替换文件名中的环境变量
      2. 1.5.2. 搜索文件系统
        1. 1.5.2.1. Example 1-46. 使用 os.path 搜索文件系统
        2. 1.5.2.2. Example 1-47. 使用 os.listdir 搜索文件系统
        3. 1.5.2.3. Example 1-48. 使用 DirectoryWalker 搜索文件系统
        4. 1.5.2.4. Example 1-49. 使用 DirectoryStatWalker 搜索文件系统
    6. 1.6. stat 模块
        1. 1.6.0.1. Example 1-50. Using the stat Module
    7. 1.7. string 模块
        1. 1.7.0.1. Example 1-51. 使用 string 模块
        2. 1.7.0.2. Example 1-52. 使用字符串方法替代 string 模块函数
        3. 1.7.0.3. Example 1-53. 使用 string 模块将字符串转为数字
    8. 1.8. re 模块
        1. 1.8.0.1. Example 1-54. 使用 re 模块来匹配字符串
        2. 1.8.0.2. Example 1-55. 使用 re 模块抽出匹配的子字符串
        3. 1.8.0.3. Example 1-56. 使用 re 模块搜索子字符串
        4. 1.8.0.4. Example 1-57. 使用 re 模块替换子字符串
        5. 1.8.0.5. Example 1-58. 使用 re 模块替换字符串(通过回调函数)
        6. 1.8.0.6. Example 1-59. 使用 re 模块匹配多个模式中的一个
    9. 1.9. math 模块
        1. 1.9.0.1. Example 1-60. 使用 math 模块
    10. 1.10. cmath 模块
        1. 1.10.0.1. Example 1-61. 使用 cmath 模块
    11. 1.11. operator 模块
        1. 1.11.0.1. Example 1-62. 使用 operator 模块
        2. 1.11.0.2. Example 1-63. 使用 operator 模块检查类型
    12. 1.12. copy 模块
        1. 1.12.0.1. Example 1-64. 使用 copy 模块复制对象
        2. 1.12.0.2. Example 1-65. 使用 copy 模块复制集合(Collections)
    13. 1.13. sys 模块
      1. 1.13.1. 处理命令行参数
        1. 1.13.1.1. Example 1-66. 使用sys模块获得脚本的参数
      2. 1.13.2. 处理模块
        1. 1.13.2.1. Example 1-67. 使用sys模块操作模块搜索路径
        2. 1.13.2.2. Example 1-68. 使用sys模块查找内建模块
        3. 1.13.2.3. Example 1-69. 使用sys模块查找已导入的模块
      3. 1.13.3. 处理引用记数
        1. 1.13.3.1. Example 1-70. 使用sys模块获得引用记数
        2. 1.13.3.2. Example 1-71. 使用sys模块获得当前平台
      4. 1.13.4. 跟踪程序
        1. 1.13.4.1. Example 1-72. 使用sys模块配置分析函数
        2. 1.13.4.2. Example 1-73. 使用sys模块配置单步跟踪函数
      5. 1.13.5. 处理标准输出/输入
        1. 1.13.5.1. Example 1-74. 使用sys重定向输出
      6. 1.13.6. 退出程序
        1. 1.13.6.1. Example 1-75. 使用sys模块退出程序
        2. 1.13.6.2. Example 1-76. 捕获sys.exit调用
        3. 1.13.6.3. Example 1-77. 另一种捕获sys.exit调用的方法
    14. 1.14. atexit 模块
        1. 1.14.0.1. Example 1-78. 使用 atexit 模块
    15. 1.15. time 模块
      1. 1.15.1. 获得当前时间
        1. 1.15.1.1. Example 1-79. 使用 time 模块获取当前时间
      2. 1.15.2. 将时间值转换为字符串
        1. 1.15.2.1. Example 1-80. 使用 time 模块格式化时间输出
      3. 1.15.3. 将字符串转换为时间对象
        1. 1.15.3.1. Example 1-81. 使用 time.strptime 函数解析时间
        2. 1.15.3.2. Example 1-82. strptime 实现
      4. 1.15.4. 转换时间值
        1. 1.15.4.1. Example 1-83. 使用 time 模块将本地时间元组转换为时间值(整数)
        2. 1.15.4.2. Example 1-84. 将 UTC 时间元组转换为时间值(整数)
      5. 1.15.5. Timing 相关
        1. 1.15.5.1. Example 1-85. 使用 time 模块评价算法
    16. 1.16. types 模块
        1. 1.16.0.1. Example 1-86. 使用 types 模块
    17. 1.17. gc 模块
        1. 1.17.0.1. Example 1-87. 使用 gc 模块收集循环引用垃圾


[index.html 返回首页]


1. 核心模块


1.1. 介绍

Python 的标准库包括了很多的模块, 从 Python 语言自身特定的类型和声明, 到一些只用于少数程序的不著名的模块.

本章描述了一些基本的标准库模块. 任何大型 Python 程序都有可能直接或间接地使用到这类模块的大部分.

1.1.1. 内建函数和异常

下面的这两个模块比其他模块加在一起还要重要: 定义内建函数(例如 len, int, range ...)的 _ _builtin_ _ 模块, 以及定义所有内建异常的 exceptions 模块.

Python 在启动时导入这两个模块, 使任何程序都能够使用它们.

1.1.2. 操作系统接口模块

Python 有许多使用了 POSIX 标准 API 和标准 C 语言库的模块. 它们为底层操作系统提供了平台独立的接口.

这类的模块包括: 提供文件和进程处理功能的 os 模块; 提供平台独立的文件名处理 (分拆目录名, 文件名, 后缀等)的 os.path 模块; 以及时间日期处理相关的 time/datetime 模块.

[!Feather注: datetime 为 Py2.3 新增模块, 提供增强的时间处理方法 ]

延伸一点说, 网络和线程模块同样也可以归为这一个类型. 不过 Python 并没有在所有的平台/版本实现这些.

1.1.3. 类型支持模块

标准库里有许多用于支持内建类型操作的库. string 模块实现了常用的字符串处理. math 模块提供了数学计算操作和常量(pi, e都属于这类常量), cmath 模块为复数提供了和 math 一样的功能.

1.1.4. 正则表达式

re 模块为 Python 提供了正则表达式支持. 正则表达式是用于匹配字符串或特定子字符串的 有特定语法的字符串模式.

1.1.5. 语言支持模块

sys 模块可以让你访问解释器相关参数,比如模块搜索路径,解释器版本号等. operator 模块提供了和内建操作符作用相同的函数. copy 模块允许 你复制对象, Python 2.0 新加入的 gc 模块提供了对垃圾收集的相关控制功能.


1.2. _ _builtin_ _ 模块

这个模块包含 Python 中使用的内建函数. 一般不用手动导入这个模块; Python会帮你做好一切.

1.2.1. 使用元组或字典中的参数调用函数

Python允许你实时地创建函数参数列表. 只要把所有的参数放入一个元组中, 然后通过内建的 apply 函数调用函数. 如 Example 1-1.

1.2.1.1. Example 1-1. 使用 apply 函数

File: builtin-apply-example-1.py

def function(a, b):
    print a, b

apply(function, ("whither", "canada?"))
apply(function, (1, 2 + 3))

*B*whither canada?
1 5*b*

要想把关键字参数传递给一个函数, 你可以将一个字典作为 apply 函数的第 3 个参数, 参考 Example 1-2.

1.2.1.2. Example 1-2. 使用 apply 函数传递关键字参数

File: builtin-apply-example-2.py

def function(a, b):
    print a, b

apply(function, ("crunchy", "frog"))
apply(function, ("crunchy",), {"b": "frog"})
apply(function, (), {"a": "crunchy", "b": "frog"})

*B*crunchy frog
crunchy frog
crunchy frog*b*

apply 函数的一个常见用法是把构造函数参数从子类传递到基类, 尤其是构造函数需要接受很多参数的时候. 如 Example 1-3 所示.

1.2.1.3. Example 1-3. 使用 apply 函数调用基类的构造函数

File: builtin-apply-example-3.py

class Rectangle:
    def _ _init_ _(self, color="white", width=10, height=10):
        print "create a", color, self, "sized", width, "x", height

class RoundedRectangle(Rectangle):
    def _ _init_ _(self, **kw):
        apply(Rectangle._ _init_ _, (self,), kw)

rect = Rectangle(color="green", height=100, width=100)
rect = RoundedRectangle(color="blue", height=20)

*B*create a green <Rectangle instance at 8c8260> sized 100 x 100
create a blue <RoundedRectangle instance at 8c84c0> sized 10 x 20*b*

Python 2.0 提供了另个方法来做相同的事. 你只需要使用一个传统的函数调用 , 使用 * 来标记元组, ** 来标记字典.

下面两个语句是等价的:

result = function(*args, **kwargs)
result = apply(function, args, kwargs)

1.2.2. 加载和重载模块

如果你写过较庞大的 Python 程序, 那么你就应该知道 import 语句是用来导入外部模块的 (当然也可以使用 from-import 版本). 不过你可能不知道 import 其实是靠调用内建 函数 _ _import_ _ 来工作的.

通过这个戏法你可以动态地调用函数. 当你只知道模块名称(字符串)的时候, 这将很方便. Example 1-4 展示了这种用法, 动态地导入所有以 "-plugin" 结尾的模块.

1.2.2.1. Example 1-4. 使用 _ _import_ _ 函数加载模块

File: builtin-import-example-1.py

import glob, os

modules = []

for module_file in glob.glob("*-plugin.py"):
    try:
        module_name, ext = os.path.splitext(os.path.basename(module_file))
        module = _ _import_ _(module_name)
        modules.append(module)
    except ImportError:
        pass # ignore broken modules

# say hello to all modules
for module in modules:
    module.hello()

*B*example-plugin says hello*b*

注意这个 plug-in 模块文件名中有个 "-" (hyphens). 这意味着你不能使用普通的 import 命令, 因为 Python 的辨识符不允许有 "-" .

Example 1-5 展示了 Example 1-4 中使用的 plug-in .

1.2.2.2. Example 1-5. Plug-in 例子

File: example-plugin.py

def hello():
    print "example-plugin says hello"

Example 1-6 展示了如何根据给定模块名和函数名获得想要的函数对象.

1.2.2.3. Example 1-6. 使用 _ _import_ _ 函数获得特定函数

File: builtin-import-example-2.py

def getfunctionbyname(module_name, function_name):
    module = _ _import_ _(module_name)
    return getattr(module, function_name)

print repr(getfunctionbyname("dumbdbm", "open"))

*B*<function open at 794fa0>*b*

你也可以使用这个函数实现延迟化的模块导入 (lazy module loading). 例如在 Example 1-7string 模块只在第一次使用的时候导入.

1.2.2.4. Example 1-7. 使用 _ _import_ _ 函数实现 延迟导入

File: builtin-import-example-3.py

class LazyImport:
    def _ _init_ _(self, module_name):
        self.module_name = module_name
        self.module = None
    def _ _getattr_ _(self, name):
        if self.module is None:
            self.module = _ _import_ _(self.module_name)
        return getattr(self.module, name)

string = LazyImport("string")

print string.lowercase

*B*abcdefghijklmnopqrstuvwxyz*b*

Python 也提供了重新加载已加载模块的基本支持. [Example 1-8 #eg-1-8 会加载 3 次 hello.py 文件.

1.2.2.5. Example 1-8. 使用 reload 函数

File: builtin-reload-example-1.py

import hello
reload(hello)
reload(hello)

*B*hello again, and welcome to the show
hello again, and welcome to the show
hello again, and welcome to the show*b*

reload 直接接受模块作为参数.

[!Feather 注:  ^ 原句无法理解, 稍后讨论.]

注意,当你重加载模块时, 它会被重新编译, 新的模块会代替模块字典里的老模块. 但是, 已经用原模块里的类建立的实例仍然使用的是老模块(不会被更新).

同样地, 使用 from-import 直接创建的到模块内容的引用也是不会被更新的.

1.2.3. 关于名称空间

dir 返回由给定模块, 类, 实例, 或其他类型的所有成员组成的列表. 这可能在交互式 Python 解释器下很有用, 也可以用在其他地方. Example 1-9展示了 dir 函数的用法.

1.2.3.1. Example 1-9. 使用 dir 函数

File: builtin-dir-example-1.py

def dump(value):
    print value, "=>", dir(value)

import sys

dump(0)
dump(1.0)
dump(0.0j) # complex number
dump([]) # list
dump({}) # dictionary
dump("string")
dump(len) # function
dump(sys) # module

*B*0 => []
1.0 => []
0j => ['conjugate', 'imag', 'real']
[] => ['append', 'count', 'extend', 'index', 'insert',
    'pop', 'remove', 'reverse', 'sort']
{} => ['clear', 'copy', 'get', 'has_key', 'items',
    'keys', 'update', 'values']
string => []
<built-in function len> => ['_ _doc_ _', '_ _name_ _', '_ _self_ _']
<module 'sys' (built-in)> => ['_ _doc_ _', '_ _name_ _',
    '_ _stderr_ _', '_ _stdin_ _', '_ _stdout_ _', 'argv',
    'builtin_module_names', 'copyright', 'dllhandle',
    'exc_info', 'exc_type', 'exec_prefix', 'executable',
...*b*

在例子 Example 1-10中定义的 getmember 函数返回给定类定义的所有类级别的属性和方法.

1.2.3.2. Example 1-10. 使用 dir 函数查找类的所有成员

File: builtin-dir-example-2.py

class A:
    def a(self):
        pass
    def b(self):
        pass

class B(A):
    def c(self):
        pass
    def d(self):
        pass

def getmembers(klass, members=None):
    # get a list of all class members, ordered by class
    if members is None:
        members = []
    for k in klass._ _bases_ _:
        getmembers(k, members)
    for m in dir(klass):
        if m not in members:
            members.append(m)
    return members

print getmembers(A)
print getmembers(B)
print getmembers(IOError)

*B*['_ _doc_ _', '_ _module_ _', 'a', 'b']
['_ _doc_ _', '_ _module_ _', 'a', 'b', 'c', 'd']
['_ _doc_ _', '_ _getitem_ _', '_ _init_ _', '_ _module_ _', '_ _str_ _']*b*

getmembers 函数返回了一个有序列表. 成员在列表中名称出现的越早, 它所处的类层次就越高. 如果无所谓顺序的话, 你可以使用字典代替列表.

[!Feather 注: 字典是无序的, 而列表和元组是有序的, 网上有关于有序字典的讨论]

vars 函数与此相似, 它返回的是包含每个成员当前值的字典. 如果你使用不带参数的 vars , 它将返回当前局部名称空间的可见元素(同 locals() 函数 ). 如 Example 1-11所表示.

1.2.3.3. Example 1-11. 使用 vars 函数

File: builtin-vars-example-1.py

book = "library2"
pages = 250
scripts = 350


print "the %(book)s book contains more than %(scripts)s scripts" % vars()

*B*the library book contains more than 350 scripts*b*

1.2.4. 检查对象类型

Python 是一种动态类型语言, 这意味着给一个定变量名可以在不同的场合绑定到不同的类型上. 在接下面例子中, 同样的函数分别被整数, 浮点数, 以及一个字符串调用:

def function(value):
    print value
function(1)
function(1.0)
function("one")

type 函数 (如 Example 1-12 所示) 允许你检查一个变量的类型. 这个函数会返回一个 type descriptor (类型描述符), 它对于 Python 解释器提供的每个类型都是不同的.

1.2.4.1. Example 1-1