Python3 模块

模块

• Python3 模块简介
• import 语句
• from…import 语句
• from…import* 语句
• name属性
• dir() 函数
• 标准模块
• 包
• 从一个包中导入*

Python3 模块简介

模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py。模块可以被别的程序引入，以使用该模块中的函数等功能。这也是使用 python 标准库的方法，我们可以把写好的一些可复用的函数，封装成模块然后发布到Python的本地库中。然后在其他的程序就可以导入你这个写好的模块了。简单来说模块就像一个常用的零件，例如组装一个高达模型时，可以把现成的零件拿过来使用，加快我们的组装速度，如果零件都需要我们自己制作就会慢很多而且难度也大。而标准库中的模块就是Python自带的零件，提供我们去使用，我们也可以开发自己的模块，自己开发的模块发布到本地后，一样可以像标准库中的模块去使用它们。 下面是一个使用 python 标准库中模块的例子。

import sys  # 导入模块的关键字是import，这里导入了sys模块

print("命令行参数如下:")
for i in sys.argv:  # 通过模块可以调用它里面的变量或者函数
    print(i)

print("nnPython路径为：")
for path in sys.path:
    print(path)

运行结果：

 命令行参数如下:  E:/PythonProject/TestMould.py Python路径为：  E:PythonProject  E:PythonProject  E:Python3.6python36.zip  E:Python3.6DLLs  E:Python3.6lib  E:Python3.6  E:Python3.6libsite-packages

1、import sys 引入 python 标准库中的 sys.py 模块；这是引入某一模块的方法。 2、sys.argv 是一个包含命令行参数的列表。 3、sys.path 包含了一个 Python 解释器自动查找所需模块的路径的列表。

import 语句

import 语句用来导入Python库中的模块，模块需要导入之后才能使用，语法如下：

