模块与包

一 模块介绍

1、什么是模块
模块就是一个功能的集合体，不是用来直接运行的，而是用来被导入使用的

模块分为三大来源：
    1、内置的模块
    2、第三方模块
    3、自定义模块

模块分为四种类型：
    1、一个py文件就是一个模块
    2、一个文件夹也是一个模块=》包
    3、已被编译为共享库或DLL的C或C++扩展
    4、使用C编写并链接到python解释器的内置模块

2、为何要用模块

    使用别人的模块：
        1、拿来主义，提升开发效率
    自定义模块：
        2、别人的功能不够用了，需要自己去写
        3、解决代码冗余

3、如何用模块
以spam.py为例来介绍模块的使用：文件名spam.py,模块名spam

#spam.py
print('from the spam.py')

money=1000

def read1():
   print('spam模块：',money)

def read2():
   print('spam模块')
   read1()

def change():
   global money
   money=0

二 使用模块之import

1、import的使用
模块可以包含可执行的语句和函数的定义，这些语句的目的是初始化模块，它们只在模块名第一次遇到导入import语句时才执行（import语句是可以在程序中的任意位置使用的,且针对同一个模块很import多次,为了防止你重复导入，python的优化手段是：第一次导入后就将模块名加载到内存了，后续的import语句仅是对已经加载到内存中的模块对象增加了一次引用，不会重新执行模块内的语句），如下

#test.py
import spam #只在第一次导入时才执行spam.py内代码,此处的显式效果是只打印一次'from the spam.py',当然其他的顶级代码也都被执行了,只不过没有显示效果.
import spam
import spam
import spam

'''
执行结果：
from the spam.py
'''

ps：我们可以从sys.module中找到当前已经加载的模块，sys.module是一个字典，内部包含模块名与模块对象的映射，该字典决定了导入模块时是否需要重新导入。

2、在第一次导入模块时会做三件事，重复导入会直接引用内存中已经加载好的结果

#1.为源文件(spam模块)创建新的名称空间，在spam中定义的函数和方法若是使用到了global时访问的就是这个名称空间。

#2.在新创建的命名空间中执行模块中包含的代码，见初始导入import spam
    提示:导入模块时到底执行了什么？
    In fact function definitions are also ‘statements’ that are 
    ‘executed’; the execution of a module-level function definition 
    enters the function name in the module’s global symbol table.
    事实上函数定义也是“被执行”的语句，模块级别函数定义的执行将函数名放
    入模块全局名称空间表，用globals()可以查看

#3.创建名字spam来引用该命名空间
    这个名字和变量名没什么区别，都是‘第一类的’，且使用spam.名字的方式
    可以访问spam.py文件中定义的名字，spam.名字与test.py中的名字来自
    两个完全不同的地方。

#模块 spam
money=1000

#test.py
import spam 
money=10
print(spam.money)

'''
执行结果：
from the spam.py
1000
'''

#test.py
import spam
def read1():
    print('========')
spam.read1()

'''
执行结果:
from the spam.py
spam->read1->money 1000
'''

#test.py
import spam
money=1
spam.change()
print(money)

'''
执行结果：
from the spam.py
1
'''

4、为模块名起别名

为已经导入的模块起别名的方式对编写可扩展的代码很有用

1 import spam as sm
2 print(sm.money)

5、在一行导入多个模块

1 import sys,os,re

三 使用模块之from ... import ...

1、from...import...的使用

 1 from spam import read1,read2

2、from...import 与import的对比

#唯一的区别就是：使用from...import...则是将spam中的名字直接导入到当前的名称空间中，所以在当前名称空间中，直接使用名字就可以了、无需加前缀：spam.

#from...import...的方式有好处也有坏处
    好处：使用起来方便了
    坏处：容易与当前执行文件中的名字冲突

验证一：当前位置直接使用read1和read2就好了，执行时，仍然以spam.py文件全局名称空间

#测试一：导入的函数read1，执行时仍然回到spam.py中寻找全局变量money
#test.py
from spam import read1
money=1000
read1()
'''
执行结果:
from the spam.py
spam->read1->money 1000
'''

#测试二:导入的函数read2，执行时需要调用read1(),仍然回到spam.py中找read1()
#test.py
from spam import read2
def read1():
    print('==========')
read2()

'''
执行结果:
from the spam.py
spam->read2 calling read
spam->read1->money 1000
'''

验证二：如果当前有重名read1或者read2，那么会有覆盖效果。

#测试三:导入的函数read1，被当前位置定义的read1覆盖掉了
#test.py
from spam import read1
def read1():
    print('==========')
