模块与包管理

模块

"""
常见的四种模块：module
1.使用python编写的.py文件
2.把一系列模块组织到一起的文件夹（注：文件夹下有一个__init__.py文件，该文件夹称之为包）
3.使用C编写并链接到python解释器的内置模块
4.已被编译为共享库或DLL的C或C++扩展
"""

# 1、什么是模块：一系列功能的集合体，模块都有'.'语法
任何一个py文件或者说数据结构都能称为模块，因为都有'.'语法

# 2、为什么会出现模块：很多相似的功能，要统一管理，将这些功能放在一个文件中，该文件就是管理这些功能的集合体，我们命名为模块

# 3、怎么使用模块
#		-- 在要使用模块功能的文件中导入模块：
import 模块名  - 模块名：用来管理一系列功能的文件名(实现功能的文件名)

# 4、在哪使用模块
#		-- 在所有要使用模块中功能的文件中导入并使用模块

#模块文件（m1.py）
def f1():
    print('扫地')

def f2():
    print('洗衣')

def f3():
    print('拖地')
    
# 使用模块文件
import m1

m1.f1()
m1.f2()
m1.f3()

导入模板完成的三件事

# 首次导入
import 模块名

# 1.将被导入的模块编译形成对应的pyc文件
# 2.进入模块，从上至下执行模块中的代码，将产生的所有名字(变量)存放在该模块文件的全局名称空间中
# 3.在使用模块的文件中，产生一个与模块名(模块文件名)同名的名字(变量)，指向模块的全局名称空间，这个名字可以称为文件对象或者模块对象

#文件对象/模块对象
代表模块，指向的是模块文件里存储对象的名称空间的地址，通过使用'.'语法去使用模块里的东西

# 模块文件 m1.py
print(1)
print(2)
print(3)
a=10

def fn():
    print(a)
print('end')

#使用模块的文件
import m1
print(m1.__dict__)  #打印m1的名称空间
print(m1.__dict__['a'])  #打印m1的名称空间
print(m1.a)  # m1文件对象通过'.'语法去使用模块里的变量a
print('t1 end')

print(m1)  #打印的是m1这个文件对象指向的模块的地址


# 再次导入

# 不再执行导入模块的前两步，只会走第三步：在当前模块中产生一个名字，指向第一次导入在内存中产生的全局名称空间

import m1
print(m1.a)
print(m1.__dict__)  #再次导入模块m1, m1的地址指向模块的名称空间

起别名

import 模块名 as 别名

# 重点：导入一旦起别名，原模块名变量失效，本质只产生了别名变量指向模块文件的全局名称空间

模块的分类

# 大方向：内置(built-in) | 自定义(系统提供 | 第三方提供 | 自己自定义)

模块的加载顺序

# 内存 > 内置 > sys.path (安装环境变量中路径的先后顺序逐一加载)

# 自定义模块加载顺序: 根据环境变量中路径的顺序依次执行，加载到了就停止，所以排在前面的路径下的自定义模块先加载

环境变量

存放路径的list，第一位默认一定是当前执行文件所在的路径

#举例

>>> part4/t1.py
import sys
print(sys)
print(sys.path)
# ['/Users/cj/Desktop/pycharm_project_2/part4', '/Users/cj/Desktop/pycharm_project_2', '/Applications/PyCharm.app/Contents/helpers/pycharm_display', '/Library/Frameworks/Python.framework/Versions/3.6/lib/python36.zip', '/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6', '/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/lib-dynload', '/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages', '/Applications/PyCharm.app/Contents/helpers/pycharm_matplotlib_backend']

>>> part3/t1.py
import sys
print(sys)
print(sys.path)
# ['/Users/cj/Desktop/pycharm_project_2/part3', '/Users/cj/Desktop/pycharm_project_2', '/Applications/PyCharm.app/Contents/helpers/pycharm_display', '/Library/Frameworks/Python.framework/Versions/3.6/lib/python36.zip', '/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6', '/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/lib-dynload', '/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages', '/Applications/PyCharm.app/Contents/helpers/pycharm_matplotlib_backend']

import sys
# sys.path就是环境变量

# 清空环境变量：所有导入都不能使用了
sys.path.clear()

# 添加指定路径到环境变量
sys.path.append()
sys.path.insert()

from...import语法导入

# 导入完成的三件事
# 1.将被导入的模块编译形成对应的pyc文件
# 2.进入模块，从上执行执行模块中的代码，将产生的所有名字存放在该模块文件的全局名称空间中
# 3.在导入模块的文件中形成(一个或多个)名字指向模块全局名称空间中的(一个或多个)具体名字

