每天一小时python官方文档学习（七）————模块与包

6. 模块

模块是一个包含Python定义和语句的文件，实际上就是一个正常的.py文件。但是作用和普通需要运行的程序不一样，它实际上有点像函数。如果说函数实现了代码的重用，模块则是实现了函数的重用。我们如果想在不同的程序中使用同一个函数， 不必把这个函数复制到每一个程序中去，而是通过把函数写在一个模块中，然后程序通过导入模块就可以使用这个函数了。

模块文件名就是模块名后跟文件后缀 .py 。在一个模块内部，模块名（作为一个字符串）可以通过全局变量 __name__ 的值获得。例如，你可以在当前目录下创建一个名为 fibo.py 的文件，模块名即为fibo，而文件中含有以下内容：

# 斐波拉契数列模块

def fib(n):    # 打印斐波拉契数列
    a, b = 0, 1
    while a < n:
        print(a, end=' ')
        a, b = b, a+b
    print()

def fib2(n):   # 返回斐波拉契数列的列表
    result = []
    a, b = 0, 1
    while a < n:
        result.append(a)
        a, b = b, a+b
    return result

这个fibo.py文件就是所谓的模块文件，它里面就是两个函数，一个负责打印斐波拉契数列，另一个负责返回斐波拉契数列的列表。我们通过在Python解释器中输入import指令即可导入这个模块：

>>> import fibo

在当前的符号表中，这并不会直接进入到定义在 fibo 函数内的名称；它只是进入到模块名 fibo 中。你可以用模块名访问这些函数：

