引言

这篇文章介绍 python 中模块和包的概念。

文章目录

0×1. 如何导入模块
0×2. 装置第三方模块
0×3. 如何导入包

0×1. 如何导入模块

简略的讲，模块就是能够扩大 python 性能的一些对象的汇合，能够是类，办法，或者简略的数值对象，他们被寄存在一个或多个独自的文件中，python 装置后自带了大量的模块文件，咱们也能够本人创立模块放入零碎对应的目录中实现调用。

以 ubuntu 零碎为例，存在与 sys.path 列表中的 py 文件，都能够被当做模块调用，不同的零碎对应的地位可能不同，但都能通过上面的命令查看到：

# 在 idle 中查看 python 蕴含了哪些目录，在这些目录下的模块文件都能被辨认和调用，sys.path 实际上是一个内置的列表，咱们能够应用 append 或 extend 办法将咱们须要蕴含的目录增加到其中，这样 python 就可能调用咱们设定的目录中的模块文件了，在这个列表中的第一个元素（本例为空字符），代表当前目录，即模块文件和调用它的文件在同一个目录中就可能实现调用，当在不同的目录中启动 py 程序的时候，这个元素会被 py 程序所在目录门路所替换
>>> import sys
>>> print(sys.path)
['','/home/qing','/usr/bin','/usr/lib/python3.4','/usr/lib/python3.4/plat-x86_64-linux-gnu','/usr/lib/python3.4/lib-dynload','/usr/local/lib/python3.4/dist-packages','/usr/lib/python3/dist-packages']

#手动增加一个目录，操作方法和列表一样，这里不再赘述
>>> sys.path.append("/home/qing/test")
>>> print(sys.path)
['','/home/qing','/usr/bin','/usr/lib/python3.4','/usr/lib/python3.4/plat-x86_64-linux-gnu','/usr/lib/python3.4/lib-dynload','/usr/local/lib/python3.4/dist-packages','/usr/lib/python3/dist-packages','/home/qing/test']

可能大家曾经留神到，在下面的实例中应用了一个 import 关键词，这个关键词能够用来调用模块和包，而 sys 正是 python 自带的模块之一（因为 python 内置的模块应用 c 语言写的，所以零碎中并没有 sys.py 文件），这个文件中蕴含一个 path 列表对象；咱们本人创立的模块能够是一个.py 后缀的 python 脚本文件，在导入模块的时候，不须要增加 py 后缀，如果相熟 HTML 中 css 文件的导入概念，import 的作用与 HTML 头部 head 标签中应用 link 标签将 css 文件导入 HTML 文档相似，请看上面的实例：

# 依据下面的解释，当初咱们在同一个目录中创立两个 py 文件，一个为模块文件，一个用来调用这个模块

#模块文件 m1.py，蕴含两个空类，仅实现简略的初始化操作
#!/usr/bin/env python3
#coding=utf-8
######
class One:

    #------
    def __init__(self,items=[]):
        """初始化列表"""
        self.items=items
  
######
class Two:

    #------
    def __init__(self,items={}):
        """初始化字典"""
        self.dect=items

#调用文件 test1.py 与 m1.py 在同一个目录中
#!/usr/bin/env python3
#coding=utf-8
#通过 m1.py 的文件名，就能间接调用这个模块文件
import m1

#lst 是 m1 模块中 One 类的一个实例对象，dect 是 m1 中 Two 类的实例对象
lst=m1.One()
dect=m1.Two()
print(lst.items,dect.dect)

#程序输入
[] {}

除了下面这种导入形式外，还能够应用 from…import 语句来实现导入，请看上面的实例：

# 批改 test1.py 文件如下
#!/usr/bin/env python3
#这句话的意思是，从 m1 模块文件中导入 Two 这个对象（即 Two 类）from m1 import Two

#这种导入形式在实例化的时候，不须要写模块名称，可能间接应用对象名称，但咱们除了可能拜访 Two 类外，不能拜访 m1 模块中其余的类，例如 One
dect=Two()

#除此之外，还有一种更乏味的导入办法，批改 test1.py 文件如下
#!/usr/bin/env python3
#"星号" 通知 python 解释器，导入 m1 模块中所有的对象，在本例中相当于将 One 和 Two 这两个类导入到以后作用域，from m1 import *

#留神间接导入模块名称，和应用 from 导入某个或多个模块对象时，实例化对象语法上的区别，前者须要应用模块名称，后者则不须要
x=One()
y=Two()

在理论环境中，”from m1 import *” 这种语法都是配合模块的 ”__all__” 列表来实现导入的，请看上面的实例：

# 在 m1.py 文件头部增加一个 "__all__" 列表
#!/usr/bin/env python3
__all__=["One"]

#test1.py 文件批改如下
#!/usr/bin/env python3
from m1 import *

#当初，在 test1.py 文件中，只能实例化 m1.py 文件头 "__all__" 列表中蕴含的那些对象，如果此时初始化一个 Two() 对象则会报错，应用这种办法，能够向用户凋谢模块中的可见对象，而一些外部对象则不会被蕴含在 "__all__" 列表中
x=One()

说到模块就不得不说一下 python 一个非凡的变量 ”__name__”，有时候咱们编写了一个模块，在测试的时候，间接运行模块时，模块外部的一些办法不会被执行，这时候就能够用到变量 ”__name__” 来被动的调用模块中的一些办法，请看上面的实例：