from 模块名 import 模块中的名字1, ..., 模块中的名字n
from 模块名 import 名字 as 别名


# from...import导入依赖环境变量 sys.path

#添加环境变量
import sys
sys.path.append(r'/Users/cj/Desktop/pycharm_project_2/part2/t1.py')

from...import *

# 模块中默认会添加 __all__ ，__all__ 就是管理模块中能被 * 导入的变量们
# __all__可以自定义，自定义 * 能导入的变量们， __all__的list中名字全部可以自定义
__all__ = ['a', 'b', 'c', 'd_', '_e']


# 系统默认添加的__all__中不会纳入 _开头的名字
#       -- 所以默认在外界通过from...import *无法导入_开头的名字
#		-- _开头的名字对from...import *是隐藏的，指名道姓依然可以被外界导入使用


#m1.py
_c=2
a=1000

#t1.py
from m1 import *
print(a)
print(_c) #报错 NameError: name '_c' is not defined

#m1.py
_c=2
a=1000

#t1.py
from m1 import _c
print(_c) #输出c的值

链式导入

# t1导入m1，m1导入m2，m2导入m3

# 执行流程：右键执行t1，在t1导入m1模块的地方直接进入m1，去执行m1，同理在m1执行过程中遇到导入m2，会马上进入m2，去执行m2，一直到m3，m3执行完毕，会回到m2中导入m3的语句，接着往下执行m2，m2执行完毕回到m1，以此类推返回到t1

# 在整个执行流程中，遇到任何模块的二次导入，都是直接引用内存中的名称空间，不会再次进入模块

#t1.py
print('t1 start')

import m1
print('t1 end')

#m1.py
print('m1 start')

import m2
print('m1 end')

#m2.py
print('m2 start')

import m3
print('m2 end')

#m3.py
print('m3 start')
import m1
import m2

print('m3 end')

循环导入

# 循环导入的问题点：名字没有产生就使用名字
# 解决循环导入：先产生名字，在导入模块
#       -- 将会产生循环导入的模块，导入语法延后 - 延后导入


# 问题
#t1.py
import m1

# m1.py
import m2
print(m2.y)
x=666

# m2.py
import m1
print(m1.x)
y=888



# 解决
#t1.py
import m1

# m1.py
x=666
import m2
print(m2.y)

# m2.py
import m1
y=888
print(m1.x)

sys.path显示

# 在pycharm中，sys.path环境变量这个列表索引0号位显示的是当前文件所在的路径，索引1号位显示的是pycharm中的项目的根目录

import sys
print(sys.path[0])  # /Users/cj/Desktop/pycharm_project_3/part1/b/c
print(sys.path[1]) # /Users/cj/Desktop/pycharm_project_3

# 但是在命令行界面，sys.path并不会显示项目的根目录
cj@cjwdeMacBook-Pro pycharm_project_3$ python3 /Users/cj/Desktop/pycharm_project_3/part1/t1.py
['/Users/cj/Desktop/pycharm_project_3/part1', '/Library/Frameworks/Python.framework/Versions/3.6/lib/python36.zip', '/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6', '/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/lib-dynload', '/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages']

跨文件导入模块分析

# 需求：跨文件夹访问
#目录结构
part1 
-> t1.py
->a(ma.py)
->b->c(mc.py)

#打开pycharm时，当前执行文件的环境变量是会被自动创建为这个文件所在的目录，所以如果import 该文件所在的目录的任意模块文件都是可以的

#有时候我们要导入当前文件所在的目录的同级目录的模块文件，或者是同级目录以下的模块文件，这个时候可以将路径加入环境变量或者通过'.'语法进行层级导入，这本质上就是一个绝对路径，起始路径是从环境变量中定义的路径开始的，如果后面需要print输出这个值，那么后面也是要写除了环境变量定义的路径外的所有路径，这种情况定义别名更方便

（方法一） 绝对导入(将文件所在的目录的路径拷贝到环境变量sys.path)
import sys

# 访问模块文件ma里的变量aaa
sys.path.append(r'/Users/cj/Desktop/pycharm_project_3/part1/a')
import ma
print(ma.aaa)

# 访问模块文件mc里的变量ccc
sys.path.append(r'/Users/cj/Desktop/pycharm_project_3/part1/b/c')
import mc
print(mc.ccc)

方法（二） 导入时写绝对路径

# 访问模块文件ma里的变量aaa
import a.ma
print(a.ma.aaa)

# 访问模块文件mc里的变量ccc
import b.c.mc
print(b.c.mc.ccc)

