Python Standard Library

翻译: Python 江湖群

2008-03-28 13:11:55

Contents

1. 执行支持模块

[index.html 返回首页]

1. 执行支持模块

就是其他模块中用到的模块.

1.1. dospath 模块

dospath 模块(参见 Example 13-1 )提供了 DOS 平台下的 os.path 功能. 你可以使用它在其他平台处理 DOS 路径.

1.1.0.1. Example 13-1. 使用 dospath 模块

File: dospath-example-1.py

import dospath 

file = "/my/little/pony"

print "isabs", "=>", dospath.isabs(file)
print "dirname", "=>", dospath.dirname(file)
print "basename", "=>", dospath.basename(file)
print "normpath", "=>", dospath.normpath(file)
print "split", "=>", dospath.split(file)
print "join", "=>", dospath.join(file, "zorba")

*B*isabs => 1
dirname => /my/little
basename => pony
normpath => \my\little\pony
split => ('/my/little', 'pony')
join => /my/little/pony\zorba*b*

注意 Python 的 DOS 支持可以使用斜杠和反斜杠作为目录分隔符.

1.2. macpath 模块

macpath 模块( 参见 Example 13-2 )提供了 Macintosh 平台下的 os.path 功能. 你也可以使用它在其他平台处理 Macintosh 路径.

1.2.0.1. Example 13-2. 使用 macpath 模块

File: macpath-example-1.py

import macpath

file = "my:little:pony"

print "isabs", "=>", macpath.isabs(file)
print "dirname", "=>", macpath.dirname(file)
print "basename", "=>", macpath.basename(file)
print "normpath", "=>", macpath.normpath(file)
print "split", "=>", macpath.split(file)
print "join", "=>", macpath.join(file, "zorba")

*B*isabs => 1
dirname => my:little
basename => pony
normpath => my:little:pony
split => ('my:little', 'pony')
join => my:little:pony:zorba*b*

1.3. ntpath 模块

ntpath 模块( 参见 Example 13-3 )提供了 Windows 平台下的 os.path 功能. 你也可以使用它在其他平台处理 Windows 路径.

1.3.0.1. Example 13-3. 使用 ntpath 模块

File: ntpath-example-1.py

import ntpath

file = "/my/little/pony"

print "isabs", "=>", ntpath.isabs(file)
print "dirname", "=>", ntpath.dirname(file)
print "basename", "=>", ntpath.basename(file)
print "normpath", "=>", ntpath.normpath(file)
print "split", "=>", ntpath.split(file)
print "join", "=>", ntpath.join(file, "zorba")

*B*isabs => 1
dirname => /my/little
basename => pony

normpath => \my\little\pony
split => ('/my/little', 'pony')
join => /my/little/pony\zorba*b*

注意该模块可以同时使用斜杠和反斜杠作为目录分隔符.

1.4. posixpath 模块

posixpath 模块( 参见 Example 13-4 )提供了 Unix 和其他 POSIX 兼容平台下的 os.path 功能. 你也可以使用它在其他平台处理 POSIX 路径. 另外, 它也可以处理 URL .

1.4.0.1. Example 13-4. 使用 posixpath 模块

File: posixpath-example-1.py

import posixpath

file = "/my/little/pony"

print "isabs", "=>", posixpath.isabs(file)
print "dirname", "=>", posixpath.dirname(file)
print "basename", "=>", posixpath.basename(file)
print "normpath", "=>", posixpath.normpath(file)
print "split", "=>", posixpath.split(file)
print "join", "=>", posixpath.join(file, "zorba")

*B*isabs => 1
dirname => /my/little
basename => pony
normpath => /my/little/pony
split => ('/my/little', 'pony')
join => /my/little/pony/zorba*b*

1.5. strop 模块

(已废弃) strop 为 string 模块中的大多函数提供了底层 C 语言实现. string 模块会自动调用它, 所以一般你不需要直接使用它.

不过在导入 Python 模块之前处理路径的时候你可能会用到它. 如 Example 13-5 所示.

