什么是模块

  1. 使用 python 编写的代码（.py 文件）
  2. 已被编译为共享库或 DLL 的 C 或 C ++ 扩展
  3. 包好一组模块的包
  4. 使用 C 编写并链接到 python 解释器的内置模块

为何要使用模块

实现代码和功能的复用

import 自定义模块 my_module.py

文件名 my_module.py, 模块名 my_module

  1. # my_module.py
  2. print('from the my_module.py')
  3. money = 100
  4. def read1():
  5.     print('my_module->read1->money',money)
  6. def read2():
  7.     print('my_module->read2 calling read1')
  8.     read1()
  9. def change():
  10.     global money
  11.     money=0

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

  1. import my_module
  2. import my_module
  3. import my_module
  4. import my_module
  5. import sys
  6. print(sys.modules())
  7. # sys.modules是一个字典，内部包含模块名与模块对象的映射，该字典决定了导入模块时是否需要重新导入。

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

  1. import my_module
  2. money=10
  3. print(my_module.money)

Python
Copy

  1. import my_module
  2. def read1():
  3.     print('=========')
  4. my_module.read1()

Python
Copy

  1. import my_module
  2. money = 1
  3. my_module.change()
  4. print(money)
  5. print(my_module.money)

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

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

为模块名起别名，相当于 m1=1;m2=m1

  1. import my_module as mm
  2. print(mm.money)

Python
Copy

示范用法：

有两中 sql 模块 mysql 和 oracle，根据用户的输入，选择不同的 sql 功能

  1. # mysql.py
  2. def sqlparse():
  3.     print('from mysql sqlparse')
  4. # oracle
  5. def sqlparse():
  6.     print('from oracle sqlparse')
  7. # test.py
  8. db_type=input('>>: ')
  9. if db_type == 'mysql':
  10.     import mysql as db
  11. elif db_type == 'oracle':
  12.     import oracle as db
  13. db.sqlparse()

Python
Copy

在一行导入多个模块

  1. import  sys.os.re

Python
Copy

from … import …

对比 import my_module，会将源文件的名称空间 ‘my_module’ 带到当前名称空间中，使用时必须是 my_module. 名字的方式
而 from 语句相当于 import，也会创建新的名称空间，但是将 my_module 中的名字直接导入到当前的名称空间中，在当前名称空间中，直接使用名字就可以了

  1. from my_module import read1,read2
  2. money = 1000
  3. read1()
  4. # 导入的函数read1，执行时仍然回到my_module.py中寻找全局变量money

Python
Copy

  1. from my_module import read1,read2
  2. money = 1000
  3. def read1():
  4.     print('*'*10)
  5. read2()
  6. # 导入的函数read2，执行时需要调用read1(),仍然回到my_module.py中找read1()

Python
Copy

  1. from my_module import read1,read2
  2. money = 1000
  3. def read1():
  4.     print('*'*10)
  5. read1()
  6. # 导入的函数read1，被当前位置定义的read1覆盖掉了

Python
Copy

  1. from my_module import read1 as read
  2. read()
  3. # 也支持as

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

  1. .....
  2. __all__ = ['money','read1']
  3. # 这样在另外一个文件中用from my_module import *就这能导入列表中规定的两个名字
  4. # test.py
  5. from my_module import *
  6. print(money)
  7. read1()
  8. read2()

Python
Copy
注意：如果 mymodule.py 中的名字前加 , 即_money，则 from my_module import *, 则_money 不能被导入

  • 编写好的一个 python 文件可以有两种用途：
    1. 脚本，一个文件就是整个程序，用来被执行
    2. 模块，文件中存放着一堆功能，用来被导入使用
  • python 为我们内置了全局变量__name__，
    1. 当文件被当做脚本执行时：__name__ 等于'__main__'
    2. 当文件被当做模块导入时：__name__等于模块名
  • 作用：用来控制.py 文件在不同的应用场景下执行不同的逻辑（或者是在模块文件中测试代码）
    1. if __name__ == '__main__':
      1. def fib(n):
      2. a, b = 0, 1
      3. while b < n:
      4.   print(b, end=',')
      5.   a, b = b, a+b
      6. print()
      7. if __name__ == "__main__":
      8. print(__name__)
      9. num = input('num :')
      10. fib(int(num))
      Python
      Copy

      模块的搜索路径

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

