day 21 模块和包

模块：已经写号的一组功能的集合

模块名，是按变量的命名规则命名的

模块的导入：

　　import 模块名

　　　　调用模块时 模块名.变量

　　模块导入的过程发生了什么？

　　　　一、找到这个模块

　　　　二、判断这个模块是否被导入过了

　　　　三、如果没有被导入　　　

　　　　　　1. 创建一个属于这个模块的命名空间

　　　　　　2. 让模块的名字执行这个空间

　　　　　　3. 执行这个模块中的代码

模块规则：

　　1. 不能重复导入

　　2. 模块和当前文件在不同命名空间

给模块起别名　　:起了别名之后使用这个模块就都使用别名引用变量了

　　import my_moudle as m:

　　作用：　　

　　　　一、减少名字的代码量

　　　　二、当你要导入的两个模块都起相同的作用时，起一个别名代替

导入多个模块：

　　建议一个一个导入

导入顺序：内置模块、第三方模块、自定义模块

 1 by luffycity.com
 2 
 3 什么是模块 ? 已经写好的一组功能的集合
 4 别人写好的函数 变量 方法 放在一个文件里 (这个文件可以被我们直接使用)这个文件就是个模块
 5 py dll文件 zip文件
 6 
 7 如何自己写一个模块
 8 创建一个py文件,给它起一个 符合变量名命名规则的名字,这个名字就是模块名
 9 
10 import my_module   # pycharm认为你的模块导入不进来
11 在导入模块的过程中发生了什么?
12 导入一个模块就是执行一个模块
13 
14 怎么使用my_module模块中的名字
15 print(my_module.name)
16 print(my_module.read1)
17 my_module.read1()
18 
19 import的命名空间,模块和当前文件在不同的命名空间中
20 name = 'egon'
21 def read1():
22     print('main read1')
23 
24 print(name)
25 print(my_module.name)
26 
27 模块是否可以被重复导入
28 import my_module
29 import my_module
30 怎么判断这个模块已经被导入过了???
31 import sys
32 print(sys.modules)
33 
34 模块导入的过程中发生了什么?
35     找到这个模块
36     判断这个模块是否被导入过了
37     如果没有被导入过
38         创建一个属于这个模块的命名空间
39         让模块的名字 指向 这个空间
40         执行这个模块中的代码
41 
42 name = 'egon'
43 def read1():
44     print('main read1')
45 
46 
47 print(name)
48 print(my_module.name)
49 my_module.read2()
50 
51 给模块起别名,起了别名之后,使用这个模块就都使用别名引用变量了
52 import my_module as m
53 m.read1()
54 
55 json pickle
56 dumps loads
57 def func(dic,t = 'json'):
58     if t == 'json':
59         import json
60         return json.dumps(dic)
61     elif t == 'pickle':
62         import pickle
63         return pickle.dumps(dic)
64 
65 def func(dic, t='json'):
66     if t == 'json':
67         import json as aaa
68     elif t == 'pickle':
69         import pickle as aaa
70     return aaa.dumps(dic)
71 
72 导入多个模块
73 import os,time
74 import os as o,time as t
75 规范建议 模块应该一个一个的导入 : 自定义模块,第三方模块,内置模块
76 内置模块
77 扩展(第三方)模块
78 自定义模块
79 
80 import os
81 
82 import django
83 
84 import my_module

import 模块

from import

　　　　from my_module import name

　　执行过程中仍然要执行这个被导入的文件

# from import导入的过程中发生了什么事儿?

　　1.找到要被导入的模块
　　2.判断这个模块是否被导入过
　　3.如果这个模块没被导入过
 　　   创建一个属于这个模块的命名空间
  　　  执行这个文件
  　　  找到你要导入的变量
   　　 给你要导入的变量创建一个引用,指向要导入的变量

# by luffycity.com

# 如何使用 from import
# 需要从一个文件中使用哪个名字,就把这个名字导入进来
# from my_module import name

# from import的过程中仍然执行了这个被导入的文件

# from my_module import read1
# import谁就只能用谁
# read1()
# from my_module import read2
# read2()

# 当前文件命名空间和模块的命名空间的问题
# from my_module import read1
# def read1():
#     print('in my read1')
# read1()
#
# from my_module import read2
# read2()

# from import导入的过程中发生了什么事儿?
# 1.找到要被导入的模块
# 2.判断这个模块是否被导入过
# 3.如果这个模块没被导入过
#     创建一个属于这个模块的命名空间
#     执行这个文件
#     找到你要导入的变量
#     给你要导入的变量创建一个引用,指向要导入的变量
# from my_module import read1
# def read1():
#     print('in my read1')
# read1()
#
# from my_module import read2
# read2()

