Python中的模块与包

一 什么是模块

模块，就是用一堆代码实现了某个功能的代码集合。如：os 是系统相关的模块；file是文件操作相关的模块

模块分为三种：

• 自定义模块
• 第三方模块
• 内置模块

二 模块导入

2.1 import

首先，举一个例子，自定义一个my_module.py文件：

a = 11

def func1():
    print('from my_module.func1')

def func2():
    print('from my_module.func2')

接下来在同级目录下新建一个module_test.py文件进行导入测试：

import my_module

print(my_module.a)      # 模块中的常量调用：模块名.常量名

my_module.func1()       # 模块中的函数调用：模块名.函数名()
my_module.func2()

由上可以看到，通过import导入模块时，直接“import+模块名”导入即可，注意：不需要加后缀

模块导入时会做三件事：

1. 首先为源文件(my_module 模块)创建新的名称空间

2. 在新建的命名空间中执行my_module.py中包含的代码

3. 创建名字my_module来引用该名称空间

注意：模块在一个程序中只会被导入一次，不会重复导入。因为当导入一个模块之后，会将模块存储在内存中，当再次导入的时候，就会到内存中查看是否导入过这个模块，如果已经导入过了，就不用再导入了。我们可以通过sys里面的modules方法获取当前已加载模块，sys.modules是一个字典，内部包含模块名与模块对象的映射。

import sys
print(sys.modules)  # 获取当前已加载模块

为模块起别名

为已经导入的模块起别名的方式对编写可扩展的代码很有用，语法如下：

import 模块名 as 别名

下面看一个实际应用的列子：有两种sql模块mysql和oracle，根据用户的输入，选择不同的sql功能

# mysql.py
def sqlparse():
    print('from mysql sqlparse')

# oracle.py
def sqlparse():
    print('from oracle sqlparse')

#module_test.py
db_type=input('>>: ')
if db_type == 'mysql':
    import mysql as db
elif db_type == 'oracle':
    import oracle as db

db.sqlparse()

一行导入多个模块

import module1,mofule2,...

2.2 from … import …

话不多说，结合my_module.py，我们展示一下from … import …的使用：

from my_module import func1,func2,a

print(a)        # 11  
func1()         # from my_module.func1    
func2()         # from my_module.func2

from...import… VS import

使用from...import...是将模块中的名字直接导入到当前的名称空间中，所以在当前名称空间中，直接使用名字就可以了，无需加前缀

from...import... 的优缺点：

优点：使用起来方便了

缺点：容易与当前执行文件中的名字冲突

注意1：当前文件直接使用导入函数名，执行时仍然以模块文件为全局名称空间

我们将my_module.py做一下修改，来验证这个说法：

a = 11

def func1():
    print('from my_module.func1')
    print(a)

def func2():
    print('from my_module.func2')
    func1()

from my_module import func1,func2

a = 100
def func1():
    print('xxxxx')
func2()

# 执行结果
from my_module.func2
from my_module.func1
11

注意2：如果当前文件中有重名func1或者func2，会有覆盖效果

from my_module import func1,func2

a = 100
def func1():
    print('xxxxx')
func1()

# 执行结果
xxxxx

from...import... 的别名

from module_name import xxx as 别名

一行导入多个

from module_name import xxx,yyy,...

from ... import *

例如：from my_module import * ， 将my_module中所有的不是以下划线(_)开头的名字都导入到当前位置

from my_module import *

print(a)
func1()
func2()

# 执行结果
11
from my_module.func1
11
from my_module.func2
from my_module.func1
11

注意：大部分情况下我们的python程序不应该使用这种导入方式，因为*你不知道你导入什么名字，很有可能会覆盖掉你之前已经定义的名字。而且可读性极其的差，在交互式环境中导入时没有问题。

我们可以通过__all__来控制*（用来发布新版本），在my_module.py中新增一行：

__all__=['a','func1']   # 只能导入列表中规定的两个名字

再次from … import *时，如果调用__all__中没有指定的名字，会报错：

from my_module import *