方法（三）通过from...import 直接访问到模块里的变量，基于方法二
# 访问模块文件ma里的变量aaa
from a.ma import aaa
print(aaa)

# 访问模块文件mc里的变量ccc
from b.c.mc import ccc
print(ccc)

#报错信息 （'.'左侧为文件）
import a.ma.aaa  #语法错误
ModuleNotFoundError: No module named 'a.ma.aaa'; 'a.ma' is not a package

#报错信息 （'.'左侧为文件）
from b.c import mc.ccc as ccc  #语法错误
SyntaxError: invalid syntax   
  
#结论: 
导模块中的'.'语法左侧必须为文件夹
import 后面最后只能导入到文件，可以是import <文件夹>.<文件>，但是不能是import <文件>.<文件>
from...import 中的import后面可以导入文件中的具体名字（变量名/函数名）

跨文件夹导入模块总结

# 1.如果a文件夹所在目录在环境变量，a文件夹中的ma模块可以被以下方式导入
import a.ma  |  from a import ma 

# 2.如果a文件夹所在目录在环境变量，a文件夹中的b文件夹的mb模块可以被以下方式导入
import a.b.mb  |  from a.b import mb

# 3.如果a文件夹所在目录在环境变量，a文件夹中的b文件夹的mb模块中的bbb名字要被直接导入 
import a.b.mb.bbb  # 错误：所有.左侧必须是文件夹 *****
from a.b import mb.bbb # 错误：所有.左侧必须是文件夹
from a.b.mb import bbb # 正确

模块的两种被执行方式

# 总结： 
# 1.一个py文件作为自执行文件，__name__变量的值为 '__main__'
# 2.一个py文件作为模块被导入执行，__name__变量的值为 '文件(模块)名'
# 3. __name__的值始终是字符串
# 4. pycharm中直接输入main就能快速出现 if __name__ == '__main__':

# 如何区别两种方式，可以让一个文件可以自执行，也可以被导入执行 共存
# 在这样的py文件中写：
if __name__ == '__main__':
    # 自执行的逻辑 => 因为在文件作为模块使用时 __name__为文件名，不满足条件
    pass
  
#案例 fn3()函数所在的文件被外部调用时候不执行，外部调用时候只执行2个函数fn1(),fn2()
# m1.py
def fn1():
    print('fn1 run')

def fn2():
    print('fn2 run')

def fn3():
    fn1()
    fn2()
    print('fn3 run')


if __name__ == '__main__':
    fn3()
    
#t1.py
from m1 import fn1,fn2
fn1()
fn2()

包

模块：一系列功能的集合体
包: 一系列模块的集合体，用文件夹来管理一系列有联系功能的模块

# 包 与 普通文件夹存在区别：包的文件夹中一定存在一个__init__.py文件
#		-- py2:必须创建  py3:建议创建，不创建系统会自动创建


# __init__.py文件
# 1）产生一个全局名称空间，提供给包的，就代表包的名称空间
# 2）管理 包可以直接点出来使用的 名字

如果没有__init__文件，在py3中会自动优化生成一个名称空间，存储一些系统的内置变量，但是不会文件夹下面模块里定义的名字（变量名/函数名），py2中则直接报错

#（案例1）
文件结构：
part5
	>mp(m1.py/m2.py)
  >t1.py
import mp  #如果没有init文件， mp的名称空间是无法产生m1,m2模块以及他们的名字的对应关系
# 需求: 可以直接通过包名使用包中的某一个模块
print(mp.m1.a)
print(mp.m1.b)
print(mp.m1.c)

# 需求: 可以直接通过包名使用包中的某个模块的名字
print(mp.x)
print(mp.y)
print(mp.z)

# （案例2）
文件结构：
part3
	->mp(m1.py, m2.py, m3.py)
  ->t1.py

 (python2 环境中)
#t1.py
import mp
print mp

报错信息：ImportError: No module named mp

  (python3 环境中)
  import mp
  print(mp)
  <module 'mp' (namespace)> # mp自己的名称空间为空
  print(mp.__dict__)  # python3自动创建一个名称空间，都是系统内置的变量的对应关系

  
# 导包完成的三件事
# 1）编译形成包中__init__.py文件的pyc文件
# 2）执行__init__.py文件，形成一个全局名称空间，将__init__.py文件中所有名字存放其中，该名称空间就代表包的名称空间
# 3）在导包的文件中，产生一个与包名相同的名字，指向包的名称空间(__init__.py文件的全局名称空间)

相对导入

