一、模块

1、什么是模块？

模块就是一系列功能的集合体,分为三大类<br />        I：内置的模块<br />        II：第三方的模块<br />        III：自定义的模块<br />            一个python文件本身就一个模块，文件名m.py，模块名叫m
        ps：模块有四种形式<br />            　　1 使用python编写的.py文件
        　　2 已被编译为共享库或DLL的C或C++扩展<br />            <br />            　　3 把一系列模块组织到一起的文件夹（注：文件夹下有一个__init__.py文件，该文件夹称之为包）<br />            <br />            　　4 使用C编写并链接到python解释器的内置模块<br />                        

2、为何有用模块

I:内置与第三的模块拿来就用，无需定义，这种拿来主义，可以极大地提升自己的开发效率<br />    II:自定义的模块<br />        可以将程序的各部分功能提取出来放到一模块中为大家共享使用<br />        好处是减少了代码冗余，程序组织结构更加清晰<br />        

3、如何用模块

y=333
z=444
import foo

3.1 首次导入模块会发生3件事

1、执行foo.py
# 2、产生foo.py的名称空间，将foo.py运行过程中产生的名字都丢到foo的名称空间中
# 3、在当前文件中产生的有一个名字foo，该名字指向2中产生的名称空间

之后的导入，都是直接引用首次导入产生的foo.py名称空间,不会重复执行代码
# import foo
# import foo
# import foo
# import foo

3.2 引用：

print(foo.x)
# print(foo.get)
# print(foo.change)
强调1：模块名.名字，是指名道姓地问某一个模块要名字对应的值，不会与当前名称空间中的名字发生冲突
# x=1111111111111
# print(x)
# print(foo.x)

强调2：无论是查看还是修改操作的都是模块本身，与调用位置无关
# import foo
#
# x=3333333333
# # foo.get()
#
# foo.change()
# print(x)
#
# print(foo.x)
# foo.get()

3.3 可以以逗号为分隔符在一行导入多个模块

建议如下所示导入多个模块
# import time
# import foo
# import m

不建议在一行同时导入多个模块
import time,foo,m

3.4 导入模块的规范

I. python内置模块
#II. 第三方模块
#III. 程序员自定义模块

import time
# import sys
#
# import 第三方1
# import 第三方2
#
# import 自定义模块1
# import 自定义模块2
# import 自定义模块3

3.5 import 。。。 as 。。。

import foo as f # f=foo
# f.get()

import abcdefgadfadfas
# #
# # abcdefgadfadfas.f1
# # abcdefgadfadfas.f2
# # abcdefgadfadfas.f3

import abcdefgadfadfas as mmm
#
# mmm.f1
# mmm.f2
# mmm.f3

6、模块是第一类对象
import foo

7、自定义模块的命名应该采用纯小写+下划线的风格

8、可以在函数内导入模块
def func():
import foo

4、一个python文件有两种用途

1. 被当成程序运行
2. 被当做模块导入

当引用模块的文件执行完毕，没有引用模块的变量了，模块就取消了

5、name

用来区分模块是被导入还是自己执行测试

print('模块foo==>')
__all__=['x',] # 控制*代表的名字有哪些
x=1
def get():
    print(x)
5
def change():
    global x
    x=0
def say():
    print('我还活在内存中呢。。。。')
# print(__name__) #
# 1、当foo.py被运行时，__name__的值为'__main__'
# 1、当foo.py被当做模块导入时，__name__的值为'foo'
if __name__ == '__main__':
    print('文件被执行')
    get()
    change()
else:
    # 被当做模块导入时做的事情
    print('文件被导入')
    pass

6、from …import

impot导入模块在使用时必须加前缀”模块.”
优点：肯定不会与当前名称空间中的名字冲突
缺点：加前缀显得麻烦

6.1 使用方法

from … import …导入也发生了三件事
1、产一个模块的名称空间
2、运行foo.py将运行过程中产生的名字都丢到模块的名称空间去
3、在当前名称空间拿到一个名字，该名字与模块名称空间中的某一个内存地址
from foo import x # x=模块foo中值0的内存地址
from foo import get
from foo import change

print(x)
# print(get)
# print(change)
# x=333333333
# print(x)
# get()
# change()
# get()

