Python笔记day21（模块）|包、异常处理

1，内容回顾

# 序列化模块
    # 数据类型转化成字符串的过程就是序列化
    # 为了方便存储和网络传输
    # json
        # dumps
        # loads
        # dump  和文件有关
        # load  load不能load多次

# import json
# data = {'username':['李华','二愣子'],'sex':'male','age':16}
# json_dic2 = json.dumps(data,sort_keys=True,indent=4,separators=(',',':'),ensure_ascii=False)
# print(json_dic2)

    # pickle
        #方法和json一样
        #dump和load的时候 文件是rb或者wb打开的
        #支持python所有的数据类型
        #序列化和反序列化需要相同的环境
    # shelve
        # open方法
        # open方法获取了一个文件句柄
        # 操作和字典类似

# 模块的导入
# import
# from import
# as重命名
# 都支持多名字导入
# sys.moudles记录了所有被导入的模块
# sys.path 记录了导入模块的时候寻找的所有路径

---

2，包

包是一种通过使用‘.模块名’来组织python模块名称空间的方式。

１. 无论是import形式还是from…import形式，凡是在导入语句中（而不是在使用时）遇到带点的，都要第一时间提高警觉：这是关于包才有的导入语法

1. 包是目录级的（文件夹级），文件夹是用来组成py文件（包的本质就是一个包含init.py文件的目录）

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

强调：

　　1）在python3中，即使包下没有init.py文件，import 包仍然不会报错，而在python2中，包下一定要有该文件，否则import 包报错

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

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

import os
os.makedirs('glance/api')
os.makedirs('glance/cmd')
os.makedirs('glance/db')
l = []
l.append(open('glance/__init__.py','w'))
l.append(open('glance/api/__init__.py','w'))
l.append(open('glance/api/policy.py','w'))
l.append(open('glance/api/versions.py','w'))
l.append(open('glance/cmd/__init__.py','w'))
l.append(open('glance/cmd/manage.py','w'))
l.append(open('glance/db/models.py','w'))
map(lambda f:f.close() ,l)

创建目录代码

glance/                   #Top-level package

├── __init__.py      #Initialize the glance package

├── api                  #Subpackage for api

│   ├── __init__.py

│   ├── policy.py

│   └── versions.py

├── cmd                #Subpackage for cmd

│   ├── __init__.py

│   └── manage.py

└── db                  #Subpackage for db

    ├── __init__.py

    └── models.py

目录结构

#文件内容

#policy.py
def get():
    print('from policy.py')

#versions.py
def create_resource(conf):
    print('from version.py: ',conf)

#manage.py
def main():
    print('from manage.py')

#models.py
def register_models(engine):
    print('from models.py: ',engine)

文件内容

2.1 注意事项

1）关于包相关的导入语句也分为import和from … import …两种，但是无论哪种，无论在什么位置，在导入时都必须遵循一个原则：凡是在导入时带点的，点的左边都必须是一个包，否则非法。可以带有一连串的点，如item.subitem.subsubitem,但都必须遵循这个原则。

2）对于导入后，在使用时就没有这种限制了，点的左边可以是包,模块，函数，类(它们都可以用点的方式调用自己的属性)。

3）对比import item 和from item import name的应用场景：
如果我们想直接使用name那必须使用后者。
2.2 import
我们在与包glance同级别的文件中测试

1 import glance.db.models
2 glance.db.models.register_models('mysql') 

2.3 from … import …
需要注意的是from后import导入的模块，必须是明确的一个不能带点，否则会有语法错误，如：from a import b.c是错误语法

我们在与包glance同级别的文件中测试

1 from glance.db import models
2 models.register_models('mysql')
3 
4 from glance.db.models import register_models
5 register_models('mysql')

2.4 _init_.py文件
不管是哪种方式，只要是第一次导入包或者是包的任何其他部分，都会依次执行包下的init.py文件(我们可以在每个包的文件内都打印一行内容来验证一下)，这个文件可以为空，但是也可以存放一些初始化包的代码。

回到顶部
2.5 from glance.api import *
在讲模块时，我们已经讨论过了从一个模块内导入所有，此处我们研究从一个包导入所有。

此处是想从包api中导入所有，实际上该语句只会导入包api下init.py文件中定义的名字，我们可以在这个文件中定义all_:

#在__init__.py中定义
x=10

def func():
    print('from api.__init.py')

__all__=['x','func','policy']

此时我们在于glance同级的文件中执行from glance.api import *就导入all中的内容（versions仍然不能导入）。

glance/                   

├── __init__.py      

├── api                  

│   ├── __init__.py   __all__ = ['policy','versions'] 

│   ├── policy.py

│   └── versions.py

├── cmd               __all__ = ['manage']    

│   ├── __init__.py

│   └── manage.py    

└── db                __all__ = ['models']              

    ├── __init__.py

    └── models.py



from glance.api import *
policy.get()

from glance.api import *

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

绝对导入：以glance作为起始

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

例如：我们在glance/api/version.py中想要导入glance/cmd/manage.py

在glance/api/version.py

#绝对导入
from glance.cmd import manage
manage.main()

