Python编程8——面向对象编程3
11 异常
当Python检测到一个错误时，解释器就无法继续执行了，反而出现了一些错误的提示，这就是所谓的"异常"。
示例：
print('---test1---')
open('123abc.txt','r')
print('---test2---')
报错：
11.1 捕获异常
（1）try…except…
把可能出现问题的代码，放在try中；
把处理异常的代码，放在except中。
try:
print('---test1---')
open('123abc.txt','r')
print('---test2---')
except IOError:
print('遇到IOError，自动跳过')
pass
运行结果：
---test1---
遇到IOError，自动跳过
（2）except捕获多个异常
如果（1）中try的语句出现其他错误类型，此时程序依旧会报异常，即except没有生效。
实际开发中，捕获多个异常的方式，如下：
try:
print('-----test--1---')
open('123abc.txt','r') # 如果12txt文件不存在，那么会产生 IOError 异常
print('-----test--2---')
print(num)# 如果num变量没有定义，那么会产生 NameError 异常
except (IOError, NameError): # 如果想通过一次except捕获到多个异常可以用一个元组的方式
print('遇到IOError或者NameError，自动跳过')
pass
注：当捕获多个异常时，可以把要捕获的异常的名字，放到except 后，并使用元组的方式仅进行存储。
（3）except捕获异常的信息描述
更改（2）的程序为：
except (IOError,NameError) as result:
print(result) # 输出捕获异常的基本信息
运行结果：
-----test--1---
[Errno 2] No such file or directory: '123abc.txt'
（4）捕获所有异常
except:
print('产生了一个异常') # 捕获所有异常，但是不存储异常的基本信息
except Exception as result:
print('捕获到了异常: %s'%result) # 输出所有捕获异常的基本信息
运行结果：
-----test--1---
捕获到了异常
[Errno 2] No such file or directory: '123abc.txt'
（5）else
在try...except...中也是如此，即如果没有捕获到异常，那么就执行else中的事情。
#coding=utf-8
try:
num = 1
print('-----test--1---')
print(num)
print('-----test--2---')
except Exception as result:
print('捕获到了异常: %s'%result) # 输出捕获的异常信息
else:
print('没有捕获到异常')
运行结果：
-----test--1---
1
-----test--2---
没有捕获到异常，真高兴
（6）try…finally…
在程序中，如果一个段代码必须要执行，即无论异常是否产生都要执行，那么此时就需要使用finally。
# coding=utf-8
import time
try:
f = open('test.txt', encoding="utf-8")
try:
for lineContent in f.readlines():
index = lineContent.rfind('\n') # 去掉文本最后的换行符
print('%s'%lineContent[:index])
time.sleep(2)
except:
# 如果在读取文件的过程中，产生了异常，那么就会捕获到。
pass
finally:
f.close()
print('---关闭文件---')
except:
print("---没有这个文件---")
运行结果：
abcde
就是这样了
fghij
1234
---关闭文件---
注：如果KeyboardInterrupt异常被触发，程序退出。但是在程序退出之前，finally从句仍然被执行，把文件关闭。
11.2 异常的传递
对于try嵌套，如果里面的try没有捕获到这个异常，那么外面的try会接收到这个异常，然后进行处理，如果外边的try依然没有捕获到，那么再进行传递。
如果一个异常是在一个函数中产生的，例如函数A---->函数B---->函数C，而异常是在函数C中产生的，那么如果函数C中没有对这个异常进行处理，那么这个异常会传递到函数B中，如果函数B有异常处理那么就会按照函数B的处理方式进行执行；如果函数B也没有异常处理，那么这个异常会继续传递，以此类推。。。如果所有的函数都没有处理，那么此时就会进行异常的默认处理，即通常见的报错信息。
如下实例，当调用test3函数时，在test1函数内部产生了异常，此异常被传递到test3函数中完成了异常处理，而当异常处理完后，并没有返回到函数test1中进行执行，而是在函数test3中继续执行。
def test1():
print("----test1-1----")
print(num) # 错误的语句
print("----test1-2----")
def test2():
print("----test2-1----")
test1()
print("----test2-2----")
def test3():
try:
print("----test3-1----")
test1()
print("----test3-2----")
except Exception as result:
print("捕获到了异常，信息是:%s"%result)
print("----test3-2----")
test3()
print("------分割线------")
test2()
11.3 抛出自定义的异常
你可以用raise语句来引发一个异常。异常/错误对象必须有一个名字，且它们应是Error或Exception类的子类。
class ShortInputException(Exception):
'''自定义的异常类'''
def __init__(self, length, atleast):
# 如果重写了父类的__init__方法，最好是先调用父类的这个方法，然后再添加自己的功能
# super().__init__() # 调用父类的__init__方法
self.length = length
self.atleast = atleast
def main():
try:
s = input('请输入 --> ')
if len(s) < 3:
# raise引发一个你定义的异常
raise ShortInputException(len(s), 3)
except ShortInputException as result: # 这个变量被绑定到了错误的实例
print('ShortInputException: 输入的长度是 %d, 长度至少应是 %d'% (result.length, result.atleast))
else:
print('没有异常发生.')
main()
11.4 异常处理中抛出异常
class Test(object):
def __init__(self, switch):
self.switch = switch #开关
def calc(self, a, b):
try:
return a/b
except Exception as result:
if self.switch:
print("捕获开启，已经捕获到了异常，信息如下:")
print(result)
else:
# 重新抛出这个异常，此时就不会被这个异常处理给捕获到，从而触发默认的异常处理
raise
a = Test(True)
a.calc(11,0)
print("-------------------分割线----------------")
a.switch = False
a.calc(11,0)
12 模块
在Python中有一个概念叫做模块（module），这个和C语言中的头文件以及Java中的包很类似。
比如在Python中要调用sqrt函数，必须用import关键字引入math这个模块，类似C语言中的语句#include <math.h>引入math.h这个头文件。
12.1 import
在Python中用关键字import来引入某个模块，比如要引用模块math，就可以在文件最开始的地方用import math来引入。
格式如下：
import module1,mudule..
当解释器遇到import语句，如果模块在当前的搜索路径就会被导入。
在调用math模块中的函数时，必须这样引用：
模块名.函数名
12.2 from…import
有时候我们只需要用到模块中的某个函数，只需要引入该函数即可，Python的from语句让你从模块中导入一个指定的部分到当前命名空间中。
语法如下：
from modname import name1, name2, ... nameN
不仅可以引入函数，还可以引入一些全局变量、类等。
通过这种方式引入的时候，调用函数时只能给出函数名，不能给出模块名，但是当两个模块中含有相同名称函数的时候，后面一次引入会覆盖前一次引入。
12.3 from…import *
把一个模块的所有内容全都导入到当前的命名空间也是可行的，语法如下：
from modname import *
注意：
这提供了一个简单的方法来导入一个模块中的所有项目，然而这种声明不该被过多地使用。
12.4 as
import time as tt
tt.sleep(1)
# time.sleep(1) # 错误语句
from time import sleep as sp
sp(1)
# sleep(1) # 错误语句
12.5 定位模块
当你导入一个模块，Python解析器对模块位置的搜索顺序是：
（1）当前目录当前脚本所在目录
（2）环境（shell）变量PYTHONPATH下的目录；
（3）接着搜索Python安装时内置的标准库目录（如 Lib 或 lib/pythonX.Y，具体路径取决于Python版本）。
（4）第三方库目录（site-packages）
最后检查第三方库的安装目录（如 site-packages 或 dist-packages），通常由包管理工具（如 pip）安装的库存储在此。
13 模块制作
13.1 定义自己的模块
在Python中，每个Python文件都可以作为一个模块，模块的名字就是文件的名字。
比如有这样一个文件test.py，在test.py中定义了函数add
test.py
def add(a,b):
return a+b
13.2 调用自己定义的模块
那么在其他文件中就可以先import test，然后通过test.add(a,b)来调用了，当然也可以通过from test import add来引入。
比如：在main.py中调用
import test
result = test.add(11,22)
print(result)
13.3 测试模块
在实际开中，当一个开发人员编写完一个模块后，为了让模块能够在项目中达到想要的效果，这个开发人员会自行在py文件中添加一些测试信息，例如：
test.py
def add(a,b):
return a+b
# 用来进行测试
ret = add(12,22)
print('int test.py file,,,,12+22=%d'%ret)
如果此时，在其他py文件中引入了此文件的话，想想看，测试的那段代码是否也会执行呢？答案：会！
test.py中的测试代码，应该是单独执行test.py文件时才应该执行的，不应该是其他的文件中引用而执行。
为了解决这个问题，python在执行一个文件时有个变量__name__
可以根据__name__变量的结果能够判断出，是直接执行的python脚本还是被引入执行的，从而能够有选择性的执行测试代码。（实际开发中常用）
test.py：
运行结果：
in test.py file,,,,12+23=35
运行结果：
3
13.4 模块中的__all__
test.py：
__all__ = ['Test','test2'] #只有[]中的函数，才会在from xxx import *时导入
class Test(object):
def test(self):
print('---Test类中的test函数')
def test2():
print('---test2函数---')
def test3():
print('---test3函数---')
main.py：
from test import *
if __name__ == '__main__':
Test().test()
test2()
test3() # 直接报错：name 'test3' is not defined
14 python中的包
14.1 引入包
从文件夹中使用from… import… 的方式导入模块，基础方法：将文件夹转换为包。
Python 要求导入的文件夹必须是一个包（包含 __init__.py 文件），才能使用 from ... import ... 语法。
14.2 __init__.py文件
__init__.py 控制着包的导入行为。
如果__init__.py为空，仅仅是把这个包导入，不会导入包中的模块。
在__init__.py文件中，定义一个__all__变量，它控制着 from 包名 import *时导入的模块。
可以在__init__.py文件中编写语句，当导入时，这些语句就会被执行。
参考：
Python官方文档：https://docs.python.org/3/library/
https://blog.csdn.net/swan777/article/details/89040802