第七篇Python之模块/包

Posted 2020-11-27 小虾米吃大鱼

一、模块（module）的概念

1、模块定义和分类

       在python中，一个.py文件就称之为一个模块（Module）。

       模块的使用方式都是一样的，细分模块可以分为三类：　

　1 自定义模块：使用python编写的单个.py文件，或者把一系列的.py文件组织在一起的文件夹。（注：文件夹下有个__init__.py文件，该文件夹称之为包）

　2 第三方模块：已被编译为共享库或DLL的C或C++扩展
 
　3 python标准库：使用C编写并链接到python解释器的内置模块

2、模块优点

1） 从文件级别组织程序，更方便管理

2） 拿来主义，提升开发效率

我们不仅仅可以单独执行脚本文件，还可以导入到其他的模块中或者下载他人模块导入自己项目中使用，实现了功能的重复利用并且极大地提升我们的开发效率。

       * 3） 模块可以避免函数名和变量名冲突

使用模块还可以避免函数名和变量名冲突。相同名字的函数和变量完全可以分别存在不同的模块中，因此，我们自己在编写模块时，不必考虑名字会与其他模块冲突。但是也要注意，尽量不要与内置函数名字冲突。

3、模块的导入

1） 模块导入的搜索路径

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

1、在第一次导入某个模块时（比如spam），会先检查该模块是否已经被加载到内存中（当前执行文件的名称空间对应的内存），如果有则直接引用
    ps：python解释器在启动时会自动加载一些模块到内存中，可以使用sys.modules查看
2、如果没有，解释器则会查找同名的内建模块
3、如果还没有找到就从sys.path给出的目录列表中依次寻找spam.py文件。

模块的查找顺序

import sys
print(sys.path) 

注意事项：按照sys.path的路径顺序优先查找，所以若在当前目录下存在与要引入模块同名的文件，就会把要导入的模块屏蔽掉。 当前目录是优先于标准库目录的，需要强调的是：我们自定义的模块名不要跟python标准库的模块名重复

sys.path从以下位置初始化：
    1 执行文件所在的当前目录
    2 PTYHONPATH（包含一系列目录名，与shell变量PATH语法一样）
    3 依赖安装时默认指定的

sys.path初始化位置

在初始化后，python程序可以修改sys.path。