1.5.0.1. Example 13-5. 使用 strop 模块

File: strop-example-1.py

import strop
import sys

# assuming we have an executable named ".../executable", add a
# directory named ".../executable-extra" to the path

if strop.lower(sys.executable)[-4:] == ".exe":
    extra = sys.executable[:-4] # windows
else:
    extra = sys.executable

sys.path.insert(0, extra + "-extra")

import mymodule

在 Python 2.0 及以后版本中, 你应该使用字符串方法代替 strop , 例如在上边的代码中. 使用 "sys.executable.lower()" 替换 "strop.lower(sys.executable)" .

1.6. imp 模块

imp 模块包含的函数可以用于实现自定义的 import 行为. Example 13-6 重载了 import 语句, 实现了对模块来源的记录功能.

1.6.0.1. Example 13-6. 使用 imp 模块

File: imp-example-1.py

import imp
import sys

def my_import(name, globals=None, locals=None, fromlist=None):
    try:
        module = sys.modules[name] # already imported?
    except KeyError:
        file, pathname, description = imp.find_module(name)
        print "import", name, "from", pathname, description
        module = imp.load_module(name, file, pathname, description)
    return module

import _ _builtin_ _
_ _builtin_ _._ _import_ _ = my_import

*B*import xmllib

import xmllib from /python/lib/xmllib.py ('.py', 'r', 1)
import re from /python/lib/re.py ('.py', 'r', 1)

import sre from /python/lib/sre.py ('.py', 'r', 1)
import sre_compile from /python/lib/sre_compile.py ('.py', 'r', 1)
import _sre from /python/_sre.pyd ('.pyd', 'rb', 3)*b*

注意这里的导入功能不支持包. 具体实现请参阅 knee 模块的源代码.

1.7. new 模块

new 模块是一个底层的模块, 你可以使用它来创建不同的内建对象, 例如类对象, 函数对象, 以及其他由 Python 运行时系统创建的类型. Example 13-7 展示了该模块的使用.

如果你使用的是 1.5.2 版本 , 那么你有可能需要重新编译 Python 来使用这个模块, 在默认情况下并不是所有平台都有这个模块. 在 2.0 及以后版本中, 不需要这么做.

1.7.0.1. Example 13-7. 使用 new 模块

File: new-example-1.py

import new

class Sample:

    a = "default"

    def _ _init_ _(self):
        self.a = "initialised"

    def _ _repr_ _(self):
        return self.a

#
# create instances

a = Sample()
print "normal", "=>", a

b = new.instance(Sample, {})
print "new.instance", "=>", b

b._ _init_ _()
print "after _ _init_ _", "=>", b

c = new.instance(Sample, {"a": "assigned"})
print "new.instance w. dictionary", "=>", c

*B*normal => initialised
new.instance => default
after _ _init_ _ => initialised
new.instance w. dictionary => assigned*b*

1.8. pre 模块

(已废弃) pre 模块是 1.5.2 中 re 模块调用的实现功能模块. 在当前版本中已废弃. Example 13-8 展示了它的使用.

1.8.0.1. Example 13-8. 使用 pre 模块

File: pre-example-1.py

import pre

p = pre.compile("[Python]+")

print p.findall("Python is not that bad")

*B*['Python', 'not', 'th', 't']*b*

1.9. sre 模块

(功能实现模块, 已声明不支持) sre 模块是 re 模块的底层实现. 一般没必要直接使用它, 而且以后版本将不会支持它. Example 13-9 展示了它的使用.

1.9.0.1. Example 13-9. 使用 sre 模块

File: sre-example-1.py

import sre

text = "The Bookshop Sketch"

# a single character
m = sre.match(".", text)
if m: print repr("."), "=>", repr(m.group(0))

# and so on, for all 're' examples...

*B*'.' => 'T'*b*

1.10. py_compile 模块

py_compile 模块用于将 Python 模块编译为字节代码. 它和 Python 的 import 语句行为类似, 不过它接受文件名而不是模块名作为参数. 使用方法如 Example 13-10 所示.