print(x)
# from foo import x # x=新地址
# print(x)

6.2 优缺点

from…impot…导入模块在使用时不用加前缀
优点：代码更精简
缺点：容易与当前名称空间混淆
from foo import x # x=模块foo中值1的内存地址
x=1111

一行导入多个名字(不推荐)
from foo import x,get,change

：导入模块中的所有名字（不推荐）
name=’egon’
from foo import
print(name)
from socket import *

了解：all
from foo import *
print(x)
print(get)
print(change)

起别名
from foo import get as g

7、循环导入问题

不能循环导入

二、模块导入优先级

无论是import还是from…import在导入模块时都涉及到查找问题
优先级：
1、内存（内置模块）
2、硬盘：按照sys.path中存放的文件的顺序依次查找要导入的模块

import sys
# 值为一个列表，存放了一系列的对文件夹
# 其中第一个文件夹是当前执行文件所在的文件夹
# print(sys.path)

import foo # 内存中已经有foo了
# foo.say()
#
# import time
# time.sleep(10)
#
# import foo
# foo.say()

1、sys.modules

了解：sys.modules查看已经加载到内存中的模块
import sys
# import foo # foo=模块的内存地址
# del foo

def func():
# import foo # foo=模块的内存地址
#
# func()
#
# # print(‘foo’ in sys.modules)
# print(sys.modules)

2、import sys

找foo.py就把foo.py的文件夹添加到环境变量中
sys.path.append(r’/Users/linhaifeng/PycharmProjects/s14/day21/aa’)
# import foo
# foo.say()

from foo import say

三、包

包就是一个包含有init.py文件的文件夹

1、为何要有包

包的本质是模块的模块的一种形式，包是用来被当做模块导入

1. 产生一个名称空间
2. 运行包下的init.py文件，将运行过程中产生的名字都丢到1的名称空间中
3. 在当前执行文件的名称空间中拿到一个名字mmm，mmm指向1的名称空间

import mmm
# print(mmm.x)
# print(mmm.y)
# mmm.say()

from mmm import x

模块的使用者：egon老湿

环境变量是以执行文件为准备的，所有的被导入的模块或者说后续的其他文件引用
的sys.path都是参照执行文件的sys.path
import sys
sys.path.append(‘/aaaaaaaaaaaaaaaaaaaaaaaaaa’)
# print(sys.path)

# 创建一个包多个模块时，在__init__文件先导入模块
from foo.m1 import f1
from foo.m2 import f2
from foo.m3 import f3
from foo.bbb.m4 import f4
# 再进行包的导入
sys.path.append(r'/Users/linhaifeng/PycharmProjects/s14/day21/aa')
import foo # foo下__init__.py
foo.f1()
foo.f2()
foo.f3()

from foo import f1,f2,f3,f4

f1()
f2()
f3()
f4()

2、强调：

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

例如：
多层包导入
from foo.bbb.f import xxx
import foo.bbb.f
其中foo、bbb、f 都必须是包

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

2. import导入文件时，产生名称空间中的名字来源于文件，

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

import foo
# # print(foo.f1)
# # print(foo.f2)
# # print(foo.f3)
# # print(foo.f4)
#
# foo.f4()

from foo import *
# print(f1)
# print(f2)
# print(f3)
# print(f4)

3、绝对导入和相对导入

绝对导入，以包的文件夹作为起始来进行导入

# import sys
# print('==========>这是在被导入的__init__.py中查看到的sys.path')
# print(sys.path)
from foo.m1 import f1
from foo.m2 import f2
from foo.m3 import f3
from foo.bbb.m4 import f4 # foo内有了一个f4
# import foo.bbb.m4.f4 # 语法错误，点的左侧必须是一个包

相对导入:仅限于包内使用，不能跨出包（包内模块之间的导入，推荐使用相对导入）
.:代表当前文件夹
..:代表上一层文件夹

from .m1 import f1
from .m2 import f2
from .m3 import f3
from .bbb.m4 import f4

强调：

1. 相对导入不能跨出包，所以相对导入仅限于包内模板彼此之间闹着玩

1. 而绝对导入是没有任何限制的，所以绝对导入是一种通用的导入方式