Day05-模块与包

1.什么是模块

　　一个模块就是一个包含了python定义和声明的文件，文件名就是模块名字加上.py的后缀。

2.为何要使用模块？

　　如果你退出python解释器然后重新进入，那么你之前定义的函数或者变量都将丢失，因此我们通常将程序写到文件中以便永久保存下来，需要时就通过python test.py方式去执行，此时test.py被称为脚本script。

     随着程序的发展，功能越来越多，为了方便管理，我们通常将程序分成一个个的文件，这样做程序的结构更清晰，方便管理。这时我们不仅仅可以把这些文件当做脚本去执行，还可以把他们当做模块来导入到其他的模块中，实现了功能的重复利用，

3.如何使用模块？

3.1 import

示例文件：temp.py，文件名temp.py,模块名temp

# temp.py 文件内容：
# /usr/bin/env python
# -*- coding:utf-8 -*-
print('from to temp')
num=1000
def foo():
    print('from to temp foo',num)
def foo1():
    print('from to foo1',num)
　　foo()
def change():
    global num
    num = 10

import temp # 导入temp模块
#输出结果：

from to temp   # 执行了模块里面的代码（print（'from to temp'））

3.1.1import导入模块后做了那些操作：

　1.产生新的名称空间
   2.以新建的名称空间为全局名称空间，执行文件的代码
   3.拿到一个模块名spam，指向spam.py产生的名称空间

3.1.2 模块可以包含可执行的语句和函数的定义，这些语句的目的是初始化模块，它们只在模块名第一次遇到导入import语句时才执行（import语句是可以在程序中的任意位置使用的,且针对同一个模块很import多次,为了防止你重复导入，python的优化手段是：第一次导入后就将模块名加载到内存了，后续的import语句仅是对已经加载大内存中的模块对象增加了一次引用，不会重新执行模块内的语句），如下 

#测试一:num与temp.num不冲突
#temp.py
import temp
num=10
print(temp.num)

'''
执行结果：
from to temp
1000
'''

#测试二：foo与temp.foo不冲突
#temp.py
def foo():
    print('from to test')
temp.foo()
'''
执行结果:
from to temp
from to temp foo 1000
'''

 1 #测试三：执行temp.change()操作的全局变量num仍然是spam中的
 2 #temp.py
 num = 10000
 import temp
 temp.change()
 print(num)
 '''
 执行结果：
 from to temp
 10000
 '''

3.1.3为模块名起别名，相当于x=temp

import temp as x
x.foo()
'''
执行结果：
from to temp
from to temp foo 1000
'''

3.1.4在一行导入多个模块

import sys,os,re

3.2 from...import...

3.2.1 from...import...导入后做了那些操作：　

　1.产生新的名称空间
　2.以新建的名称空间为全局名称空间，执行文件的代码
　3.直接拿到就是spam.py产生的名称空间中名字

from temp import num,foo,foo1,change

这样在当前位置直接使用foo和foo1就好了，执行时，仍然以temp.py文件全局名称空间

#测试一：导入的函数foo，执行时仍然回到temp.py中寻找全局变量num
from temp import foo
num=100000
foo()
'''
执行结果:
from to temp
from to temp foo 1000

'''

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

'''
执行结果:
from to temp
from to foo1 1000
from to temp foo 1000
'''

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

#测试三:导入的函数foo，被当前位置定义的foo覆盖掉了
from temp import num,foo,foo1,change
def foo():
    print('==========')
foo()
'''
执行结果:
from to temp
==========
'''

需要特别强调的一点是：python中的变量赋值不是一种存储操作，而只是一种绑定关系，如下：

from temp import num,foo,foo1,change
num=100#将当前位置的名字money绑定到了100
print(num)#打印当前的名字
foo()#读取spam.py中的名字money,仍然为1000
'''
执行结果:
from to temp
100
from to temp foo 1000
'''

3.2.2from ... import ...

　优点:方便，不用加前缀
　缺点：容易跟当前文件的名称空间冲突

3.2.3from spam import * 把spam中所有的不是以下划线(_)开头的名字都导入到当前位置，大部分情况下我们的python程序不应该使用这种导入方式，因为*你不知道你导入什么名字，很有可能会覆盖掉你之前已经定义的名字。而且可读性极其的差，在交互式环境中导入时没有问题。

 

from temp import * #将模块spam中所有的名字都导入到当前名称空间
print(num)
print(foo)
print(foo1)
print(change)

'''
执行结果:
from to temp
1000
<function foo at 0x000000000069D8C8>
<function foo1 at 0x000000000069D840>
<function change at 0x000000000069D950>

'''

 

可以使用__all__来控制*（用来发布新版本）

在temp.py中新增一行

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

3.2.4支持as

from temp import num as numbers

3.2.5也支持导入多行

from spam import (foo,
                  foo1,
                  num)

3.3 把模块当做脚本执行 

我们可以通过模块的全局变量__name__来查看模块名：
当做脚本运行：
__name__ 等于'__main__'

# /usr/bin/env python
# -*- coding:utf-8 -*-
print('from to temp')
num=1000
def foo():
    print('from to temp foo',num)
def foo1():
    print('from to foo1',num)
    foo()
def change():
    global num
    num = 10
print('当前文件的用途是',__name__)

'''
执行结果:
from to temp
当前文件的用途是 __main__
'''

