6. Modules

# Fibonacci numbers module

def fib(n):    # write Fibonacci series up to n
    a, b = 0, 1
    while b < n:
        print(b, end=' ')
        a, b = b, a+b
    print()

def fib2(n):   # return Fibonacci series up to n
    result = []
    a, b = 0, 1
    while b < n:
        result.append(b)
        a, b = b, a+b
    return result

>>> import fibo

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

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

注意

出于性能考虑，每个模块在每个解释器会话中只导入一遍。因此, 如果你更改了你的模块,你必须重启解释器 – 或者, 如果你想用交互的方式测试你的模块, 可以使用importlib.reload(), e.g.import importlib; importlib.reload(modulename).

6.1.1. Executing modules as scripts

当你用下列的方式运行一个 Python 模块

python fibo.py <arguments>

the code in the module will be executed, just as if you imported it, but with the __name__ set to "__main__". 这意味着，通过在你的模块末尾添加此代码︰

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

就可以让此文件既可以作为可执行的脚本，也可以当作可以导入的模块，因为解析命令行的那部分代码只有在模块作为 “main” 文件执行时才被调用：

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

如果模块是被导入的，将不会运行这段代码：

>>> import fibo
>>>

这种方法通常用来为模块提供一个方便的用户接口，或者用来测试（例如直接运行脚本会执行一组测试用例）。

6.1.2. The Module Search Path

当一个叫spam 的模块被导入, 解释器会先在内置模块中搜索该模块.If not found, it then searches for a file named spam.py in a list of directories given by the variable sys.path.sys.path is initialized from these locations:

• 脚本所在的目录（如果没有指明文件，则为当前目录）。
• PYTHONPATH (a list of directory names, with the same syntax as the shell variable PATH).
• 与安装相关的默认值。

After initialization, Python programs can modify sys.path. 脚本所在的目录被放置在搜索路径的最开始，也就是在标准库的路径之前。这意味着将会加载当前目录中的脚本，库目录中具有相同名称的模块不会被加载。除非你是有意想替换标准库，否则这应该被当成是一个错误。See section Standard Modules for more information.

6.1.3. “Compiled” Python files

To speed up loading modules, Python caches the compiled version of each module in the __pycache__ directory under the name module.version.pyc, where the version encodes the format of the compiled file; it generally contains the Python version number. For example, in CPython release 3.3 the compiled version of spam.py would be cached as __pycache__/spam.cpython-33.pyc. 这种命名约定允许由不同发布和不同版本的Python编译的模块同时存在。

Python checks the modification date of the source against the compiled version to see if it’s out of date and needs to be recompiled. 这是完全自动化的过程。同时，编译后的模块是跨平台的，所以同一个库可以在不同架构的系统之间共享。

Python 在两种情况下不检查缓存。First, it always recompiles and does not store the result for the module that’s loaded directly from the command line. 第二，如果没有源模块它不会检查缓存。若要支持没有源文件（只有编译版）的发布，编译后的模块必须在源目录下，并且必须没有源文件的模块。

部分高级技巧：

• You can use the -O or -OO switches on the Python command to reduce the size of a compiled module. The -O switch removes assert statements, the -OO switch removes both assert statements and __doc__ strings. 因为某些程序可能会依赖于具有这些可用，您应只使用此选项，如果你知道你在做什么。“Optimized” modules have an opt-tag and are usually smaller. Future releases may change the effects of optimization.
• A program doesn’t run any faster when it is read from a .pyc file than when it is read from a .py file; the only thing that’s faster about .pyc files is the speed with which they are loaded.
• The module compileall can create .pyc files for all modules in a directory.
• There is more detail on this process, including a flow chart of the decisions, in PEP 3147.

6.4.1. Importing * From a Package

当用户输入 from sound.effects import *时会发生什么?理想情况下，他应该是希望到文件系统中寻找包里面有哪些子模块，并把它们全部导入进来。这可能需要很长时间，而且导入子模块可能会产生想不到的副作用，这些作用本应该只有当子模块是显式导入时才会发生。

唯一的解决办法是包的作者为包提供显式的索引。The import statement uses the following convention: if a package’s __init__.py code defines a list named __all__, it is taken to be the list of module names that should be imported when from package import * is encountered. 当包有新版本包发布时，就需要包的作者更新这个列表了。如果包的作者认为不可以用 import * 方式导入它们的包，也可以决定不支持它。For example, the file sound/effects/__init__.py could contain the following code:

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

This would mean that from sound.effects import * would import the three named submodules of the sound package.

If __all__ is not defined, the statement from sound.effects import * does not import all submodules from the package sound.effects into the current namespace; it only ensures that the package sound.effects has been imported (possibly running any initialization code in __init__.py) and then imports whatever names are defined in the package. This includes any names defined (and submodules explicitly loaded) by __init__.py. It also includes any submodules of the package that were explicitly loaded by previous import statements. 请考虑此代码：

import sound.effects.echo
import sound.effects.surround
from sound.effects import *

In this example, the echo and surround modules are imported in the current namespace because they are defined in the sound.effects package when the from...importstatement is executed. (This also works when __all__ is defined.)

Although certain modules are designed to export only names that follow certain patterns when you use import *, it is still considered bad practise in production code.

Remember, there is nothing wrong with using from Package import specific_submodule! 事实上，这是推荐的写法，除非导入的模块需要使用其它包中的同名子模块。

6.4.2. Intra-package References

When packages are structured into subpackages (as with the sound package in the example), you can use absolute imports to refer to submodules of siblings packages. For example, if the module sound.filters.vocoder needs to use the echo module in the sound.effects package, it can use from sound.effects import echo.

You can also write relative imports, with the from module import name form of import statement. 这些导入使用前导的点号表示相对导入的是从当前包还是上级的包。From thesurround module for example, you might use:

from . import echo
from .. import formats
from ..filters import equalizer

注意，相对导入基于当前模块的名称。Since the name of the main module is always "__main__", modules intended for use as the main module of a Python application must always use absolute imports.

6.4.3. Packages in Multiple Directories

Packages support one more special attribute, __path__. This is initialized to be a list containing the name of the directory holding the package’s __init__.py before the code in that file is executed. This variable can be modified; doing so affects future searches for modules and subpackages contained in the package.

虽然通常不需要此功能，它可以用于扩展包中的模块的集合。

脚注