python—day15 包的认识、执行顺序、执行流程、循环导入、包的导入、绝对、相对导入

一、包的认识

包通过文件夹来管理一系列功能相近的模块
​
包：一系列模块的集合体
重点：包中一定有一个专门用来管理包中所有模块的文件
包名：存放一系列模块的文件夹名字
包名(包对象)存放的是管理模块的那个文件的地址，指向其全局名称空间

　

二、模块的加载顺序

# 模块的加载顺序：内存 => 内置 => sys.path（一系列自定义模块）
​
import sys
sys.path  # 环境变量：存放文件路径的列表
# 重点：默认列表第一个元素就是当前被执行文件所在的目录
​
# 可以自定义往sys.path添加路径
sys.path.append(r'想导入的模块的绝对路径')  # 添加到环境变量最后，最后被查找
sys.path.insert(0, r'想导入的模块的绝对路径')  # 添加到指定索引，索引就决定了自定义模块的查找顺序

import time
print(time)# 输出结果<module 'time' (built-in)>

# 第一次导入：内存》内置》自定义，最终是在自定义中找到，完成导入，并在内存中缓存模块的内存地址
import m1
print(m1.num) # 输出100
time.sleep(5)  # 输出'D:\\fullstack_s41\\day16\\2、模块的加载顺序'

# 再次导入，从内存中可以找到，即当前文件为删除状态，内存中的地址仍然被引用
import m1 as mm1
print(mm1.num)

import  sys
# 环境变量：就是存放文件路径的列表
# 重点：默认列表第一个元素就是当前被执行文件所在的目录
print(sys.path)

# 可以自定义往sys.path添加路径
sys.path.append(r'D:\fullstack_s41\day16\2、模块的加载顺序')
sys.path.insert(0,r'D:\fullstack_s41\day16\2、模块的加载顺序')
print(sys.path)

# 可以自定义往sys.path添加路径
sys.path.append(r'D:\fullstack_s41\day16\1、包的认识')  # sys.path.append(r'想导入的模块的绝对路径')添加到环境变量后，最后被查找
sys.path.insert(0,r'想导入的模块的绝对路径') # 添加到指定索引，索引就决定了自定义模块的查找顺序

三、模块导入的执行流程

导入模块的指令：
    -- 相对于 函数名() 调用函数体，函数调用会进入函数体，从上至下逐句解释执行函数体代码
    -- 导入模块，会进入模块文件，从上至下逐句解释执行模块文件代码
    -- 如果在模块中又遇到导入其他模块，会接着进入导入的模块，从上至下逐句解释执行文件中代码，依次类推

　

# 导入模块
import m3
print(m3.a)
print('end')

# 导入的模块要一步步进行执行在返回之前的原模块在进行一步步执行（如果在添加一个模块则从第一个导入的模块运行完再运行新加入的模块最后返回第一个原模块第一步进行运行）
# 这些操作步骤和执行顺序也造就了模块的循环导入调用函数体
# 操作流程：相当于函数名（），函数调用会进入函数体，从上至下逐句解释执行函数体代码
# 导入模块，会进入模块文件，从上至下逐句解释执行模块文件代码
# 如果在模块中又遇见其他模块，接着进入导入的模块，从上至下逐句解释执行文件中代码，以此类推

四、循环导入

模块之间出现了环状导入，如：m1.py 中导入了m2，m2.py 中又导入了m1.py
​
循环导入的问题：
    -- 导入模块是要使用模块中的变量
    -- 正常逻辑都是在文件最上方先完成对模块的导入，再在下方定义自身模块变量，以及使用导入的模块中的变量
    -- 由于导入模块的特殊机制，第一次导入模块会编译执行导入的模块，也就是会进入模块逐句执行模块内容，再次导入只是使用内存中的名字
    -- 就会出现下面的情况，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循环导入问题：延后导入---但产生对方要使用的名字，再去完成带入对方

# 1、from导入马上就会使用名字，极容易出现错误，建议循环导入情况下使用import导入
# 2、先提前产生名字，再导入模块
# 3、将导入逻辑放在函数中，将导入的逻辑延后到函数的调用，只有调用在产生名字之后即可

import m4  调用m4模块
import mm4     调用mm4模块