# 如果咱们编写了上面这个 helloworld.py 模块，模块所有代码之前的第一个字符串是模块的阐明文档，__author__变量前面是这个模块的作者名称，这些都是装饰性的语句能够不写
#!/usr/bin/env python
#coding=utf-8
"helloworld.py 模块"  #模块阐明
__author__="www.qingsword.com" #模块作者

#打印出以后__name__变量的值
print("__name__ is",__name__)
def test_m():
    print("Hello World")

#如果__name__变量的值是__main__调用 test_m() 办法
if __name__=="__main__":
    test_m()

#间接执行这个模块，将会打印出上面的内容
__name__ is __main__
Hello World

#但如果咱们当初应用另外一个文件导入这个模块
import helloworld

#执行 import 语句后，只失去了上面这一句
__name__ is helloworld

#由此咱们失去两个重要的论断：#如果模块是被导入，__name__的值为模块名字
#如果模块是被间接执行，__name__的值为 "__main__"

#这样设计的益处不言而喻，当咱们测试模块时间接运行模块代码__name__的值为 "__main__"，通过 if 语句判断能够调用咱们须要调用的函数，如果是其余文件调用这个模块，那么__name__的值为模块名字，if 判断失败，将不会间接调用模块中如何办法，如果须要调用，要应用办法名称，在导入模块的文件中打印出__name__变量，程序的流程就会高深莫测
#!/usr/bin/env python
#coding=utf-8
import helloworld
helloworld.test_m()
print("__name__ is",__name__)

#程序输入，第一个__name__输入的是模块的名称（这是在 import 导入 helloworld 模块时，模块中的 print 的输入），第二个__name__输入的是以后的文件的名称，所有被间接运行的 py 文件的__name__变量值都是 "__main__"
__name__ is helloworld
Hello World
__name__ is __main__

0×2. 装置第三方模块

除了能创立本人的模块外，python 提供了大量的第三方模块，这些模块都各有性能，为程序开发节约了不少工夫，ubuntu 中装置第三方模块的办法非常简单，我只须要晓得模块名称，就可能应用 pip 或 pip3 轻松的装置他们，上面用 Pillow 图形库举例，关上终端，输出上面的命令装置 Pillow 图形库：

# 如果应用的是 python3，对应的第三方模块装置命令就是 pip3，如果是 python2，那么就是 pip
www@qingsword.com:~$ sudo pip3 install Pillow

须要什么模块能够先去 python 第三方模块官方网站 ”pypi.python.org” 查找模块名，而后应用下面的办法装置他们。

0×3. 如何导入包

模块只是一个独自的文件，而 ” 包 ” 能够是多个模块文件的汇合，python 中的 ” 包 ” 是以文件夹的模式存在的，python 辨别一个文件夹是 ” 包 ” 还是一般文件夹，次要搜寻文件夹中是否存在 ”__init__.py” 文件，如果有，则判断这个文件夹为 ” 包 ”，请看上面的实例：

# 创立一个 pack1 文件夹，在其中创立一个 "__init__.py" 文件，并在其中创立两个模块文件 m1.py，m2.py，将这个文件夹和须要调用它的文件放在同一个目录中

#m1.py 文件内容，创立两个空类如下
#!/usr/bin/env python3
######
class m1_class1:
    #------
    def __init__(self,items=[]):
        self.lst=items

######
class m1_class2:
    #------
    def __init__(self,items={}):
        self.dect=items

#m2.py 文件内容
#!/usr/bin/env python3
######
class m2_class1:
    #------
    def __init__(self,items=[]):
        self.lst=items

######
class m2_class2:
    #------
    def __init__(self,items={}):
        self.dect=items

#在 python3 标准中，当初曾经能够应用 py 脚本拜访这个包了，只管 "__init__.py" 文件还是空的，只须要将包文件夹和想要拜访这个包的脚本文件放在同一个目录中，咱们就能够像导入模块那样来导入包中的模块，创立一个文件 test2.py，将它和 part1 包放在同一个目录中，输出上面的内容
#!/usr/bin/env python
#coding=utf-8
#导入 pack1 包中的 m1 和 m2 模块
import pack1.m1,pack1.m2

#别离实例化这两个模块中的类
p1=pack1.m1.m1_class1()
p2=pack1.m2.m2_class2()
print(p1.lst,p2.dect)

#程序输入
[] {}

同模块导入一样，如果咱们不心愿包中的所有模块都被拜访到，这时就能够利用包目录中的 ”__init__.py” 文件，在这个文件中输出上面的内容

# 给 "__init__.py" 文件增加上面的内容
__all__=["m1"]

#批改 test2.py 文件的导入形式，应用 from
#!/usr/bin/env python
#coding=utf-8
#这条语句将搜寻 pack1 包中的 "__init__.py" 文件的__all__列表，并且仅加载列表中列出的模块，所以在这个实例中，test2.py 文件将不能拜访 m2 模块中的内容，除非应用 import 导入，或将 m2 增加到__all__列表中
from pack1 import *

#与模块的 from 类似，应用这种办法导入的包文件，实例化时不须要增加包的顶级目录名称
p1=m1.m1_class1()