循环导入

一、包的概念

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

二、模块的加载顺序

1、模块的加载顺序：内存 => 内置 => sys.path(一系列自定义模块)
2、第一次导入：内存 => 内置 => 自定义
最终在自定义中找到，完成导入，并在内存中缓存模块的内存地址

主文件

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

import my_time
print(my_time.x)    # 结果为 1000

my_time.py

x = 1000

再次被导入，从内存中就直接可以找到，

即当前文件为删除状态，内存中的地址任然可以被引用

 主文件

import m1 as mmm1
print(mmm1.num)     # 结果为 888

m1.py：

num = 888

环境变量：存放文件路径的列表：

重点：默认列表第一个元素就是当前被执行文件所在的目录 

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

sys.path.append(r'想导入的模块的绝对路径')

添加到环境变量后，最后被查找 # sys.path.insert(0,r'想导入的模块的绝对路径') 

添加到指定索引，索引就决定了自定义模块的查找顺序

import sys
sys.path.append(r'D:SH-fullstack-s3day162 模块的加载顺序')
print(sys.path)
sys.path.insert(0,r'D:SH-fullstack-s3day162 模块的加载顺序')
print(sys.path)

三、导入模块的执行顺序

主文件

import m3
print(m3.x)
print(m3.y)
print(m3.a)
print(m3.b)
print('end')

# 结果为
mm3 imported
m3 imported
200
500
1000
2000
end

m3.py：

from mm3 import x,y
print('m3 imported')

a = 1000
b = 2000

mm3.py：

print('mm3 imported')
x = 200
y = 500

 

导入模块的执行流程

相对于 函数名（）调用函数体，函数调用会进入函数体，从上至下逐句解释执行函数体代码

导入模块，会进入模块文件，从上至下逐句解释执行模块文件代码

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

四、循环导入

import m4
import mm4

m4.py：

# 方式一
num = 666
import mm4
print(mm4.arg)

# 方式二
num = 666
from mm4 import arg
print(arg)

# 方式三
def fn():
    import mm4
    print(mm4.arg)
num = 666
fn()

mm4.py：

# 方式一
arg = 777
import m4
print(m4.num)

# 方式二
arg = 777
from m4 import num
print(num)


# 方式三
def fn():
    import m4
    print(m4.num)
arg = 777
fn()

循环导入导致的问题：

两个模块直接相互导入，且相互使用其名称空间中的名字，但是有些名字没有产生就使用，就出现了循环导入问题 

解决import m4循环导入问题：延后导入，先产生对方要使用的名字，再去完成导入对方  

from导入马上会使用名字，极容易出现错误，建议循环导入情况下，使用import导入

先提前产生名字，在导入模块（先做饭，再出门）

在导入逻辑放在函数中，将导入的逻辑延后到函数的调用，只要调用在产生名字后即可