一.包

　　1.包的定义

　　　包：就是一系列模块的结合体

　　2.重点

　　　1.包中一定要有一个专门来管理包中所有模块的文件

　　　2.包名：存放一系列模块的文件夹名字

　　　3.包名(包对象)存放的是管理模块的那个文件的地址，指向其全局名称空间

二.模块的加载顺序

　　1.模块的加载顺序：

　　　　第一次：内存 -> 内置模块 ->sys.path(自定义的一系列模块)

　　　　再次导入：从内存中就可以直接找到，即使文件被删除其内存地址也可以被使用

　　2.sys.path：环境变量，存放文件路径的列表,列表第一个元素默认是当前被执行文件所在的目录。

　　3.可以自定义往sys.path中添加路径

　　　　sys.path.append(r'想导入的模块的绝对路径') #添加到最后，最后被查找

　　　　sys.path.insert(0.r'想导入的模块的绝对路径')# 添加到指定位置，索引决定模块的查找顺序

三.模块的导入

　　3.1 模块导入的执行流程

　　　　1.导入模块的指令:

　　　　与函数的调用方式相似,导入模块会进入模块文件,从上到下逐句解释执行模块文件代码

　　　　如果在模块中又遇到导入其他模块，会接着进入导入的模块，并从上到下逐句解释代码，以此类推

　　3.2 模块的循环导入

　　　　1.循环导入就是模块之间出现了环状导入,如:m1.py中导入了m2,m2.py中又导入了m1

　　　　2.循环导入的问题：

　　　　　　两个模块直接相互导入,且相互使用了对方名称空间中的名字，但有些名字没有产生救被使用了。

　　　　　　正常逻辑都是在文件最上方完成对模块的导入,再在下方定义自身模块的变量和使用导入模块中的变量

　　　　　　由于第一次导入模块会编译执行导入的模块而后逐句执行如果导入模块中使用了还未被赋值的变量就会出现问题

　　　　　　例如：m1.py文件　　　　　　　　m2.py文件

　　　　　　　　　import m2　　　　　　　　import m1

　　　　　　　　　x = 10　　　　　　　　　 y = 10

　　　　　　　　　print(m2.y)　　　　　　　print(m1.x)

　　　　 3.循环导入的解决方法

　　　　　　延后导入:

　　　　　　　　1.将循环导入对应包要使用的变量提前定义，再导入相应的包

　　　　　　　　2.将导包的路径放在函数体中,保证存放导包逻辑的函数调用在使用变量定义之后

　　　　　　重点：from导包极容易出现循环导入问题，建议改用import导入方式

四.包的导入

　　1.导包：

　　  1.保证包所在文件夹在环境变量sys.path中

　　　 2.导入的文件夹名就是包名

　　2.导包操作完成的三件事

　　　 1.编译执行包中的__init__.py文件，会在包中的__pycache__创建对应的pyc文件　

　　　 2.产生__init__.py文件的全局名称空间，用来存放__init__出现的名字

　　　 3.产生包名指向__init__.py文件的全局名称空间 |指定变量名指向包中指定名字

　　　　总结：包名就是文件夹名，名称空间是__init__.py产生的

五.包中模块的使用与导入

　　1.使用包中模块中的名字：采用import导入

　　　　1.在使用文件中，直接在要使用的文件中用import一层层找到想要的名字

　　　　import 包名.文件名 as别名

　　　　2.起完别名，原名不可以再使用

　　　　　原名：包名.文件名 => 包名.文件名.变量民

　　　　　别名：别名 => 别名.变量名

　　　　3.注意点：

　　　　　　1.在包__init__.py中不建议使用import导入

　　　　　　2.在包__init__.py中不建议使用as起别名

　　　　　总结:不建议__init__.py中采用import管理名字 ==> 空着不写

　　2.包中使用import导入:绝对导入

　　　　1.在包的__init__文件中

　　　　import 模块名 # 问题:所属包不在环境变量中会报错

　　　　import 包名.模块名 # 问题:包所属文件夹不在环境变量，报错

　　　　import 包名.模块名 as 别名 # 在外界 包名.模块名|包名.别名都可以访问

　　　　import 包名.模块名.名字 # 问题:导包语句 . 左侧必须全部是包(文件夹)

　　　　2.在外界

　　　　import 包名

　　　　包名.名字 # 访问的是__init__中的名字

　　　　包名.模块 # 访问的是模块地址　　

　　　　包名.模块.名字 # 访问的是模块中的名字

　　　　import 包名.模块

　　　　　包名.模块 # 访问的是模块地址　　

　　　　包名.模块.名字 # 访问的是模块中的名字

　　　　from 包名 import 模块
　　　　模块 # 访问的模块这个地址
　　　　模块.名字 # 访问的模块中的名字

　　　　from 包名.模块 import 名字
　　　　名字 # 访问的模块中的名字

　　3.包中使用from导入:相对导入　

　　　　1.没有子包

　　　　　　pk包
　　　　　　　　-- __init__.py
　　　　　　　　-- 名字 a = 10
　　　　　　　　-- pkm.py
　　　　　　　　-- 名字 b = 20
　　　　　　在外界导入
　　　　　　import pk
　　　　　　pk.a 访问a
　　　　　　pk.b 访问b

　　　　　　init管理文件导入
　　　　　　a不需要操作
　　　　　　from .pkm import b

　　　　2.有子包

　　　　　　1）
　　　　　　　　pk包
　　　　　　　　　　-- __init__.py
　　　　　　　　sub子包
　　　　　　　　　　-- __init__.py
　　　　　　　　　　　　名字 x = 10
　　　　　　　　　　-- subm.py
　　　　　　　　　　　　名字 y = 10

　　　　　　　　在外界导入
　　　　　　　　import pk
　　　　　　　　pk.x 访问x
　　　　　　　　pk.y 访问y

　　　　　　　　在pk的init管理文件导入
　　　　　　　　from .sub import x
　　　　　　　　from .sub.subm import y

　　　　　　2）
　　　　　　　　pk包
　　　　　　　　　　-- __init__.py
　　　　　　　　sub子包
　　　　　　　　　　-- __init__.py
　　　　　　　　　　　　名字 x = 10
　　　　　　　　　　-- subm.py
　　　　　　　　　　　　名字 y = 10

　　　　　　　　在外界导入
　　　　　　　　import pk
　　　　　　　　pk.sub.x 访问x
　　　　　　　　pk.sub.y 访问y

　　　　　　　　在pk的init管理文件：要产生sub名字
　　　　　　　　from . import sub => pk.sub

　　　　　　　　在sub的init管理文件：要产生x，y名字
　　　　　　　　x不需要操作 => pk.sub.x
　　　　　　　　from .subm import y => pk.sub.y

　　　　　　　　注：有相对导入.语法的文件都不能自执行