python标准库介绍——10 sys 模块详解

==sys 模块==


``sys`` 模块提供了许多函数和变量来处理 Python 运行时环境的不同部分.

=== 处理命令行参数===

在解释器启动后, ``argv`` 列表包含了传递给脚本的所有参数, 如 [Example 1-66 #eg-1-66] 所示. 
列表的第一个元素为脚本自身的名称.

====Example 1-66. 使用sys模块获得脚本的参数====[eg-1-66]

```
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".

=== 处理模块 ===

``path`` 列表是一个由目录名构成的列表, Python 从中查找扩展模块( Python 源模块, 编译模块,或者二进制扩展). 
启动 Python 时,这个列表从根据内建规则, PYTHONPATH 环境变量的内容, 以及注册表( Windows 系统)等进行初始化. 
由于它只是一个普通的列表, 你可以在程序中对它进行操作, 如 [Example 1-67 #eg-1-67] 所示.

====Example 1-67. 使用sys模块操作模块搜索路径====[eg-1-67]

```
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 解释器中所有内建模块的名称, [Example 1-68 #eg-1-68] 
 给出了它的样例代码.

====Example 1-68. 使用sys模块查找内建模块====[eg-1-68]

```
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`` 语句在从磁盘导入内容之前会先检查这个字典.

正如你在 [Example 1-69 #eg-1-69] 中所见到的, Python 在处理你的脚本之前就已经导入了很多模块.

====Example 1-69. 使用sys模块查找已导入的模块====[eg-1-69]

```
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*
```

=== 处理引用记数===

``getrefcount`` 函数 (如 [Example 1-70 #eg-1-70] 所示) 返回给定对象的引用记数 - 
也就是这个对象使用次数. Python 会跟踪这个值, 当它减少为0的时候, 就销毁这个对象.

====Example 1-70. 使用sys模块获得引用记数====[eg-1-70]

```
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*
```

注意这个值总是比实际的数量大, 因为该函数本身在确定这个值的时候依赖这个对象.

== 检查主机平台===

[Example 1-71 #eg-1-71] 展示了 ``platform`` 变量, 它包含主机平台的名称.

====Example 1-71. 使用sys模块获得当前平台====[eg-1-71]

```
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).

=== 跟踪程序===

``setprofiler`` 函数允许你配置一个分析函数(profiling function). 
这个函数会在每次调用某个函数或方法时被调用(明确或隐含的), 
或是遇到异常的时候被调用. 让我们看看 [Example 1-72 #eg-1-72] 的代码.

====Example 1-72. 使用sys模块配置分析函数====[eg-1-72]

```
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`` 模块提供了一个完整的分析器框架. 

[Example 1-73 #eg-1-73] 中的 ``settrace`` 函数与此类似, 
但是 ``trace`` 函数会在解释器每执行到新的一行时被调用.

====Example 1-73. 使用sys模块配置单步跟踪函数====[eg-1-73]

```
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 )框架. 

=== 处理标准输出/输入 ===

``stdin`` , ``stdout`` , 以及 ``stderr`` 变量包含与标准 I/O 流对应的流对象. 
如果需要更好地控制输出,而 ``print`` 不能满足你的要求, 它们就是你所需要的. 
你也可以 //替换// 它们, 这时候你就可以重定向输出和输入到其它设备( device ), 
或者以非标准的方式处理它们. 如 [Example 1-74 #eg-1-74] 所示.

====Example 1-74. 使用sys重定向输出====[eg-1-74]

```
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`` 属性.)

=== 退出程序===

执行至主程序的末尾时,解释器会自动退出. 但是如果需要中途退出程序, 你可以调用 ``sys.exit`` 函数, 
它带有一个可选的整数参数返回给调用它的程序. [Example 1-75 #eg-1-75] 给出了范例.

====Example 1-75. 使用sys模块退出程序====[eg-1-75]

```
File: sys-exit-example-1.py

import sys

print "hello"

sys.exit(1)

print "there"

*B*hello*b*
```

注意 ``sys.exit`` 并不是立即退出. 而是引发一个 //SystemExit// 异常. 
这意味着你可以在主程序中捕获对 ``sys.exit`` 的调用, 如 [Example 1-76 #eg-1-76] 所示.

====Example 1-76. 捕获sys.exit调用====[eg-1-76]

```
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), 它将在程序退出的时候自动被调用. 如 [Example 1-77 #eg-1-77] 所示.

====Example 1-77. 另一种捕获sys.exit调用的方法====[eg-1-77]

```
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`` 模块来注册多个退出处理函数.