1.10.0.1. Example 13-10. 使用 py_compile 模块

File: py-compile-example-1.py

import py_compile

# explicitly compile this module
py_compile.compile("py-compile-example-1.py")

compileall 模块可以把一个目录树下的所有 Python 文件编译为字节代码.

1.11. compileall 模块

compileall 模块用于将给定目录下(以及 Python path )的所有 Python 脚本编译为字节代码. 它也可以作为可执行脚本使用(在 Unix 系统下, Python 安装时会自动调用执行它). 用法参见 Example 13-11 .

1.11.0.1. Example 13-11. 使用 compileall 模块编译目录中的所有脚本

File: compileall-example-1.py

import compileall

print "This may take a while!"

compileall.compile_dir(".", force=1)

*B*This may take a while!
Listing . ...
Compiling .\SimpleAsyncHTTP.py ...
Compiling .\aifc-example-1.py ...
Compiling .\anydbm-example-1.py ...
...*b*

1.12. ihooks 模块

ihooks 模块为替换导入提供了一个框架. 这允许多个导入机制共存. 使用方法参见 Example 13-12 .

1.12.0.1. Example 13-12. 使用 ihooks 模块

File: ihooks-example-1.py

import ihooks, imp, os

def import_from(filename):
    "Import module from a named file"

    loader = ihooks.BasicModuleLoader()
    path, file = os.path.split(filename)
    name, ext  = os.path.splitext(file)
    m = loader.find_module_in_dir(name, path)
    if not m:
        raise ImportError, name
    m = loader.load_module(name, m)
    return m

colorsys = import_from("/python/lib/colorsys.py")

print colorsys

*B*<module 'colorsys' from '/python/lib/colorsys.py'>*b*

1.13. linecache 模块

linecache 模块用于从模块源文件中读取代码. 它会缓存最近访问的模块 (整个源文件). 如 Example 13-13 .

1.13.0.1. Example 13-13. 使用 linecache 模块

File: linecache-example-1.py

import linecache

print linecache.getline("linecache-example-1.py", 5)

*B*print linecache.getline("linecache-example-1.py", 5)*b*

traceback 模块使用这个模块实现了对导入操作的跟踪.

1.14. macurl2path 模块

(功能实现模块) macurl2path 模块用于 URL 和 Macintosh 文件名的相互映射. 一般没有必要直接使用它, 请使用 urllib 中的机制. 它的用法参见 Example 13-14 .

1.14.0.1. Example 13-14. 使用 macurl2path 模块

File: macurl2path-example-1.py

import macurl2path

file = ":my:little:pony"

print macurl2path.pathname2url(file)
print macurl2path.url2pathname(macurl2path.pathname2url(file))

*B*my/little/pony
:my:little:pony*b*

1.15. nturl2path 模块

(功能实现模块) nturl2path 模块用于 URL 和 Windows 文件名的相互映射. 用法参见 Example 13-15 .

1.15.0.1. Example 13-15. 使用 nturl2path 模块

File: nturl2path-example-1.py

import nturl2path

file = r"c:\my\little\pony"

print nturl2path.pathname2url(file)
print nturl2path.url2pathname(nturl2path.pathname2url(file))

*B*///C|/my/little/pony
C:\my\little\pony*b*

同样地, 请通过 urllib 模块来访问这些函数, 如 Example 13-16 所示.

1.15.0.2. Example 13-16. 通过 urllib 调用 nturl2path 模块

File: nturl2path-example-2.py

import urllib

file = r"c:\my\little\pony"

print urllib.pathname2url(file)
print urllib.url2pathname(urllib.pathname2url(file))

*B*///C|/my/little/pony
C:\my\little\pony*b*

1.16. tokenize 模块

tokenize 模块将一段 Python 源文件分割成不同的 token . 你可以在代码高亮工具中使用它.

在 Example 13-17 中, 我们分别打印出这些 token .

1.16.0.1. Example 13-17. 使用 tokenize 模块

File: tokenize-example-1.py

import tokenize

file = open("tokenize-example-1.py")

