python——异常类型

捕获异常try...except...finally...else

python为高级语言，就是通过try...except...finally...else机制来处理错误。

让我们来看一下这段错误代码：

try：
    print("try...")
    s = 10/0 #异常，之后代码不执行
    print("not run this code")
except ZeroDivisonError as e: #有错误执行一下语句
    print("except",e)
finally:
    print("finally...") # 有没有错误都要执行finally；此处可以不加
print("END")

try下加入要执行代码，如果代码某处发生错误，错误之后代码段不执行直接跳到except捕获的错误类型抛出错误提示，最后走finally执行完毕，这里finally可有可无。else没有错误发生时执行。

如果你不知道执行代码段可能发生什么种类的错误，可以捕获全部错误，比如：

try：
    f = open("unexsit.file","r") 
    f.read()
except Exception as e:
    print("出错了，但是什么类型呢，打印一下吧"，e)

#[Errno 2] No such file or directory: unexsit.file

 常见错误类

AttributeError 不存在属性

IoError  输入或输出异常

ImportError 无法引入模块或包。（一般是路径问题或模块名称有误）

IndentationError 语法错误（SyntaxError子类），一般是代码缩进错误

KeyError 字典中不存在关键字

KeyboardInterrupt Ctrl+C被按下

NameError 使用一个未被赋予对象的变量

SyntaxError 语法错误

TypeError 传入对象类型与要求不符

UnboundLocalError 变量作用域的问题（详见：https://docs.python.org/2/faq/programming.html#why-am-i-getting-an-unboundlocalerror-when-the-variable-has-a-value）

x=9

def test():
    print(x)#
    x =1#python从上到下解释，会吧x当做局部变量，然而上边print要打印未声明的局部变量，报错

test()
#UnboundLocalError: local variable 'x' referenced before assignment
//修改
x=9
def test():
    global x
    print(x)
    x =1

test()

官方解释法：

It can be a surprise to get the UnboundLocalError in previously working code when it is modified by adding an assignment statement somewhere in the body of a function.

This code:

>>>
>>> x = 10
>>> def bar():
...     print x
>>> bar()
10
works, but this code:

>>>
>>> x = 10
>>> def foo():
...     print x
...     x += 1
results in an UnboundLocalError:

>>>
>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment
This is because when you make an assignment to a variable in a scope, that variable becomes local to that scope and shadows any similarly named variable in the outer scope. Since the last statement in foo assigns a new value to x, the compiler recognizes it as a local variable. Consequently when the earlier print x attempts to print the uninitialized local variable and an error results.

In the example above you can access the outer scope variable by declaring it global:

>>>
>>> x = 10
>>> def foobar():
...     global x
...     print x
...     x += 1
>>> foobar()
10
This explicit declaration is required in order to remind you that (unlike the superficially analogous situation with class and instance variables) you are actually modifying the value of the variable in the outer scope:

>>>
>>> print x
11

ValueError 传入不期望值

自定义异常

自定义异常通过继承异常基类的方法的派生类。（好绕嘴）如下：

class MyException(Exception):
    def __init__(self,name):
        self.msg = name

    def __str__(self):
       return self.msg # 可以不重写，继承基类

#调用
try:
    if flag:
        pass
    else:
        raise MyException("自定义错误")
except MyException as e:
    print(e)