Python 错误和异常

异常Exception

错误Error:又称解析错误,是可以避免的
异常Exception:在没有出现上面错误的前提下,语句和语法都是正确的,本身是意外情况,异常是不可避免的

In [1]: "asd" = 100
  File "<ipython-input-2-2b4a41f6b880>", line 1
    "asd" = 100
# 这是错误               ^
SyntaxError: can't assign to literal

In [2]: with open("test") as f:
   ...:     f.read()
   ...:     
Traceback (most recent call last):

  File "<ipython-input-1-22412c9ffa87>", line 1, in <module>
    with open("test") as f:
# 这是异常
FileNotFoundError: [Errno 2] No such file or directory: 'test'

在高级编程语言中,一般都有错误和异常的概念,异常可以捕获,错误不能被捕获
尽可能的避免错误
尽可能的捕获、处理异常

产生异常

产生

• raise语句显式的抛出异常
• Python解释器自己检测到异常并引发它

In [3]: print(1/0)  # ZeroDivisionError  

In [4]: raise TimeoutError # raise抛出的异常

异常的捕获

try：
    待捕获异常的代码块
except [异常类型]: 
    异常的处理代码块

In [5]: def fn():
   ...:     try:
   ...:         print(1/0)
   ...:     except ZeroDivisionError: # 指定捕获的异常类型
   ...:         print("ZeroDivisionError!")
   ...:     
   ...:     print("catch it!")
   ...:     

In [6]: fn()
ZeroDivisionError!
catch it!

注意:如果写明异常类型,异常类型要与上面发生的异常匹配,否则捕捉不到

In [7]: def fn():
   ...:     try:
   ...:         print(1/0)
                print("hi") # 因为上面发生了异常,这一句并不会被执行
   ...:     except FileNotFoundError: # 发生的异常和指定的异常类型不匹配
   ...:         print("ZeroDivisionError!")
   ...:     
   ...:     print("catch it!")
   ...: 

In [8]: fn()
Traceback (most recent call last):

  File "<ipython-input-8-e1d0f67027b9>", line 1, in <module>
    fn()

  File "<ipython-input-7-479fd82f5488>", line 3, in fn
    print(1/0)

ZeroDivisionError: division by zero

异常类及继承层次

BaseException
 +-- SystemExit
 +-- KeyboardInterrupt
 +-- GeneratorExit
 +-- Exception
      +-- StopIteration
      +-- StopAsyncIteration
      +-- ArithmeticError
      |    +-- FloatingPointError
      |    +-- OverflowError
      |    +-- ZeroDivisionError
      +-- AssertionError
      +-- AttributeError
      +-- BufferError
      +-- EOFError
      +-- ImportError
      |    +-- ModuleNotFoundError
      +-- LookupError
      |    +-- IndexError
      |    +-- KeyError
      +-- MemoryError
      +-- NameError
      |    +-- UnboundLocalError
      +-- OSError
      |    +-- BlockingIOError
      |    +-- ChildProcessError
      |    +-- ConnectionError
      |    |    +-- BrokenPipeError
      |    |    +-- ConnectionAbortedError
      |    |    +-- ConnectionRefusedError
      |    |    +-- ConnectionResetError
      |    +-- FileExistsError
      |    +-- FileNotFoundError
      |    +-- InterruptedError
      |    +-- IsADirectoryError
      |    +-- NotADirectoryError
      |    +-- PermissionError
      |    +-- ProcessLookupError
      |    +-- TimeoutError
      +-- ReferenceError
      +-- RuntimeError
      |    +-- NotImplementedError
      |    +-- RecursionError
      +-- SyntaxError
      |    +-- IndentationError
      |         +-- TabError
      +-- SystemError
      +-- TypeError
      +-- ValueError
      |    +-- UnicodeError
      |         +-- UnicodeDecodeError
      |         +-- UnicodeEncodeError
      |         +-- UnicodeTranslateError
      +-- Warning
           +-- DeprecationWarning
           +-- PendingDeprecationWarning
           +-- RuntimeWarning
           +-- SyntaxWarning
           +-- UserWarning
           +-- FutureWarning
           +-- ImportWarning
           +-- UnicodeWarning
           +-- BytesWarning
           +-- ResourceWarning

各种异常类型关系

BaseException及子类

1.SystemExit

sys.exit()引发的异常,异常不捕获处理,直接交给解释器,解释器退出
如果except该句捕获了该异常,则继续往后执行,如果没有捕获,解释器退出

