6. 模块

退出 Python 解释器后，再次进入时，之前在 Python 解释器中定义的函数和变量就丢失了。因此，编写较长程序时，建议用文本编辑器代替解释器，执行文件中的输入内容，这就是编写 脚本 。随着程序越来越长，为了方便维护，最好把脚本拆分成多个文件。编写脚本还一个好处，不同程序调用同一个函数时，不用每次把函数复制到各个程序。

为实现这些需求，Python 把各种定义存入一个文件，在脚本或解释器的交互式实例中使用。这个文件就是 模块 ；模块中的定义可以 导入 到其他模块或 主 模块（在顶层和计算器模式下，执行脚本中可访问的变量集）。

模块是包含 Python 定义和语句的文件。其文件名是模块名加后缀名 .py 。在模块内部，通过全局变量 __name__ 可以获取模块名（即字符串）。例如，用文本编辑器在当前目录下创建 fibo.py 文件，输入以下内容：

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

现在，进入 Python 解释器，用以下命令导入该模块：

  1. >>> import fibo

这项操作不直接把 fibo 函数定义的名称导入到当前符号表，只导入模块名 fibo 。要使用模块名访问函数：

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

如果经常使用某个函数，可以把它赋值给局部变量：

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

6.1. 模块详解

模块包含可执行语句及函数定义。这些语句用于初始化模块，且仅在 import 语句 第一次 遇到模块名时执行。1 (文件作为脚本运行时，也会执行这些语句。)

模块有自己的私有符号表，用作模块中所有函数的全局符号表。因此，在模块内使用全局变量时，不用担心与用户定义的全局变量发生冲突。另一方面，可以用与访问模块函数一样的标记法，访问模块的全局变量，modname.itemname。

可以把其他模块导入模块。按惯例，所有 import 语句都放在模块（或脚本）开头，但这不是必须的。导入的模块名存在导入模块的全局符号表里。

import 语句有一个变体，可以直接把模块里的名称导入到另一个模块的符号表。例如：

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

这段代码不会把模块名导入到局部符号表里（因此，本例没有定义 fibo）。

还有一种变体可以导入模块内定义的所有名称：

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

这种方式会导入所有不以下划线（_）开头的名称。大多数情况下，不要用这个功能，这种方式向解释器导入了一批未知的名称，可能会覆盖已经定义的名称。

注意，一般情况下，不建议从模块或包内导入 *， 因为，这项操作经常让代码变得难以理解。不过，为了在交互式编译器中少打几个字，这么用也没问题。

模块名后使用 as 时，直接把 as 后的名称与导入模块绑定。

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

与 import fibo 一样，这种方式也可以有效地导入模块，唯一的区别是，导入的名称是 fib。

from 中也可以使用这种方式，效果类似：

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

注解

为了保证运行效率，每次解释器会话只导入一次模块。如果更改了模块内容，必须重启解释器；仅交互测试一个模块时，也可以使用 importlib.reload()，例如 import importlib; importlib.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. 0 1 1 2 3 5 8 13 21 34

导入模块时，不运行这些代码：

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

这种操作常用于为模块提供便捷用户接口，或用于测试（把模块当作执行测试套件的脚本运行）。

6.1.2. 模块搜索路径

导入 spam 模块时，解释器首先查找名为 spam 的内置模块。如果没找到，解释器再从 sys.path 变量中的目录列表里查找 spam.py 文件。sys.path 初始化时包含以下位置：

  • 输入脚本的目录（或未指定文件时的当前目录）。

  • PYTHONPATH （目录列表，与 shell 变量 PATH 的语法一样）。

  • 默认安装目录。

注解

在支持 symlink 的文件系统中，输入脚本目录是在追加 symlink 后计算出来的。换句话说，包含 symlink 的目录并 没有 添加至模块搜索路径。

初始化后，Python 程序可以更改 sys.path。运行脚本的目录在标准库路径之前，置于搜索路径的开头。即，加载的是该目录里的脚本，而不是标准库的同名模块。 除非刻意替换，否则会报错。详见 标准模块。

6.1.3. “已编译的” Python 文件

为了快速加载模块，Python 把模块的编译版缓存在 __pycache__ 目录中，文件名为 module.*version*.pyc，version 对编译文件格式进行编码，一般是 Python 的版本号。例如，CPython 的 3.3 发行版中，spam.py 的编译版本缓存为 __pycache__/spam.cpython-33.pyc。使用这种命名惯例，可以让不同 Python 发行版及不同版本的已编译模块共存。

Python 对比编译版本与源码的修改日期，查看它是否已过期，是否要重新编译，此过程完全自动化。此外，编译模块与平台无关，因此，可在不同架构系统之间共享相同的支持库。

Python 在两种情况下不检查缓存。其一，从命令行直接载入模块，只重新编译，不存储编译结果；其二，没有源模块，就不会检查缓存。为了支持无源文件（仅编译）发行版本， 编译模块必须在源目录下，并且绝不能有源模块。

给专业人士的一些小建议：

  • 在 Python 命令中使用 -O 或 -OO 开关，可以减小编译模块的大小。-O 去除断言语句，-OO 去除断言语句和 __doc__ 字符串。有些程序可能依赖于这些内容，因此，没有十足的把握，不要使用这两个选项。“优化过的”模块带有 opt- 标签，并且文件通常会一小些。将来的发行版或许会改进优化的效果。

  • 从 .pyc 文件读取的程序不比从 .py 读取的执行速度快，.pyc 文件只是加载速度更快。

  • compileall 模块可以为一个目录下的所有模块创建 .pyc 文件。

  • 本过程的细节及决策流程图，详见 PEP 3147。

