python try 错误处理 总结

阅读前请看一下：我是一个热衷于记录的人，每次写博客会反复研读，尽量不断提升博客质量。文章设置为仅粉丝可见，是因为写博客确实花了不少精力。希望互相进步谢谢！！

前言

错误处理的一些总结，参考文如下：

廖老师之python之错误处理

异常处理——捕获异常和抛出异常

提示：以下是本篇文章正文内容，下面案例可供参考

一、try…except(…else)(…finally)？

1、语法注意事项

• 每一个try，都必须至少有一个except。而else、finally可有可无。

• 当我们认为某些代码可能会出错时，就可以用try来运行这段代码。

  如果执行出错，则该段代码的后续代码不会继续执行，而是直接跳转至错误处理代码，即except语句块，执行完except后，如果后有else、finally两个语句块，则不执行else语句块，而是执行finally语句块，最后再执行之外的代码。

  如果执行没有错，则不会执行except语句块，如果后有else、finally，则顺序执行else、finally两个语句块，最后执行其他的代码。

• 可以有多个except来捕获不同类型的错误。

• 如果不确定错误的类型，则统一except Exception。Exception是异常的统称，就像格式化语句print(‘%s is beautiful’ % name)，拿不准就%s。except Exception as err 其实就是将捕获到的错误，赋值给err变量。这里的err可以取任意变量名来表示，这样就可以通过打印或者日志记录来将异常里的错误原因进行记录。

  如果已经得知会可能出现的报错原因时，即确定错误的类型，可以将具体异常类型直接放在except语句中，最为常见的是以下几种异常类型：

  ImportError:无法引入模块或包
  IndexError:下标索引超出序列边界
  NameError:使用一个还未赋予对象的变量
  SyntaxError:代码逻辑语法出错，不能执行，不能被捕获
  TypeError:传入的对象类型与要求不符合
  ValueError:传入一个不被期望的值，即使类型正确
  KeyError:试图访问你字典里不存在的键
  IOError:输入输出异常，文件操作
  需要注意的是，语法错误是不能被异常捕获！！！

  以上所有的注意事项，下面这段代码均能体现：

  #传的参strs为一个字符串
  def test(strs):
      try:
          print('try...')
          result = 10 / int(strs)      #可能出错的代码放try里面
          print('result: %s' % result)
      except ValueError as e:  #int()函数可能会抛出ValueError，所以用一个except捕获ValueError
          print('ValueError: %s' %e)
      except ZeroDivisionError as e:  #除数不能为0，所以用一个except捕获ZeroDivisionError
          print('ZeroDivisionError: %s' %e)
      else:
          print('No Error')
      finally:
          print('finally')
      print('END')
  
  print(test('1'))
  #Output:
  #   try...
  #   result: 10.0
  #   No Error
  #   finally
  #   END
  
  print(test('0'))
  #Output:
  #   try...
  #   ZeroDivisionError: division by zero
  #   finally
  #   END
  
  print(test('a')) 
  #Output:
  #   try...
  #   ValueError: invalid literal for int() with base 10: 'a'
  #   finally
  #   END
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37

• Python的错误其实也是class，所有的错误类型都继承自BaseException，所以在使用except时需要注意的是，它不但捕获该类型的错误，还把其子类也“一网打尽”。比如：

  def foo():
      r = 10 / int('0')
      return r
  try:
      foo()
  except ValueError as e:
      print('ValueError')
  except UnicodeError as e:
      print('UnicodeError')
  1
  2
  3
  4
  5
  6
  7
  8
  9

  第二个except永远也捕获不到UnicodeError，因为UnicodeError是ValueError的子类，如果有，也被第一个except给捕获了。

  Python所有的错误都是从BaseException类派生的，常见的错误类型和继承关系看这里：https://docs.python.org/3/library/exceptions.html#exception-hierarchy

2、使用try…except的好处

• 使用try…except捕获错误还有一个巨大的好处，就是可以跨越多层调用，比如函数main()调用bar()，bar()调用foo()，结果foo()出错了，这时，只要main()捕获到了，就可以处理

  def foo(s):
      return 10 / int(s)
  
  def bar(s):
      return foo(s) * 2
  
  def main():
      try:
          bar(0)
      except Exception as e:
          print('Error: %s' %e)
      finally:
          print('finally...')
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13

  也就是说，不需要在每个可能出错的地方去捕获错误，只要在合适的层次去捕获错误就可以了。这样一来，就大大减少了写try…except…finally的麻烦。

二、调用栈