>>> fibo.fib(1000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__    #查看全局变量__name__，即显示模块名
'fibo'

除了直接访问和调用，把模块中函数赋值给一个局部变量也是可以的：

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

6.1. 有关模块的更多信息

我们都知道，模块可以包含可执行的语句以及函数定义。这些语句通常是用于初始化模块的，它们仅在模块第一次在 import 语句中被导入时才执行（实际上，函数定义也是“被执行”的“语句”，模块级函数定义的执行在模块的全局符号表中输入该函数名）。

每个模块都有它自己的私有符号表，该表用作模块中定义的所有函数的全局符号表。因此，模块的作者可以在模块内使用全局变量，而不必担心与用户的全局变量发生意外冲突。

import 语句有一个变体，它可以把名字从（from）一个被调模块内直接导入（import）到现模块的符号表里。例如：

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

这并不会把被调模块名引入到局部变量表里，因此在这个例子里，fibo 是未被定义的，fibo里面只有fib被导入了，fib2未被导入。如果想导入模块内定义的所有名称：

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

这会调入所有不以下划线_开头的名称。 在多数情况下，Python程序员都不会使用这个功能，因为它在解释器中引入了一组未知的名称，而它们很可能会覆盖一些你已经定义过的东西。注意通常情况下从一个模块或者包内调入 * 的做法是不太被接受的， 因为这通常会导致代码的可读性很差。不过，在交互式编译器中为了节省打字可以这么用。

最后，我们可以在模块名称后面加上 as，则跟在 as 之后的名称将直接绑定到所导入的模块，这通常用于给模块名提供一个缩写，则调用模块函数时不用写那么多字，例如import tensorflow as tf、import numpy as np等等。

6.1.1. 以脚本的方式执行模块

模块文件既然是.py文件，那当然也可以直接执行它，在Python解释器中输入：

>>> python fibo.py # 如果有参数则写在这里

模块里的代码会被执行。那直接执行和导入模块有什么区别呢？

区别就在于 __name__ 的值会不一样。上面我们看到，导入模块后，通过fibo.__name__我们能看到__name__的值为’fibo’即模块名；但是直接执行以后，__name__会被赋值为 "__main__"。 因此，我们可以通过条件判断语句，规定一些语句时只有直接执行模块时才有效的：

if __name__ == "__main__":
		# 直接执行模块时才会运行的语句，导入模块时不运行

6.1.2. 模块搜索路径

当一个模块被导入时，解释器会怎么样在电脑中寻找这个模块文件呢？
解释器首先寻找具有该名称的内置模块。如果没有找到，然后解释器从 sys.path 变量给出的目录列表里寻找文件。sys.path 初始有这些目录地址:

• 包含输入脚本的目录（或者未指定文件时的当前目录）
• PYTHONPATH （一个包含目录名称的列表，它和shell变量 PATH有一样的语法）
• 取决于安装的默认设置

6.1.3. “编译过的”Python文件

为了加速模块载入，Python在 __pycache__ 目录里缓存了每个模块的编译后版本，名称为 module.version.pyc ，其中名称中的版本字段对编译文件的格式进行编码，它一般使用Python版本号。

6.2. 标准模块

Python附带了一个标准模块库，这些模块内置于解释器中，它们提供对不属于语言核心但仍然内置的操作的访问，以提高效率或提供对系统调用等操作系统原语的访问。标准库也是属于不要求全部记住，但是常用的应该有印象的知识，建议多查阅官方文档

这些模块的集合是一个配置选项，它也取决于底层平台。例如，winreg 模块只在Windows操作系统上提供。一个特别值得注意的模块 sys，它被内嵌到每一个Python解释器中。变量 sys.ps1 和 sys.ps2 定义用作主要和辅助提示的字符串，这两个变量只有在编译器是交互模式下才被定义，例如：

>>> import sys
>>> sys.ps1
'>>> '
>>> sys.ps2
'... '
>>> sys.ps1 = 'C> '
C> print('Yuck!')
Yuck!
C>

6.3. dir() 函数

内置函数 dir() 用于查找模块定义的名称，它返回一个排序过的字符串列表，这个列表就包括所有类型的名称：变量，模块，函数，等等：

>>> import fibo, sys   # 先导入fibo和sys模块
>>> dir(fibo)   # 查找fibo模块
['__name__', 'fib', 'fib2']
>>> dir(sys)    # 查找sys模块
['__displayhook__', '__doc__', '__excepthook__', '__loader__', '__name__',
 '__package__', '__stderr__', '__stdin__', '__stdout__',
 '_clear_type_cache', '_current_frames', '_debugmallocstats', '_getframe',
 '_home', '_mercurial', '_xoptions', 'abiflags', 'api_version', 'argv',
 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder',
 'call_tracing', 'callstats', 'copyright', 'displayhook',
 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix',
 'executable', 'exit', 'flags', 'float_info', 'float_repr_style',
 'getcheckinterval', 'getdefaultencoding', 'getdlopenflags',
 'getfilesystemencoding', 'getobjects', 'getprofile', 'getrecursionlimit',
 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettotalrefcount',
 'gettrace', 'hash_info', 'hexversion', 'implementation', 'int_info',
 'intern', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path',
 'path_hooks', 'path_importer_cache', 'platform', 'prefix', 'ps1',
 'setcheckinterval', 'setdlopenflags', 'setprofile', 'setrecursionlimit',
 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout',
 'thread_info', 'version', 'version_info', 'warnoptions']

如果没有参数，dir() 会列出你当前定义的名称：

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

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

6.4. 包

包是一种通过用“带点号的模块名”来构造 Python 模块命名空间的方法，简单来说，包就是模块的集合。例如，模块名 A.B 表示 A 包中名为 B 的子模块。正如模块的使用使得不同模块的作者不必担心彼此的全局变量名称一样，使用加点的模块名可以使得 NumPy 或 Pillow 等多模块软件包的作者不必担心彼此的模块名称一样。

假设有这么一个包的文件，它有三个子包，每个子包里面有各自的模块：

sound/                          包含三个子包的包
      __init__.py               对sound初始化的模块
      formats/                  用于文件格式转换的子包
              __init__.py		对formats初始化的模块
              wavread.py
              wavwrite.py
              aiffread.py
              aiffwrite.py
              auread.py
              auwrite.py
              ...
      effects/                  包含不同音效的子包
              __init__.py		对effects初始化的模块
              echo.py
              surround.py
              reverse.py
              ...
      filters/                  用于声音滤波的子包
              __init__.py		对filters初始化的模块
              equalizer.py
              vocoder.py
              karaoke.py
              ...

我们可以从包中导入单个模块，例如：

import sound.effects.echo

这会加载子模块 sound.effects.echo ，但引用它时必须使用它的全名：

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

也可以直接导入子模块：

from sound.effects import echo

这会加载子模块 echo ，并使其在没有包前缀的情况下可用，因此可以不使用全名：

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

甚至还可以直接导入所需的函数或变量：

from sound.effects.echo import echofilter

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

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