def handle_token(type, token, (srow, scol), (erow, ecol), line):
    print "%d,%d-%d,%d:\t%s\t%s" % \
        (srow, scol, erow, ecol, tokenize.tok_name[type], repr(token))

tokenize.tokenize(
    file.readline,
    handle_token
    )

*B*1,0-1,6:     NAME    'import'
1,7-1,15:    NAME    'tokenize'
1,15-1,16:   NEWLINE '\012'
2,0-2,1:     NL      '\012'
3,0-3,4:     NAME    'file'
3,5-3,6:     OP      '='
3,7-3,11:    NAME    'open'
3,11-3,12:   OP      '('
3,12-3,35:   STRING  '"tokenize-example-1.py"'
3,35-3,36:   OP      ')'
3,36-3,37:   NEWLINE '\012'
...*b*

注意这里的 tokenize 函数接受两个可调用对象作为参数: 前一个用于获取新的代码行, 第二个用于在获得每个 token 时调用.

1.17. keyword 模块

keyword 模块(参见 Example 13-18 )有一个包含当前 Python 版本所使用的关键字的列表. 它还提供了一个字典, 以关键字作为 key , 以一个描述性函数作为 value , 它可用于检查给定单词是否是 Python 关键字.

1.17.0.1. Example 13-18. 使用 keyword 模块

File: keyword-example-1.py

import keyword

name = raw_input("Enter module name: ")

if keyword.iskeyword(name):
    print name, "is a reserved word."
    print "here's a complete list of reserved words:"
    print keyword.kwlist

*B*Enter module name: assert
assert is a reserved word.
here's a complete list of reserved words:
['and', 'assert', 'break', 'class', 'continue', 'def', 'del',
'elif', 'else', 'except', 'exec', 'finally', 'for', 'from',
'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or',
'pass', 'print', 'raise', 'return', 'try', 'while']*b*

1.18. parser 模块

(可选) parser 模块提供了一个到 Python 内建语法分析器和编译器的接口.

Example 13-19 将一个简单的表达式编译为一个抽象语法树( abstract syntax tree , AST ), 然后将 AST 转换为一个嵌套列表, 转储树 ( 其中每个节点包含一个语法符号或者是一个 token )中的内容, 将所有数字加上 1 , 最后将列表转回一个代码对象. 至少我认为它是这么做的.

1.18.0.1. Example 13-19. 使用 parser 模块

File: parser-example-1.py

import parser
import symbol, token

def dump_and_modify(node):
    name = symbol.sym_name.get(node[0])
    if name is None:
        name = token.tok_name.get(node[0])
    print name,
    for i in range(1, len(node)):
        item = node[i]
        if type(item) is type([]):
            dump_and_modify(item)
        else:
            print repr(item)
            if name == "NUMBER":
                # increment all numbers!
                node[i] = repr(int(item)+1)

ast = parser.expr("1 + 3")

list = ast.tolist()

dump_and_modify(list)

ast = parser.sequence2ast(list)

print eval(parser.compileast(ast))

*B*eval_input testlist test and_test not_test comparison
expr xor_expr and_expr shift_expr arith_expr term factor
power atom NUMBER '1'
PLUS '+'
term factor power atom NUMBER '3'
NEWLINE ''
ENDMARKER ''
6*b*

1.19. symbol 模块

symbol 模块包含 Python 语法中的非终止符号. 可能只有你涉及 parser 模块的时候用到它. 用法参见 Example 13-20 .

1.19.0.1. Example 13-20. 使用 symbol 模块

File: symbol-example-1.py

import symbol

print "print", symbol.print_stmt
print "return", symbol.return_stmt

*B*print 268
return 274*b*

1.20. token 模块

token 模块包含标准 Python tokenizer 所使用的 token 标记. 如 Example 13-21 所示.

1.20.0.1. Example 13-21. 使用 token 模块

File: token-example-1.py

import token

print "NUMBER", token.NUMBER
print "PLUS", token.STAR
print "STRING", token.STRING

*B*NUMBER 2
PLUS 16
STRING 3*b*