当做模块导入：
__name__=模块名

from temp import foo
'''
执行结果:
from to temp
当前文件的用途是 temp
'''

作用：用来控制.py文件在不同的应用场景下执行不同的逻辑
if __name__ == '__main__':

# /usr/bin/env python
# -*- coding:utf-8 -*-
print('from to temp')
num=1000
def foo():
    print('from to temp foo',num)
def foo1():
    print('from to foo1',num)
    foo()
def change():
    global num
    num = 10
print('from to temp')
if __name__ == '__main__':  # 作为脚本测试自己定义的功能，被当模块使用时，下面的函数不被执行
    change()
    print(num)

'''
执行结果:
from to temp
from to temp
10

'''

3.4 模块搜索路径

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

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

如果没有，解释器则会查找同名的内建模块，如果还没有找到就从sys.path给出的目录列表中依次寻找spam.py文件。

所以总结模块的查找顺序是：内存中已经加载的模块->内置模块->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归档文件，python会把.zip归档文件当成一个目录去处理，

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

二.包

包是一种通过使用‘.模块名’来组织python模块名称空间的方式。

１. 无论是import形式还是from...import形式，凡是在导入语句中（而不是在使用时）遇到带点的，都要第一时间提高警觉：这是关于包才有的导入语法，点的左边必须是包，最后一个点的左边必须是包，后边可以是包也可以是模块

2. 包是目录级的（文件夹级），文件夹是用来组成py文件（包的本质就是一个包含__init__.py文件的目录）

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

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

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

#文件内容

#policy.py
def get():
    print('from policy.py')

#versions.py
def create_resource(conf):
    print('from version.py: ',conf)

#manage.py
def main():
    print('from manage.py')

#models.py
def register_models(engine):
    print('from models.py: ',engine)

2.1 注意事项
1.关于包相关的导入语句也分为import和from ... import ...两种，但是无论哪种，无论在什么位置，在导入时都必须遵循一个原则：凡是在导入时带点的，点的左边都必须是一个包，否则非法。可以带有一连串的点，如item.subitem.subsubitem,但都必须遵循这个原则。

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

3.对比import item 和from item import name的应用场景：
如果我们想直接使用name那必须使用后者。

2.2 import

我们在与包glance同级别的文件中测试

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

2.3from...import...

需要注意的是from后import导入的模块，必须是明确的一个不能带点，否则会有语法错误，如：from a import b.c是错误语法

我们在与包glance同级别的文件中测试

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

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

2.4__init__.py文件

不管是哪种方式，只要是第一次导入包或者是包的任何其他部分，都会依次执行包下的__init__.py文件(我们可以在每个包的文件内都打印一行内容来验证一下)，这个文件可以为空，但是也可以存放一些初始化包的代码。

import glance.api.policy
print('============>')
glance.api.policy.get()
'''
输出结果：
from glance._init_py
from api
from policy
============>
from policy.py
'''
#在每个__init__加了打印信息这样加载那个包里面的init里面的代码都会执行

2.5from glance.api import *

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

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

#在__init__.py中定义
x=10

def func():
    print('from api.__init.py')

__all__=['x','func','policy']

此时我们在于glance同级的文件中执行from glance.api import *就导入__all__中的内容（versions仍然不能导入）。

2.6绝对导入和相对导入

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

绝对导入：以glance作为起始

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

例如：我们在glance/api/version.py中想要导入glance/cmd/manage.py

在glance/api/version.py

#绝对导入
from glance.cmd import manage
manage.main()

#相对导入
from ..cmd import manage
manage.main()

测试结果：注意一定要在于glance同级的文件中测试

from glance.api import versions 

注意：在使用pycharm时，有的情况会为你多做一些事情，这是软件相关的东西，会影响你对模块导入的理解，因而在测试时，一定要回到命令行去执行，模拟我们生产环境，你总不能拿着pycharm去上线代码吧！！！

特别需要注意的是：可以用import导入内置或者第三方模块（已经在sys.path中），但是要绝对避免使用import来导入自定义包的子模块(没有在sys.path中)，应该使用from... import ...的绝对或者相对导入,且包的相对导入只能用from的形式。

比如我们想在glance/api/versions.py中导入glance/api/policy.py，有的同学一抽这俩模块是在同一个目录下，十分开心的就去做了，它直接这么做

 

#在version.py中
 
import policy
policy.get()

 

没错，我们单独运行version.py是一点问题没有的，运行version.py的路径搜索就是从当前路径开始的，于是在导入policy时能在当前目录下找到

但是你想啊，你子包中的模块version.py极有可能是被一个glance包同一级别的其他文件导入，比如我们在于glance同级下的一个test.py文件中导入version.py，如下

from glance.api import versions

'''
执行结果:
ImportError: No module named 'policy'
'''

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

2.7单独导入包

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

#在与glance同级的test.py中
import glance
glance.cmd.manage.main()

'''
执行结果：
AttributeError: module 'glance' has no attribute 'cmd'

'''

解决方法：

#在glance/__init__.py 用相对路径导入cmd包
 from . import cmd

 #在glance/cmd/__init__.py用相对路径导入manage模块
 from . import manage

执行：

#在于glance同级的test.py中测试
import glance
glance.cmd.manage.main()

__all__不能解决，因为__all__是用于控制from...import *