注意：自定义的模块名不应该与系统内置模块重名

编译 python 文件

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

包

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

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

为何要使用包

包的本质就是一个文件夹，那么文件夹唯一的功能就是将文件组织起来
随着功能越写越多，我们无法将所以功能都放到一个文件中，于是我们使用模块去组织功能，而随着模块越来越多，我们就需要用文件夹将模块文件组织起来，以此来提高程序的结构性和可维护性

注意事项

  1. 关于包相关的导入语句也分为import和from ... import ...两种，但是无论哪种，无论在什么位置，在导入时都必须遵循一个原则：凡是在导入时带点的，点的左边都必须是一个包，否则非法。可以带有一连串的点，如item.subitem.subsubitem, 但都必须遵循这个原则。但对于导入后，在使用时就没有这种限制了，点的左边可以是包, 模块，函数，类 (它们都可以用点的方式调用自己的属性)。
  2. import 导入文件时，产生名称空间中的名字来源于文件，import 包，产生的名称空间的名字同样来源于文件，即包下的__init__.py，导入包本质就是在导入该文件
  3. 包 A 和包 B 下有同名模块也不会冲突，如 A.a 与 B.a 来自俩个命名空间

包的使用

示例文件

  1. glance/                   #Top-level package
  2. ├── __init__.py      #Initialize the glance package
  3. ├── api                  #Subpackage for api
  4. │   ├── __init__.py
  5. │   ├── policy.py
  6. │   └── versions.py
  7. ├── cmd                #Subpackage for cmd
  8. │   ├── __init__.py
  9. │   └── manage.py
  10. └── db                  #Subpackage for db
  11.     ├── __init__.py
  12.     └── models.py

Python
Copy
文件内容

  1. #文件内容
  2. #policy.py
  3. def get():
  4.     print('from policy.py')
  5. #versions.py
  6. def create_resource(conf):
  7.     print('from version.py: ',conf)
  8. #manage.py
  9. def main():
  10.     print('from manage.py')
  11. #models.py
  12. def register_models(engine):
  13.     print('from models.py: ',engine)

Python
Copy

使用 import 导入包

  1. import glance.db.models
  2. # 在导入glance的时候会执行glance下的__init__.py中的代码
  3. glance.db.models.register_models('mysql')

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

  1. import glance
  2. glance.cmd.manage.main()

Python
Copy
解决方法

  1. # glance/__init__.py
  2. from . import cmd
  3. # glance/cmd/__init__.py
  4. from . import manage

Python
Copy

使用 from … import …

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

  1. from glance.db import models
  2. from glance.db.models import register_models
  3. models.register_models('mysql')
  4. register_models('mysql')

Python
Copy
from glance.api import *
想从包 api 中导入所有，实际上该语句只会导入包 api 下__init__.py文件中定义的名字，我们可以在这个文件中定义__all__

  1. x = 10
  2. def func():
  3.     print('from api.__init.py')
  4. __all__=['x','func','policy']

Python
Copy

  1. from glance.api import *
  2. func()
  3. print(x)
  4. policy.get()

Python
Copy

绝对导入和相对导入

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

绝对导入: 以执行文件的 sys.path 为起始点开始导入, 称之为绝对导入

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

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

  1. 符号: . 代表当前所在文件的文件加,.. 代表上一级文件夹,… 代表上一级的上一级文件夹
  2. 优点: 导入更加简单
  3. 缺点: 只能在导入包中的模块时才能使用注意:
    • 相对导入只能用于包内部模块之间的相互导入, 导入者与被导入者都必须存在于一个包内
    • 试图在顶级包之外使用相对导入是错误的, 言外之意, 必须在顶级包内使用相对导入, 每增加一个. 代表跳到上一级文件夹, 而上一级不应该超出顶级包