6. 模块¶

如果你退出 Python 解释器并重新进入，你做的任何定义(变量和方法)都会丢失。因此，如果你想要编写一些更大的程序，为准备解释器输入使用一个文本编辑器会更好，并以那个文件替代作为输入执行。这就是传说中的 脚本。 随着你的程序变得越来越长，你可能想要将它分割成几个更易于维护的文件。你也可能想在不同的程序中使用顺手的函数，而不是把代码在它们之间中拷来拷去。

为了满足这些需要，Python 提供了一个方法可以从文件中获取定义，在脚本或者解释器的一个交互式实例中使用。这样的文件被称为 模块；模块中的定义可以 导入 到另一个模块或 主模块 中(在脚本执行时可以调用的变量集位于最高级，并且处于计算器模式)。

模块是包括 Python 定义和声明的文件。文件名就是模块名加上 .py 后缀。模块的模块名(做为一个字符串)可以由全局变量 name 得到。例如，你可以用自己惯用的文件编辑器在当前目录下创建一个叫 fibo.py 的文件，录入如下内容:

  1. # Fibonacci numbers module
  2.  
  3. def fib(n):    # write Fibonacci series up to n
  4.     a, b = 0, 1
  5.     while b < n:
  6.         print b
  7.         a, b = b, a+b
  8.  
  9.  
  10. def fib2(n): # return Fibonacci series up to n
  11.     result = []
  12.     a, b = 0, 1
  13.     while b < n:
  14.         result.append(b)
  15.         a, b = b, a+b
  16.     return result

现在进入 Python 解释器并使用以下命令导入这个模块:

  1. >>> import fibo