import module1[, module2[,… moduleN]

当解释器遇到 import 语句，如果模块在当前的搜索路径就会被导入。搜索路径是一个解释器会事先进行搜索的所有目录的列表。 例如：我们在PyCharm工具中创建一个model.py文件，这个文件就相当于是一个模块了，接着可以在文件里自定义一个函数

然后再创建一个Hello.py文件，在这个文件中可以通过import导入这个模块，通过这个导入的模块就可以调用此模块里面的函数：

# Filename: Hello.py

# 导入模块
import model

# 现在可以调用模块里包含的函数了
model.println()

运行结果：

Test!

如果你打算经常使用一个函数，你可以把它赋值给一个变量：

import model

println=model.println
println()

运行结果：

Test!

以上示例属于是一个自定义模块的创建和导入过程。

一个模块只会被导入一次，不管你执行了多少次import语句，所以这样可以防止导入模块被一遍又一遍地执行。 当我们使用import语句的时候，Python解释器是怎样找到对应的文件的呢？ 这就涉及到了Python的搜索路径：

• 搜索路径是由一系列目录名组成的
• Python解释器就依次从这些目录中去寻找所引入的模块。
• 搜索路径是在Python编译或安装的时候确定的，安装新的库应该也会修改。
• 搜索路径被存储在sys模块中的path变量

这看起来很像环境变量，事实上，也可以通过定义环境变量的方式来确定搜索路径。 可以做一个简单的实验来查看Python的搜索路径，代码示例：

import sys

print(sys.path) # 将目录列表打印出来

运行结果：

[‘E:PythonProject’, ‘E:PythonProject’, ‘E:Python3.6python36.zip’, ‘E:Python3.6DLLs’, ‘E:Python3.6lib’, ‘E:Python3.6’, ‘E:Python3.6libsite-packages’]

sys.path 返回的是一个列表，其中第一项，代表当前目录（如果从解释器中执行的话，会是一个空字符串），也就是这个.py文件的所在路径。

from…import 语句

Python的from语句可以让你从模块中导入指定的函数或变量到当前的脚本中，语法如下：

from modname import name1[, name2[, … nameN]]

例如，要导入 model模块的 println函数，代码示例：

from model import println

println()

这个声明不会把整个model模块导入到当前的脚本中，它只会将model里的println函数引入进来，然后我们就可以直接对这个函数进行调用了。 如果要导入多个函数或者变量的话，需要使用逗号隔开。

from…import* 语句

把一个模块的所有内容全都导入到当前的脚本中是可行的，只需使用如下声明：

from modname import *

这提供了一个简单的方法来导入一个模块中的所有项目。然而这种声明不该被过多地使用。

name属性

每一个模块或者说脚本文件都会有一个主程序或者说代码的执行起点，类似于Java、C/C++、C#中的main方法，当脚本运行时，这个主程序就会被执行。这个主程序在执行时会被分配一个名字，但是这个名字并非是固定的，例如：在作为一个脚本被执行时，这个主程序的名字为_main_，在另一个脚本被做为一个导入的模块执行时，这个主程序的名字就为模块的名称。而相对的每一个脚本都有一个自己的_name_属性，这个属性的值对应着当前主程序的名称，下面用实际例子演示一下：

#filename：TestMould.py

if __name__ == '__main__':  # 作为一个脚本执行时主程序的名称为__main__
    print(__name__)
    print("我被作为当前脚本运行")
else:
    print(__name__)
    print("我被作为另一个脚本中的一个模块运行")

运行结果：

 _main_  程序自身在运行

如果在另一个脚本中被当做一个模块执行时，_name_ 属性的值就不会为_main_：

#filename：Hello.py

import TestMould  # 被作为另一个脚本的导入模块执行时，主程序的名称为模块的名称

运行结果：

 TestMould  我被作为另一个脚本中的一个模块运行

说明： 每个模块（脚本）都有一个_name_属性，当其值是’_main_’时，表明该模块自身在运行也就是作为脚本在运行，否则就是被作为引入模块在运行。而不管是作为脚本执行还是作为引入模块执行，主程序都会被执行，只不过名称不一样罢了。

dir() 函数

dir()是一个内置的函数（BIF），这个函数可以找到导入的模块内定义的所有函数和属性、变量的名称。然后以一个字符串列表的形式返回:

>>> import sys
>>> dir(sys)
['__displayhook__', '__doc__', '__excepthook__', '__name__', '__package__', '__stderr__', '__stdin
__', '__stdout__', '_clear_type_cache', '_current_frames', '_getframe', '_mercurial', 'api_version
', 'argv', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats', 'copyright', 'displa
yhook', 'dllhandle', 'dont_write_bytecode', 'exc_clear', 'exc_info', 'exc_type', 'excepthook', 'e
xec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'getcheckinterval',
 'getdefaultencoding', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 
 'getsizeof', 'gettrace', 'getwindowsversion', 'hexversion', 'long_info', 'maxint', 'maxsize', '
 maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', '
 prefix', 'ps1', 'ps2', 'py3kwarning', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 's
 ettrace', 'stderr', 'stdin', 'stdout', 'subversion', 'version', 'version_info', 'warnoptions',
  'winver']
>>>

如果dir函数中不传递参数，那么 dir() 函数会罗列出当前脚本中定义的所有函数、模块、变量、属性的名称：

>>> import sys
>>> def test():
...     print("test")
... 
>>> a=123
>>> dir()
['__builtins__', '__doc__', '__name__', '__package__', 'a', 'sys', 'test']
>>>

标准模块

Python 本身带着一些标准的模块库，之前也提到过，具体的标准模块会在一篇单独的文章中介绍一些常用的（因为太多了）。 有些模块直接被构建在解析器里，这些虽然不是一些语言内置的功能，但是他却能很高效的使用，甚至是系统级调用也没问题。 这些组件会根据不同的操作系统进行不同形式的配置，比如 winreg 这个模块就只会提供给 Windows 系统。 应该注意到这有一个特别的模块 sys，sys是System（系统）的缩写 ，它内置在每一个 Python 解析器中。变量 sys.ps1 和 sys.ps2 定义了主提示符和副提示符所对应的字符串：

>>> import sys
>>> sys.ps1  # 解释器中的主提示符
'>>> '
>>> sys.ps2  # 解释器中的副提示符（当我们写一个函数时就会显示这个副提示符）
'... '
>>> sys.ps1 = 'C> '  # 把解释器中的主提示符更改为'C> '
C> print('Yuck!')
Yuck!
C>

包

包是一种管理 Python 模块命名空间的形式，类似于一个文件夹，而这个文件夹下会有很多子文件，这些子文件就是一个个的模块。当我们需要使用一个包下的某个模块时，和其他编程语言一样需要使用 . 来作为访问符。 比如一个模块的名称是 A.B， 那么他表示一个包 A中的子模块 B 。 就好像使用模块的时候，你不用担心不同模块之间的全局变量相互影响一样，采用点模块名称这种形式也不用担心不同库之间的模块重名的情况。 这样不同的作者都可以提供 NumPy 模块，或者是 Python 图形库。 不妨假设你想设计一套统一处理声音文件和数据的模块（或者称之为一个”包”）。 现存很多种不同的音频文件格式（基本上都是通过后缀名区分的，例如： .wav，:file:.aiff，:file:.au，），所以你需要有一组不断增加的模块，用来在不同的格式之间转换。 并且针对这些音频数据，还有很多不同的操作（比如混音，添加回声，增加均衡器功能，创建人造立体声效果），所你还需要一组怎么也写不完的模块来处理这些操作。 这里给出了一种可能的包结构（在分层的文件系统中）:

1.sound/                          顶层包
2.      __init__.py               初始化 sound 包
3.      formats/                  文件格式转换子包
4.              __init__.py
5.              wavread.py
6.              wavwrite.py
7.              aiffread.py
8.              aiffwrite.py
9.              auread.py
10.              auwrite.py
11.              ...
12.      effects/                  声音效果子包
13.              __init__.py
14.              echo.py
15.              surround.py
16.              reverse.py
17.              ...
18.      filters/                  filters 子包
19.              __init__.py
20.              equalizer.py
21.              vocoder.py
22.              karaoke.py
23.              ...

在导入一个包的时候，Python 会根据 sys.path 中的目录来寻找这个包中包含的子目录。 目录只有包含一个叫做 init.py 的文件才会被认作是一个包，主要是为了避免一些滥俗的名字（比如叫做 string）不小心的影响搜索路径中的有效模块。 最简单的情况，放一个空的_init_.py文件就可以了。当然这个文件中也可以包含一些初始化代码或者为（将在后面介绍的） _all_变量赋值。 用户可以每次只导入一个包里面的特定模块，示例：

import sound.effects.echo    # 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)

注意当使用from package import item这种形式的时候，对应的item既可以是包里面的子模块（子包），或者包里面定义的其他名称，比如函数，类或者变量。 import语法会首先把item当作一个包定义的名称，如果没找到，再试图按照一个模块去导入。如果还没找到，恭喜一个：ImportError 异常被抛出了。 反之，如果使用形如import item.subitem.subsubitem这种导入形式，除了最后一项，都必须是包，而最后一项则可以是模块或者是包，但是不可以是类，函数或者变量的名字。

从一个包中导入：*

设想一下，如果我们使用 from sound.effects import * 会发生什么？ Python 会进入文件系统，找到这个包里面所有的子模块，一个一个的把它们都导入进来。 但是很不幸，这个方法在 Windows平台上工作的就不是非常好，因为Windows是一个大小写不区分的系统。 在这类平台上，没有人敢担保一个叫做 ECHO.py 的文件导入为模块 echo 还是 Echo 甚至 ECHO。 （例如，Windows 95就很讨厌的把每一个文件的首字母大写显示）而且 DOS 的 8+3 命名规则对长模块名称的处理会把问题搞得更纠结。 为了解决这个问题，只能烦劳包作者提供一个精确的包的索引了。 导入语句遵循如下规则：如果包定义文件 _init_.py 存在一个叫做 _all_ 的列表变量，那么在使用 from package import * 的时候就把这个列表中的所有名字作为包内容导入。 作为包的作者，可别忘了在更新包之后保证 _all_ 也更新了啊。你说我就不这么做，我就不使用导入*这种用法，好吧，没问题，谁让你是老板呢。这里有一个例子，在 sounds/effects/_init_.py中包含如下代码:

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

这表示当你使用from sound.effects import *这种用法时，你只会导入包里面这三个子模块。 如果 _all_ 真的没有定义，那么使用from sound.effects import *这种语法的时候，就不会导入包 sound.effects 里的任何子模块。他只是把包sound.effects和它里面定义的所有内容导入进来（可能运行_init_.py里定义的初始化代码）。 这会把 _init_.py 里面定义的所有名字导入进来。并且他不会破坏掉我们在这句话之前导入的所有明确指定的模块。看下这部分代码：

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

这个例子中，在执行from…import前，包sound.effects中的echo和surround模块都被导入到当前的命名空间中了。（当然如果定义了_all_就更没问题了） 通常我们并不主张使用*这种方法来导入模块，因为这种方法经常会导致代码的可读性降低。不过这样倒的确是可以省去不少敲键的功夫，而且一些模块都设计成了只能通过特定的方法导入。 记住，使用from Package import specific_submodule这种方法永远不会有错。事实上，这也是推荐的方法。除非是你要导入的子模块有可能和其他包的子模块重名。 如果在结构中包是一个子包（比如这个例子中对于包sound来说），而你又想导入兄弟包（同级别的包）你就得使用导入绝对的路径来导入。比如，如果模块sound.filters.vocoder 要使用包sound.effects中的模块echo，你就要写成 from sound.effects import echo。

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

无论是隐式的还是显式的相对导入都是从当前模块开始的。主模块的名字永远是”_main_”，一个Python应用程序的主模块，应当总是使用绝对路径引用。 包还提供一个额外的属性_path_。这是一个目录列表，里面每一个包含的目录都有为这个包服务的_init_.py，你得在其他_init_.py被执行前定义哦。可以修改这个变量，用来影响包含在包里面的模块和子包。 这个功能并不常用，一般用来扩展包里面的模块。