• 如果错误未被捕获，则会一直往上抛，直至被Python解释器捕获，打印一个错误信息，停止程序的执行并退出程序。来看看err.py：

  # err.py:
  def foo(s):
      return 10 / int(s)
  
  def bar(s):
      return foo(s) * 2
  
  def main():
      bar('0')
  
  main()
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11

  执行，结果如下：

   python3 err.py 
  	> 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 
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11

```python
1
2

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

  错误信息第1行：

  Traceback (most recent call last): 告诉我们这是错误的跟踪信息。

  第2~3行：

  File “err.py”, line 11, in
  main() 调用main()出错了，在代码文件err.py的第11行代码，但原因是第9行：

  File “err.py”, line 9, in main
  bar(‘0’) 调用bar(‘0’)出错了，在代码文件err.py的第9行代码，但原因是第6行：

  File “err.py”, line 6, in bar
  return foo(s) * 2 原因是return foo(s) * 2这个语句出错了，但这还不是最终原因，继续往下看：

  File “err.py”, line 3, in foo
  return 10 / int(s) 原因是return 10 / int(s)这个语句出错了，这是错误产生的源头，因为下面打印了：

  ZeroDivisionError: integer division or modulo by zero 根据错误类型 ZeroDivisionError，我们判断，int(s)本身并没有出错，但是int(s)返回0，在计算10 / 0时出错，至此，找到错误源头。

  出错的时候，一定要分析错误的调用栈信息，才能定位错误的位置！！！
出错的时候，一定要分析错误的调用栈信息，才能定位错误的位置！！！
出错的时候，一定要分析错误的调用栈信息，才能定位错误的位置！！！

三、记录错误logging模块

• 如果不捕获错误，自然可以让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')
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15

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

  $ python3 err_logging.py
  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
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11

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

四、抛出错误

1、错误怎么来的？

• 因为错误是class，捕获一个错误就是捕获到该class的一个实例。因此，错误并不是凭空产生的，而是有意创建并抛出的。

2、怎么抛？rasie关键字

• 使用rasie关键字

  • 抛出内置错误实例

    def foo(s):
        n = int(s)
        if n == 0:
            raise ValueError('invalid value: %s' %s)
        return 10 / n
    
    print(foo('0'))
    1
    2
    3
    4
    5
    6
    7

  • 抛出自定义错误实例。

    根据需要，可以定义一个错误的class，选择好继承关系，然后，用raise语句抛出。

    class FooError(ValueError):
        pass
    
    def foo(s):
        n = int(s)
        if n==0:
            raise FooError('invalid value: %s' % s)
        return 10 / n
    
    foo('0')
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10

  • 只有在必要的时候才定义我们自己的错误类型。如果可以选择Python已有的内置的错误类型（比如ValueError，TypeError），尽量使用Python内置的错误类型。

3、抛出错误raise和捕获错误try…except的关联？

• 错误是在执行代码时可能产生的。若一旦产生，即便没有人为raise主动抛出，系统也会自动抛出。即便没有try…except人为主动去捕捉，python解释器也会自动捕捉。这就是为什么起初写程序时，代码里既没有raise语句，也没有try…except语句，但有bug却会返回错误栈并退出执行。这就是因为错误一层一层往上抛，最终被python解释器捕获。
• 那自定义raise和try…except的好处在于可以人为地去定位可能出错的代码，帮助我们更好的分析。

五、常见但特殊的错误处理方式

• # err_reraise.py
  
  def foo(s):
      n = int(s)
      if n==0:
          raise ValueError('invalid value: %s' % s)
      return 10 / n
  
  def bar():
      try:
          foo('0')
      except ValueError as e:
          print('ValueError!')
          raise
  
  bar()
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16

  在bar()函数中，我们明明已经捕获了错误，但是，打印一个ValueError!后，又把错误通过raise语句抛出去了，这不有病么？

  其实这种错误处理方式不但没病，而且相当常见。捕获错误目的只是记录一下，便于后续追踪。但是，由于当前函数不知道应该怎么处理该错误，所以，最恰当的方式是继续往上抛，让顶层调用者去处理。好比一个员工处理不了一个问题时，就把问题抛给他的老板，如果他的老板也处理不了，就一直往上抛，最终会抛给CEO去处理。

  raise语句如果不带参数，就会把当前错误原样抛出。

• 此外，在except中raise一个Error，还可以把一种类型的错误转化成另一种类型：

  try:
      10 / 0
  except ZeroDivisionError:
      raise ValueError('input value')
  1
  2
  3
  4

  只要是合理的转换逻辑就可以，但是，决不应该把一个IOError转换成毫不相干的ValueError。

总结

码字不易，谢谢点赞！！！
码字不易，谢谢点赞！！！
码字不易，谢谢点赞！！！