这样做不会直接把 fibo 中的函数导入当前的语义表；它只是引入了模块名 fibo。你可以通过模块名按如下方式访问这个函数:

  1. >>> fibo.fib(1000)
  2. 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
  3. >>> fibo.fib2(100)
  4. [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
  5. >>> fibo.__name__
  6. 'fibo'

如果打算频繁使用一个函数，你可以将它赋予一个本地变量:

  1. >>> fib = fibo.fib
  2. >>> fib(500)
  3. 1 1 2 3 5 8 13 21 34 55 89 144 233 377

6.1. 深入模块¶

除了包含函数定义外，模块也可以包含可执行语句。这些语句一般用来初始化模块。它们仅在 第一次 被导入的地方执行一次。[1]

每个模块都有自己私有的符号表，被模块内所有的函数定义作为全局符号表使用。因此，模块的作者可以在模块内部使用全局变量，而无需担心它与某个用户的全局变量意外冲突。从另一个方面讲，如果你确切的知道自己在做什么，你可以使用引用模块函数的表示法访问模块的全局变量，modname.itemname。

模块可以导入其他的模块。一个(好的)习惯是将所有的 import 语句放在模块的开始(或者是脚本)，这并非强制。被导入的模块名会放入当前模块的全局符号表中。

import 语句的一个变体直接从被导入的模块中导入命名到本模块的语义表中。例如:

  1. >>> from fibo import fib, fib2
  2. >>> fib(500)
  3. 1 1 2 3 5 8 13 21 34 55 89 144 233 377

这样不会从局域语义表中导入模块名(如上所示，fibo 没有定义)。

甚至有种方式可以导入模块中的所有定义:

  1. >>> from fibo import *
  2. >>> fib(500)
  3. 1 1 2 3 5 8 13 21 34 55 89 144 233 377

这样可以导入所有除了以下划线( _ )开头的命名。

需要注意的是在实践中往往不鼓励从一个模块或包中使用 * 导入所有，因为这样会让代码变得很难读。不过，在交互式会话中这样用很方便省力。

Note

出于性能考虑，每个模块在每个解释器会话中只导入一遍。因此，如果你修改了你的模块，需要重启解释器或者如果你就是想交互式的测试这么一个模块，可以用 reload() 重新加载，例如 reload(modulename)。

6.1.1. 作为脚本来执行模块¶

当你使用以下方式运行 Python 模块时，模块中的代码便会被执行:

  1. python fibo.py <arguments>

模块中的代码会被执行，就像导入它一样，不过此时 name 被设置为 "main"。这相当于，如果你在模块后加入如下代码:

  1. if __name__ == "__main__":
  2.     import sys
  3.     fib(int(sys.argv[1]))

就可以让此文件像作为模块导入时一样作为脚本执行。此代码只有在模块作为 “main” 文件执行时才被调用:

  1. -  python fibo.py 50
  2. 1 1 2 3 5 8 13 21 34

如果模块被导入，不会执行这段代码:

  1. >>> import fibo
  2. >>>

这通常用来为模块提供一个便于测试的用户接口(将模块作为脚本执行测试需求)。

6.1.2. 模块的搜索路径¶

导入一个叫 spam 的模块时，解释器先在当前目录中搜索名为 spam.py 的文件。如果没有找到的话，接着会到 sys.path 变量中给出的目录列表中查找。sys.path 变量的初始值来自如下：

  • 输入脚本的目录(当前目录)。

  • 环境变量 PYTHONPATH 表示的目录列表中搜索

(这和 shell 变量 PATH 具有一样的语法，即一系列目录名的列表)。

  • Python 默认安装路径中搜索。

实际上，解释器由 sys.path 变量指定的路径目录搜索模块，该变量初始化时默认包含了输入脚本(或者当前目录)，PYTHONPATH 和安装目录。这样就允许 Python 程序了解如何修改或替换模块搜索目录。需要注意的是由于这些目录中包含有搜索路径中运行的脚本，所以这些脚本不应该和标准模块重名，否则在导入模块时 Python 会尝试把这些脚本当作模块来加载。这通常会引发错误。请参见 标准模块 以了解更多的信息。

6.1.3. “编译的” Python 文件¶

对于引用了大量标准模块的短程序，有一个提高启动速度的重要方法，如果在 spam.py 所在的目录下存在一个名为 spam.pyc 的文件，它会被视为 spam 模块的预“编译”( byte-compiled，二进制编译)版本。用于创建 spam.pyc 的这一版 spam.py 的修改时间记录在 spam.pyc 文件中，如果两者不匹配，.pyc 文件就被忽略。

通常你不需要为创建 spam.pyc 文件做任何工作。一旦 spam.py 成功编译，就会尝试生成对应版本的 spam.pyc 。如果有任何原因导致写入不成功，生成的 spam.pyc 文件就会视为无效，随后即被忽略。spam.pyc 文件的内容是平台独立的，所以 Python 模块目录可以在不同架构的机器之间共享。

部分高级技巧:

  • 以 -O 参数调用 Python 解释器时，会生成优化代码并保存在 .pyo 文件中。现在的优化器没有太多帮助；它只是删除了断言( assert)语句。使用 -O 参数，所有 的字节码(bytecode)都会被优化；.pyc 文件被忽略，.py 文件被编译为优化代码。

  • 向 Python 解释器传递两个 -O 参数(-OO)会执行完全优化的二进制优化编译，这偶尔会生成错误的程序。现在的优化器，只是从字节码中删除了 doc 符串，生成更为紧凑的 .pyo 文件。因为某些程序依赖于这些变量的可用性，你应该只在确定无误的场合使用这一选项。

  • 来自 .pyc 文件或 .pyo 文件中的程序不会比来自 .py 文件的运行更快；.pyc 或 .pyo 文件只是在它们加载的时候更快一些。

  • 通过脚本名在命令行运行脚本时，不会将为该脚本创建的二进制代码写入 .pyc 或 .pyo 文件。当然，把脚本的主要代码移进一个模块里，然后用一个小的启动脚本导入这个模块，就可以提高脚本的启动速度。也可以直接在命令行中指定一个 .pyc 或 .pyo 文件。

  • 对于同一个模块(译者：这里指例程 spam.py)，可以只有 spam.pyc 文件(或者 spam.pyo，在使用 -O 参数时)而没有 spam.py 文件。这样可以打包发布比较难于逆向工程的 Python 代码库。

  • compileall 模块可以为指定目录中的所有模块创建 .pyc 文件(或者使用 -O 参数创建 .pyo 文件)。

6.2. 标准模块¶

Python 带有一个标准模块库，并发布有独立的文档，名为 Python 库参考手册(此后称其为“库参考手册”)。有一些模块内置于解释器之中，这些操作的访问接口不是语言内核的一部分，但是已经内置于解释器了。这既是为了提高效率，也是为了给系统调用等操作系统原生访问提供接口。这类模块集合是一个依赖于底层平台的配置选项。例如，winreg 模块只提供在 Windows 系统上才有。有一个具体的模块值得注意：sys，这个模块内置于所有的 Python 解释器。变量 sys.ps1 和 sys.ps2 定义了主提示符和辅助提示符字符串:

  1. >>> import sys
  2. >>> sys.ps1
  3. '>>> '
  4. >>> sys.ps2
  5. '... '
  6. >>> sys.ps1 = 'C> '
  7. C> print 'Yuck!'
  8. Yuck!
  9. C>

这两个变量只在解释器的交互模式下有意义。

变量 sys.path 是解释器模块搜索路径的字符串列表。它由环境变量 PYTHONPATH 初始化，如果没有设定 PYTHONPATH ，就由内置的默认值初始化。你可以用标准的列表操作修改它:

  1. >>> import sys
  2. >>> sys.path.append('/ufs/guido/lib/python')

6.3. dir() 函数¶

内置函数 dir() 用于按模块名搜索模块定义，它返回一个排好序的字符串类型的存储列表:

  1. >>> import fibo, sys
  2. >>> dir(fibo)
  3. ['__name__', 'fib', 'fib2']
  4. >>> dir(sys)  
  5. ['__displayhook__', '__doc__', '__excepthook__', '__name__', '__package__',
  6.  '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache',
  7.  '_current_frames', '_getframe', '_mercurial', 'api_version', 'argv',
  8.  'builtin_module_names', 'byteorder', 'call_tracing', 'callstats',
  9.  'copyright', 'displayhook', 'dont_write_bytecode', 'exc_clear', 'exc_info',
  10.  'exc_traceback', 'exc_type', 'exc_value', 'excepthook', 'exec_prefix',
  11.  'executable', 'exit', 'flags', 'float_info', 'float_repr_style',
  12.  'getcheckinterval', 'getdefaultencoding', 'getdlopenflags',
  13.  'getfilesystemencoding', 'getobjects', 'getprofile', 'getrecursionlimit',
  14.  'getrefcount', 'getsizeof', 'gettotalrefcount', 'gettrace', 'hexversion',
  15.  'long_info', 'maxint', 'maxsize', 'maxunicode', 'meta_path', 'modules',
  16.  'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix', 'ps1',
  17.  'py3kwarning', 'setcheckinterval', 'setdlopenflags', 'setprofile',
  18.  'setrecursionlimit', 'settrace', 'stderr', 'stdin', 'stdout', 'subversion',
  19.  'version', 'version_info', 'warnoptions']

无参数调用时，dir() 函数返回当前定义的命名列表:

  1. >>> a = [1, 2, 3, 4, 5]
  2. >>> import fibo
  3. >>> fib = fibo.fib
  4. >>> dir()
  5. ['__builtins__', '__doc__', '__file__', '__name__', 'a', 'fib', 'fibo', 'sys']

注意该列表列出了所有类型的名称：变量，模块，函数，等等。

dir() 不会列出内置函数和变量名。如果你想列出这些内容，它们在标准模块 builtin 中定义:

  1. >>> import __builtin__
  2. >>> dir(__builtin__)  
  3. ['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException',
  4.  'BufferError', 'BytesWarning', 'DeprecationWarning', 'EOFError',
  5.  'Ellipsis', 'EnvironmentError', 'Exception', 'False', 'FloatingPointError',
  6.  'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning',
  7.  'IndentationError', 'IndexError', 'KeyError', 'KeyboardInterrupt',
  8.  'LookupError', 'MemoryError', 'NameError', 'None', 'NotImplemented',
  9.  'NotImplementedError', 'OSError', 'OverflowError',
  10.  'PendingDeprecationWarning', 'ReferenceError', 'RuntimeError',
  11.  'RuntimeWarning', 'StandardError', 'StopIteration', 'SyntaxError',
  12.  'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'True',
  13.  'TypeError', 'UnboundLocalError', 'UnicodeDecodeError',
  14.  'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError',
  15.  'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning',
  16.  'ZeroDivisionError', '_', '__debug__', '__doc__', '__import__',
  17.  '__name__', '__package__', 'abs', 'all', 'any', 'apply', 'basestring',
  18.  'bin', 'bool', 'buffer', 'bytearray', 'bytes', 'callable', 'chr',
  19.  'classmethod', 'cmp', 'coerce', 'compile', 'complex', 'copyright',
  20.  'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval',
  21.  'execfile', 'exit', 'file', 'filter', 'float', 'format', 'frozenset',
  22.  'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input',
  23.  'int', 'intern', 'isinstance', 'issubclass', 'iter', 'len', 'license',
  24.  'list', 'locals', 'long', 'map', 'max', 'memoryview', 'min', 'next',
  25.  'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit',
  26.  'range', 'raw_input', 'reduce', 'reload', 'repr', 'reversed', 'round',
  27.  'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super',
  28.  'tuple', 'type', 'unichr', 'unicode', 'vars', 'xrange', 'zip']

6.4. 包¶

包通常是使用用“圆点模块名”的结构化模块命名空间。例如，名为 A.B 的模块表示了名为 A 的包中名为 B 的子模块。正如同用模块来保存不同的模块架构可以避免全局变量之间的相互冲突，使用圆点模块名保存像 NumPy 或 Python Imaging Library 之类的不同类库架构可以避免模块之间的命名冲突。

假设你现在想要设计一个模块集(一个“包”)来统一处理声音文件和声音数据。存在几种不同的声音格式(通常由它们的扩展名来标识，例如：.wav,.aiff, .au)，于是，为了在不同类型的文件格式之间转换，你需要维护一个不断增长的包集合。可能你还想要对声音数据做很多不同的操作(例如混音，添加回声，应用平衡功能，创建一个人造效果)，所以你要加入一个无限流模块来执行这些操作。你的包可能会是这个样子(通过分级的文件体系来进行分组)：

  1. sound/                          Top-level package
  2.       __init__.py               Initialize the sound package
  3.       formats/                  Subpackage for file format conversions
  4.               __init__.py
  5.               wavread.py
  6.               wavwrite.py
  7.               aiffread.py
  8.               aiffwrite.py
  9.               auread.py
  10.               auwrite.py
  11.               ...
  12.       effects/                  Subpackage for sound effects
  13.               __init__.py
  14.               echo.py
  15.               surround.py
  16.               reverse.py
  17.               ...
  18.       filters/                  Subpackage for filters
  19.               __init__.py
  20.               equalizer.py
  21.               vocoder.py
  22.               karaoke.py
  23.               ...

当导入这个包时，Python通过 sys.path 搜索路径查找包含这个包的子目录。

为了让 Python 将目录当做内容包，目录中必须包含 init.py 文件。这是为了避免一个含有烂俗名字的目录无意中隐藏了稍后在模块搜索路径中出现的有效模块，比如 string。最简单的情况下，只需要一个空的 init.py 文件即可。当然它也可以执行包的初始化代码，或者定义稍后介绍的 all 变量。

用户可以每次只导入包里的特定模块，例如:

  1. import sound.effects.echo

这样就导入了 sound.effects.echo 子模块。它必需通过完整的名称来引用:

  1. sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)