6.2. 标准模块

Python 附带了标准模块库，详见 Python 标准库参考手册（以下简称为“库参考”）。解释器中内置了一些模块，用于访问不属于语言核心的内置操作，其目的主要是为了提高运行效率，或访问系统调用等操作系统原语。这些模块的集合是依赖于底层平台的配置选项。例如，winreg 模块仅供 Windows 使用。特别要注意内嵌到 Python 解释器中的模块 sys。变量 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. ['__breakpointhook__', '__displayhook__', '__doc__', '__excepthook__',
  6.  '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__',
  7.  '__stderr__', '__stdin__', '__stdout__', '__unraisablehook__',
  8.  '_clear_type_cache', '_current_frames', '_debugmallocstats', '_framework',
  9.  '_getframe', '_git', '_home', '_xoptions', 'abiflags', 'addaudithook',
  10.  'api_version', 'argv', 'audit', 'base_exec_prefix', 'base_prefix',
  11.  'breakpointhook', 'builtin_module_names', 'byteorder', 'call_tracing',
  12.  'callstats', 'copyright', 'displayhook', 'dont_write_bytecode', 'exc_info',
  13.  'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info',
  14.  'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_origin_tracking_depth',
  15.  'getallocatedblocks', 'getdefaultencoding', 'getdlopenflags',
  16.  'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile',
  17.  'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval',
  18.  'gettrace', 'hash_info', 'hexversion', 'implementation', 'int_info',
  19.  'intern', 'is_finalizing', 'last_traceback', 'last_type', 'last_value',
  20.  'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks',
  21.  'path_importer_cache', 'platform', 'prefix', 'ps1', 'ps2', 'pycache_prefix',
  22.  'set_asyncgen_hooks', 'set_coroutine_origin_tracking_depth', 'setdlopenflags',
  23.  'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr',
  24.  'stdin', 'stdout', 'thread_info', 'unraisablehook', 'version', 'version_info',
  25.  'warnoptions']

没有参数时，dir() 列出当前定义的名称：

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

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

dir() 不会列出内置函数和变量的名称。这些内容的定义在标准模块 builtins 里：

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

6.4. 包

包是一种用“点式模块名”构造 Python 模块命名空间的方法。例如，模块名 A.B 表示包 A 中名为 B 的子模块。正如模块可以区分不同模块之间的全局变量名称一样，点式模块名可以区分 NumPy 或 Pillow 等不同多模块包之间的模块名称。

假设要为统一处理声音文件与声音数据设计一个模块集（“包”）。声音文件的格式很多（通常以扩展名来识别，例如：.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)

Import 语句的另一种变体是直接导入所需的函数或变量：

  1. from sound.effects.echo import echofilter

同样，这样也会加载子模块 echo，但可以直接使用函数 echofilter()：

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

注意，使用 from package import item 时，item 可以是包的子模块（或子包），也可以是包中定义的函数、类或变量等其他名称。import 语句首先测试包中是否定义了 item；如果未在包中定义，则假定 item 是模块，并尝试加载。如果找不到 item，则触发 ImportError 异常。

相反，使用 import item.subitem.subsubitem 句法时，除最后一项外，每个 item 都必须是包；最后一项可以是模块或包，但不能是上一项中定义的类、函数或变量。

6.4.1. 从包中导入 *

使用 from sound.effects import * 时会发生什么？理想情况下，该语句在文件系统查找并导入包的所有子模块。这项操作花费的时间较长，并且导入子模块可能会产生不必要的副作用，这种副作用只有在显式导入子模块时才会发生。

唯一的解决方案是提供包的显式索引。import 语句使用如下惯例：如果包的 __init__.py 代码定义了列表 __all__，运行 from package import * 时，它就是用于导入的模块名列表。发布包的新版本时，包的作者应更新此列表。如果包的作者认为没有必要在包中执行导入 * 操作，也可以不提供此列表。例如，sound/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 *

本例中，执行 from...import 语句时，将把 echo 和 surround 模块导入至当前命名空间，因为，它们是在 sound.effects 包里定义的。（该导入操作在定义了 __all__ 时也有效。）

虽然，可以把模块设计为用 import * 时只导出遵循指定模式的名称，但仍不提倡在生产代码中使用这种做法。

记住，使用 from package import specific_submodule 没有任何问题！ 实际上，除了导入模块使用不同包的同名子模块之外，这种方式是推荐用法。

6.4.2. 子包参考

包中含有多个子包时（与示例中的 sound 包一样），可以使用绝对导入引用兄弟包中的子模块。例如，要在模块 sound.filters.vocoder 中使用 sound.effects 包的 echo 模块时，可以用 from sound.effects import echo 导入。

还可以用 import 语句的 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 文件中的代码执行前所在的目录名列表。这个变量可以修改，但这样做会影响将来搜索包中模块和子包的操作。

这个功能虽然不常用，但可用于扩展包中的模块集。

脚注

1

实际上，函数定义也是“可执行”的“语句”；执行模块级函数定义时，函数名将被导入到模块的全局符号表。