## 复习
```python
'''
函数回调：在调用，再实现(所运用的知识点：函数对象作为函数的参数)
模块（.py文件）：import | from
模块：一系列功能的集合体
优点：1.文件级别管理代码 2.拿来主义
导入完成的三件事：
1.编译执行模块文件形成对应的pyc文件
2.形成模块的全局名称空间，存放模块中的名字
3.通过import关键字产生名字指向对应的地址
（m0|mm0存放全局名称空间的地址 | a|aa存放的是变量a的地址）
注：一个文件就会产生一个全局名称空间，之间不互通
注：用as起别名后，原名字失效
自执行与模块的区分
__name__:
1.== 模块名(文件名)：该文件为模块，被导入使用
2. == '__main__'：该文件为自执行文件
'''
from part1 import m0 as mmm
from part1.m0 import a as aa
bb = aa
def a(callback=None):
aa = 10
bb = 20
if callback:
res = callback(aa, bb)
pass
def b(*args):
return 'b'
a(b)
def c(*args):
return 'c'
a(c)
def d():
# global mmm
e(mmm)
def e(arg):
print('>>>', arg.b)
d()
# import sys
# print(sys.path)
```
## 包的认识
```python
'''
包通过文件夹来管理一系列功能相近的模块
包：一系列模块的集合体
重点：包中一定有一个专门用来管理包中所有模块的文件
包名：存放一系列模块的文件夹的名字
包名(包对象)存放的是管理模块的那个文件的地址，指向其全局名称空间
'''
'''
***
重点：包
难点：包，循环导入
模块加载顺序 **
模块导入执行顺序 **
循环导入 *****
创建并使用包 ***
import与from **
子包：了了解
绝对导入(了了解)，相对导入（***）
'''
```
## 模块的加载顺序
```python
# 模块的加载顺序：内存 => 内置 => sys.path（一系列自定义模块）
import sys
sys.path # 环境变量：存放文件路径的列表
# 重点：默认列表第一个元素就是当前被执行文件所在的目录
# 可以自定义往sys.path添加路径
sys.path.append(r'想导入的模块的绝对路径') # 添加到环境变量最后，最后被查找
sys.path.insert(0, r'想导入的模块的绝对路径') # 添加到指定索引，索引就决定了自定义模块的查找顺序
'''
import time
print(time)
# import my_time
# print(my_time)
# 第一次导入：内存->内置->自定义，最终在自定义中找到，完成导入，并在内存中缓存模块的内存地址
import m1
print(m1.num)
# time.sleep(5)
# 再次导入，从内存中就可以直接找到，即时当前文件为删除状态，内存中的地址任然可以被引用
import m1 as mm1
print(mm1.num)
'''
```
## 模块导入的执行流程
```python
'''
导入模块的指令：
-- 相对于 函数名() 调用函数体，函数调用会进入函数体，从上至下逐句解释执行函数体代码
-- 导入模块，会进入模块文件，从上至下逐句解释执行模块文件代码
-- 如果在模块中又遇到导入其他模块，会接着进入导入的模块，从上至下逐句解释执行文件中代码，依次类推
'''
```
## 循环导入
```python
'''
模块之间出现了环状导入，如：m1.py 中导入了m2，m2.py 中又导入了m1
循环导入的问题：
-- 导入模块是要使用模块中的变量
-- 正常逻辑都是在文件最上方先完成对模块的导入，再在下方定义自身模块变量，以及使用导入的模块中的变量
-- 由于导入模块的特殊机制，第一次导入模块会编译执行导入的模块，也就是会进入模块逐句执行模块内容，再次导入只是使用内存中的名字
-- 就会出现下面的情况，m2在使用m1中的变量x，但变量x却并未产生，这就出现了循环导入问题
m1.py文件
import m2
x = 10
print(m2.y)
m2.py文件
import m1
y = 10
print(m2.x)
解决循环导入的问题：延后导入
1、将循环导入对应包要使用的变量提前定义，再导入响应的包
2、将导包的路径放到函数体中，保证存放导包逻辑的函数调用在要使用的变量定义之后
重点：
问题：from导包极容易出现循环导入问题
解决：建议from导入方式改用import导入方式
'''
'''
# import m4
import mm4
'''
# 循环导入导致的问题：
# 两个模块直接相互导入，且相互使用其名称空间中的名字，但是有些名字没有产生就使用，就出现了循环导入问题
# 解决循import m4环导入问题：延后导入 - 但产生对方要使用的名字，再去完成导入对方
# 1.from导入马上会使用名字，极容易出现错误，建议循环导入情况下，使用import导入
# 2.先提前产生名字，在导入模块
# 3.在导入逻辑放在函数中，将导入的逻辑延后到函数的调用，只要调用在产生名字后即可
```
## 包的导入
```python
```
```python
# import本质：通过查找环境变量(sys.path)中的绝对路径来完成导入
# 导包：
# 1.保证包所在文件夹在环境变量中
# 2.导入的文件夹名就是包名
import pk
'''
pk文件夹
-- __init__.py
'''
```
## 导包完成的三件事
```python
'''
导包完成的三项事：
1.编译执行包中的__init__.py文件，会在包中__pycache__创建对应的pyc文件
2.产生__init__.py文件的全局名称空间，用来存放__init__出现的名字
3.产生包名指向__init__.py文件的全局名称空间 | 指定变量名指向包中指定名字
'''
# 总结：包名为文件夹名，名称空间是__init__.py产生的
# 右键执行该文件，sys.path第一个元素是当前文件夹路径
import sys
# print(sys.path)
# 重点：后期包基本上不和执行文件在同一目录，只要保证包所在文件夹路径在环境变量中即可
# sys.path.append(r'D:fullstack_s4day16代码part4')
# del sys.path[0]
# print(sys.path)
# 将当前所在文件路径移除，同样会出现导入异常
# import本质：通过查找环境变量中的绝对路径来完成导入
# 导包：
# 1.保证包在环境变量中
# 2.导入的文件夹名就是包名
# import pk
# print(pk.a)
# print(pk.b)
from pk import a, b
print(a)
print(b)
```
## 使用包中模块中的名字：采用import导入
```python
'''
注意点：
1.在包__init__.py中不建议使用import导入
2、在包__init__.py中不建议使用as起别名
总结：不建议__init__.py中采用import管理名字 ==> 空着不写
在使用文件中
直接在要使用的文件中用import一层层找到你想要的名字
import 包名.文件名 as 别名
# 起完别名，原名不可以再使用
原名：包名.文件名 => 包名.文件名.变量名
别名：别名 => 别名.变量名
'''
# import sys
# sys.path.append(r'D:fullstack_s4day16代码part6pk6')
# import pm1
# pk6当前与执行文件test6在同一目录，使用可以直接import pk6
# 然后在此基础上再导入pm1
import pk6.pm1
num = 100
# 在包中：
# 1、不建议使用import导入
# 2、不建议使用as起别名
import pkk6.pkkm1 as pk
# import pk6
#
# print(pk6.pm1)
# print(pk6.pm1.num)
# import pkk6
# print(pkk6.num)
# import pkk6.pkkm1
# pkk6.pkkm1.fn()
# pkk6.pk.fn()
# import pkk6.pkkm1 as pk
# pk.fn()
# pkk6.pkkm1.fn()
# 如果使用import来导入包并使用包中模块中的名字
# 直接在要使用的文件中用import一层层找到你想要的名字
# import ppk6.ppkm1 as pk
# # print(ppk6.ppkm1.num) # 起完别名，原名不可以再使用
# print(pk.num)
# import ppk6.ppkm1.num as num
import part6.ppk6.ppkm1
# 导包的点语法：必须保证所有.左侧都是文件夹
```
## 包中使用import导入：绝对导入
```python
# 在包的__init__文件中
import 模块名 # 问题：所属包不在环境变量，报错
import 包名.模块名 # 问题：包所属文件夹不在文件变量，报错
import 包名.模块名 as 别名 # 在外界：包名.模块名 | 包名.别名 都可以访问
import 包名.模块名.名字 # 问题：导包语句.语法左侧必须全部是包(文件夹)
# 外界
import 包名
包名.名字 # 访问的是__init__中的名字
包名.模块 # 访问的模块这个地址
包名.模块.名字 # 访问的模块中的名字
import 包名.模块
包名.模块 # 访问的模块这个地址
包名.模块.名字 # 访问的模块中的名字
from 包名 import 模块
模块 # 访问的模块这个地址
模块.名字 # 访问的模块中的名字
from 包名.模块 import 名字
名字 # 访问的模块中的名字
```
## 包中使用from导入：相对导入
```python
# 没有子包
''' 1）
pk包
-- __init__.py
-- 名字 a = 10
-- pkm.py
-- 名字 b = 20
在外界
import pk
pk.a 访问a
pk.b 访问b
init管理文件
a不需要操作
from .pkm import b
'''
# 有子包
''' 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
'''
# 注：有相对导入.语法的文件都不能自执行
```