导入包时有一个可以选择的方式:

  1. from sound.effects import echo

这样就加载了 echo 子模块，并且使得它在没有包前缀的情况下也可以使用，所以它可以如下方式调用:

  1. echo.echofilter(input, output, delay=0.7, atten=4)

还有另一种变体用于直接导入函数或变量:

  1. from sound.effects.echo import echofilter

这样就又一次加载了 echo 子模块，但这样就可以直接调用它的 echofilter() 函数:

  1. echofilter(input, output, delay=0.7, atten=4)

需要注意的是使用 from package import item 方式导入包时，这个子项(item)既可以是包中的一个子模块(或一个子包)，也可以是包中定义的其它命名，像函数、类或变量。import 语句首先核对是否包中有这个子项，如果没有，它假定这是一个模块，并尝试加载它。如果没有找到它，会引发一个 ImportError 异常。

相反，使用类似 import item.subitem.subsubitem 这样的语法时，这些子项必须是包，最后的子项可以是包或模块，但不能是前面子项中定义的类、函数或变量。

6.4.1. 从 * 导入包¶

那么当用户写下 from sound.effects import * 时会发生什么事？理想中，总是希望在文件系统中找出包中所有的子模块，然后导入它们。这可能会花掉很长时间，并且出现期待之外的边界效应，导出了希望只能显式导入的包。