import sys
sys.path.append(\'/a/b/c/d\')
sys.path.insert(0,\'/x/y/z\')

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

#首先制作归档文件：zip module.zip foo.py bar.py 
import sys
sys.path.append(\'module.zip\')
import foo,bar

#也可以使用zip中目录结构的具体位置
sys.path.append(\'module.zip/lib/python\')


#windows下的路径不加r开头，会语法错误
sys.path.insert(0,r\'C:\\Users\\Administrator\\PycharmProjects\\a\')
 

#至于.egg文件是由setuptools创建的包，这是按照第三方python库和扩展时使用的一种常见格式，.egg文件实际上只是添加了额外元数据(如版本号，依赖项等)的.zip文件。

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

View Code

2） 模块导入的过程

第一次导入模块会有三步流程，重复导入python会直接引用内存中已经加载好的结果，即后续的import语句仅是对已经加载到内存中的模块对象增加了一次引用，不会重新执行模块内的语句。

import sys
#test.py

#1.为源文件(导入的模块sys)创建新的名称空间，在模块中定义的函数和方法若是使用到了global时访问的就是这个名称空间。

#2.在新创建的命名空间中执行模块中包含的代码
    事实上，函数定义也是“被执行”的语句，模块级别函数定义的执行将函数名放
    入模块全局名称空间表，用globals()可以查看

#3.创建名字sys来引用该命名空间
    这个名字和变量名没什么区别，都是‘第一类的’，且使用sys.名字（sys.MName）的方式
    可以访问sys.py文件中定义的名字，sys.MName与test.py中的名字来自
    两个完全不同的地方。

每个模块都是一个独立的名称空间，定义在这个模块中的函数，把这个模块的名称空间当做全局名称空间，这样我们在编写自己的模块时，就不用担心我们定义在自己模块中全局变量会在被导入时，与使用者的全局变量冲突

print(\'from the spam.py\')

money=1000

def read1():
    print(\'spam模块：\',money)

def read2():
    print(\'spam模块\')
    read1()

def change():
    global money
    money=0

spam.py

import spam #只在第一次导入时才执行spam.py内代码
import spam
import spam

#执行结果：from the spam.py

test.py

import spam 
money=10
print(spam.money)

\'\'\'
执行结果：
from the spam.py
1000
\'\'\'

test1.py

import spam
def read1():
    print(\'========\')
spam.read1()

\'\'\'
执行结果：
from the spam.py
spam模块： 1000
\'\'\'

test2.py

import spam
money=1
spam.change()
print(money)

\'\'\'
执行结果：
from the spam.py
1
\'\'\'

test3.py

3）为导入模块名起别名

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

import sys as sss
print(sss.path)

from sys import path as spp
print(spp)

4）模块导入方法

A、导入一个或多个模块

import module1[, module2[,... moduleN]

B、导入模块里的单个或全部对象，这个导入方法将模块中的名字直接导入到当前的名称空间中，所以在当前名称空间中，调用直接使用名字就可以了、无需加前缀，但容易与当前执行文件中的名字冲突：

from modname import name1[, name2[, ... nameN]]    #可以直接调用name1[, name2[, ... nameN]]
from modname import *    #比较不推荐，因为*你不知道你导入什么名字，很有可能会覆盖掉你之前已经定义的名字。而且可读性极其的差，在交互式环境中导入时没有问题。

　　可以使用__all__来控制*（用来发布新版本），在spam.py中新增一行

__all__=[\'money\',\'read1\'] #这样在另外一个文件中用from spam import *就这能导入列表中规定的两个名字

　　

验证一：当前位置直接使用read1和read2就好了，执行时，仍然以spam.py文件全局名称空间

#测试一：导入的函数read1，执行时仍然回到spam.py中寻找全局变量money
#test.py
from spam import read1
money=100
read1()
\'\'\'
执行结果:
from the spam.py
spam模块： 1000            #spam->read1->money 1000
\'\'\'

#测试二:导入的函数read2，执行时需要调用read1(),仍然回到spam.py中找read1()
#test.py
from spam import read2
def read1():
    print(\'==========\')
read2()

\'\'\'
执行结果:
from the spam.py
spam模块                        #spam->read2 calling read
spam模块： 1000             #spam->read1->money 1000
\'\'\'

View Code

验证二：如果当前有重名read1或者read2，那么会有覆盖效果。

#测试三:导入的函数read1，被当前位置定义的read1覆盖掉了
#test.py
from spam import read1
def read1():
    print(\'==========\')
read1()
\'\'\'
执行结果:
from the spam.py
==========
\'\'\'

View Code

验证三：导入的方法在执行时，始终是以源文件为准的

from spam import money,read1
money=100 #将当前位置的名字money绑定到了100
print(money) #打印当前的名字
read1() #读取spam.py中的名字money,仍然为1000

\'\'\'
from the spam.py
spam->read1->money 1000
\'\'\'

View Code　　

5）模块循环导入问题

模块循环/嵌套导入抛出异常的根本原因是由于在python中模块被导入一次之后，就不会重新导入，只会在第一次导入时执行模块内代码

在我们的项目中应该尽量避免出现循环/嵌套导入，如果出现多个模块都需要共享的数据，可以将共享的数据集中存放到某一个地方

在程序出现了循环/嵌套导入后的异常分析、解决方法如下

#示范文件内容如下
#m1.py
print(\'正在导入m1\')
from m2 import y

x=\'m1\'

#m2.py
print(\'正在导入m2\')
from m1 import x

y=\'m2\'

#run.py
import m1

#测试一
执行run.py会抛出异常
正在导入m1
正在导入m2
Traceback (most recent call last):
  File "/Users/linhaifeng/PycharmProjects/pro01/1 aaaa练习目录/aa.py", line 1, in <module>
    import m1
  File "/Users/linhaifeng/PycharmProjects/pro01/1 aaaa练习目录/m1.py", line 2, in <module>
    from m2 import y
  File "/Users/linhaifeng/PycharmProjects/pro01/1 aaaa练习目录/m2.py", line 2, in <module>
    from m1 import x
ImportError: cannot import name \'x\'

#测试一结果分析
先执行run.py--->执行import m1，开始导入m1并运行其内部代码--->打印内容"正在导入m1"
--->执行from m2 import y 开始导入m2并运行其内部代码--->打印内容“正在导入m2”--->执行from m1 import x,由于m1已经被导入过了，所以不会重新导入，所以直接去m1中拿x，然而x此时并没有存在于m1中，所以报错


#测试二:执行文件不等于导入文件，比如执行m1.py不等于导入了m1
直接执行m1.py抛出异常
正在导入m1
正在导入m2
正在导入m1
Traceback (most recent call last):
  File "/Users/linhaifeng/PycharmProjects/pro01/1 aaaa练习目录/m1.py", line 2, in <module>
    from m2 import y
  File "/Users/linhaifeng/PycharmProjects/pro01/1 aaaa练习目录/m2.py", line 2, in <module>
    from m1 import x
  File "/Users/linhaifeng/PycharmProjects/pro01/1 aaaa练习目录/m1.py", line 2, in <module>
    from m2 import y
ImportError: cannot import name \'y\'


#测试二分析
执行m1.py，打印“正在导入m1”，执行from m2 import y ，导入m2进而执行m2.py内部代码--->打印"正在导入m2"，执行from m1 import x，此时m1是第一次被导入，执行m1.py并不等于导入了m1，于是开始导入m1并执行其内部代码--->打印"正在导入m1"，执行from m1 import y，由于m1已经被导入过了，所以无需继续导入而直接问m2要y，然而y此时并没有存在于m2中所以报错



# 解决方法:
方法一:导入语句放到最后
#m1.py
print(\'正在导入m1\')

x=\'m1\'

from m2 import y

#m2.py
print(\'正在导入m2\')
y=\'m2\'

from m1 import x

方法二:导入语句放到函数中
#m1.py
print(\'正在导入m1\')

def f1():
    from m2 import y
    print(x,y)

x = \'m1\'

# f1()

#m2.py
print(\'正在导入m2\')

def f2():
    from m1 import x
    print(x,y)

y = \'m2\'

#run.py
import m1

m1.f1()

示例文件

View Code

#m1.py
f1()
print(\'正在导入m1\')
import m2

x=\'m1\'

print(m2.y)


#m2.py
print(\'正在导入m2\')
import m1

y=\'m2\'

#run.py
import m1

思考

View Code

 * 6） 模块的重载

      考虑到性能的原因，每个模块只被导入一次,放入字典sys.module中，如果你改变了模块的内容，你必须重启程序，python不支持重新加载或卸载之前导入的模块，

有的同学可能会想到直接从sys.module中删除一个模块不就可以卸载了吗，注意了，你删了sys.module中的模块对象仍然可能被其他程序的组件所引用，因而不会被清楚。

特别的对于我们引用了这个模块中的一个类，用这个类产生了很多对象，因而这些对象都有关于这个模块的引用。

如果只是你想交互测试的一个模块，使用 importlib.reload(), e.g. import importlib; importlib.reload(modulename)，这只能用于测试环境。

def func1():
    print(\'func1\')

aa.py

import time,importlib
import aa
 
time.sleep(20)
# importlib.reload(aa)
aa.func1()

aa_test.py

在20秒的等待时间里，修改aa.py中func1的内容，等待test.py的结果。

打开importlib注释，重新测试

二、python文件

       python文件区分两种用途:模块与脚本

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

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

python文件的编译：

为了提高加载模块的速度，强调强调强调：提高的是加载速度而绝非运行速度。python解释器会在__pycache__目录中下缓存每个模块编译后的版本，格式为：module.version.pyc。通常会包含python的版本号。例如，在CPython3.3版本下，spam.py模块会被缓存成__pycache__/spam.cpython-33.pyc。这种命名规范保证了编译后的结果多版本共存。

Python检查源文件的修改时间与编译的版本进行对比，如果过期就需要重新编译。这是完全自动的过程。并且编译的模块是平台独立的，所以相同的库可以在不同的架构的系统之间共享，即pyc使一种跨平台的字节码，类似于JAVA火.NET,是由python虚拟机来执行的，但是pyc的内容跟python的版本相关，不同的版本编译后的pyc文件不同，2.5编译的pyc文件不能到3.5上执行，并且pyc文件是可以反编译的，因而它的出现仅仅是用来提升模块的加载速度的，不是用来加密的。

python文件编译

#python解释器在以下两种情况下不检测缓存
#1 如果是在命令行中被直接导入模块，则按照这种方式，每次导入都会重新编译，并且不会存储编译后的结果（python3.3以前的版本应该是这样）
    python -m spam.py

#2 如果源文件不存在，那么缓存的结果也不会被使用，如果想在没有源文件的情况下来使用编译后的结果，则编译后的结果必须在源目录下
sh-3.2# ls
__pycache__ spam.py
sh-3.2# rm -rf spam.py 
sh-3.2# mv __pycache__/spam.cpython-36.pyc ./spam.pyc
sh-3.2# python3 spam.pyc 
spam
 

#提示：
1.模块名区分大小写，foo.py与FOO.py代表的是两个模块
2.你可以使用-O或者-OO转换python命令来减少编译模块的大小
    -O转换会帮你去掉assert语句
    -OO转换会帮你去掉assert语句和__doc__文档字符串
    由于一些程序可能依赖于assert语句或文档字符串，你应该在在确认需要
    的情况下使用这些选项。
3.在速度上从.pyc文件中读指令来执行不会比从.py文件中读指令执行更快，只有在模块被加载时，.pyc文件才是更快的

4.只有使用import语句是才将文件自动编译为.pyc文件，在命令行或标准输入中指定运行脚本则不会生成这类文件，因而我们可以使用compieall模块为一个目录中的所有模块创建.pyc文件

模块可以作为一个脚本（使用python -m compileall）编译Python源  
python -m compileall /module_directory 递归着编译
如果使用python -O -m compileall /module_directory -l则只一层
  
命令行里使用compile()函数时，自动使用python -O -m compileall
  
详见：https://docs.python.org/3/library/compileall.html#module-compileall

View Code

三、python内置全局变量__name__

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

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

if __name__ == \'__main__\':

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

1）避免代码被import，也就是被调用时，屏蔽代码段

2）调试运行代码

#fib.py

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

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


#执行：python fib.py <arguments>
python fib.py 50 #在命令行

View Code

四、python包

1、python包的定义

包就是一个包含有__init__.py文件的文件夹，所以其实我们创建包的目的就是为了用文件夹将文件/模块组织起来

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

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

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

2、python包的优点

包的本质就是一个文件夹，那么文件夹唯一的功能就是将文件组织起来。

随着功能越写越多，我们无法将所以功能都放到一个文件中，于是我们使用模块去组织功能。

而随着模块越来越多，我们就需要用文件夹将模块文件组织起来，以此来提高程序的结构性和可维护性。

3、包的使用之import 和注意事项

1） 在import/from...import时，点的左边都必须是一个包，否则非法。可以带有一连串的点，如item.subitem.subsubitem,但都必须遵循这个原则。   

但对于导入后，在使用时就没有这种限制了，点的左边可以是包,模块，函数，类(它们都可以用点的方式调用自己的属性)。   

而from...import后面的导入模块，必须是不能带点，否则会有语法错误。

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

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

 

### 使用import导入包：单独导入包名称时不会导入包中所有包含的所有子模块

import glance
glance.cmd.manage.main()   #AttributeError: module \'glance\' has no attribute \'cmd\'，单独导入包名，子模块无法调用

#解决方法
from . import cmd         #glance/__init__.py，导入包本质就是在导入__init__.py文件
from . import manage      #glance/cmd/__init__.py 
#or 
import glance.cmd.manage glance.cmd.manage.main()

 

### 使用from ... import ...导入包的模块

from glance.db import models
models.register_models(\'mysql\')

from glance.db.models import register_models
register_models(\'mysql\')　　

 

### 从一个包导入所有*: 想从包api中导入所有，实际上该语句只会导入包api下__init__.py文件中定义的名字，我们可以在这个文件中定义__all___:

#glance同级目录test.py文件
from glance.api import *

#api/__init__.py文件
x=10
def func():
    print(\'from api.__init.py\')
 
__all__=[\'x\',\'func\',\'policy\']

 

#glance同级目录test.py文件中
from glance import *
get()
create_resource(\'a.conf\')
main()
register_models(\'mysql\')

#在glance.__init__.py中
from .api.policy import get
from .api.versions import create_resource
from .cmd.manage import main
from .db.models import  register_models

__all__=[\'get\',\'create_resource\',\'main\',\'register_models\']

from glance import * 

   

       ### 绝对导入和相对导入

　　最顶级包glance是写给别人用的，然后在glance包内部也会有彼此之间互相导入的需求，这时候就有绝对导入和相对导入两种方式：     

绝对导入：以执行文件的sys.path为起始点开始导入,称之为绝对导入（以glance作为起始）

# 优点: 执行文件与被导入的模块中都可以使用
# 缺点: 所有导入都是以sys.path为起始点,导入麻烦

相对导入：参照当前所在文件的文件夹为起始开始查找,称之为相对导入。       

# 符号:  "."代表当前所在文件的文件夹,".."代表上一级文件夹,"..."代表上一级的上一级文件夹
# 优点:  导入更加简单
# 缺点:  只能在导入包中的模块时才能使用（只能在一个包中使用，不能用于不同目录内）

 比如：

# glance/api/version.py中想要导入glance/cmd/manage.py
# 在glance/api/version.py，单独运行报错原因：只能在同一个包内进行导入，不同目录之间无法进行相对或绝对导入

# 绝对导入，单独run version.py会报错 “ModuleNotFoundError: No module named \'glance\'”
from glance.cmd import manage 
manage.main() 

# 相对导入，单独run version.py会报错 “ValueError: attempted relative import beyond top-level package”
from ..cmd import manage 
manage.main()

# 测试代码：glance的同级目录test.py,
from glance.api import versions

注意:

* 相对导入只能用于包内部模块之间的相互导入,导入者与被导入者都必须存在于一个包内

* 试图在顶级包之外使用相对导入是错误的,言外之意,必须在顶级包内使用相对导入,每增加一个“.”代表跳到上一级文件夹,而上一级不应该超出顶级包。

  ---- 报错“attempted relative import beyond top-level package”

* 导入路径必须注意，包以及包的模块都是用来被导入的，而不是被直接执行的。而环境变量都是以执行文件为准的。

#api/version.py中,单独执行没有问题。
import policy
policy.get()

#glance同级下的一个test.py，这样就报错了
from glance.api import versions  #ImportError: No module named \'policy\'

\'\'\'
分析:
此时我们导入versions在versions.py中执行，import policy需要找从sys.path也就是从当前目录找policy.py,这必然是找不到的
\'\'\'

 

  ├── test.py
  └── glance                  #Top-level package
           │
           ├── __init__.py      #Initialize the glance package
           │
           ├── api                  #Subpackage for api
           │     ├── __init__.py
           │     ├── policy.py
           │     └── versions.py
           │
           ├── cmd                #Subpackage for cmd
           │     ├── __init__.py
           │     └── manage.py
           │
           └── db                  #Subpackage for db
                  ├── __init__.py
                  └── models.py

       实验: https://pan.baidu.com/s/1C1Rzioen64WvvuOiQuamZQ

# import的使用
# import glance.api.policy
# glance.api.policy.get()   #from policy.py以上是关于第七篇Python之模块/包的主要内容，如果未能解决你的问题，请参考以下文章
 
 Python之路第七篇--Python基础之面向对象及相关
 python基础篇第七篇模块补充xml操作
 第七篇 python基础之函数，递归，内置函数
 第七篇 python基础之函数，递归，内置函数
 第七篇 python基础之函数，递归，内置函数
 第七篇 python基础之函数，递归，内置函数