print(a)
func1()
func2()         # 报错：NameError: name 'func2' is not defined

三 模块搜索路径

模块的查找顺序是：内存中已经加载的模块-->内置模块-->sys.path路径中包含的模块

具体执行：

1. 在第一次导入某个模块时，比如：my_package，会先检查该模块是否已经被加载到内存中（当前执行文件的名称空间对应的内存），如果有则直接引用

2. 如果没有，解释器则会查找同名的内建模块

3. 如果没有，就从sys.path给出的目录列表中依次寻找my_package.py文件

ps：python解释器在启动时会自动加载一些模块到内存中，可以使用sys.modules查看

sys.path的初始化的值来自于：
The directory containing the input script (or the current directory when no file is specified).
PYTHONPATH (a list of directory names, with the same syntax as the shell variable PATH).
The installation-dependent default.

注意：自定义的模块名千万不要与系统内置模块重名

在初始化后，python程序可以修改sys.path，路径放到前面的优先于标准库被加载

import sys

# 添加
sys.path.append(r'E:\PythonCode\function\my_package')
# 指定位置插入
sys.path.insert(0,r'E:\PythonCode\function\my_package')

注意：搜索时按照sys.path中从左到右的顺序查找，位于前的优先被查找，sys.path中还可能包含.zip归档文件和.egg文件，python会把.zip归档文件当成一个目录去处理。

需要强调的一点是：只能从.zip文件中导入.py，.pyc等文件。使用C编写的共享库和扩展块无法直接从.zip文件中加载（此时setuptools等打包系统有时能提供一种规避方法），且从.zip中加载文件不会创建.pyc或者.pyo文件，因此一定要事先创建他们，来避免加载模块是性能下降。

四 包

4.1 什么是包

官网解释：Packages are a way of structuring Python’s module namespace by using “dotted module names”.  翻译过来就是包是一种通过使用‘.模块名’来组织python模块名称空间的方式。

具体的：包就是一个包含有__init__.py文件的文件夹，我们创建包的目的就是为了用文件夹将文件/模块组织起来。

需要注意的是： 　　

1. 在python3中，即使包下没有__init__.py文件，import 包仍然不会报错，而在python2中，包下一定要有该文件，否则import 包报错 　　

2. 创建包的目的不是为了运行，而是被导入使用，记住，包只是模块的一种形式而已，包的本质就是一种模块

4.2 包的导入

需要注意的是：

1. 关于包相关的导入语句也分为import和from ... import ...两种，但是无论哪种，无论在什么位置，在导入时都必须遵循一个原则：凡是在导入时带点的，点的左边都必须是一个包，否则非法。可以带有一连串的点，如xx.xxx.xxxx，但都必须遵循这个原则。但对于导入后，在使用时就没有这种限制了，点的左边可以是包、模块、函数、类(它们都可以用点的方式调用自己的属性)。

2. import导入文件时，产生名称空间中的名字来源于文件，import 包，产生的名称空间的名字同样来源于文件，即包下的__init__.py，导入包本质就是在导入该文件

3. 包A和包B下有同名模块也不会冲突，如A.a与B.a来自俩个命名空间

接下来，我们自己创建一个包，目录结构如下：

文件内容如下：

# m1.py
def func1():
    print('from my_package.m1')

# m2.py
def func2():
    print('from my_package.aaa.m2')

# m3.py
def func3():
    print('from my_package.aaa.m3')

# m4.py
def func4():
    print('from my_package.bbb.m4')

4.2.1 import

在于my_package同级目录下创建包测试文件：package_test.py

import my_package.aaa.m2

my_package.aaa.m2.func2()       # from my_package.aaa.m2

单独导入包名称时不会导入包中所包含的所有子模块，如:

import my_package

my_package.aaa.m2.func2()       # 报错：AttributeError: module 'my_package' has no attribute 'aaa'

解决办法：

# my_package/__init__.py
from my_package import aaa或from . import aaa

# aaa/__init__.py
from my_package.aaa import m2或from . import m2

这是因为导入包时本质上是执行的包下面的__init__.py文件。