对于包的作者来说唯一的解决方案就是给提供一个明确的包索引。import 语句按如下条件进行转换：执行 from package import 时，如果包中的 init.py 代码定义了一个名为 all 的列表，就会按照列表中给出的模块名进行导入。新版本的包发布时作者可以任意更新这个列表。如果包作者不想 import 的时候导入他们的包中所有模块，那么也可能会决定不支持它(import *)。例如，sounds/effects/init.py 这个文件可能包括如下代码:

  1. __all__ = ["echo", "surround", "reverse"]

这意味着 from sound.effects import * 语句会从 sound 包中导入以上三个已命名的子模块。

如果没有定义 all，from sound.effects import * 语句 不会 从 sound.effects 包中导入所有的子模块。无论包中定义多少命名，只能确定的是导入了 sound.effects 包(可能会运行 init.py 中的初始化代码)以及包中定义的所有命名会随之导入。这样就从 init.py 中导入了每一个命名(以及明确导入的子模块)。同样也包括了前述的 import 语句从包中明确导入的子模块，考虑以下代码:

  1. import sound.effects.echo
  2. import sound.effects.surround
  3. from sound.effects import *

在这个例子中， echo 和 surround 模块导入了当前的命名空间，这是因为执行 from…import 语句时它们已经定义在 sound.effects 包中了(定义了 all 时也会同样工作)。