In [10]: try:
    ...:     sys.exit(1)
    ...: except SystemExit:
    ...:     print("SysExit")
    ...: print("catch it!")
SysExit
catch it!

2.KeynoardInterrupt

对应的中断行为Ctrl+C

注:在解释器环境下使用这种捕获,普通ide环境热键冲突

In [12]: import time

In [13]: try:
    ...:     while True:
    ...:         time.sleep(1)
    ...:         print("===")
    ...: except KeyboardInterrupt:
    ...:     print("Ctrl + C")
    ...: print("==end==")
===
===
===
===
Ctrl + C
==end==

3.Exception及子类

Exception是所有内建的、非系统退出的异常的基类

注:python将有些语法错误归类到Exception下面,但这种错误是不可捕获的

• ArithmeticError:所有算数计算引发的异常,子类有:

  • FloatPointError
  • OverflowError
  • ZeroDivisionEroor

• LookupError : 使用映射的键或者序列的索引无效时引发的异常的基类

  • IndexError
  • KeyError

• 自定义异常类 :

class MyException(Exception):
    pass

In [35]: class M(ArithmeticError):
    ...:     pass
    ...:     

In [36]: try:
    ...:     raise M()
    ...: except M:
    ...:     print("catch it!")
    ...:     
catch it!

这里有个坑,就是自定义的异常只能手动raise抛出,解释器不知道你定义的异常类是什么鬼,即使你是从别的异常类继承下来的类

多种捕获

except可以指定捕获的类型,捕获多种异常
多个except即可,但是之后最多匹配一个异常

In [38]: try:
    ...:     1/0
    ...:     raise FileNotFoundError
    ...:     open("test")
    ...:     sys.exit(2)
    ...: except ZeroDivisionError:
    ...:     print("catch 1")
    ...: except FileNotFoundError:
    ...:     print("catch 2")
    ...: except Exception:
    ...:     print("catch 3")
    ...: except:
    ...:     print("catch 4")
    ...: print(5)
catch 1
5

捕获规则:
①从上到下依次比较,如果匹配,则执行匹配的except语句块
②如果一个except语句捕获,其他except语句不会再次捕获了
③如果没有任何一个except语句捕获这异常,则该异常向外抛出

捕获的原则:
从小到大,从具体到宽泛

as字句

except ... as ...

raise抛出的异常,应该都是异常类的实例
使用exception as e:查看e以及类型查看是否按要求捕获到

In [40]: try:
    ...:     raise 1
    ...: except Exception as e:
    ...:     print("catch it")
    ...:     print(e)
    ...:     
catch it
exceptions must derive from BaseException # 

rasie语句

注意区分下面两种情况

In [50]: class M(Exception):
    ...:     def __init__(self, code, message):
    ...:         self.code = code
    ...:         self.message = message
    ...:         
    
# 1
In [51]: try:
    ...:     raise M # 抛出的是类,但是这个类被解释器无参实例化,所以报参数错误
    ...: except M as e:
    ...:     print("catch it!")
    ...: except Exception as e:
    ...:     print("111")
    ...:     print(e)
    ...: print("===")
111
__init__() missing 2 required positional arguments: 'code' and 'message'
===

# 2
In [52]: try:
    ...:     raise M(200,"ok")  # 抛出的是类的实例化,所以被except M as e捕获
    ...: except M as e:
    ...:     print("catch it!")
    ...: except Exception as e:
    ...:     print("111")
    ...:     print(e)
    ...: print("===")
catch it!
===

• rasie后要求应该是BaseException类的子类或者实例化,如果是类,将被无参实例化
• raise后什么都没有,表示抛出最近一个被激活的异常,如果没有被激活的异常,则抛类型异常,这种方式很少用

In [53]: try:
    ...:     raise FileNotFoundError
    ...: except:
    ...:     raise # 抛出上面最近的一个被激活的异常FileNotFoundError
    ...: finally:
    ...:     print("finally")
    ...: print("==end==")
finally
Traceback (most recent call last):

  File "<ipython-input-53-1200dd6fb7ab>", line 2, in <module>
    raise FileNotFoundError

FileNotFoundError

finally

即最后一定要执行的语句块
可以在函数中使用finally,并且函数的返回值取决于最后一个执行的return语句
函数遇到真正的最后一个可以被执行的return就不会执行了

In [57]: def f():
    ...:     # return 1
    ...:     try:
    ...:         return 2
    ...:     finally: # 一定会被执行的语句块
    ...:         return 3
    ...:     return 4
    ...:     

