'''Python Standard Library'''
''翻译: Python 江湖群''
2008-03-28 13:11:51
<<TableOfContents>>
----
[index.html 返回首页]
----
= 1. 核心模块 =
"Since the functions in the C runtime library are not part of the Win32 API,
we believe the number of applications that will be affected by this bug to
be very limited."
- Microsoft, January 1999
----
== 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}}} 函数调用函数. 如 [[#eg-1-1|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 个参数,
参考 [[#eg-1-2|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}}} 函数的一个常见用法是把构造函数参数从子类传递到基类,
尤其是构造函数需要接受很多参数的时候. 如 [[#eg-1-3|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_ _}}} 来工作的.
通过这个戏法你可以动态地调用函数. 当你只知道模块名称(字符串)的时候, 这将很方便.
[[#eg-1-4|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 的辨识符不允许有 "-" .
[[#eg-1-5|Example 1-5]] 展示了 [[#eg-1-4|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"
}}}
[[#eg-1-6|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). 例如在 [[#eg-1-7|Example 1-7]] 中
的 {{{string}}} 模块只在第一次使用的时候导入.
==== 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 解释器下很有用, 也可以用在其他地方. [[#eg-1-9|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*
}}}
在例子 [[#eg-1-10|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()}}} 函数 ). 如 [[#eg-1-11|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}}} 函数 (如 [[#eg-1-12|Example 1-12]] 所示) 允许你检查一个变量的类型. 这个函数会返回一个
''type descriptor (类型描述符)'', 它对于 Python 解释器提供的每个类型都是不同的.
==== 1.2.4.1. Example 1-12. 使用 type 函数 ====
{{{
File: builtin-type-example-1.py
def dump(value):
print type(value), value
dump(1)
dump(1.0)
dump("one")
*B*<type 'int'> 1
<type 'float'> 1.0
<type 'string'> one*b*
}}}
每个类型都有一个对应的类型对象, 所以你可以使用 {{{is}}} 操作符 (对象身份?) 来
检查类型. (如 [[#eg-1-13|Example 1-13]]所示).
==== 1.2.4.2. Example 1-13. 对文件名和文件对象使用 type 函数 ====
{{{
File: builtin-type-example-2.py
def load(file):
if isinstance(file, type("")):
file = open(file, "rb")
return file.read()
print len(load("samples/sample.jpg")), "bytes"
print len(load(open("samples/sample.jpg", "rb"))), "bytes"
*B*4672 bytes
4672 bytes*b*
}}}
{{{callable}}} 函数, 如 [[#eg-1-14|Example 1-14]] 所示, 可以检查一个对象是否是可调用的
(无论是直接调用或是通过 {{{apply}}}). 对于函数, 方法, {{{lambda}}} 函式, 类,
以及实现了 {{{_ _call_ _}}} 方法的类实例, 它都返回 True.
==== 1.2.4.3. Example 1-14. 使用 callable 函数 ====
{{{
File: builtin-callable-example-1.py
def dump(function):
if callable(function):
print function, "is callable"
else:
print function, "is *not* callable"
class A:
def method(self, value):
return value
class B(A):
def _ _call_ _(self, value):
return value
a = A()
b = B()
dump(0) # simple objects
dump("string")
dump(callable)
dump(dump) # function
dump(A) # classes
dump(B)
dump(B.method)
dump(a) # instances
dump(b)
dump(b.method)
*B*0 is *not* callable
string is *not* callable
<built-in function callable> is callable
<function dump at 8ca320> is callable
A is callable
B is callable
<unbound method A.method> is callable
<A instance at 8caa10> is *not* callable
<B instance at 8cab00> is callable
<method A.method of B instance at 8cab00> is callable*b*
}}}
注意类对象 (A 和 B) 都是可调用的; 如果调用它们, 就产生新的对象(类实例). 但是 A 类的实例不可调用, 因为它的类没有实现 {{{_ _call_ _}}} 方法.
你可以在 {{{operator}}} 模块中找到检查对象是否为某一内建类型(数字, 序列, 或者字典等)
的函数. 但是, 因为创建一个类很简单(比如实现基本序列方法的类), 所以对这些
类型使用显式的类型判断并不是好主意.
在处理类和实例的时候会复杂些. Python 不会把类作为本质上的类型对待; 相反地, 所有的类都属于一个特殊的类类型(special class type), 所有的类实例属于一个特殊的实例类型(special instance type).
这意味着你不能使用 {{{type}}} 函数来测试一个实例是否属于一个给定的类; 所有的实例都是同样
的类型! 为了解决这个问题, 你可以使用 {{{isinstance}}} 函数,它会检查一个对象是
不是给定类(或其子类)的实例. [[#eg-1-15|Example 1-15]] 展示了 {{{isinstance}}} 函数的使用.
==== 1.2.4.4. Example 1-15. 使用 isinstance 函数 ====
{{{
File: builtin-isinstance-example-1.py
class A:
pass
class B:
pass
class C(A):
pass
class D(A, B):
pass
def dump(object):
print object, "=>",
if isinstance(object, A):
print "A",
if isinstance(object, B):
print "B",
if isinstance(object, C):
print "C",
if isinstance(object, D):
print "D",
print
a = A()
b = B()
c = C()
d = D()
dump(a)
dump(b)
dump(c)
dump(d)
dump(0)
dump("string")
*B*<A instance at 8ca6d0> => A
<B instance at 8ca750> => B
<C instance at 8ca780> => A C
<D instance at 8ca7b0> => A B D
0 =>
string =>*b*
}}}
{{{issubclass}}} 函数与此相似, 它用于检查一个类对象是否与给定类相同,
或者是给定类的子类. 如 [[#eg-1-16|Example 1-16]] 所示.
注意, {{{isinstance}}} 可以接受任何对象作为参数, 而 {{{issubclass}}} 函数在接受非类对象参
数时会引发 ''TypeError'' 异常.
==== 1.2.4.5. Example 1-16. 使用 issubclass 函数 ====
{{{
File: builtin-issubclass-example-1.py
class A:
pass
class B:
pass
class C(A):
pass
class D(A, B):
pass
def dump(object):
print object, "=>",
if issubclass(object, A):
print "A",
if issubclass(object, B):
print "B",
if issubclass(object, C):
print "C",
if issubclass(object, D):
print "D",
print
dump(A)
dump(B)
dump(C)
dump(D)
dump(0)
dump("string")
*B*A => A
B => B
C => A C
D => A B D
0 =>
Traceback (innermost last):
File "builtin-issubclass-example-1.py", line 29, in ?
File "builtin-issubclass-example-1.py", line 15, in dump
TypeError: arguments must be classes*b*
}}}
=== 1.2.5. 计算 Python 表达式 ===
Python 提供了在程序中与解释器交互的多种方法. 例如 {{{eval}}} 函数将一个字符串
作为 Python 表达式求值. 你可以传递一串文本, 简单的表达式, 或者使用
内建 Python 函数. 如 [[#eg-1-17|Example 1-17]] 所示.
==== 1.2.5.1. Example 1-17. 使用 eval 函数 ====
{{{
File: builtin-eval-example-1.py
def dump(expression):
result = eval(expression)
print expression, "=>", result, type(result)
dump("1")
dump("1.0")
dump("'string'")
dump("1.0 + 2.0")
dump("'*' * 10")
dump("len('world')")
*B*1 => 1 <type 'int'>
1.0 => 1.0 <type 'float'>
'string' => string <type 'string'>
1.0 + 2.0 => 3.0 <type 'float'>
'*' * 10 => ********** <type 'string'>
len('world') => 5 <type 'int'>*b*
}}}
如果你不确定字符串来源的安全性, 那么你在使用 {{{eval}}} 的时候会遇到些麻烦. 例如,
某个用户可能会使用 {{{_ _import_ _}}} 函数加载 {{{os}}} 模块, 然后从硬盘删除文件
(如 [[#eg-1-18|Example 1-18]] 所示).
==== 1.2.5.2. Example 1-18. 使用 eval 函数执行任意命令 ====
{{{
File: builtin-eval-example-2.py
print eval("_ _import_ _('os').getcwd()")
print eval("_ _import_ _('os').remove('file')")
*B*/home/fredrik/librarybook
Traceback (innermost last):
File "builtin-eval-example-2", line 2, in ?
File "<string>", line 0, in ?
os.error: (2, 'No such file or directory')*b*
}}}
这里我们得到了一个 ''os.error'' 异常, 这说明 ''Python 事实上在尝试删除文件!''
幸运地是, 这个问题很容易解决. 你可以给 {{{eval}}} 函数传递第 2
个参数, 一个定义了该表达式求值时名称空间的字典.
我们测试下, 给函数传递个空字典:
{{{
>>> print eval("_ _import_ _('os').remove('file')", {})
Traceback (innermost last):
File "<stdin>", line 1, in ?
File "<string>", line 0, in ?
os.error: (2, 'No such file or directory')
}}}
呃.... 我们还是得到了个 ''os.error'' 异常.
这是因为 Python 在求值前会检查这个字典, 如果没有发现名称为 {{{_ _builtins_ _}}}
的变量(复数形式), 它就会添加一个:
{{{
>>> namespace = {}
>>> print eval("_ _import_ _('os').remove('file')", namespace)
Traceback (innermost last):
File "<stdin>", line 1, in ?
File "<string>", line 0, in ?
os.error: (2, 'No such file or directory')
>>> namespace.keys()
['_ _builtins_ _']
}}}
如果你打印这个 namespace 的内容, 你会发现里边有所有的内建函数.
{{{
[!Feather 注: 如果我RP不错的话, 添加的这个_ _builtins_ _就是当前的_ _builtins_ _]
}}}
我们注意到了如果这个变量存在, Python 就不会去添加默认的, 那么我们的解决方法也来了,
为传递的字典参数加入一个 {{{_ _builtins_ _}}} 项即可. 如 [[#eg-1-19|Example 1-19]] 所示.
==== 1.2.5.3. Example 1-19. 安全地使用 eval 函数求值 ====
{{{
File: builtin-eval-example-3.py
print eval("_ _import_ _('os').getcwd()", {})
print eval("_ _import_ _('os').remove('file')", {"_ _builtins_ _": {}})
*B*/home/fredrik/librarybook
Traceback (innermost last):
File "builtin-eval-example-3.py", line 2, in ?
File "<string>", line 0, in ?
NameError: _ _import_ _*b*
}}}
即使这样, 你仍然无法避免针对 CPU 和内存资源的攻击. (比如, 形如
{{{eval("'*'*1000000*2*2*2*2*2*2*2*2*2")}}} 的语句在执行后会使你的程序耗尽系统资源).
=== 1.2.6. 编译和执行代码 ===
{{{eval}}} 函数只针对简单的表达式. 如果要处理大块的代码, 你应该使用 {{{compile}}} 和 {{{exec}}} 函数
(如 [[#eg-1-20|Example 1-20]] 所示).
==== 1.2.6.1. Example 1-20. 使用 compile 函数检查语法 ====
{{{
File: builtin-compile-example-1.py
NAME = "script.py"
BODY = """
prnt 'owl-stretching time'
"""
try:
compile(BODY, NAME, "exec")
except SyntaxError, v:
print "syntax error:", v, "in", NAME
# syntax error: invalid syntax in script.py
}}}
成功执行后, {{{compile}}} 函数会返回一个代码对象, 你可以使用 {{{exec}}} 语句执行它,
参见 [[#eg-1-21|Example 1-21]] .
==== 1.2.6.2. Example 1-21. 执行已编译的代码 ====
{{{
File: builtin-compile-example-2.py
BODY = """
print 'the ant, an introduction'
"""
code = compile(BODY, "<script>", "exec")
print code
exec code
*B*<code object ? at 8c6be0, file "<script>", line 0>
the ant, an introduction*b*
}}}
使用 [[#eg-1-22|Example 1-22]] 中的类可以在程序执行时实时地生成代码. {{{write}}} 方法用于添加代码,
{{{indent}}} 和 {{{dedent}}} 方法用于控制缩进结构. 其他部分交给类来处理.
==== 1.2.6.3. Example 1-22. 简单的代码生成工具 ====
{{{
File: builtin-compile-example-3.py
import sys, string
class CodeGeneratorBackend:
"Simple code generator for Python"
def begin(self, tab="\t"):
self.code = []
self.tab = tab
self.level = 0
def end(self):
self.code.append("") # make sure there's a newline at the end
return compile(string.join(self.code, "\n"), "<code>", "exec")
def write(self, string):
self.code.append(self.tab * self.level + string)
def indent(self):
self.level = self.level + 1
# in 2.0 and later, this can be written as: self.level += 1
def dedent(self):
if self.level == 0:
raise SyntaxError, "internal error in code generator"
self.level = self.level - 1
# or: self.level -= 1
#
# try it out!
c = CodeGeneratorBackend()
c.begin()
c.write("for i in range(5):")
c.indent()
c.write("print 'code generation made easy!'")
c.dedent()
exec c.end()
*B*code generation made easy!
code generation made easy!
code generation made easy!
code generation made easy!
code generation made easy!*b*
}}}
Python 还提供了 {{{execfile}}} 函数, 一个从文件加载代码, 编译代码, 执行代码的快捷方式.
[[#eg-1-23|Example 1-23]] 简单地展示了如何使用这个函数.
==== 1.2.6.4. Example 1-23. 使用 execfile 函数 ====
{{{
File: builtin-execfile-example-1.py
execfile("hello.py")
def EXECFILE(filename, locals=None, globals=None):
exec compile(open(filename).read(), filename, "exec") in locals, globals
EXECFILE("hello.py")
*B*hello again, and welcome to the show
hello again, and welcome to the show*b*
}}}
[[#eg-1-24|Example 1-24]] 中的代码是 [[#eg-1-23|Example 1-23]] 中使用的 hello.py 文件.
==== 1.2.6.5. Example 1-24. hello.py 脚本 ====
{{{
File: hello.py
print "hello again, and welcome to the show"
}}}
=== 1.2.7. 从 _ _builtin_ _ 模块重载函数 ===
因为 Python 在检查局部名称空间和模块名称空间前不会检查内建函数, 所以有时候你可能要显式地引用
{{{_ _builtin_ _}}} 模块. 例如 [[#eg-1-25|Example 1-25]] 重载了内建的 {{{open}}} 函数.
这时候要想使用原来的 {{{open}}} 函数, 就需要脚本显式地指明模块名称.
==== 1.2.7.1. Example 1-25. 显式地访问 _ _builtin_ _ 模块中的函数 ====
{{{
File: builtin-open-example-1.py
def open(filename, mode="rb"):
import _ _builtin_ _
file = _ _builtin_ _.open(filename, mode)
if file.read(5) not in("GIF87", "GIF89"):
raise IOError, "not a GIF file"
file.seek(0)
return file
fp = open("samples/sample.gif")
print len(fp.read()), "bytes"
fp = open("samples/sample.jpg")
print len(fp.read()), "bytes"
*B*3565 bytes
Traceback (innermost last):
File "builtin-open-example-1.py", line 12, in ?
File "builtin-open-example-1.py", line 5, in open
IOError: not a GIF file*b*
}}}
{{{
[!Feather 注: 明白这个open()函数是干什么的么? 检查一个文件是否是 GIF 文件,
一般如这类的图片格式都在文件开头有默认的格式.
另外打开文件推荐使用file()而不是open() , 虽然暂时没有区别]
}}}
----
== 1.3. exceptions 模块 ==
{{{exceptions}}} 模块提供了标准异常的层次结构. Python 启动的时候会自动导入这个模块,
并且将它加入到 {{{_ _builtin_ _}}} 模块中. 也就是说, 一般不需要手动导入这个模块.
在 1.5.2 版本时它是一个普通模块, 2.0 以及以后版本成为内建模块.
该模块定义了以下标准异常:
* ''Exception'' 是所有异常的基类. 强烈建议(但不是必须)自定义的异常异常也继承这个类.
* ''SystemExit(Exception)'' 由 {{{sys.exit}}} 函数引发. 如果它在最顶层没有被 {{{try-except}}} 语句捕获,
那么解释器将直接关闭而不会显示任何跟踪返回信息.
* ''StandardError(Exception)'' 是所有内建异常的基类(除 ''SystemExit'' 外).
* ''KeyboardInterrupt(StandardError)'' 在用户按下 Control-C(或其他打断按键)后 被引发. 如果它可能会在你使用 "捕获所有" 的 {{{try-except}}} 语句时导致奇怪的问题.
* ''ImportError(StandardError)'' 在 Python 导入模块失败时被引发.
* ''EnvironmentError'' 作为所有解释器环境引发异常的基类. (也就是说, 这些异常一般不是由于程序 bug 引起).
* ''IOError(EnvironmentError)'' 用于标记 I/O 相关错误.
* ''OSError(EnvironmentError)'' 用于标记 {{{os}}} 模块引起的错误.
* ''WindowsError(OSError)'' 用于标记 {{{os}}} 模块中 Windows 相关错误.
* ''NameError(StandardError)'' 在 Python 查找全局或局部名称失败时被引发.
* ''UnboundLocalError(NameError)'' , 当一个局部变量还没有赋值就被使用时, 会引发这个异常. 这个异常只有在2.0及之后的版本有; 早期版本只会引发一个普通的 ''NameError'' .
* ''AttributeError(StandardError)'' , 当 Python 寻找(或赋值)给一个实例属性, 方法, 模块功能或其它有效的命名失败时, 会引发这个异常.
* ''SyntaxError(StandardError)'' , 当解释器在编译时遇到语法错误, 这个异常就被引发.
* (2.0 及以后版本) ''IndentationError(SyntaxError)'' 在遇到非法的缩进时被引发. 该异常只用于 2.0 及以后版本, 之前版本会引发一个 ''SyntaxError'' 异常.
* (2.0 及以后版本) ''TabError(IndentationError)'' , 当使用 {{{-tt}}} 选项检查不一致缩进时有可能被引发. 该异常只用于 2.0 及以后版本, 之前版本会引发一个 ''SyntaxError'' 异常.
* ''TypeError(StandardError)'' , 当给定类型的对象不支持一个操作时被引发.
* ''AssertionError(StandardError)'' 在 {{{assert}}} 语句失败时被引发(即表达式为 false 时).
* ''LookupError(StandardError)'' 作为序列或字典没有包含给定索引或键时所引发异常的基类.
* ''IndexError(LookupError)'' , 当序列对象使用给定索引数索引失败时(不存在索引对应对象)引发该异常.
* ''KeyError(LookupError)'' 当字典对象使用给定索引索引失败时(不存在索引对应对象)引发该异常.
* ''ArithmeticError(StandardError)'' 作为数学计算相关异常的基类.
* ''OverflowError(ArithmeticError)'' 在操作溢出时被引发(例如当一个整数太大, 导致不能符合给定类型).
* ''ZeroDivisionError(ArithmeticError)'' , 当你尝试用 0 除某个数时被引发.
* ''FloatingPointError(ArithmeticError)'' , 当浮点数操作失败时被引发.
* ''ValueError(StandardError)'' , 当一个参数类型正确但值不合法时被引发.
* (2.0 及以后版本) ''UnicodeError(ValueError)'' , Unicode 字符串类型相关异常. 只使用在 2.0 及以后版本.
* ''RuntimeError(StandardError)'' , 当出现运行时问题时引发, 包括在限制模式下尝试访问外部内容, 未知的硬件问题等等.
* ''NotImplementedError(RuntimeError)'' , 用于标记未实现的函数, 或无效的方法.
* ''SystemError(StandardError)'' , 解释器内部错误. 该异常值会包含更多的细节
(经常会是一些深层次的东西, 比如 "{{{eval_code2: NULL globals" )}}}.
这本书的作者编了 5 年程序都没见过这个错误. (想必是没有用 {{{raise SystemError}}}).
* ''MemoryError(StandardError)'' , 当解释器耗尽内存时会引发该异常. 注意只有在底层内存分配抱怨时这个异常才会发生; 如果是在你的旧机器上, 这个异常发生之前系统会陷入混乱的内存交换中.
你可以创建自己的异常类. 只需要继承内建的 ''Exception'' 类(或者它的任意一个合适的子类)即可, 有需要时可以再重载它的 {{{_ _str_ _}}} 方法. [[#eg-1-26|Example 1-26]] 展示了如何使用 {{{exceptions}}} 模块.
==== 1.3.0.1. Example 1-26. 使用 exceptions 模块 ====
{{{
File: exceptions-example-1.py
# python imports this module by itself, so the following
# line isn't really needed
# python 会自动导入该模块, 所以以下这行是不必要的
# import exceptions
class HTTPError(Exception):
# indicates an HTTP protocol error
def _ _init_ _(self, url, errcode, errmsg):
self.url = url
self.errcode = errcode
self.errmsg = errmsg
def _ _str_ _(self):
return (
"<HTTPError for %s: %s %s>" %
(self.url, self.errcode, self.errmsg)
)
try:
raise HTTPError("http://www.python.org/foo", 200, "Not Found")
except HTTPError, error:
print "url", "=>", error.url
print "errcode", "=>", error.errcode
print "errmsg", "=>", error.errmsg
raise # reraise exception
*B*url => http://www.python.org/foo
errcode => 200
errmsg => Not Found
Traceback (innermost last):
File "exceptions-example-1", line 16, in ?
HTTPError: <HTTPError for http://www.python.org/foo: 200 Not Found>*b*
}}}
----
== 1.4. os 模块 ==
这个模块中的大部分函数通过对应平台相关模块实现, 比如 {{{posix}}} 和
{{{nt. os}}} 模块会在第一次导入的时候自动加载合适的执行模块.
=== 1.4.1. 处理文件 ===
内建的 {{{open / file}}} 函数用于创建, 打开和编辑文件, 如 [[#eg-1-27|Example 1-27]] 所示. 而
{{{os}}} 模块提供了重命名和删除文件所需的函数.
==== 1.4.1.1. Example 1-27. 使用 os 模块重命名和删除文件 ====
{{{
File: os-example-3.py
import os
import string
def replace(file, search_for, replace_with):
# replace strings in a text file
back = os.path.splitext(file)[0] + ".bak"
temp = os.path.splitext(file)[0] + ".tmp"
try:
# remove old temp file, if any
os.remove(temp)
except os.error:
pass
fi = open(file)
fo = open(temp, "w")
for s in fi.readlines():
fo.write(string.replace(s, search_for, replace_with))
fi.close()
fo.close()
try:
# remove old backup file, if any
os.remove(back)
except os.error:
pass
# rename original to backup...
os.rename(file, back)
# ...and temporary to original
os.rename(temp, file)
#
# try it out!
file = "samples/sample.txt"
replace(file, "hello", "tjena")
replace(file, "tjena", "hello")
}}}
=== 1.4.2. 处理目录 ===
{{{os}}} 模块也包含了一些用于目录处理的函数.
{{{listdir}}} 函数返回给定目录中所有文件名(包括目录名)组成的列表, 如
[[#eg-1-28|Example 1-28]] 所示. 而 Unix 和 Windows 中使用的当前目录和父目录标记(. 和 .. )不包含在此列表中.
==== 1.4.2.1. Example 1-28. 使用 os 列出目录下的文件 ====
{{{
File: os-example-5.py
import os
for file in os.listdir("samples"):
print file
*B*sample.au
sample.jpg
sample.wav
...*b*
}}}
{{{getcwd}}} 和 {{{chdir}}} 函数分别用于获得和改变当前工作目录. 如 [[#eg-1-29|Example 1-29]] 所示.
==== 1.4.2.2. Example 1-29. 使用 os 模块改变当前工作目录 ====
{{{
File: os-example-4.py
import os
# where are we?
cwd = os.getcwd()
print "1", cwd
# go down
os.chdir("samples")
print "2", os.getcwd()
# go back up
os.chdir(os.pardir)
print "3", os.getcwd()
*B*1 /ematter/librarybook
2 /ematter/librarybook/samples
3 /ematter/librarybook*b*
}}}
{{{makedirs}}} 和 {{{removedirs}}} 函数用于创建或删除目录层，如 [[#eg-1-30|Example 1-30]] 所示.
==== 1.4.2.3. Example 1-30. 使用 os 模块创建/删除多个目录级 ====
{{{
File: os-example-6.py
import os
os.makedirs("test/multiple/levels")
fp = open("test/multiple/levels/file", "w")
fp.write("inspector praline")
fp.close()
# remove the file
os.remove("test/multiple/levels/file")
# and all empty directories above it
os.removedirs("test/multiple/levels")
}}}
{{{removedirs}}} 函数会删除所给路径中最后一个目录下所有的空目录.
而 {{{mkdir}}} 和 {{{rmdir}}} 函数只能处理单个目录级. 如 [[#eg-1-31|Example 1-31]] 所示.
==== 1.4.2.4. Example 1-31. 使用 os 模块创建/删除目录 ====
{{{
File: os-example-7.py
import os
os.mkdir("test")
os.rmdir("test")
os.rmdir("samples") # this will fail
*B*Traceback (innermost last):
File "os-example-7", line 6, in ?
OSError: [Errno 41] Directory not empty: 'samples'*b*
}}}
如果需要删除非空目录, 你可以使用 {{{shutil}}} 模块中的 {{{rmtree}}} 函数.
=== 1.4.3. 处理文件属性 ===
{{{stat}}} 函数可以用来获取一个存在文件的信息, 如 [[#eg-1-32|Example 1-32]]
所示. 它返回一个类元组对象(stat_result对象, 包含 10 个元素),
依次是st_mode (权限模式), st_ino (inode number), st_dev (device),
st_nlink (number of hard links), st_uid (所有者用户 ID), st_gid
(所有者所在组 ID ), st_size (文件大小, 字节), st_atime (最近一次访问时间),
st_mtime (最近修改时间), st_ctime (平台相关; Unix下的最近一次元数据/metadata修改时间,
或者 Windows 下的创建时间) - 以上项目也可作为属性访问.
{{{
[!Feather 注: 原文为 9 元元组. 另,返回对象并非元组类型,为 struct.]
}}}
==== 1.4.3.1. Example 1-32. 使用 os 模块获取文件属性 ====
{{{
File: os-example-1.py
import os
import time
file = "samples/sample.jpg"
def dump(st):
mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime = st
print "- size:", size, "bytes"
print "- owner:", uid, gid
print "- created:", time.ctime(ctime)
print "- last accessed:", time.ctime(atime)
print "- last modified:", time.ctime(mtime)
print "- mode:", oct(mode)
print "- inode/dev:", ino, dev
#
# get stats for a filename
st = os.stat(file)
print "stat", file
dump(st)
print
#
# get stats for an open file
fp = open(file)
st = os.fstat(fp.fileno())
print "fstat", file
dump(st)
*B*stat samples/sample.jpg
- size: 4762 bytes
- owner: 0 0
- created: Tue Sep 07 22:45:58 1999
- last accessed: Sun Sep 19 00:00:00 1999
- last modified: Sun May 19 01:42:16 1996
- mode: 0100666
- inode/dev: 0 2
fstat samples/sample.jpg
- size: 4762 bytes
- owner: 0 0
- created: Tue Sep 07 22:45:58 1999
- last accessed: Sun Sep 19 00:00:00 1999
- last modified: Sun May 19 01:42:16 1996
- mode: 0100666
- inode/dev: 0 0*b*
}}}
返回对象中有些属性在非 Unix 平台下是无意义的, 比如 ({{{st_inode}}} , {{{st_dev}}})为
Unix 下的为每个文件提供了唯一标识, 但在其他平台可能为任意无意义数据 .
{{{stat}}} 模块包含了很多可以处理该返回对象的常量及函数. 下面的代码展示了其中的一些.
可以使用 {{{chmod}}} 和 {{{utime}}} 函数修改文件的权限模式和时间属性，如 [[#eg-1-33|Example 1-33]] 所示.
==== 1.4.3.2. Example 1-33. 使用 os 模块修改文件的权限和时间戳 ====
{{{
File: os-example-2.py
import os
import stat, time
infile = "samples/sample.jpg"
outfile = "out.jpg"
# copy contents
fi = open(infile, "rb")
fo = open(outfile, "wb")
while 1:
s = fi.read(10000)
if not s:
break
fo.write(s)
fi.close()
fo.close()
# copy mode and timestamp
st = os.stat(infile)
os.chmod(outfile, stat.S_IMODE(st[stat.ST_MODE]))
os.utime(outfile, (st[stat.ST_ATIME], st[stat.ST_MTIME]))
print "original", "=>"
print "mode", oct(stat.S_IMODE(st[stat.ST_MODE]))
print "atime", time.ctime(st[stat.ST_ATIME])
print "mtime", time.ctime(st[stat.ST_MTIME])
print "copy", "=>"
st = os.stat(outfile)
print "mode", oct(stat.S_IMODE(st[stat.ST_MODE]))
print "atime", time.ctime(st[stat.ST_ATIME])
print "mtime", time.ctime(st[stat.ST_MTIME])
*B*original =>
mode 0666
atime Thu Oct 14 15:15:50 1999
mtime Mon Nov 13 15:42:36 1995
copy =>
mode 0666
atime Thu Oct 14 15:15:50 1999
mtime Mon Nov 13 15:42:36 1995*b*
}}}
=== 1.4.4. 处理进程 ===
{{{system}}} 函数在当前进程下执行一个新命令, 并等待它完成, 如 [[#eg-1-34|Example 1-34]] 所示.
==== 1.4.4.1. Example 1-34. 使用 os 执行操作系统命令 ====
{{{
File: os-example-8.py
import os
if os.name == "nt":
command = "dir"
else:
command = "ls -l"
os.system(command)
*B*-rwxrw-r-- 1 effbot effbot 76 Oct 9 14:17 README
-rwxrw-r-- 1 effbot effbot 1727 Oct 7 19:00 SimpleAsyncHTTP.py
-rwxrw-r-- 1 effbot effbot 314 Oct 7 20:29 aifc-example-1.py
-rwxrw-r-- 1 effbot effbot 259 Oct 7 20:38 anydbm-example-1.py
...*b*
}}}
命令通过操作系统的标准 shell 执行, 并返回 shell 的退出状态. 需要注意的是在 Windows 95/98
下, shell 通常是 {{{command.com}}} , 它的推出状态总是 0.
由于 11os.system11 直接将命令传递给 shell , 所以如果你不检查传入参数的时候会很危险
(比如命令 {{{os.system("viewer %s" % file)}}}, 将 file 变量设置为
"{{{sample.jpg; rm -rf $HOME" ....}}}). 如果不确定参数的安全性, 那么最好使用
{{{exec}}} 或 {{{spawn}}} 代替(稍后介绍).
{{{exec}}} 函数会使用新进程替换当前进程(或者说是"转到进程"). 在 [[#eg-1-35|Example 1-35]] 中,
字符串 "goodbye" 永远不会被打印.
==== 1.4.4.2. Example 1-35. 使用 os 模块启动新进程 ====
{{{
File: os-exec-example-1.py
import os
import sys
program = "python"
arguments = ["hello.py"]
print os.execvp(program, (program,) + tuple(arguments))
print "goodbye"
*B*hello again, and welcome to the show*b*
}}}
Python 提供了很多表现不同的 {{{exec}}} 函数. [[#eg-1-35|Example 1-35]] 使用的是
{{{execvp}}} 函数, 它会从标准路径搜索执行程序, 把第二个参数(元组)作为单独的参数传递给程序, 并使用当前的环境变量来运行程序. 其他七个同类型函数请参阅 ''Python Library Reference'' .
在 Unix 环境下, 你可以通过组合使用 {{{exec}}} , {{{fork}}} 以及 {{{wait}}} 函数来从当前程序调用另一个程序,
如 [[#eg-1-36|Example 1-36]] 所示. {{{fork}}} 函数复制当前进程, {{{wait}}} 函数会等待一个子进程执行结束.
==== 1.4.4.3. Example 1-36. 使用 os 模块调用其他程序 (Unix) ====
{{{
File: os-exec-example-2.py
import os
import sys
def run(program, *args):
pid = os.fork()
if not pid:
os.execvp(program, (program,) + args)
return os.wait()[0]
run("python", "hello.py")
print "goodbye"
*B*hello again, and welcome to the show
goodbye*b*
}}}
{{{fork}}} 函数在子进程返回中返回 0 (这个进程首先从 {{{fork}}} 返回值),
在父进程中返回一个非 0 的进程标识符(子进程的 PID ). 也就是说,
只有当我们处于子进程的时候 "{{{not pid}}}" 才为真.
{{{fork}}} 和 {{{wait}}} 函数在 Windows 上是不可用的, 但是你可以使用 {{{spawn}}} 函数,
如 [[#eg-1-37|Example 1-37]] 所示. 不过, {{{spawn}}} 不会沿着路径搜索可执行文件,
你必须自己处理好这些.
==== 1.4.4.4. Example 1-37. 使用 os 模块调用其他程序 (Windows) ====
{{{
File: os-spawn-example-1.py
import os
import string
def run(program, *args):
# find executable
for path in string.split(os.environ["PATH"], os.pathsep):
file = os.path.join(path, program) + ".exe"
try:
return os.spawnv(os.P_WAIT, file, (file,) + args)
except os.error:
pass
raise os.error, "cannot find executable"
run("python", "hello.py")
print "goodbye"
*B*hello again, and welcome to the show
goodbye*b*
}}}
{{{spawn}}} 函数还可用于在后台运行一个程序. [[#eg-1-38|Example 1-38]] 给 {{{run}}} 函数添加了一个可选的
{{{mode}}} 参数; 当设置为 {{{os.P_NOWAIT}}} 时, 这个脚本不会等待子程序结束,
默认值 {{{os.P_WAIT}}} 时 {{{spawn}}} 会等待子进程结束.
其它的标志常量还有 {{{os.P_OVERLAY}}} ,它使得 {{{spawn}}} 的行为和 {{{exec}}} 类似,
以及 {{{os.P_DETACH}}} , 它在后台运行子进程, 与当前控制台和键盘焦点隔离.
==== 1.4.4.5. Example 1-38. 使用 os 模块在后台执行程序 (Windows) ====
{{{
File: os-spawn-example-2.py
import os
import string
def run(program, *args, **kw):
# find executable
mode = kw.get("mode", os.P_WAIT)
for path in string.split(os.environ["PATH"], os.pathsep):
file = os.path.join(path, program) + ".exe"
try:
return os.spawnv(mode, file, (file,) + args)
except os.error:
pass
raise os.error, "cannot find executable"
run("python", "hello.py", mode=os.P_NOWAIT)
print "goodbye"
*B*goodbye
hello again, and welcome to the show*b*
}}}
[[#eg-1-39|Example 1-39]] 提供了一个在 Unix 和 Windows 平台上通用的 {{{spawn}}} 方法.
==== 1.4.4.6. Example 1-39. 使用 spawn 或 fork/exec 调用其他程序 ====
{{{
File: os-spawn-example-3.py
import os
import string
if os.name in ("nt", "dos"):
exefile = ".exe"
else:
exefile = ""
def spawn(program, *args):
try:
# possible 2.0 shortcut!
return os.spawnvp(program, (program,) + args)
except AttributeError:
pass
try:
spawnv = os.spawnv
except AttributeError:
# assume it's unix
pid = os.fork()
if not pid:
os.execvp(program, (program,) + args)
return os.wait()[0]
else:
# got spawnv but no spawnp: go look for an executable
for path in string.split(os.environ["PATH"], os.pathsep):
file = os.path.join(path, program) + exefile
try:
return spawnv(os.P_WAIT, file, (file,) + args)
except os.error:
pass
raise IOError, "cannot find executable"
#
# try it out!
spawn("python", "hello.py")
print "goodbye"
*B*hello again, and welcome to the show
goodbye*b*
}}}
[[#eg-1-39|Example 1-39]] 首先尝试调用 {{{spawnvp}}} 函数. 如果该函数不存在
(一些版本/平台没有这个函数), 它将继续查找一个名为 {{{spawnv}}} 的函数并且
开始查找程序路径. 作为最后的选择, 它会调用 {{{exec}}} 和 {{{fork}}} 函数完成工作.
=== 1.4.5. 处理守护进程(Daemon Processes) ===
Unix 系统中, 你可以使用 {{{fork}}} 函数把当前进程转入后台(一个"守护者/daemon"). 一般来说, 你需要派生(fork off)一个当前进程的副本, 然后终止原进程, 如 [[#eg-1-40|Example 1-40]] 所示.
==== 1.4.5.1. Example 1-40. 使用 os 模块使脚本作为守护执行 (Unix) ====
{{{
File: os-example-14.py
import os
import time
pid = os.fork()
if pid:
os._exit(0) # kill original
print "daemon started"
time.sleep(10)
print "daemon terminated"
}}}
需要创建一个真正的后台程序稍微有点复杂, 首先调用 {{{setpgrp}}} 函数创建一个 "进程组首领/process group leader". 否则, 向无关进程组发送的信号(同时)会引起守护进程的问题:
{{{
os.setpgrp()
}}}
为了确保守护进程创建的文件能够获得程序指定的 mode flags(权限模式标记?), 最好删除 user mode mask:
{{{
os.umask(0)
}}}
然后, 你应该重定向 ''stdout/stderr'' 文件, 而不能只是简单地关闭它们(如果你的程序需要 {{{stdout}}}
或 {{{stderr}}} 写入内容的时候, 可能会出现意想不到的问题).
{{{
class NullDevice:
def write(self, s):
pass
sys.stdin.close()
sys.stdout = NullDevice()
sys.stderr = NullDevice()
}}}
换言之, 由于 Python 的 {{{print}}} 和 C 中的 {{{printf/fprintf}}} 在设备(device)
没有连接后不会关闭你的程序, 此时守护进程中的 {{{sys.stdout.write()}}} 会抛出一个 ''IOError'' 异常, 而你的程序依然在后台运行的很好....
另外, 先前例子中的 {{{_exit}}} 函数会终止当前进程. 而 {{{sys.exit}}} 不同, 如果调用者(caller)
捕获了 ''SystemExit'' 异常, 程序仍然会继续执行. 如 [[#eg-1-41|Example 1-41]] 所示.
==== 1.4.5.2. Example 1-41. 使用 os 模块终止当前进程 ====
{{{
File: os-example-9.py
import os
import sys
try:
sys.exit(1)
except SystemExit, value:
print "caught exit(%s)" % value
try:
os._exit(2)
except SystemExit, value:
print "caught exit(%s)" % value
print "bye!"
*B*caught exit(1)*b*
}}}
----
== 1.5. os.path 模块 ==
{{{os.path}}} 模块包含了各种处理长文件名(路径名)的函数. 先导入 (import) {{{os}}}
模块, 然后就可以以 {{{os.path}}} 访问该模块.
=== 1.5.1. 处理文件名 ===
{{{os.path}}} 模块包含了许多与平台无关的处理长文件名的函数.
也就是说, 你不需要处理前后斜杠, 冒号等. 我们可以看看 [[#eg-1-42|Example 1-42]] 中的样例代码.
==== 1.5.1.1. Example 1-42. 使用 os.path 模块处理文件名 ====
{{{
File: os-path-example-1.py
import os
filename = "my/little/pony"
print "using", os.name, "..."
print "split", "=>", os.path.split(filename)
print "splitext", "=>", os.path.splitext(filename)
print "dirname", "=>", os.path.dirname(filename)
print "basename", "=>", os.path.basename(filename)
print "join", "=>", os.path.join(os.path.dirname(filename),
os.path.basename(filename))
*B*using nt ...
split => ('my/little', 'pony')
splitext => ('my/little/pony', '')
dirname => my/little
basename => pony
join => my/little\pony*b*
}}}
注意这里的 {{{split}}} 只分割出最后一项(不带斜杠).
{{{os.path}}} 模块中还有许多函数允许你简单快速地获知文件名的一些特征，如 [[#eg-1-43|Example 1-43]] 所示。
==== 1.5.1.2. Example 1-43. 使用 os.path 模块检查文件名的特征 ====
{{{
File: os-path-example-2.py
import os
FILES = (
os.curdir,
"/",
"file",
"/file",
"samples",
"samples/sample.jpg",
"directory/file",
"../directory/file",
"/directory/file"
)
for file in FILES:
print file, "=>",
if os.path.exists(file):
print "EXISTS",
if os.path.isabs(file):
print "ISABS",
if os.path.isdir(file):
print "ISDIR",
if os.path.isfile(file):
print "ISFILE",
if os.path.islink(file):
print "ISLINK",
if os.path.ismount(file):
print "ISMOUNT",
print
*B*. => EXISTS ISDIR
/ => EXISTS ISABS ISDIR ISMOUNT
file =>
/file => ISABS
samples => EXISTS ISDIR
samples/sample.jpg => EXISTS ISFILE
directory/file =>
../directory/file =>
/directory/file => ISABS*b*
}}}
{{{expanduser}}} 函数以与大部分Unix shell相同的方式处理用户名快捷符号(~,
不过在 Windows 下工作不正常), 如 [[#eg-1-44|Example 1-44]] 所示.
==== 1.5.1.3. Example 1-44. 使用 os.path 模块将用户名插入到文件名 ====
{{{
File: os-path-expanduser-example-1.py
import os
print os.path.expanduser("~/.pythonrc")
# /home/effbot/.pythonrc
}}}
{{{expandvars}}} 函数将文件名中的环境变量替换为对应值, 如 [[#eg-1-45|Example 1-45]] 所示.
==== 1.5.1.4. Example 1-45. 使用 os.path 替换文件名中的环境变量 ====
{{{
File: os-path-expandvars-example-1.py
import os
os.environ["USER"] = "user"
print os.path.expandvars("/home/$USER/config")
print os.path.expandvars("$USER/folders")
*B*/home/user/config
user/folders*b*
}}}
=== 1.5.2. 搜索文件系统 ===
{{{walk}}} 函数会帮你找出一个目录树下的所有文件 (如 [[#eg-1-46|Example 1-46]]
所示). 它的参数依次是目录名, 回调函数, 以及传递给回调函数的数据对象.
==== 1.5.2.1. Example 1-46. 使用 os.path 搜索文件系统 ====
{{{
File: os-path-walk-example-1.py
import os
def callback(arg, directory, files):
for file in files:
print os.path.join(directory, file), repr(arg)
os.path.walk(".", callback, "secret message")
*B*./aifc-example-1.py 'secret message'
./anydbm-example-1.py 'secret message'
./array-example-1.py 'secret message'
...
./samples 'secret message'
./samples/sample.jpg 'secret message'
./samples/sample.txt 'secret message'
./samples/sample.zip 'secret message'
./samples/articles 'secret message'
./samples/articles/article-1.txt 'secret message'
./samples/articles/article-2.txt 'secret message'
...*b*
}}}
{{{walk}}} 函数的接口多少有点晦涩 (也许只是对我个人而言, 我总是记不住参数的顺序).
[[#eg-1-47|Example 1-47]] 中展示的 {{{index}}} 函数会返回一个文件名列表,
你可以直接使用 {{{for-in}}} 循环处理文件.
==== 1.5.2.2. Example 1-47. 使用 os.listdir 搜索文件系统 ====
{{{
File: os-path-walk-example-2.py
import os
def index(directory):
# like os.listdir, but traverses directory trees
stack = [directory]
files = []
while stack:
directory = stack.pop()
for file in os.listdir(directory):
fullname = os.path.join(directory, file)
files.append(fullname)
if os.path.isdir(fullname) and not os.path.islink(fullname):
stack.append(fullname)
return files
for file in index("."):
print file
*B*.\aifc-example-1.py
.\anydbm-example-1.py
.\array-example-1.py
...*b*
}}}
如果你不想列出所有的文件 (基于性能或者是内存的考虑) , [[#eg-1-48|Example 1-48]] 展示了另一种方法.
这里 ''DirectoryWalker'' 类的行为与序列对象相似, 一次返回一个文件. (generator?)
==== 1.5.2.3. Example 1-48. 使用 DirectoryWalker 搜索文件系统 ====
{{{
File: os-path-walk-example-3.py
import os
class DirectoryWalker:
# a forward iterator that traverses a directory tree
def _ _init_ _(self, directory):
self.stack = [directory]
self.files = []
self.index = 0
def _ _getitem_ _(self, index):
while 1:
try:
file = self.files[self.index]
self.index = self.index + 1
except IndexError:
# pop next directory from stack
self.directory = self.stack.pop()
self.files = os.listdir(self.directory)
self.index = 0
else:
# got a filename
fullname = os.path.join(self.directory, file)
if os.path.isdir(fullname) and not os.path.islink(fullname):
self.stack.append(fullname)
return fullname
for file in DirectoryWalker("."):
print file
*B*.\aifc-example-1.py
.\anydbm-example-1.py
.\array-example-1.py
...*b*
}}}
注意 ''DirectoryWalker'' 类并不检查传递给 {{{_ _getitem_ _}}} 方法的索引值.
这意味着如果你越界访问序列成员(索引数字过大)的话, 这个类将不能正常工作.
最后, 如果你需要处理文件大小和时间戳, [[#eg-1-49|Example 1-49]] 给出了一个类,
它返回文件名和它的 {{{os.stat}}} 属性(一个元组). 这个版本在每个文件上都能节省一次或两次
{{{stat}}} 调用( {{{os.path.isdir}}} 和 {{{os.path.islink}}} 内部都使用了 {{{stat}}} ),
并且在一些平台上运行很快.
==== 1.5.2.4. Example 1-49. 使用 DirectoryStatWalker 搜索文件系统 ====
{{{
File: os-path-walk-example-4.py
import os, stat
class DirectoryStatWalker:
# a forward iterator that traverses a directory tree, and
# returns the filename and additional file information
def _ _init_ _(self, directory):
self.stack = [directory]
self.files = []
self.index = 0
def _ _getitem_ _(self, index):
while 1:
try:
file = self.files[self.index]
self.index = self.index + 1
except IndexError:
# pop next directory from stack
self.directory = self.stack.pop()
self.files = os.listdir(self.directory)
self.index = 0
else:
# got a filename
fullname = os.path.join(self.directory, file)
st = os.stat(fullname)
mode = st[stat.ST_MODE]
if stat.S_ISDIR(mode) and not stat.S_ISLNK(mode):
self.stack.append(fullname)
return fullname, st
for file, st in DirectoryStatWalker("."):
print file, st[stat.ST_SIZE]
*B*.\aifc-example-1.py 336
.\anydbm-example-1.py 244
.\array-example-1.py 526*b*
}}}
----
== 1.6. stat 模块 ==
[[#eg-1-50|Example 1-50]] 展示了 {{{stat}}} 模块的基本用法,
这个模块包含了一些 {{{os.stat}}} 函数中可用的常量和测试函数.
==== 1.6.0.1. Example 1-50. Using the stat Module ====
{{{
File: stat-example-1.py
import stat
import os, time
st = os.stat("samples/sample.txt")
print "mode", "=>", oct(stat.S_IMODE(st[stat.ST_MODE]))
print "type", "=>",
if stat.S_ISDIR(st[stat.ST_MODE]):
print "DIRECTORY",
if stat.S_ISREG(st[stat.ST_MODE]):
print "REGULAR",
if stat.S_ISLNK(st[stat.ST_MODE]):
print "LINK",
print
print "size", "=>", st[stat.ST_SIZE]
print "last accessed", "=>", time.ctime(st[stat.ST_ATIME])
print "last modified", "=>", time.ctime(st[stat.ST_MTIME])
print "inode changed", "=>", time.ctime(st[stat.ST_CTIME])
*B*mode => 0664
type => REGULAR
size => 305
last accessed => Sun Oct 10 22:12:30 1999
last modified => Sun Oct 10 18:39:37 1999
inode changed => Sun Oct 10 15:26:38 1999*b*
}}}
----
== 1.7. string 模块 ==
{{{string}}} 模块提供了一些用于处理字符串类型的函数,
如 [[#eg-1-51|Example 1-51]] 所示.
==== 1.7.0.1. Example 1-51. 使用 string 模块 ====
{{{
File: string-example-1.py
import string
text = "Monty Python's Flying Circus"
print "upper", "=>", string.upper(text)
print "lower", "=>", string.lower(text)
print "split", "=>", string.split(text)
print "join", "=>", string.join(string.split(text), "+")
print "replace", "=>", string.replace(text, "Python", "Java")
print "find", "=>", string.find(text, "Python"), string.find(text, "Java")
print "count", "=>", string.count(text, "n")
*B*upper => MONTY PYTHON'S FLYING CIRCUS
lower => monty python's flying circus
split => ['Monty', "Python's", 'Flying', 'Circus']
join => Monty+Python's+Flying+Circus
replace => Monty Java's Flying Circus
find => 6 -1
count => 3*b*
}}}
在 Python 1.5.2 以及更早版本中, {{{string}}} 使用 {{{strop}}} 中的函数来实现模块功能.
在 Python1.6 和后继版本，更多的字符串操作都可以作为字符串方法来访问,
如 [[#eg-1-52|Example 1-52]] 所示, {{{string}}} 模块中的许多函数只是对相对应字符串方法的封装.
==== 1.7.0.2. Example 1-52. 使用字符串方法替代 string 模块函数 ====
{{{
File: string-example-2.py
text = "Monty Python's Flying Circus"
print "upper", "=>", text.upper()
print "lower", "=>", text.lower()
print "split", "=>", text.split()
print "join", "=>", "+".join(text.split())
print "replace", "=>", text.replace("Python", "Perl")
print "find", "=>", text.find("Python"), text.find("Perl")
print "count", "=>", text.count("n")
*B*upper => MONTY PYTHON'S FLYING CIRCUS
lower => monty python's flying circus
split => ['Monty', "Python's", 'Flying', 'Circus']
join => Monty+Python's+Flying+Circus
replace => Monty Perl's Flying Circus
find => 6 -1
count => 3*b*
}}}
为了增强模块对字符的处理能力, 除了字符串方法, {{{string}}}
模块还包含了类型转换函数用于把字符串转换为其他类型, (如 [[#eg-1-53|Example 1-53]] 所示).
==== 1.7.0.3. Example 1-53. 使用 string 模块将字符串转为数字 ====
{{{
File: string-example-3.py
import string
print int("4711"),
print string.atoi("4711"),
print string.atoi("11147", 8), # octal 八进制
print string.atoi("1267", 16), # hexadecimal 十六进制
print string.atoi("3mv", 36) # whatever...
print string.atoi("4711", 0),
print string.atoi("04711", 0),
print string.atoi("0x4711", 0)
print float("4711"),
print string.atof("1"),
print string.atof("1.23e5")
*B*4711 4711 4711 4711 4711
4711 2505 18193
4711.0 1.0 123000.0*b*
}}}
大多数情况下 (特别是当你使用的是1.6及更高版本时) ，你可以使用 {{{int}}} 和 {{{float}}}
函数代替 {{{string}}} 模块中对应的函数。
{{{atoi}}} 函数可以接受可选的第二个参数, 指定数基(number base).
如果数基为 0, 那么函数将检查字符串的前几个字符来决定使用的数基:
如果为 "0x," 数基将为 16 (十六进制), 如果为 "0," 则数基为 8 (八进制).
默认数基值为 10 (十进制), 当你未传递参数时就使用这个值.
在 1.6 及以后版本中, {{{int}}} 函数和 {{{atoi}}} 一样可以接受第二个参数.
与字符串版本函数不一样的是 , {{{int}}} 和 {{{float}}} 可以接受 Unicode 字符串对象.
----
== 1.8. re 模块 ==
"Some people, when confronted with a problem, think 'I know, I'll use regular expressions.' Now they have two problems."
- Jamie Zawinski, on comp.lang.emacs
{{{re}}} 模块提供了一系列功能强大的正则表达式 (regular expression) 工具,
它们允许你快速检查给定字符串是否与给定的模式匹配 (使用 {{{match}}} 函数),
或者包含这个模式 (使用 {{{search}}} 函数). 正则表达式是以紧凑(也很神秘)的语法写出的字符串模式.
{{{match}}} 尝试从字符串的起始匹配一个模式, 如 [[#eg-1-54|Example 1-54]] 所示.
如果模式匹配了某些内容 (包括空字符串, 如果模式允许的话) ,
它将返回一个匹配对象. 使用它的 {{{group}}} 方法可以找出匹配的内容.
==== 1.8.0.1. Example 1-54. 使用 re 模块来匹配字符串 ====
{{{
File: re-example-1.py
import re
text = "The Attila the Hun Show"
# a single character 单个字符
m = re.match(".", text)
if m: print repr("."), "=>", repr(m.group(0))
# any string of characters 任何字符串
m = re.match(".*", text)
if m: print repr(".*"), "=>", repr(m.group(0))
# a string of letters (at least one) 只包含字母的字符串(至少一个)
m = re.match("\w+", text)
if m: print repr("\w+"), "=>", repr(m.group(0))
# a string of digits 只包含数字的字符串
m = re.match("\d+", text)
if m: print repr("\d+"), "=>", repr(m.group(0))
*B* '.' => 'T'
'.*' => 'The Attila the Hun Show'
'\\w+' => 'The'*b*
}}}
可以使用圆括号在模式中标记区域. 找到匹配后, {{{group}}} 方法可以抽取这些区域的内容，
如 [[#eg-1-55|Example 1-55]] 所示. {{{group(1)}}} 会返回第一组的内容, {{{group(2)}}}
返回第二组的内容, 这样... 如果你传递多个组数给 {{{group}}} 函数, 它会返回一个元组.
==== 1.8.0.2. Example 1-55. 使用 re 模块抽出匹配的子字符串 ====
{{{
File: re-example-2.py
import re
text ="10/15/99"
m = re.match("(\d{2})/(\d{2})/(\d{2,4})", text)
if m:
print m.group(1, 2, 3)
*B*('10', '15', '99')*b*
}}}
{{{search}}} 函数会在字符串内查找模式匹配, 如 [[#eg-1-56|Example 1-56]] 所示.
它在所有可能的字符位置尝试匹配模式, 从最左边开始, 一旦找到匹配就返回一个匹配对象.
如果没有找到相应的匹配, 就返回 ''None'' .
==== 1.8.0.3. Example 1-56. 使用 re 模块搜索子字符串 ====
{{{
File: re-example-3.py
import re
text = "Example 3: There is 1 date 10/25/95 in here!"
m = re.search("(\d{1,2})/(\d{1,2})/(\d{2,4})", text)
print m.group(1), m.group(2), m.group(3)
month, day, year = m.group(1, 2, 3)
print month, day, year
date = m.group(0)
print date
*B*10 25 95
10 25 95
10/25/95*b*
}}}
[[#eg-1-57|Example 1-57]] 中展示了 {{{sub}}} 函数, 它可以使用另个字符串替代匹配模式.
==== 1.8.0.4. Example 1-57. 使用 re 模块替换子字符串 ====
{{{
File: re-example-4.py
import re
text = "you're no fun anymore..."
# literal replace (string.replace is faster)
# 文字替换 (string.replace 速度更快)
print re.sub("fun", "entertaining", text)
# collapse all non-letter sequences to a single dash
# 将所有非字母序列转换为一个"-"(dansh,破折号)
print re.sub("[^\w]+", "-", text)
# convert all words to beeps
# 将所有单词替换为 BEEP
print re.sub("\S+", "-BEEP-", text)
*B*you're no entertaining anymore...
you-re-no-fun-anymore-
-BEEP- -BEEP- -BEEP- -BEEP-*b*
}}}
你也可以通过回调 (callback) 函数使用 {{{sub}}} 来替换指定模式.
[[#eg-1-58|Example 1-58]] 展示了如何预编译模式.
==== 1.8.0.5. Example 1-58. 使用 re 模块替换字符串(通过回调函数) ====
{{{
File: re-example-5.py
import re
import string
text = "a line of text\\012another line of text\\012etc..."
def octal(match):
# replace octal code with corresponding ASCII character
# 使用对应 ASCII 字符替换八进制代码
return chr(string.atoi(match.group(1), 8))
octal_pattern = re.compile(r"\\(\d\d\d)")
print text
print octal_pattern.sub(octal, text)
*B*a line of text\012another line of text\012etc...
a line of text
another line of text
etc...*b*
}}}
如果你不编译, {{{re}}} 模块会为你缓存一个编译后版本, 所有的小脚本中,
通常不需要编译正则表达式. Python1.5.2 中, 缓存中可以容纳 20 个匹配模式, 而在 2.0 中,
缓存则可以容纳 100 个匹配模式.
最后, [[#eg-1-59|Example 1-59]] 用一个模式列表匹配一个字符串. 这些模式将会组合为一个模式, 并预编译以节省时间.
==== 1.8.0.6. Example 1-59. 使用 re 模块匹配多个模式中的一个 ====
{{{
File: re-example-6.py
import re, string
def combined_pattern(patterns):
p = re.compile(
string.join(map(lambda x: "("+x+")", patterns), "|")
)
def fixup(v, m=p.match, r=range(0,len(patterns))):
try:
regs = m(v).regs
except AttributeError:
return None # no match, so m.regs will fail
else:
for i in r:
if regs[i+1] != (-1, -1):
return i
return fixup
#
# try it out!
patterns = [
r"\d+",
r"abc\d{2,4}",
r"p\w+"
]
p = combined_pattern(patterns)
print p("129391")
print p("abc800")
print p("abc1600")
print p("python")
print p("perl")
print p("tcl")
*B*0
1
1
2
2
None*b*
}}}
----
== 1.9. math 模块 ==
{{{math}}} 模块实现了许多对浮点数的数学运算函数. 这些函数一般是对平台 C
库中同名函数的简单封装, 所以一般情况下, 不同平台下计算的结果可能稍微地有所不同,
有时候甚至有很大出入. [[#eg-1-60|Example 1-60]] 展示了如何使用 {{{math}}} 模块.
==== 1.9.0.1. Example 1-60. 使用 math 模块 ====
{{{
File: math-example-1.py
import math
print "e", "=>", math.e
print "pi", "=>", math.pi
print "hypot", "=>", math.hypot(3.0, 4.0)
# and many others...
*B*e => 2.71828182846
pi => 3.14159265359
hypot => 5.0*b*
}}}
完整函数列表请参阅 ''Python Library Reference'' .
----
== 1.10. cmath 模块 ==
[[#eg-1-61|Example 1-61]] 所展示的 {{{cmath}}} 模块包含了一些用于复数运算的函数.
==== 1.10.0.1. Example 1-61. 使用 cmath 模块 ====
{{{
File: cmath-example-1.py
import cmath
print "pi", "=>", cmath.pi
print "sqrt(-1)", "=>", cmath.sqrt(-1)
pi => 3.14159265359
sqrt(-1) => 1j
}}}
完整函数列表请参阅 ''Python Library Reference'' .
----
== 1.11. operator 模块 ==
{{{operator}}} 模块为 Python 提供了一个 "功能性" 的标准操作符接口. 当使用 {{{map}}} 以及
{{{filter}}} 一类的函数的时候, {{{operator}}} 模块中的函数可以替换一些 {{{lambda}}} 函式.
而且这些函数在一些喜欢写晦涩代码的程序员中很流行. [[#eg-1-62|Example 1-62]] 展示了
{{{operator}}} 模块的一般用法.
==== 1.11.0.1. Example 1-62. 使用 operator 模块 ====
{{{
File: operator-example-1.py
import operator
sequence = 1, 2, 4
print "add", "=>", reduce(operator.add, sequence)
print "sub", "=>", reduce(operator.sub, sequence)
print "mul", "=>", reduce(operator.mul, sequence)
print "concat", "=>", operator.concat("spam", "egg")
print "repeat", "=>", operator.repeat("spam", 5)
print "getitem", "=>", operator.getitem(sequence, 2)
print "indexOf", "=>", operator.indexOf(sequence, 2)
print "sequenceIncludes", "=>", operator.sequenceIncludes(sequence, 3)
*B*add => 7
sub => -5
mul => 8
concat => spamegg
repeat => spamspamspamspamspam
getitem => 4
indexOf => 1
sequenceIncludes => 0*b*
}}}
[[#eg-1-63|Example 1-63]] 展示了一些可以用于检查对象类型的 {{{operator}}} 函数.
==== 1.11.0.2. Example 1-63. 使用 operator 模块检查类型 ====
{{{
File: operator-example-2.py
import operator
import UserList
def dump(data):
print type(data), "=>",
if operator.isCallable(data):
print "CALLABLE",
if operator.isMappingType(data):
print "MAPPING",
if operator.isNumberType(data):
print "NUMBER",
if operator.isSequenceType(data):
print "SEQUENCE",
print
dump(0)
dump("string")
dump("string"[0])
dump([1, 2, 3])
dump((1, 2, 3))
dump({"a": 1})
dump(len) # function 函数
dump(UserList) # module 模块
dump(UserList.UserList) # class 类
dump(UserList.UserList()) # instance 实例
*B*<type 'int'> => NUMBER
<type 'string'> => SEQUENCE
<type 'string'> => SEQUENCE
<type 'list'> => SEQUENCE
<type 'tuple'> => SEQUENCE
<type 'dictionary'> => MAPPING
<type 'builtin_function_or_method'> => CALLABLE
<type 'module'> =>
<type 'class'> => CALLABLE
<type 'instance'> => MAPPING NUMBER SEQUENCE*b*
}}}
这里需要注意 {{{operator}}} 模块使用非常规的方法处理对象实例. 所以使用
{{{isNumberType}}} , {{{isMappingType}}} , 以及 {{{isSequenceType}}} 函数的时候要小心,
这很容易降低代码的扩展性.
同样需要注意的是一个字符串序列成员 (单个字符) 也是序列. 所以当在递归函数使用 isSequenceType 来截断对象树的时候, 别把普通字符串作为参数(或者是任何包含字符串的序列对象).
----
== 1.12. copy 模块 ==
{{{copy}}} 模块包含两个函数, 用来拷贝对象, 如 [[#eg-1-64|Example 1-64]] 所示.
{{{copy(object) => object}}} 创建给定对象的 "浅/浅层(shallow)" 拷贝(copy). 这里
"浅/浅层(shallow)" 的意思是复制对象本身, 但当对象是一个容器 (container) 时,
它的成员仍然指向原来的成员对象.
==== 1.12.0.1. Example 1-64. 使用 copy 模块复制对象 ====
{{{
File: copy-example-1.py
import copy
a = [[1],[2],[3]]
b = copy.copy(a)
print "before", "=>"
print a
print b
# modify original
a[0][0] = 0
a[1] = None
print "after", "=>"
print a
print b
*B*before =>
[[1], [2], [3]]
[[1], [2], [3]]
after =>
[[0], None, [3]]
[[0], [2], [3]]*b*
}}}
你也可以使用[:]语句 (完整切片) 来对列表进行浅层复制, 也可以使用 {{{copy}}} 方法复制字典.
相反地, {{{deepcopy(object) => object}}} 创建一个对象的深层拷贝(deepcopy),
如 [[#eg-1-65|Example 1-65]] 所示, 当对象为一个容器时, 所有的成员都被递归地复制了。
==== 1.12.0.2. Example 1-65. 使用 copy 模块复制集合(Collections) ====
{{{
File: copy-example-2.py
import copy
a = [[1],[2],[3]]
b = copy.deepcopy(a)
print "before", "=>"
print a
print b
# modify original
a[0][0] = 0
a[1] = None
print "after", "=>"
print a
print b
*B*before =>
[[1], [2], [3]]
[[1], [2], [3]]
after =>
[[0], None, [3]]
[[1], [2], [3]]*b*
}}}
----
== 1.13. sys 模块 ==
{{{sys}}} 模块提供了许多函数和变量来处理 Python 运行时环境的不同部分.
=== 1.13.1. 处理命令行参数 ===
在解释器启动后, {{{argv}}} 列表包含了传递给脚本的所有参数, 如 [[#eg-1-66|Example 1-66]] 所示.
列表的第一个元素为脚本自身的名称.
==== 1.13.1.1. Example 1-66. 使用sys模块获得脚本的参数 ====
{{{
File: sys-argv-example-1.py
import sys
print "script name is", sys.argv[0]
if len(sys.argv) > 1:
print "there are", len(sys.argv)-1, "arguments:"
for arg in sys.argv[1:]:
print arg
else:
print "there are no arguments!"
*B*script name is sys-argv-example-1.py
there are no arguments!*b*
}}}
如果是从标准输入读入脚本 (比如 "{{{python < sys-argv-example-1.py}}}"),
脚本的名称将被设置为空串. 如果把脚本作为字符串传递给python (使用 {{{-c}}} 选项),
脚本名会被设置为 "-c".
=== 1.13.2. 处理模块 ===
{{{path}}} 列表是一个由目录名构成的列表, Python 从中查找扩展模块( Python 源模块, 编译模块,或者二进制扩展).
启动 Python 时,这个列表从根据内建规则, PYTHONPATH 环境变量的内容, 以及注册表( Windows 系统)等进行初始化.
由于它只是一个普通的列表, 你可以在程序中对它进行操作, 如 [[#eg-1-67|Example 1-67]] 所示.
==== 1.13.2.1. Example 1-67. 使用sys模块操作模块搜索路径 ====
{{{
File: sys-path-example-1.py
import sys
print "path has", len(sys.path), "members"
# add the sample directory to the path
sys.path.insert(0, "samples")
import sample
# nuke the path
sys.path = []
import random # oops!
*B*path has 7 members
this is the sample module!
Traceback (innermost last):
File "sys-path-example-1.py", line 11, in ?
import random # oops!
ImportError: No module named random*b*
}}}
{{{builtin_module_names}}} 列表包含 Python 解释器中所有内建模块的名称, [[#eg-1-68|Example 1-68]]
给出了它的样例代码.
==== 1.13.2.2. Example 1-68. 使用sys模块查找内建模块 ====
{{{
File: sys-builtin-module-names-example-1.py
import sys
def dump(module):
print module, "=>",
if module in sys.builtin_module_names:
print "<BUILTIN>"
else:
module = _ _import_ _(module)
print module._ _file_ _
dump("os")
dump("sys")
dump("string")
dump("strop")
dump("zlib")
*B*os => C:\python\lib\os.pyc
sys => <BUILTIN>
string => C:\python\lib\string.pyc
strop => <BUILTIN>
zlib => C:\python\zlib.pyd*b*
}}}
{{{modules}}} 字典包含所有加载的模块. {{{import}}} 语句在从磁盘导入内容之前会先检查这个字典.
正如你在 [[#eg-1-69|Example 1-69]] 中所见到的, Python 在处理你的脚本之前就已经导入了很多模块.
==== 1.13.2.3. Example 1-69. 使用sys模块查找已导入的模块 ====
{{{
File: sys-modules-example-1.py
import sys
print sys.modules.keys()
*B*['os.path', 'os', 'exceptions', '_ _main_ _', 'ntpath', 'strop', 'nt',
'sys', '_ _builtin_ _', 'site', 'signal', 'UserDict', 'string', 'stat']*b*
}}}
=== 1.13.3. 处理引用记数 ===
{{{getrefcount}}} 函数 (如 [[#eg-1-70|Example 1-70]] 所示) 返回给定对象的引用记数 -
也就是这个对象使用次数. Python 会跟踪这个值, 当它减少为0的时候, 就销毁这个对象.
==== 1.13.3.1. Example 1-70. 使用sys模块获得引用记数 ====
{{{
File: sys-getrefcount-example-1.py
import sys
variable = 1234
print sys.getrefcount(0)
print sys.getrefcount(variable)
print sys.getrefcount(None)
*B*50
3
192*b*
}}}
注意这个值总是比实际的数量大, 因为该函数本身在确定这个值的时候依赖这个对象.
== 检查主机平台===
[[#eg-1-71|Example 1-71]] 展示了 {{{platform}}} 变量, 它包含主机平台的名称.
==== 1.13.3.2. Example 1-71. 使用sys模块获得当前平台 ====
{{{
File: sys-platform-example-1.py
import sys
#
# emulate "import os.path" (sort of)...
if sys.platform == "win32":
import ntpath
pathmodule = ntpath
elif sys.platform == "mac":
import macpath
pathmodule = macpath
else:
# assume it's a posix platform
import posixpath
pathmodule = posixpath
print pathmodule
}}}
典型的平台有Windows 9X/NT(显示为 {{{win32}}} ), 以及 Macintosh(显示为 {{{mac}}} ) .
对于 Unix 系统而言, platform 通常来自 "{{{uname -r}}}" 命令的输出, 例如 {{{irix6}}} , {{{linux2}}} ,
或者 {{{sunos5}}} (Solaris).
=== 1.13.4. 跟踪程序 ===
{{{setprofiler}}} 函数允许你配置一个分析函数(profiling function).
这个函数会在每次调用某个函数或方法时被调用(明确或隐含的),
或是遇到异常的时候被调用. 让我们看看 [[#eg-1-72|Example 1-72]] 的代码.
==== 1.13.4.1. Example 1-72. 使用sys模块配置分析函数 ====
{{{
File: sys-setprofiler-example-1.py
import sys
def test(n):
j = 0
for i in range(n):
j = j + i
return n
def profiler(frame, event, arg):
print event, frame.f_code.co_name, frame.f_lineno, "->", arg
# profiler is activated on the next call, return, or exception
# 分析函数将在下次函数调用, 返回, 或异常时激活
sys.setprofile(profiler)
# profile this function call
# 分析这次函数调用
test(1)
# disable profiler
# 禁用分析函数
sys.setprofile(None)
# don't profile this call
# 不会分析这次函数调用
test(2)
*B*call test 3 -> None
return test 7 -> 1*b*
}}}
基于该函数, {{{profile}}} 模块提供了一个完整的分析器框架.
[[#eg-1-73|Example 1-73]] 中的 {{{settrace}}} 函数与此类似,
但是 {{{trace}}} 函数会在解释器每执行到新的一行时被调用.
==== 1.13.4.2. Example 1-73. 使用sys模块配置单步跟踪函数 ====
{{{
File: sys-settrace-example-1.py
import sys
def test(n):
j = 0
for i in range(n):
j = j + i
return n
def tracer(frame, event, arg):
print event, frame.f_code.co_name, frame.f_lineno, "->", arg
return tracer
# tracer is activated on the next call, return, or exception
# 跟踪器将在下次函数调用, 返回, 或异常时激活
sys.settrace(tracer)
# trace this function call
# 跟踪这次函数调用
test(1)
# disable tracing
# 禁用跟踪器
sys.settrace(None)
# don't trace this call
# 不会跟踪这次函数调用
test(2)
*B*call test 3 -> None
line test 3 -> None
line test 4 -> None
line test 5 -> None
line test 5 -> None
line test 6 -> None
line test 5 -> None
line test 7 -> None
return test 7 -> 1*b*
}}}
基于该函数提供的跟踪功能, {{{pdb}}} 模块提供了完整的调试( debug )框架.
=== 1.13.5. 处理标准输出/输入 ===
{{{stdin}}} , {{{stdout}}} , 以及 {{{stderr}}} 变量包含与标准 I/O 流对应的流对象.
如果需要更好地控制输出,而 {{{print}}} 不能满足你的要求, 它们就是你所需要的.
你也可以 ''替换'' 它们, 这时候你就可以重定向输出和输入到其它设备( device ),
或者以非标准的方式处理它们. 如 [[#eg-1-74|Example 1-74]] 所示.
==== 1.13.5.1. Example 1-74. 使用sys重定向输出 ====
{{{
File: sys-stdout-example-1.py
import sys
import string
class Redirect:
def _ _init_ _(self, stdout):
self.stdout = stdout
def write(self, s):
self.stdout.write(string.lower(s))
# redirect standard output (including the print statement)
# 重定向标准输出(包括print语句)
old_stdout = sys.stdout
sys.stdout = Redirect(sys.stdout)
print "HEJA SVERIGE",
print "FRISKT HUM\303\226R"
# restore standard output
# 恢复标准输出
sys.stdout = old_stdout
print "M\303\205\303\205\303\205\303\205L!"
*B*heja sverige friskt hum\303\266r
M\303\205\303\205\303\205\303\205L!*b*
}}}
要重定向输出只要创建一个对象, 并实现它的 {{{write}}} 方法.
(除非 C 类型的实例外：Python 使用一个叫做 {{{softspace}}} 的整数属性来控制输出中的空白.
如果没有这个属性, Python 将把这个属性附加到这个对象上. 你不需要在使用 Python 对象时担心,
但是在重定向到一个 C 类型时, 你应该确保该类型支持 {{{softspace}}} 属性.)
=== 1.13.6. 退出程序 ===
执行至主程序的末尾时,解释器会自动退出. 但是如果需要中途退出程序, 你可以调用 {{{sys.exit}}} 函数,
它带有一个可选的整数参数返回给调用它的程序. [[#eg-1-75|Example 1-75]] 给出了范例.
==== 1.13.6.1. Example 1-75. 使用sys模块退出程序 ====
{{{
File: sys-exit-example-1.py
import sys
print "hello"
sys.exit(1)
print "there"
*B*hello*b*
}}}
注意 {{{sys.exit}}} 并不是立即退出. 而是引发一个 ''SystemExit'' 异常.
这意味着你可以在主程序中捕获对 {{{sys.exit}}} 的调用, 如 [[#eg-1-76|Example 1-76]] 所示.
==== 1.13.6.2. Example 1-76. 捕获sys.exit调用 ====
{{{
File: sys-exit-example-2.py
import sys
print "hello"
try:
sys.exit(1)
except SystemExit:
pass
print "there"
*B*hello
there*b*
}}}
如果准备在退出前自己清理一些东西(比如删除临时文件), 你可以配置一个
"退出处理函数"(exit handler), 它将在程序退出的时候自动被调用. 如 [[#eg-1-77|Example 1-77]] 所示.
==== 1.13.6.3. Example 1-77. 另一种捕获sys.exit调用的方法 ====
{{{
File: sys-exitfunc-example-1.py
import sys
def exitfunc():
print "world"
sys.exitfunc = exitfunc
print "hello"
sys.exit(1)
print "there" # never printed # 不会被 print
*B*hello
world*b*
}}}
在 Python 2.0 以后, 你可以使用 {{{atexit}}} 模块来注册多个退出处理函数.
----
== 1.14. atexit 模块 ==
(用于2.0版本及以上) {{{atexit}}} 模块允许你注册一个或多个终止函数(暂且这么叫),
这些函数将在解释器终止前被自动调用.
调用 {{{register}}} 函数, 便可以将函数注册为终止函数, 如 [[#eg-1-78|Example 1-78]] 所示.
你也可以添加更多的参数, 这些将作为 {{{exit}}} 函数的参数传递.
==== 1.14.0.1. Example 1-78. 使用 atexit 模块 ====
{{{
File: atexit-example-1.py
import atexit
def exit(*args):
print "exit", args
# register two exit handler
atexit.register(exit)
atexit.register(exit, 1)
atexit.register(exit, "hello", "world")
*B*exit ('hello', 'world')
exit (1,)
exit ()*b*
}}}
该模块其实是一个对 {{{sys.exitfunc}}} 钩子( hook )的简单封装.
----
== 1.15. time 模块 ==
{{{time}}} 模块提供了一些处理日期和一天内时间的函数. 它是建立在 C 运行时库的简单封装.
给定的日期和时间可以被表示为浮点型(从参考时间, 通常是 1970.1.1 到现在经过的秒数.
即 Unix 格式), 或者一个表示时间的 struct (类元组).
=== 1.15.1. 获得当前时间 ===
[[#eg-1-79|Example 1-79]] 展示了如何使用 {{{time}}} 模块获取当前时间.
==== 1.15.1.1. Example 1-79. 使用 time 模块获取当前时间 ====
{{{
File: time-example-1.py
import time
now = time.time()
print now, "seconds since", time.gmtime(0)[:6]
print
print "or in other words:"
print "- local time:", time.localtime(now)
print "- utc:", time.gmtime(now)
*B*937758359.77 seconds since (1970, 1, 1, 0, 0, 0)
or in other words:
- local time: (1999, 9, 19, 18, 25, 59, 6, 262, 1)
- utc: (1999, 9, 19, 16, 25, 59, 6, 262, 0)*b*
}}}
{{{localtime}}} 和 {{{gmtime}}} 返回的类元组包括年, 月, 日, 时, 分, 秒, 星期, 一年的第几天, 日光标志.
其中年是一个四位数(在有千年虫问题的平台上另有规定, 但还是四位数), 星期从星期一(数字 0 代表)开始,
1月1日是一年的第一天.
=== 1.15.2. 将时间值转换为字符串 ===
你可以使用标准的格式化字符串把时间对象转换为字符串, 不过 {{{time}}} 模块已经提供了许多标准转换函数,
如 [[#eg-1-80|Example 1-80]] 所示.
==== 1.15.2.1. Example 1-80. 使用 time 模块格式化时间输出 ====
{{{
File: time-example-2.py
import time
now = time.localtime(time.time())
print time.asctime(now)
print time.strftime("%y/%m/%d %H:%M", now)
print time.strftime("%a %b %d", now)
print time.strftime("%c", now)
print time.strftime("%I %p", now)
print time.strftime("%Y-%m-%d %H:%M:%S %Z", now)
# do it by hand...
year, month, day, hour, minute, second, weekday, yearday, daylight = now
print "%04d-%02d-%02d" % (year, month, day)
print "%02d:%02d:%02d" % (hour, minute, second)
print ("MON", "TUE", "WED", "THU", "FRI", "SAT", "SUN")[weekday], yearday
*B*Sun Oct 10 21:39:24 1999
99/10/10 21:39
Sun Oct 10
Sun Oct 10 21:39:24 1999
09 PM
1999-10-10 21:39:24 CEST
1999-10-10
21:39:24
SUN 283*b*
}}}
=== 1.15.3. 将字符串转换为时间对象 ===
在一些平台上, {{{time}}} 模块包含了 {{{strptime}}} 函数, 它的作用与 {{{strftime}}} 相反.
给定一个字符串和模式, 它返回相应的时间对象, 如 [[#eg-1-81|Example 1-81]] 所示.
==== 1.15.3.1. Example 1-81. 使用 time.strptime 函数解析时间 ====
{{{
File: time-example-6.py
import time
# make sure we have a strptime function!
# 确认有函数 strptime
try:
strptime = time.strptime
except AttributeError:
from strptime import strptime
print strptime("31 Nov 00", "%d %b %y")
print strptime("1 Jan 70 1:30pm", "%d %b %y %I:%M%p")
}}}
只有在系统的 C 库提供了相应的函数的时候, {{{time.strptime}}} 函数才可以使用.
对于没有提供标准实现的平台, [[#eg-1-82|Example 1-82]] 提供了一个不完全的实现.
==== 1.15.3.2. Example 1-82. strptime 实现 ====
{{{
File: strptime.py
import re
import string
MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug",
"Sep", "Oct", "Nov", "Dec"]
SPEC = {
# map formatting code to a regular expression fragment
"%a": "(?P<weekday>[a-z]+)",
"%A": "(?P<weekday>[a-z]+)",
"%b": "(?P<month>[a-z]+)",
"%B": "(?P<month>[a-z]+)",
"%C": "(?P<century>\d\d?)",
"%d": "(?P<day>\d\d?)",
"%D": "(?P<month>\d\d?)/(?P<day>\d\d?)/(?P<year>\d\d)",
"%e": "(?P<day>\d\d?)",
"%h": "(?P<month>[a-z]+)",
"%H": "(?P<hour>\d\d?)",
"%I": "(?P<hour12>\d\d?)",
"%j": "(?P<yearday>\d\d?\d?)",
"%m": "(?P<month>\d\d?)",
"%M": "(?P<minute>\d\d?)",
"%p": "(?P<ampm12>am|pm)",
"%R": "(?P<hour>\d\d?):(?P<minute>\d\d?)",
"%S": "(?P<second>\d\d?)",
"%T": "(?P<hour>\d\d?):(?P<minute>\d\d?):(?P<second>\d\d?)",
"%U": "(?P<week>\d\d)",
"%w": "(?P<weekday>\d)",
"%W": "(?P<weekday>\d\d)",
"%y": "(?P<year>\d\d)",
"%Y": "(?P<year>\d\d\d\d)",
"%%": "%"
}
class TimeParser:
def _ _init_ _(self, format):
# convert strptime format string to regular expression
format = string.join(re.split("(?:\s|%t|%n)+", format))
pattern = []
try:
for spec in re.findall("%\w|%%|.", format):
if spec[0] == "%":
spec = SPEC[spec]
pattern.append(spec)
except KeyError:
raise ValueError, "unknown specificer: %s" % spec
self.pattern = re.compile("(?i)" + string.join(pattern, ""))
def match(self, daytime):
# match time string
match = self.pattern.match(daytime)
if not match:
raise ValueError, "format mismatch"
get = match.groupdict().get
tm = [0] * 9
# extract date elements
y = get("year")
if y:
y = int(y)
if y < 68:
y = 2000 + y
elif y < 100:
y = 1900 + y
tm[0] = y
m = get("month")
if m:
if m in MONTHS:
m = MONTHS.index(m) + 1
tm[1] = int(m)
d = get("day")
if d: tm[2] = int(d)
# extract time elements
h = get("hour")
if h:
tm[3] = int(h)
else:
h = get("hour12")
if h:
h = int(h)
if string.lower(get("ampm12", "")) == "pm":
h = h + 12
tm[3] = h
m = get("minute")
if m: tm[4] = int(m)
s = get("second")
if s: tm[5] = int(s)
# ignore weekday/yearday for now
return tuple(tm)
def strptime(string, format="%a %b %d %H:%M:%S %Y"):
return TimeParser(format).match(string)
if _ _name_ _ == "_ _main_ _":
# try it out
import time
print strptime("2000-12-20 01:02:03", "%Y-%m-%d %H:%M:%S")
print strptime(time.ctime(time.time()))
*B*(2000, 12, 20, 1, 2, 3, 0, 0, 0)
(2000, 11, 15, 12, 30, 45, 0, 0, 0)*b*
}}}
=== 1.15.4. 转换时间值 ===
将时间元组转换回时间值非常简单, 至少我们谈论的当地时间 (local time) 如此.
只要把时间元组传递给 {{{mktime}}} 函数, 如 [[#eg-1-83|Example 1-83]] 所示.
==== 1.15.4.1. Example 1-83. 使用 time 模块将本地时间元组转换为时间值(整数) ====
{{{
File: time-example-3.py
import time
t0 = time.time()
tm = time.localtime(t0)
print tm
print t0
print time.mktime(tm)
*B*(1999, 9, 9, 0, 11, 8, 3, 252, 1)
936828668.16
936828668.0*b*
}}}
但是, 1.5.2 版本的标准库没有提供能将 UTC 时间
(Universal Time, Coordinated: 特林威治标准时间)转换为时间值的函数
( Python 和对应底层 C 库都没有提供). [[#eg-1-84|Example 1-84]] 提供了该函数的一个
Python 实现, 称为 {{{timegm}}} .
==== 1.15.4.2. Example 1-84. 将 UTC 时间元组转换为时间值(整数) ====
{{{
File: time-example-4.py
import time
def _d(y, m, d, days=(0,31,59,90,120,151,181,212,243,273,304,334,365)):
# map a date to the number of days from a reference point
return (((y - 1901)*1461)/4 + days[m-1] + d +
((m > 2 and not y % 4 and (y % 100 or not y % 400)) and 1))
def timegm(tm, epoch=_d(1970,1,1)):
year, month, day, h, m, s = tm[:6]
assert year >= 1970
assert 1 <= month <= 12
return (_d(year, month, day) - epoch)*86400 + h*3600 + m*60 + s
t0 = time.time()
tm = time.gmtime(t0)
print tm
print t0
print timegm(tm)
*B*(1999, 9, 8, 22, 12, 12, 2, 251, 0)
936828732.48
936828732*b*
}}}
从 1.6 版本开始, {{{calendar}}} 模块提供了一个类似的函数 {{{calendar.timegm}}} .
=== 1.15.5. Timing 相关 ===
{{{time}}} 模块可以计算 Python 程序的执行时间, 如 [[#eg-1-85|Example 1-85]] 所示.
你可以测量 "wall time" (real world time), 或是"进程时间" (消耗的 CPU 时间).
==== 1.15.5.1. Example 1-85. 使用 time 模块评价算法 ====
{{{
File: time-example-5.py
import time
def procedure():
time.sleep(2.5)
# measure process time
t0 = time.clock()
procedure()
print time.clock() - t0, "seconds process time"
# measure wall time
t0 = time.time()
procedure()
print time.time() - t0, "seconds wall time"
*B*0.0 seconds process time
2.50903499126 seconds wall time*b*
}}}
并不是所有的系统都能测量真实的进程时间. 一些系统中(包括 Windows ),
{{{clock}}} 函数通常测量从程序启动到测量时的 wall time.
进程时间的精度受限制. 在一些系统中, 它超过 30 分钟后进程会被清理.
(原文: On many systems, it wraps around after just over 30 minutes.)
另参见 {{{timing}}} 模块( Windows 下的朋友不用忙活了,没有地~), 它可以测量两个事件之间的 wall time.
----
== 1.16. types 模块 ==
{{{types}}} 模块包含了标准解释器定义的所有类型的类型对象, 如 [[#eg-1-86|Example 1-86]] 所示.
同一类型的所有对象共享一个类型对象. 你可以使用 {{{is}}} 来检查一个对象是不是属于某个给定类型.
==== 1.16.0.1. Example 1-86. 使用 types 模块 ====
{{{
File: types-example-1.py
import types
def check(object):
print object,
if type(object) is types.IntType:
print "INTEGER",
if type(object) is types.FloatType:
print "FLOAT",
if type(object) is types.StringType:
print "STRING",
if type(object) is types.ClassType:
print "CLASS",
if type(object) is types.InstanceType:
print "INSTANCE",
print
check(0)
check(0.0)
check("0")
class A:
pass
class B:
pass
check(A)
check(B)
a = A()
b = B()
check(a)
check(b)
*B*0 INTEGER
0.0 FLOAT
0 STRING
A CLASS
B CLASS
<A instance at 796960> INSTANCE
<B instance at 796990> INSTANCE*b*
}}}
注意所有的类都具有相同的类型, 所有的实例也是一样. 要测试一个类或者实例所属的类,
可以使用内建的 {{{issubclass}}} 和 {{{isinstance}}} 函数.
{{{types}}} 模块在第一次引入的时候会破坏当前的异常状态. 也就是说,
不要在异常处理语句块中导入该模块 (''或其他会导入它的模块'') .
----
== 1.17. gc 模块 ==
(可选, 2.0 及以后版本) {{{gc}}} 模块提供了到内建循环垃圾收集器的接口.
Python 使用引用记数来跟踪什么时候销毁一个对象; 一个对象的最后一个引用一旦消失, 这个对象就会被销毁.
从 2.0 版开始, Python 还提供了一个循环垃圾收集器, 它每隔一段时间执行.
这个收集器查找指向自身的数据结构, 并尝试破坏循环. 如 [[#eg-1-87|Example 1-87]] 所示.
你可以使用 {{{gc.collect}}} 函数来强制完整收集. 这个函数将返回收集器销毁的对象的数量.
==== 1.17.0.1. Example 1-87. 使用 gc 模块收集循环引用垃圾 ====
{{{
File: gc-example-1.py
import gc
# create a simple object that links to itself
class Node:
def _ _init_ _(self, name):
self.name = name
self.parent = None
self.children = []
def addchild(self, node):
node.parent = self
self.children.append(node)
def _ _repr_ _(self):
return "<Node %s at %x>" % (repr(self.name), id(self))
# set up a self-referencing structure
root = Node("monty")
root.addchild(Node("eric"))
root.addchild(Node("john"))
root.addchild(Node("michael"))
# remove our only reference
del root
print gc.collect(), "unreachable objects"
print gc.collect(), "unreachable objects"
*B*12 unreachable objects
0 unreachable objects*b*
}}}
如果你确定你的程序不会创建自引用的数据结构, 你可以使用 {{{gc.disable}}} 函数禁用垃圾收集,
调用这个函数以后, Python 的工作方式将与 1.5.2 或更早的版本相同.
----
## moin code generated by txt2tags 2.4 (http://txt2tags.sf.net)
## cmdline: txt2tags -t moin -o moin/chapter1.moin chapter1.t2t