# 导入多个名字?
# from my_module import read1,read2
# read1()
# read2()

# 给导入的名字起别名
# from my_module import read1 as r1,read2 as r2
# def read1():
#     print('in my read1')
# r1()
# r2()
# read1()

# from my_module import * 在导入的过程中 内存的引用变化
# from my_module import *
# name = 'egon'
# print(name)   # egon
# read1()
# read2()       # alex

# * 和 __all__ __all__能够约束*导入的变量的内容
# from my_module import *
# print(name)
# read1()
# read2()

# from my_module import read1
# read1()

from import

把模块当成脚本使用

　　当这个文件被当作脚本执行的时候 __name__ =="__main__"

　　当这个文件被当作模块导入的时候 __name__ ==''模块的名字'

模块的搜索路径：

import sys
import calculate
print(sys.path)
path = r'D:sylars15day215模块的循环引用'
sys.path.append(path)

模块引用中的情况：

　　1. 模块之间不允许循环引用

　　2. 已经被导入的模块发生了修改，是不会被感知的

　　　　要想被修改的模块被正在运行中的程序感知到，需要重启这个程序

　　3. 把模块当成脚本来使用

包：

　　文件夹中有一个__init__.py文件、是几个模块的集合

　　导入一个包，相当于执行了这个包下面的__init__.py文件

绝对导入：

　　优点：执行一个py脚本的时候，这个脚本以及和这个脚本同级的模块中只能用绝对导入

　　缺点：所有的导入都要从一个根目录下往后解释文件夹之间的关系；如果当前导入包的文件和被导入的包的位置关系发生了变化，那么所有的init文件都要做相应的调整

相对导入：

　　优点：1.不需要去反复的修改路径，只要一个包中的所有文件夹和文件的相对位置不发生变化

　　　　 2.不需要去关心当前这个包和被执行的文件之间的层级关系

　　缺点：1、含有相对导入的py文件不能被直接执行

　　　　 2、必须放在包中被导入的调用才能正常的使用

 1 # by luffycity.com
 2 
 3 # 包 : 文件夹中有一个__init__.py文件
 4 # 包 : 是几个模块的集合
 5 
 6 # 从包中导入模块
 7 # import
 8 # import glance.api.policy
 9 # glance.api.policy.get()
10 
11 # import glance.api.policy as policy
12 # policy.get()
13 
14 # from import
15 # from glance.api import policy
16 # policy.get()
17 
18 # from glance.api.policy import get
19 # get()
20 
21 
22 # 直接导入包 ,需要通过设计init文件,来完成导入包之后的操作
23 # 导入一个包
24     # 不意味着这个包下面的所有内容都是可以被使用的
25     # 导入一个包到底发生什么了?
26         # 相当于执行了这个包下面的__init__.py文件
27 
28 # 绝对导入 :
29 # 在执行一个py脚本的时候,这个脚本以及和这个脚本同级的模块中只能用绝对导入
30 # 缺点
31 # 所有的导入都要从一个根目录下往后解释文件夹之间的关系
32 # 如果当前导入包的文件和被导入的包的位置关系发生了变化,那么所有的init文件
33 # 都要做相应的调整
34 
35 
36 # import glance
37 # -glance.__init__.py
38     # import api
39 # sys.path = ['D:sylars15day21']
40 # glance.api.policy.get()
41 
42 # from bbbbb import glance
43 
44 
45 # 相对导入 :
46 # 不需要去反复的修改路径
47     # 只要一个包中的所有文件夹和文件的相对位置不发生改变
48 # 也不需要去关心当前这个包和被执行的文件之间的层级关系
49 # 缺点
50 # 含有相对导入的py文件不能被直接执行
51 # 必须放在包中被导入的调用才能正常的使用
52 
53 # import glance
54 # glance.api.policy.get()
55 
56 # from bbbbb import glance2
57 # glance2.api.policy.get()
58 
59 # from . import bbbbb   # 含有相对导入的文件不能被直接执行
60 
61 # from bbbbb import demo1
62 
63 # 如果只是从包中导入模块的话,那么我们不需要做任何多余的操作
64 # 直接导入就行了
65 # import urllib   # urllib是一个包,单纯的导入一个包啥也不会发生,包中的request.py也不能用
66 # urllib.request
67 
68 # from urllib import request
69 # print(request)
70 
71 # 如果我们希望导入包的时候,能够顺便把模块也导入进来
72 # 需要设计init文件
73 # 绝对目录的导入相对目录的导入各有千秋

包

day 21 模块 和 包

day 21 模块和包