第二十五天- 包

# 包：

# 定义：
# 包是⼀种通过'模块名'来组织python模块名称空间的⽅式.我们创建的每个⽂件夹都可
# 称之为包.但要注意,在python2中规定.包内必须存在 __init__.py⽂件.在python3中可以
# 省略，但是最好都保留.当我们导入一个包的时候，默认执行这个包内的__init__.py;创建包
# 的⽬的不是为了运⾏, ⽽是被导入使⽤. 包只是⼀种形式⽽已.包的本质就是⼀种模块

# 作用：
# 随着功能越写越多,我们无法将所有功能都放在⼀个⽂件中,于是我们用模块去组织功能,
# 随着模块越来越多,我们就需要用文件夹将模块文件组织起来,以此来提⾼程序的结构性和可维护性

# 创建包：
# 包很好创建，只要是文件夹，里面有__init__.py就可

 1 import os
 2 
 3 os.makedirs('glance/api')
 4 os.makedirs('glance/cmd')
 5 os.makedirs('glance/db')
 6 l = []
 7 l.append(open('glance/__init__.py','w'))
 8 l.append(open('glance/api/__init__.py','w'))
 9 l.append(open('glance/api/policy.py','w'))
10 l.append(open('glance/api/versions.py','w'))
11 l.append(open('glance/cmd/__init__.py','w'))
12 l.append(open('glance/cmd/manage.py','w'))
13 l.append(open('glance/db/__init__.py','w'))
14 l.append(open('glance/db/models.py','w'))
15 map(lambda f:f.close() ,l)

# 再给每个⽂件中添加⼀些⽅法:

# 接下来.在test中使用包中的内容. 

 1 # import导入包
 2 import glance.db.models
 3 glance.db.models.register_models('mysql')
 4 
 5 '''
 6 哦哈哈哈哈
 7 from models.py:  mysql
 8 
 9 '''
10 
11 # 打印结果可看到  默认先执行了__init__  然后有执行了models

1 # from xxx import xxx 导入包
2 from glance.db.models import register_models
3 register_models('mysql')
4 
5 # 达到相同效果
6 '''
7 哦哈哈哈哈
8 from models.py:  mysql
9 '''

# 注意. from xxx import xxx这种形式,import后⾯不可以出现"点" 也就是from a.b import c 是ok的.但from a import b.c 是错的

# 由上可知，当仅导入一个包时，实际上是导入的该包下的__init__.py

 1 # __init__.py
 2 print("哦哈哈哈哈")
 3 
 4 name = "小白"
 5 age = 21
 6 
 7 
 8 def chi():
 9     print("小白很能吃")
10 
11 
12 class Car:
13     def fly(self):
14         print("我的车能飞")
15 
16 # test.py
17 import glance
18 print(glance.name)
19 glance.chi()
20 c = glance.Car()
21 c.fly()
22 '''
23 哦哈哈哈哈
24 小白
25 小白很能吃
26 我的车能飞
27 '''

# from xxx import * (能用，但不常用)
# 如，在__init__.py中用__all__[]限制

 1 print("哦哈哈哈哈")
 2 
 3 name = "小白"
 4 age = 21
 5 
 6 
 7 def chi():
 8     print("小白很能吃")
 9 
10 
11 class Car:
12     def fly(self):
13         print("我的车能飞")
14 
15 
16 __all__ = [name, chi]

# test.py中执行会报错

1 from glance import *
2 
3 print(name)
4 chi()
5 # c = Car()  # 报错
6 # c.fly()

# 绝对导入和相对导入：
#     相对导入: 相对于当前模块所在的包.使用的时候必须在包外面启动
#         以. 或者..作为起始   ..上层  .当前
#     绝对导入: 根据包的根目录去导入内容
#         以glance作为起始

# 全部都依赖于 sys.path

# 相对导入 如,在glance/api/policy.py中使⽤glance/cmd/manage.py

 1 # policy.py
 2 
 3 # 引入 manage
 4 # 绝对路径 从包的根目录去导包
 5 from glance.cmd import manage
 6 
 7 def get():
 8     manage.main()
 9     print('from policy.py')
10 
11 get()
12 '''
13 哦哈哈哈哈
14 from manage.py
15 from policy.py
16 
17 '''
18 # 打印可看到仍默认先执行__init__，然后成功引用了 manage

# 引入 versions
# 同级目录 也得绝对路径去导包

 1 # policy.py
 2 
 3 from glance.api import versions
 4 
 5 
 6 def get():
 7     versions.create_resource("哦呵呵")
 8     print('from policy.py')
 9 
10 get()
11 '''
12 哦哈哈哈哈
13 from version.py:  哦呵呵
14 from policy.py
15 '''

# 相对路径 ..上层  .当前

 1 # policy.py
 2 
 3 # 调用同层
 4 from .import versions
 5 
 6 
 7 def get():
 8     versions.create_resource("hahaha")
 9     print('from policy.py')
10 
11 # 深坑： 注意 相对路径只能在包外启动
12 
13 # test.py
14 
15 from glance.api import policy
16 policy.get()
17 
18 '''
19 哦哈哈哈哈
20 from version.py:  hahaha
21 from policy.py
22 '''

 1 #policy.py
 2 
 3 # 调用上层
 4 from ..db import models
 5 
 6 def get():
 7     models.register_models("enenenenmmm")
 8     print('from policy.py')
 9 
10 
11 
12 # test.py
13 
14 from glance.api import policy
15 policy.get()
16 
17 '''
18 哦哈哈哈哈
19 from models.py:  enenenenmmm
20 from policy.py
21 '''

# 总结：
# 访问包 尽量在包外启动程序
# 相对导入 只能在包外测试！！

# 用print(sys.path)去查看包的范围

1 import sys
2 
3 print(sys.path)

# 补充：

# sys.path 随动.随着启动文件改变.启动文件所在的文件夹就是你的path里的第一个
# import glance # 导入的包实际上是__init__.py

# 若非要使用包范围外的 可用.append()  (不常用)

1 import sys
2 print(sys.path)
3 # sys.path.append("E:\hehe")
4 sys.path.insert(0, "E:\hehe")
5 import 超范围
6 超范围.func()