python全栈开发 day16 十六、包

一、包的概念

包：一系列模块的集合体。包通过文件夹管理一系列功能相近的模块

重点：包中一定有一个专门用来管理包中所有模块的文件

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

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

二、模块的加载顺序

1、模块的加载顺序：内存 => 内置 => sys.path(一系列自定义模块)

sys.path：环境变量

2、第一次导入：内存 => 内置 => 自定义

最终在自定义中找到，完成导入，并在内存中缓存模块的内存地址

主文件

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


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

my_time

x = 1000

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

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

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

m1：

num = 888

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

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

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

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

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

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

# 例如：
import sys
sys.path.append(r'D:\SH-fullstack-s3\day16\2 模块的加载顺序')
print(sys.path)
sys.path.insert(0,r'D:\SH-fullstack-s3\day16\2 模块的加载顺序')
print(sys.path)

三、导入模块的执行顺序

1、

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：

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


a = 1000
b = 2000

mm3：

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

2、导入模块的执行流程

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

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

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

四、循环导入

1、

import m4
import mm4

m4：

# 方式一
# 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：

# 方式一
# 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()

2、

循环导入导致的问题：

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

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

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

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

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