尽管某些模块设计为使用 import * 时它只导出符全某种模式的命名，仍然不建议在生产代码中使用这种写法。

记住，from Package import specific_submodule 没有错误！事实上，除非导入的模块需要使用其它包中的同名子模块，否则这是推荐的写法。

6.4.2. 包内引用¶

如果包中使用了子包结构(就像示例中的 sound 包)，可以按绝对位置从相邻的包中引入子模块。例如，如果 sound.filters.vocoder 包需要使用 sound.effects 包中的 echo 模块，它可以 from sound.effects import echo。

你可以用这样的形式 from module import name 来写显式的相对位置导入。那些显式相对导入用点号标明关联导入当前和上级包。以 surround 模块为例，你可以这样用:

  1. from . import echo
  2. from .. import formats
  3. from ..filters import equalizer

需要注意的是显式或隐式相对位置导入都基于当前模块的命名。因为主模块的名字总是 "main"，Python 应用程序的主模块应该总是用绝对导入。

6.4.3. 多重目录中的包¶

包支持一个更为特殊的特性，path。在包的 init.py 文件代码执行之前，该变量初始化一个目录名列表。该变量可以修改，它作用于包中的子包和模块的搜索功能。

这个功能可以用于扩展包中的模块集，不过它不常用。

Footnotes

|[1]|事实上函数定义既是“声明”又是“可执行体”；执行体由函数在模块全局语义表中的命名导入。

原文:

http://www.pythondoc.com/pythontutorial27/modules.html