read1()
'''
执行结果:
from the spam.py
==========

验证三：导入的方法在执行时，始终是以源文件为准的(名称空间的关系以定义阶段为准)

from spam import money,read1
money=100 #将当前位置的名字money绑定到了100
print(money) #打印当前的名字
read1() #读取spam.py中的名字money,仍然为1000

'''
from the spam.py
100
spam->read1->money 1000
'''

3、也支持as

1 from spam import read1 as read

4、一行导入多个名字

from spam import read1,read2,money

5、from...import *

from spam import * 把spam中所有的不是以下划线(_)开头的名字都导入到当前位置

大部分情况下我们的python程序不应该使用这种导入方式，因为*你不知道你导入什么名字，很有可能会覆盖掉你之前已经定义的名字。而且

四 py文件区分两种用途:模块与脚本

#编写好的一个python文件可以有两种用途：
    一：脚本，一个文件就是整个程序，用来被执行
    二：模块，文件中存放着一堆功能，用来被导入使用


#python为我们内置了全局变量__name__，
    当文件被当做脚本执行时：__name__ 等于'__main__'
    当文件被当做模块导入时：__name__等于模块名

#作用：用来控制.py文件在不同的应用场景下执行不同的逻辑
    if __name__ == '__main__':

五 模块搜索路径

模块的查找顺序是：内存中已经加载的模块->内置模块->sys.path路径中包含的模块

# 一：模块的搜索路径与查找优先级
# （1）先从内存中已经导入的模块里找
 import mmm
 mmm.f1()

 import time
 time.sleep(10)

# 暂停的十秒里删除mmm文件
# 但是mmm文件已经运行且在内存中
# 所以再次导入还能被找到

 print('='*20)

 import mmm
 mmm.f1()
#再次导入模块成功

# 最后程序结束内存已经完全释放
# 再去找mmm文件就找不到了
# （2）然后再查找内置的模块
import sys
print(sys.modules) #找到解释器自带的内置模块
# 解释器打开时内置模块也跟着打开，且也随着在内存中运行

# （3）最后去sys.path列表中存放的多个文件夹里依次检索
# 示例1：
 import sys
 print(sys.path)

 import m1
 m1.f1()   不在当前文件夹内 需要添加到环境变量

sys.path.append(r'm1的文件路径')
import m1
 m1.f1()
添加需要的模块的当前文件夹的路径，即可保存到环境变量中，且是以执行文件为准的
print(sys.path)

六 包的介绍

1、什么是包？

#官网解释
Packages are a way of structuring Python’s module namespace by using “dotted module names”
包是一种通过使用‘.模块名’来组织python模块名称空间的方式。

#具体的：包就是一个包含有__init__.py文件的文件夹，所以其实我们创建包的目的就是为了用文件夹将文件/模块组织起来

#需要强调的是：
　　1. 在python3中，即使包下没有__init__.py文件，import 包仍然不会报错，而在python2中，包下一定要有该文件，否则import 包报错

　　2. 创建包的目的不是为了运行，而是被导入使用，记住，包只是模块的一种形式而已，包的本质就是一种模块

2、为何要使用包

包的本质就是一个文件夹，那么文件夹唯一的功能就是将文件组织起来
随着功能越写越多，我们无法将所以功能都放到一个文件中，于是我们使用模块去组织功能，
而随着模块越来越多，我们就需要用文件夹将模块文件组织起来，以此来提高程序的结构性和可维护性

3、注意事项

（1）关于包相关的导入语句也分为import和from ... import ...两种，但是无论哪种，无论在什么位置，在导入时都必须遵循一个原则：凡是在导入时带点的，点的左边都必须是一个包，否则非法。可以带有一连串的点，如item.subitem.subsubitem,但都必须遵循这个原则。但对于导入后，在使用时就没有这种限制了，点的左边可以是包,模块，函数，类(它们都可以用点的方式调用自己的属性)。

（2）import导入文件时，产生名称空间中的名字来源于文件，import 包，产生的名称空间的名字同样来源于文件，即包下的__init__.py，导入包本质就是在导入该文件

（3）包A和包B下有同名模块也不会冲突，如A.a与B.a来自俩个命名空间

七 包的使用

首次导入包这种模块，发生两件事
1.创建模块的名称空间，运行包下的__init__.py的文件，将运行过程中产生的名字都
丢入模块的名称空间中

2.在当前位置拿到一个名字aaa，该名字指向__init__.py的名称空间，即aaa.名字，
名字是来自于__init__.py中的

'''
aaa包下的文件__init__
'''
# 导入包其实就是在导入包里的__init__文件
# 所以在这个文件里面导入执行文件所需要导入模块的名字
# 导入模块里的名字以包的顶级目录为起始去添加
# 然后让执行文件的调用方式不变
# 包aaa的本质还是模块，应该存在于执行文件的环境变量中（与执行文件在同一文件夹内）

from aaa.m1 import  f1

from aaa.m2 import  f2

from aaa.m3 import f2
'''

执行文件

from aaa import f1   
f1()                 
#导出了文件夹aaa下的文件中的函数f1

3.绝对导入和相对导入

我们的最顶级包aaa是写给别人用的，然后在aaa包内部也会有彼此之间互相导入的需求，这时候就有绝对导入和相对导入两种方式：

绝对导入：以aaa作为起始

相对导入：用.或者..的方式最为起始（只能在一个包中使用，不能用于不同目录内）

总结

# 绝对导入: 以执行文件的sys.path为起始点开始导入,称之为绝对导入
#        优点: 执行文件与被导入的模块中都可以使用
#        缺点: 所有导入都是以sys.path为起始点,导入麻烦

# 相对导入: 参照当前所在文件的文件夹为起始开始查找,称之为相对导入
#        符号: .代表当前所在文件的文件加,..代表上一级文件夹,...代表上一级的上一级文件夹
#        优点: 导入更加简单
#        缺点: 只能在导入包中的模块时才能使用