4.2.2 from ... import ...

通过该方式我们需要注意：impor后不能带点，否则会有语法错误，如：from a import b.c是错误语法

from my_package import m1
from my_package.aaa import m2,m3
from my_package.bbb import m4

m1.func1()      # from my_package.m1
m2.func2()      # from my_package.aaa.m2
m3.func3()      # from my_package.aaa.func3
m4.func4()      # from my_package.bbb.m4

4.2.3 from ... import *

在学习模块时，我们已经讨论过了从一个模块内导入所有*，此处我们研究从一个包导入所有*。

执行from ... import *语句，比如：from my_package import *，实际上只会导入my_package 下__init__.py文件中定义的名字，所以，与模块类似，我们可以在__init__这个文件中定义__all___。

def func5():
    print('from my_package.__init__.func5')

__all__ = ['m1','aaa','func5']

my_package/__init__.py

from my_package import *

m1.func1()
func5()
print(aaa)
print(bbb)  # 报错 NameError: name 'bbb' is not defined

注意：如果不使用__all__，则需要在my_package 下__init__.py中导入需要引用的模块，否则会报错

4.3 绝对导入和相对导入

一般最外层my_package是作为外部引用的，在其内部会有彼此之间互相导入的需求，这时候就有绝对导入和相对导入两种方式：

绝对导入：以my_package作为起始

相对导入：用.或者..的方式作为为起始（只能在一个包中使用，不能用于不同目录内）

例如：我们在my_package/aaa/m2.py中想要导入my_package/bbb/m4.py

# 绝对导入
from my_package.bbb import m4
m4.func4()

# 相对导入
from ..bbb import m4    # .或..的在该模块下执行报错：SystemError: Parent module '' not loaded, cannot perform relative import
m4.func4()

注意：相对路径执行时，一定要在与my_package同级的文件中进行，否则会报错

写在最后--着重强调：

现在有个情况，需要在my_package/aaa/m2.py中导入my_package/aaa/m3.py，我们可能会这样做：

# m2.py
import m3
m3.func3()

这样我们单独运行m2.py是一点问题没有的，运行m2.py的路径搜索就是从当前路径开始的，于是在导入m3时能在当前目录下找到。但模块m2.py被其他非同级目录下的文件引用时，比如：在与my_package同级下的package_test.py文件导入时，如下：

from my_package.aaa import m2

# 执行结果：ImportError: No module named 'm3'

这是为什么呢？

这是因为此时我们导入m2，在m2.py中执行import m3时需要从sys.path也就是从当前目录找m3.py，当然会找不到。正确的做法是在my_package/aaa/m2.py中采用相对或绝对的方式导入m3.py

from my_package.aaa import m3      # 绝对导入
# from ..aaa import m3  # 相对导入

五 其他补充

5.1 py文件的两种用途

编写好的一个python文件可以有两种用途：

1. 脚本：一个文件就是整个程序，用来被执行

2. 模块：文件中存放着一堆功能，用来被导入使用

python为我们内置了全局变量__name__

1. 当文件被当做脚本执行时：__name__ 等于'__main__'

2. 当文件被当做模块导入时：__name__等于模块名

所以，我们可以应用

if __name__ == '__main__':

来控制.py文件在不同的应用场景下执行不同的逻辑

# my_module1.py

def func1():
       print('xxx')

if __name__ == '__main__':
print('当做脚本运行时打印')  # 当做脚本执行时打印

# module_test.py

import my_module1	# 不会执行print('当做脚本运行时打印')

my_module1.func1()     # xxx

5.2 编译python文件

为了提高加载模块的速度，强调：提高的是加载速度而绝非运行速度。python解释器会在__pycache__目录中下（py3）缓存每个模块编译后的版本，格式为：module.version.pyc。通常会包含python的版本号。

1. 以pyc为后缀的就为编译文件

2. 编译pyc文件的时候，只有在导入文件的时候才做（就是作为一个模块的时候才去编译）

详情可以参考：PYTHON基础之第一个PY程序关于.pyc文件的描述