16 包

桃扇骨 2022-01-09 13:07 230阅读 0赞

## 包 ##

一系列模块的集合体

-- 包就是管理功能相近的一系列模块的文件夹  
 -- 该文件夹包含一个特殊文件\_\_init\_\_.py，专门用来管理包中所有模块的文件  
 -- 存放一系列模块的文件夹名就是包名，产生的包名就是指向\_\_init\_\_.py的全局名称空间

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

## 模块的加载顺序 ##

模块的加载顺序：内存 => 内置 => sys.path（一系列自定义模块）

1.导入模块会优先在内存中查找  
　　2.内存中没有被加载的话，再去查找内置模块  
　　3.还没有查找到，就根据sys.path中的路径顺序逐一查找

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

## 模块导入的执行流程 ##

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

## 循环导入 ##

模块之间出现了环状导入，如：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本质：通过查找环境变量(sys.path)中的绝对路径来完成导入

导包：

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

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

import pk

pk文件夹

-- \_\_init\_\_.py

## 导包完成的三件事 ##

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

总结：包名为文件夹名，名称空间是\_\_init\_\_.py产生的

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

注意点：

1.在包\_\_init\_\_.py中不建议使用import导入

2、在包\_\_init\_\_.py中不建议使用as起别名

总结：不建议\_\_init\_\_.py中采用import管理名字 ==> 空着不写

在使用文件中

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

import 包名.文件名 as 别名

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

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

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

## 包中使用import导入：绝对导入 ##

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

## 包中使用from导入：相对导入 ##

没有子包

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

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

相对导入是存在于包内的语法  
 .代表当前文件夹  
 ..代表上一级文件夹

...代表上上一级文件夹

1. 导入模块的加载顺序：内存 > 内置 > sys.path
    2. 导入模块的执行流程：遇到导模块 -> 直接就进入模块文件，从上执行执行导入 -> 在遇到导包，再进入执行
    3. 循环导入：1.形成了环状导入；2.使用名字时名字未产生 -> 延后导入
    4. 包及包的概念：一系列模块的集合体，__init__.py就是一个模块，只是其名称空间可以被包名指向
    5. 绝对导入：import 导入 和 from 不是以.开头的导入，都是绝对导入, 和sys.path息息相关
    6. 相对导入：from .开头的导入，这样的文件不能作为可执行文件，所以是包内语法
        1）包内语法：不止init文件可以使用，包内的所有模块都可以使用
        2）.是当前目录，..是上一级目录，以此类推

## 字符串导入 ##

importlib导入模块

# 包 xxx
    
    a.py文件
    name = 'from a.py'
    
    b.py文件
    import importlib
    
    s = 'xxx.a'
    res = importlib.import_module(s)
    print(res.name)  # from a.py

# #

转载于:https://www.cnblogs.com/zhouyongv5/p/10679039.html