Python模块和包

一、模块

1. 什么是模块

   常见的场景：一个模块就是一个包含了Python定义和声明的文件，文件名就是模块名字加上.py的后缀。

   但其实import加载的模块分为四个通用类别：　

   　　1 使用Python编写的代码（.py文件）

   　　2 已被编译为共享库或DLL的C或C++扩展

   　　3 包好一组模块的包

   　　4 使用C编写并链接到Python解释器的内置模块

2. 为什么要使用模块

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

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

3. 如何使用模块

   1. import …

      # 自定义一个my_module.py文件（模块）
      # 简单的打印一句话
      print("来导入我啊，来啊来啊来啊...")
      
      
      # 在同一个目录下的另一个py文件中导入该模块
      import my_module
      print("小样，看我把你弄过弄死你~")
      
      # 来导入我啊，来啊来啊来啊...
      # 小样，看我把你弄过弄死你~

      执行完之后发现执行了模块中的语句，打印了两句话，由此可以推出，导入模块时会执行该模块中的内容，那如果重复导入模块是不是会多次执行模块中的内容呢？我们接下来试试：

      # 自定义一个my_module.py文件（模块）
      # 简单的打印一句话
      print("来导入我啊，来啊来啊来啊...")
      
      
      # 在同一个目录下的另一个py文件中导入该模块
      import my_module
      print("小样，看我把你弄过弄死你~")
      import my_module      # 再次导入模块
      
      # 来导入我啊，来啊来啊来啊...
      # 小样，看我把你弄过弄死你~
      # 再次导入模块之后发现结果并没有发现改变。

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

      总结：首次导入模块my_module时会做三件事：

      1. 为源文件(my_module模块)创建新的名称空间，在my_module中定义的函数和方法若是使用到了global时访问的就是这个名称空间。
      2. 在新创建的命名空间中执行模块中包含的代码
      3. 创建名字my_module来引用该命名空间

   2. from … import …

      对比import my_module，会将源文件的名称空间’my_module’带到当前名称空间中，使用时必须是my_module.名字的方式

      而from 语句相当于import，也会创建新的名称空间，但是将my_module中的名字直接导入到当前的名称空间中，在当前名称空间中，直接使用名字就可以了。

      # my_module
      a = 10
      print("来导入我啊，来啊来啊来啊...")
      
      # 执行文件
      from my_module import a
      print("小样，看我把你弄过弄死你~")
      print(a)
      
      # 来导入我啊，来啊来啊来啊...
      # 小样，看我把你弄过弄死你~
      # 10

      如果当前有重名a，那么会有覆盖效果。

      # my_module
      a = 10
      print("来导入我啊，来啊来啊来啊...")
      
      # 执行文件
      from my_module import a
      print("小样，看我把你弄过弄死你~")
      a = 20
      print(a)
      
      # 来导入我啊，来啊来啊来啊...
      # 小样，看我把你弄过弄死你~
      # 20

   3. from … import *

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

      # my_module
      a = 10
      print("来导入我啊，来啊来啊来啊...")
      def func():
          print("哈哈哈哈")
      
      # 执行文件
      from my_module import *
      print(a)
      func()
      
      # 来导入我啊，来啊来啊来啊...
      # 10
      # 哈哈哈哈

      如果你想规定别人只能导入你模块中指定的变量时，可以在模块中使用__all__指定别人导入特定的变量

      # my_module
      __all__ = ["func"]
      a = 10
      print("来导入我啊，来啊来啊来啊...")
      def func():
          print("哈哈哈哈")
      
      # 执行文件
      from my_module import *
      func()        # 来导入我啊，来啊来啊来啊...
      print(a)  # NameError: name 'a' is not defined

4. 模块的别名

   import my_module as m
   from my_module import func as f
   
   # 当对模块进行重命名之后，指向模块内存空间中的指针将会发生改变重新指向新命名的变量，即使用模块只能用重命名之后的变量名
   
   # 模块也可以一行导入多个
   import os, sys （不推荐）
   from my_module import a, func

5. 模块的循环引用问题

   假如有两个模块a，b。我可不可以在a模块中import b ，再在b模块中import a？

   # a模块
   import b
   def funca():
       print("我是A")
   b.funcb()
   
   # b模块
   import a 
   def funcb():
       print("我是B")
   a.funca()
   
   # 1、当我在a模块运行时
   # AttributeError: module 'b' has no attribute 'funcb'
   
   # 2、当我在b模块运行时
   # AttributeError: module 'a' has no attribute 'funca'

   为什么相互调用时无论执行哪一个模块都提示模块中没有可执行的变量呢？

   

   分析：在上面第3步的时候，由于循环导入导致b.py并没有加载完就接着回去执行了a.py，这个时候在a.py中执行b.funcb()就会告诉你没有这个变量。同理如果限制性b.py，就找不到funca这个变量。

6. 模块的加载与修改

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

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

7. 把模块当做脚本执行

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

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

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

   def fib(n):   
       a, b = 0, 1
       while b < n:
           print(b, end=' ')
           a, b = b, a+b
       print()
   
   if __name__ == "__main__":
       print(__name__)
       num = input('num :')
       fib(int(num))

8. 模块搜索路径

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

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

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

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

二、包

1. 什么是包

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

   1. 无论是import形式还是from…import形式，凡是在导入语句中（而不是在使用时）遇到带点的，都要第一时间提高警觉：这是关于包才有的导入语法
   2. 包是目录级的（文件夹级），文件夹是用来组成py文件（包的本质就是一个包含__init__.py文件的目录）
   3. import导入文件时，产生名称空间中的名字来源于文件，import 包，产生的名称空间的名字同样来源于文件，即包下的__init__.py，导入包本质就是在导入该文件

   强调

   1. 在python3中，即使包下没有__init__.py文件，import 包仍然不会报错，而在python2中，包下一定要有该文件，否则import 包报错
   2. 创建包的目的不是为了运行，而是被导入使用，记住，包只是模块的一种形式而已，包即模块

2. import

   1. 创建目录代码

      import os
      os.makedirs('glance/api')
      os.makedirs('glance/cmd')
      os.makedirs('glance/db')
      l = []
      l.append(open('glance/__init__.py','w'))
      l.append(open('glance/api/__init__.py','w'))
      l.append(open('glance/api/policy.py','w'))
      l.append(open('glance/api/versions.py','w'))
      l.append(open('glance/cmd/__init__.py','w'))
      l.append(open('glance/cmd/manage.py','w'))
      l.append(open('glance/db/models.py','w'))
      map(lambda f:f.close() ,l)

   2. 目录结构

      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

   3. 文件内容

      #文件内容
      
      #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)

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

   import glance.db.models
   glance.db.models.register_models("mysql")
   # from models.py:  mysql

3. from … import …

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

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

   from glance.db import models
   from glance.api import policy
   
   models.register_models("mysql")  # from models.py:  mysql
   policy.get()               # from policy.py

4. __init__.py文件

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

5. from glance.api import *

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

   #在__init__.py中定义
   x=10
   
   def func():
       print('from api.__init.py')
   
   __all__=['x','func','policy']

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()

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

7. 单独导入包

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

   # 在glace同级文件test下
   import glance
   glance.api.policy.get()
   # AttributeError: module 'glance' has no attribute 'api'

   解决办法：

   # 在glace包下的__init__文件中
   from . import api
   
   # 在api包下的__init__文件中
   from . import policy
   
   # 再次在glace同级文件test下执行
   import glance
   glance.api.policy.get()
   # from policy.py