需求1 : 可以直接通过包名使用包中的某个模块的名字

文件结构：
part3
	->mp(m1.py, m2.py, m3.py,__init__.py)
  ->t1.py
 
(方法一) 直接将值存入__init__.py 文件
#t1.py
 # 可以直接通过包名使用包中的某个模块的名字
print(mp.x)
print(mp.y)
print(mp.z)

# __init__.py
x=111
y=222
z=333

(方法二) 将m1导入__init__.py 文件
#t1.py
 # 可以直接通过包名使用包中的某个模块的名字
import mp
print(mp.m1.a)
print(mp.m1.b)
print(mp.m1.b)
print(mp.m1.c)

# __init__.py
from . import m1


# '.'就是mp

需求2: 可以直接通过包名使用包中的某个模块的名字

#t1.py
import mp  # 导入一个绝对路径/Users/cj/Desktop/pycharm_project_3/part5/mp，所以__init__文件中可以使用相对路径，相当于__init__文件中再导入模块都是基于这个路径导入了
print(mp.x)
print(mp.y)
print(mp.z)

# __init__.py
from .m2 import x
from .m2 import y
from .m2 import z

# '.'就是mp

需求3：直接通过包名使用包中子包模块中的名字

文件结构：
part3
	->mp(m1.py, m2.py, m3.py,__init__.py)--> subp(s1.py, __init__.py)
  ->t1.py
  # subp/s1.py
  sss=8888
  
  #mp/__init__.py
  from .subp.s1 import sss
  from .subp import s1
  
  #t1.py
  print(mp.sss)
  print(mp.s1.sss)

总结

1. mp是一个包，下面存着各个模块文件，运行文件中只要是导入了 import mp，则只要是__init__ 文件里面导入的模块，都能使用；
__init__ 文件中导入模块可以使用相对路径，可以用'.'代替mp
2. import mp ----> 执行文件下相当于导入一个路径 /Users/cj/Desktop/pycharm_project_3/part5/mp
所以__init__文件中可以使用相对路径，相当于__init__文件中再导入模块都是基于这个路径导入了
3. from...import... 格式的文件，后面只能跟一个文件夹或者文件或者名字，不能跟多个字文件夹，文件，名字，用'.'分隔

from . import m1  #正确
from .m2 import x #正确
from .m2 import y  #正确
from . import m2.z  #错误

直接使用包中模块

# 如果只是想作为普通文件夹，py3中可以省略__init__文件，本质上文件夹也是包

# 导入的手段：1.指名道姓到某一个模块 | 2.指名道姓到某一个模块中的名字

包的管理

#在包中管理模块，或者模块与模块直接功能相互使用，通过from .开头 import 语法进行导入，这种导入叫相对导入
# 在包的__init__.py文件或是包中任意一个模块中
# . 代表当前文件所在目录
# .. 代表当前文件所在目录的上一级目录
# 注：.语法不能出包，因为包外的文件都能自执行，但拥有.开头导入的文件不能自执行

文件结构：
part3
	->mp(m1.py, m2.py, m3.py,__init__.py)--> subp(s1.py,s1.py,s3.py __init__.py)
  ->t1.py
  
  # subp/s1.py
  sss=8888
  
  # subp/s2.py
  res=99999
  
  # subp/s3.py
  from .s2 import res
from ..subp.s1 import sss

def fn():
    # 要使用s2中的res

    print('s3 fn run')
    print(res)
    
    #要使用s1中的sss
    print(sss)
    
  #mp/__init__.py
from .subp.s3 import fn
  # t1.py
  mp.fn()

# __name__ 代表路径
文件结构：
part3
	->mp(m1.py, m2.py, m3.py,__init__.py)--> subp(s1.py,s1.py,s3.py __init__.py)
  ->t1.py
  
  # subp/s1.py
  sss=8888
  
  # subp/s2.py
  res=99999
  
  # subp/s3.py
  from .s2 import res
from ..subp.s1 import sss

def fn():
    # 要使用s2中的res

    print('s3 fn run')
    print(res)
    
    #要使用s1中的sss
    print(sss)
    
    # print(__name__)
    
  #mp/__init__.py
from .subp.s3 import fn
  # t1.py
  mp.fn()
  
  # __name__ 最后的输出结果 mp.subp.s3

包管理的好处

包管理内部采用相对导入管理模块或者模块中的名字（变量/函数名），外部调用模块的文件采用绝对导入导入一个包名，实际上导入的是路径，这样做的好处是复用性高，外界想要使用包中的模块只要导入包的路径，接下来都不用修改内部代码