#相对导入
from ..cmd import manage
manage.main()

测试结果：注意一定要在于glance同级的文件中测试

from glance.api import versions 

注意：在使用pycharm时，有的情况会为你多做一些事情，这是软件相关的东西，会影响你对模块导入的理解，因而在测试时，一定要回到命令行去执行，模拟我们生产环境，你总不能拿着pycharm去上线代码吧！！！

特别需要注意的是：可以用import导入内置或者第三方模块（已经在sys.path中），但是要绝对避免使用import来导入自定义包的子模块(没有在sys.path中)，应该使用from… import …的绝对或者相对导入,且包的相对导入只能用from的形式。

比如我们想在glance/api/versions.py中导入glance/api/policy.py，有的同学一抽这俩模块是在同一个目录下，十分开心的就去做了，它直接这么做

 #在version.py中

 import policy
 policy.get()

没错，我们单独运行version.py是一点问题没有的，运行version.py的路径搜索就是从当前路径开始的，于是在导入policy时能在当前目录下找到

但是你想啊，你子包中的模块version.py极有可能是被一个glance包同一级别的其他文件导入，比如我们在于glance同级下的一个test.py文件中导入version.py，如下

from glance.api import versions

'''
执行结果:
ImportError: No module named 'policy'
'''

'''
分析:
此时我们导入versions在versions.py中执行
import policy需要找从sys.path也就是从当前目录找policy.py,
这必然是找不到的
'''

glance/                   

├── __init__.py      from glance import api
                             from glance import cmd
                             from glance import db

├── api                  

│   ├── __init__.py  from glance.api import policy
                              from glance.api import versions

│   ├── policy.py

│   └── versions.py

├── cmd                 from glance.cmd import manage

│   ├── __init__.py

│   └── manage.py

└── db                   from glance.db import models

    ├── __init__.py

    └── models.py

绝对导入

glance/                   

├── __init__.py      from . import api  #.表示当前目录
                     from . import cmd
                     from . import db

├── api                  

│   ├── __init__.py  from . import policy
                     from . import versions

│   ├── policy.py

│   └── versions.py

├── cmd              from . import manage

│   ├── __init__.py

│   └── manage.py    from ..api import policy   
                     #..表示上一级目录，想再manage中使用policy中的方法就需要回到上一级glance目录往下找api包，从api导入policy

└── db               from . import models

    ├── __init__.py

    └── models.py

相对导入

2.7 单独导入包
单独导入包名称时不会导入包中所有包含的所有子模块，如

#在与glance同级的test.py中
import glance
glance.cmd.manage.main()

'''
执行结果：
AttributeError: module 'glance' has no attribute 'cmd'

'''

解决方法：

#glance/__init__.py
 from . import cmd

 #glance/cmd/__init__.py
 from . import manage

执行：

 #在于glance同级的test.py中
 import glance
 glance.cmd.manage.main()

千万别问：all不能解决吗，all是用于控制from…import *

import glance之后直接调用模块中的方法

glance/                   

├── __init__.py     from .api import *
                    from .cmd import *
                    from .db import *    
├── api                  

│   ├── __init__.py   __all__ = ['policy','versions'] 

│   ├── policy.py

│   └── versions.py

├── cmd               __all__ = ['manage']    

│   ├── __init__.py

│   └── manage.py    

└── db                __all__ = ['models']              

    ├── __init__.py

    └── models.py


import glance
policy.get()

import glance

---

3，异常处理

# 1/0
# name
# 2+'3'
# [][3]
#{}['k']
# try:
#     print('1111')
#     # 1/0
#     print('2222')
#     # name
#     # 2+'3'
#     # [][3]
#     # {}['k']
#     ret = int(input('number >>>'))
#     print(ret*'*')
# except ValueError:
#     print('输入的数据类型有误')
# except Exception:
#     print('你错了，老铁')
# else:
#     print('没有异常的时候执行else中的代码')
# print('===========')
# def func():
#     try:
#         f = open('file','w')
#         ''''''
#         return True
#     except:
#         return False
#     finally:
#         print('执行finally了')
#         f.close()
#
# print(func())





# 程序一旦发生错误，就从错误的位置停下来了，不在继续执行后面的内容
# 使用try和except就能处理异常
    #try是我们需要处理的代码
    #except 后面跟一个错误类型 当代码发生错误且错误类型符合的时候 就会执行except中的代码
    #except支持多分支
    #有没有一个能处理所有错误的类型 : Exception
        # 有了万能的处理机制仍然需要把能预测到的问题单独处理
        # 单独处理的所有内容都应该写在万能异常之前
    # else : 没有异常的时候执行else中的代码
    # finally : 不管代码是否异常，都会执行
        # finally和return相遇的时候 依然会执行
        # 函数里做异常处理用,不管是否异常去做一些收尾工作


# try:
#     main()
# except Exception:
#     pass

try:
    print('1111')
    # 1/0
    print('2222')
    # name
    # 2+'3'
    # [][3]
    # {}['k']
    ret = int(input('number >>>'))
    print(ret*'*')
except Exception as error:
    print('你错了，老铁',error)