In [58]: f()
Out[58]: 3

注:如果except没有捕获到异常,finally结束后的后面的语句不会执行,最后会抛出一个异常

异常的传递

异常总是向外层抛出,一直抛出到被捕获,如果到了最外层还没被捕获,就会中断异常所在的线程的执行。

def foo(s):
    return 10 / int(s)

def bar(s):
    return foo(s) * 2

def main():
    bar('0')

main()

Traceback (most recent call last):
  File "err.py", line 11, in <module>
    main()
  File "err.py", line 9, in main
    bar('0')
  File "err.py", line 6, in bar
    return foo(s) * 2
  File "err.py", line 3, in foo
    return 10 / int(s)
ZeroDivisionError: division by zero

出错并不可怕，可怕的是不知道哪里出错了。解读错误信息是定位错误的关键。我们从上往下可以看到整个错误的调用函数链。
最后我们定位到错误的源头：foo函数中的10/0

记录错误

如果不捕获错误，自然可以让Python解释器来打印出错误堆栈，但程序也被结束了。既然我们能捕获错误，就可以把错误堆栈打印出来，然后分析错误原因，同时，让程序继续执行下去。

Python内置的logging模块可以非常容易地记录错误信息：

import logging

def foo(s):
    return 10 / int(s)

def bar(s):
    return foo(s) * 2

def main():
    try:
        bar('0')
    except Exception as e:
        logging.exception(e)

main()
print('END')

同样是出错，但程序打印完错误信息后会继续执行，并正常退出:

ERROR:root:division by zero
Traceback (most recent call last):
  File "err_logging.py", line 13, in main
    bar('0')
  File "err_logging.py", line 9, in bar
    return foo(s) * 2
  File "err_logging.py", line 6, in foo
    return 10 / int(s)
ZeroDivisionError: division by zero
END

通过配置，logging还可以把错误记录到日志文件里，方便事后排查

这里转自廖雪峰博客
Python关于模块 logging — Python 的日志记录工具
后面详细介绍logging日志记录工具

try嵌套

内部捕获不到异常,回向外层传递异常
但是如果内部有finally且其中有return、break语句,则异常就不会继续往外抛出,异常就会被丢弃了

In [2]: def foo():
   ...:     try:
   ...:         1/0
   ...:     except KeyError as e: # 异常不匹配,所以捕捉不到异常
   ...:         print(e)
   ...:     finally:
   ...:         print("foo!")
   ...:         return 2  # 异常在这里被丢弃
   ...:         
   ...: try:
   ...:     foo() 
   ...: except:
   ...:     print("catch") 
   ...: else: # 因为上面的foo()函数并不会抛出异常,所以else语句正常执行
   ...:     print("good else")
   ...: finally: # finally一定执行
   ...:     print("end")
   ...:     
foo!
good else
end

异常的捕获时机

1.立即捕获,需要立即返回一个明确的结果

比如遇到异常就 return 0

In [3]: def parse_int(s):
   ...:     try:
   ...:         return int(s)
   ...:     except:
   ...:         return 0 # 遇到异常就返回0
   ...:         

In [4]: parse_int([])
Out[4]: 0

2.边界捕获

• 封装产生了边界
• 例如open函数,出现的异常交给调用处理,文件存在了,就不用了创建了,看是否修改还是删除
• 根据实际环境选择捕获时机

else字句

else表示没有任何异常发生,则执行

In [9]: try:
   ...:     0/1
   ...:     print("===")
   ...: except:
   ...:     print("123")
   ...: else: # 上面没抛异常,这里会被执行
   ...:     print("success")
   ...: finally:
   ...:     print("finally")
   ...:     
===
success
finally

总结

try:
    <语句>                      # 运行时的代码
except [异常类]:
    <语句>
    raise                       # 抛出上面收到的异常
except [异常类] as <变量名>:    # 捕获某种异常并获得对象e
    <语句>
else:                           # 如果没有任何异常发生则执行
    <语句>
finally:
    <语句>                      # 退出try时总会执行 

try的工作原理

1.如果try语句执行时发生异常,搜索except字句,并执行第一个匹配该异常的except字句
2.如果try语句中语句执行时发生异常,却没有匹配的except字句,异常将被递交到外层的try,如果外层不处理这个异常,异常将继续将外层传递,如果到了最外层还没被处理,就终止异常所在的线程
3.如果try执行时没发生异常,如有else字句,那么这个else字句可以被执行
4.无论try是否发生异常,finally都会被执行

python官方文档"错误和异常"