模块是一个包含Python定义和语句的文件。文件名就是模块名后跟文件后缀 .py 。在一个模块内部，模块名（作为一个字符串）可以通过全局变量 __name__ 的值获得。

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

一.有关模块的更多信息

  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
  1. >>> from fibo import *
  2. >>> fib(500)
  3. 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
  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
  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

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

当你用下面方式运行一个Python模块:

  1. python fibo.py <arguments>

模块里的代码会被执行，就好像你导入了模块一样，但是 __name__ 被赋值为 "__main__"。 这意味着通过在你的模块末尾添加这些代码:

  1. if __name__ == "__main__":
  2.     import sys
  3.     fib(int(sys.argv[1]))
  1. $ python fibo.py 50
  2. 0 1 1 2 3 5 8 13 21 34
  1. >>> import fibo
  2. >>>

所以，if __name__ == '__main__'的意思是：当 .py 文件被直接运行时，if __name__ == '__main__'之下的代码块将被运行；当 .py 文件以模块形式被导入时，if __name__ == '__main__'之下的代码块不被运行。

2.模块搜索路径

当一个名为 spam 的模块被导入的时候，解释器首先寻找具有该名称的内置模块。如果没有找到，然后解释器从 sys.path 变量给出的目录列表里寻找名为 spam.py 的文件。sys.path 初始有这些目录地址:

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

    二.标准模块

    Python附带了一个标准模块库，在单独的文档Python库参考（以下称为“库参考”）中进行了描述。一些模块内置于解释器中；它们提供对不属于语言核心但仍然内置的操作的访问，以提高效率或提供对系统调用等操作系统原语的访问。这些模块的集合是一个配置选项，它也取决于底层平台。
    **一个特别值得注意的模块 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>

三.dir（）函数

内置函数 dir() 用于查找模块定义的名称。 它返回一个排序过的字符串列表:

  1. >>> import fibo, sys
  2. >>> dir(fibo)
  3. ['__name__', 'fib', 'fib2']
  4. >>> dir(sys)  
  5. ['__displayhook__', '__doc__', '__excepthook__', '__loader__', '__name__',
  6.  '__package__', '__stderr__', '__stdin__', '__stdout__',
  7.  '_clear_type_cache', '_current_frames', '_debugmallocstats', '_getframe',
  8.  '_home', '_mercurial', '_xoptions', 'abiflags', 'api_version', 'argv',
  9.  'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder',
  10.  'call_tracing', 'callstats', 'copyright', 'displayhook',
  11.  'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix',
  12.  'executable', 'exit', 'flags', 'float_info', 'float_repr_style',
  13.  'getcheckinterval', 'getdefaultencoding', 'getdlopenflags',
  14.  'getfilesystemencoding', 'getobjects', 'getprofile', 'getrecursionlimit',
  15.  'getrefcount', 'getsizeof', 'getswitchinterval', 'gettotalrefcount',
  16.  'gettrace', 'hash_info', 'hexversion', 'implementation', 'int_info',
  17.  'intern', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path',
  18.  'path_hooks', 'path_importer_cache', 'platform', 'prefix', 'ps1',
  19.  'setcheckinterval', 'setdlopenflags', 'setprofile', 'setrecursionlimit',
  20.  'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout',
  21.  'thread_info', 'version', 'version_info', '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 中:

四.包

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

  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 里的目录，查找包的子目录。
必须要有 __init__.py 文件才能让 Python 将包含该文件的目录当作包。 这样可以防止具有通常名称例如 string 的目录在无意中隐藏稍后在模块搜索路径上出现的有效模块。
**包的用户可以从包中导入单个模块，例如:

  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 语句首先测试是否在包中定义了item；如果没有，它假定它是一个模块并尝试加载它。如果找不到它，则引发 ImportError 异常。相反，当使用 import item.subitem.subsubitem 这样的语法时，除了最后一项之外的每一项都必须是一个包；最后一项可以是模块或包，但不能是前一项中定义的类或函数或变量。

1.从包中导入*

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 *

在这个例子中， echo 和 surround 模块是在执行 from...import 语句时导入到当前命名空间中的，因为它们定义在 sound.effects 包中。（这在定义了 __all__ 时也有效。）
**