五、包的导入

​
# import本质：通过查找环境变量(sys.path)中的绝对路径来完成导入
# 导包：
# 1.保证包所在文件夹在环境变量中
# 2.导入的文件夹名就是包名
import pk
​

pk文件夹
    -- __init__.py

　　

# 右键执行该文件，sys.path第一个元素是当前文件夹的路径  #是主文件右键中copy path键是拷贝绝对路径
import sys
print(sys.path)  # 第一个元素D:\Python36\python3.exe D:/fullstack_s41/day16/5、包/5、包.py就是这个地址

# 重点：后期包基本上不和执行文件同一目录，只有保证包所在的文件夹路径在环境变量中即可
# 将5中的包pk放到4的文件夹下，就会报错
sys.path.append(r'D:\fullstack_s41\day16\4、循环导入') # 报错

del sys.path[0]
print(sys.path) #  将当前所在文件路径移除，统一会出现异常

# import 本质：通过查找环境变量中的绝对路径来完成导入
# 导包
# 1、保证包所在的文件夹在环境变量中
# 2、导入的文件夹就是包名
# eg：import  pk   #  pk：就是导入的包名
print(pk.a)
print(pk.b)

from pk import a,b
print(a)
print(b)  # 外置取值
# 包名是一个文件夹，名称空间是：建包是产生的_init_.py文件产生的

六、导包完成的三件事

导包完成的三项事：
1.编译执行包中的__init__.py文件，会在包中__pycache__创建对应的pyc文件
2.产生__init__.py文件的全局名称空间，用来存放__init__出现的名字
3.产生包名指向__init__.py文件的全局名称空间 | 指定变量名指向包中指定名字

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

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导入

注意点：
1.在包__init__.py中不建议使用import导入
2、在包__init__.py中不建议使用as起别名
总结：不建议__init__.py中采用import管理名字 ==> 空着不写
​
在使用文件中
直接在要使用的文件中用import一层层找到你想要的名字
import 包名.文件名 as 别名
​
# 起完别名，原名不可以再使用
原名：包名.文件名 => 包名.文件名.变量名
别名：别名 => 别名.变量名

import pk7

print(pk7.pkm7)
print(pk7.m)

import pk7.pkm7
pk7.pkm7.func()

错误：所有.前都必须为文件夹
import pk7.pkm7.func as func

外界通过import导入方式最多只能导到模板
外界通过from导入方式和import差不多，最多可以直接导到具体的名字
from pk7.pkm7 import func
func()

错误：所有.前都必须为文件夹
from pk7.pkm7.func import func

在所有包的init文件没有管理下，直接通过外界导入访问
import pk7.sub
print(pk7.sub.sub_a)
import pk7.sub.subm as sub
print(sub.subm_a)

from pk7.sub import sub_a
print(sub_a)

from pk7.sub.subm import subm_a
print(subm_a)

八、包中使用import导入：绝对导入

# 在包的__init__文件中
import 模块名  # 问题：所属包不在环境变量，报错
import 包名.模块名  # 问题：包所属文件夹不在文件变量，报错
import 包名.模块名 as 别名  # 在外界：包名.模块名 | 包名.别名 都可以访问
import 包名.模块名.名字  # 问题：导包语句.语法左侧必须全部是包(文件夹)
​
​
# 外界
import 包名
包名.名字  # 访问的是__init__中的名字
包名.模块  # 访问的模块这个地址
包名.模块.名字  # 访问的模块中的名字
​
import 包名.模块
包名.模块  # 访问的模块这个地址
包名.模块.名字  # 访问的模块中的名字
​
from 包名 import 模块
模块  # 访问的模块这个地址
模块.名字  # 访问的模块中的名字
​
from 包名.模块 import 名字
名字  # 访问的模块中的名字

# .代表当前文件夹
from .pkm8 import num
from .pkm8 import fn

# from .sub import x
# from .sub.subm import y
from . import sub

from .sub import subm

九、包中使用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

​
# 有子包
​
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
​

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

# .代表当前 | ..代表上一级目录 | ...代表上上一级目录
from ..pkm2 import name as pkm2_name
from ..sub1.sub1m import name as sub1m_name

def fn2():
    print(pkm2_name)
    print(sub1m_name)