python异常(9)

野性酷女 2022-06-10 13:49 148阅读 0赞

# Python有两种错误很容易辨认：语法错误和异常 #

## **语法错误** ##

Python 的语法错误或者称之为解析错

# **异常** #

异常即非正常状态，在Python中使用异常对象来表示异常。若程序在编译或运行过程中发生错误，程序的执行过程就会发生改变，抛出异常对象，程序流进入异常处理。如果异常对象没有被处理或捕捉，程序就会执行回溯(Traceback)来终止程序。

# **异常类型** #

**通用异常类型表**

<table> 
 <tbody> 
 <tr> 
 <td> 异常 </td> 
 <td> 描述 </td> 
 </tr> 
 <tr> 
 <td> BaseException </td> 
 <td> 所有异常的基类 </td> 
 </tr> 
 <tr> 
 <td> SystemExit </td> 
 <td> 解释器请求退出 </td> 
 </tr> 
 <tr> 
 <td> KeyboardInterrupt </td> 
 <td> 用户中断执行(通常是输入^C) </td> 
 </tr> 
 <tr> 
 <td> Exception </td> 
 <td> 常规错误的基类 </td> 
 </tr> 
 <tr> 
 <td> StopIteration </td> 
 <td> 迭代器没有更多的值 </td> 
 </tr> 
 <tr> 
 <td> GeneratorExit </td> 
 <td> 生成器(generator)发生异常来通知退出 </td> 
 </tr> 
 <tr> 
 <td> StandardError </td> 
 <td> 所有的内建标准异常的基类 </td> 
 </tr> 
 <tr> 
 <td> ArithmeticError </td> 
 <td> 所有数值计算错误的基类 </td> 
 </tr> 
 <tr> 
 <td> FloatingPointError </td> 
 <td> 浮点计算错误 </td> 
 </tr> 
 <tr> 
 <td> OverflowError </td> 
 <td> 数值运算超出最大限制 </td> 
 </tr> 
 <tr> 
 <td> ZeroDivisionError </td> 
 <td> 除(或取模)零 (所有数据类型) </td> 
 </tr> 
 <tr> 
 <td> AssertionError </td> 
 <td> 断言语句失败 </td> 
 </tr> 
 <tr> 
 <td> AttributeError </td> 
 <td> 对象没有这个属性 </td> 
 </tr> 
 <tr> 
 <td> EOFError </td> 
 <td> 没有内建输入,到达EOF 标记 </td> 
 </tr> 
 <tr> 
 <td> EnvironmentError </td> 
 <td> 操作系统错误的基类 </td> 
 </tr> 
 <tr> 
 <td> IOError </td> 
 <td> 输入/输出操作失败 </td> 
 </tr> 
 <tr> 
 <td> OSError </td> 
 <td> 操作系统错误 </td> 
 </tr> 
 <tr> 
 <td> WindowsError </td> 
 <td> 系统调用失败 </td> 
 </tr> 
 <tr> 
 <td> ImportError </td> 
 <td> 导入模块/对象失败 </td> 
 </tr> 
 <tr> 
 <td> LookupError </td> 
 <td> 无效数据查询的基类 </td> 
 </tr> 
 <tr> 
 <td> IndexError </td> 
 <td> 序列中没有此索引(index) </td> 
 </tr> 
 <tr> 
 <td> KeyError </td> 
 <td> 映射中没有这个键 </td> 
 </tr> 
 <tr> 
 <td> MemoryError </td> 
 <td> 内存溢出错误(对于Python 解释器不是致命的) </td> 
 </tr> 
 <tr> 
 <td> NameError </td> 
 <td> 未声明/初始化对象 (没有属性) </td> 
 </tr> 
 <tr> 
 <td> UnboundLocalError </td> 
 <td> 访问未初始化的本地变量 </td> 
 </tr> 
 <tr> 
 <td> ReferenceError </td> 
 <td> 弱引用(Weak reference)试图访问已经垃圾回收了的对象 </td> 
 </tr> 
 <tr> 
 <td> RuntimeError </td> 
 <td> 一般的运行时错误 </td> 
 </tr> 
 <tr> 
 <td> NotImplementedError </td> 
 <td> 尚未实现的方法 </td> 
 </tr> 
 <tr> 
 <td> SyntaxError </td> 
 <td> Python 语法错误 </td> 
 </tr> 
 <tr> 
 <td> IndentationError </td> 
 <td> 缩进错误 </td> 
 </tr> 
 <tr> 
 <td> TabError </td> 
 <td> Tab 和空格混用 </td> 
 </tr> 
 <tr> 
 <td> SystemError </td> 
 <td> 一般的解释器系统错误 </td> 
 </tr> 
 <tr> 
 <td> TypeError </td> 
 <td> 对类型无效的操作 </td> 
 </tr> 
 <tr> 
 <td> ValueError </td> 
 <td> 传入无效的参数 </td> 
 </tr> 
 <tr> 
 <td> UnicodeError </td> 
 <td> Unicode 相关的错误 </td> 
 </tr> 
 <tr> 
 <td> UnicodeDecodeError </td> 
 <td> Unicode 解码时的错误 </td> 
 </tr> 
 <tr> 
 <td> UnicodeEncodeError </td> 
 <td> Unicode 编码时错误 </td> 
 </tr> 
 <tr> 
 <td> UnicodeTranslateError </td> 
 <td> Unicode 转换时错误 </td> 
 </tr> 
 <tr> 
 <td> Warning </td> 
 <td> 警告的基类 </td> 
 </tr> 
 <tr> 
 <td> DeprecationWarning </td> 
 <td> 关于被弃用的特征的警告 </td> 
 </tr> 
 <tr> 
 <td> FutureWarning </td> 
 <td> 关于构造将来语义会有改变的警告 </td> 
 </tr> 
 <tr> 
 <td> OverflowWarning </td> 
 <td> 旧的关于自动提升为长整型(long)的警告 </td> 
 </tr> 
 <tr> 
 <td> PendingDeprecationWarning </td> 
 <td> 关于特性将会被废弃的警告 </td> 
 </tr> 
 <tr> 
 <td> RuntimeWarning </td> 
 <td> 可疑的运行时行为(runtime behavior)的警告 </td> 
 </tr> 
 <tr> 
 <td> SyntaxWarning </td> 
 <td> 可疑的语法的警告 </td> 
 </tr> 
 <tr> 
 <td> UserWarning </td> 
 <td> 用户代码生成的警告 </td> 
 </tr> 
 </tbody> 
</table>

**Exception类**：是通用异常基类下列异常类均继承于Exception类，Python解析器会自动将通用异常类型名称放在内建命名空间中，所以当使用通用异常类型时，不需要import exceptions模块。

## **异常处理** ##

以下例子中，让用户输入一个合法的整数，但是允许用户中断这个程序（使用 Control-C 或者操作系统提供的方法）。用户中断的信息会引发一个 KeyboardInterrupt 异常。

>>> while True:

try:

x  = int(input("Please enter a number: "))

break

except ValueError:

print("Oops!  That was no valid number.  Try again   ")

try语句按照如下方式工作；

· 首先，执行try子句（在关键字try和关键字except之间的语句）

· 如果没有异常发生，忽略except子句，try子句执行后结束。

· 如果在执行try子句的过程中发生了异常，那么try子句余下的部分将被忽略。如果异常的类型和 except 之后的名称相符，那么对应的except子句将被执行。最后执行 try 语句之后的代码。

· 如果一个异常没有与任何的except匹配，那么这个异常将会传递给上层的try中。

一个 try 语句可能包含多个except子句，分别来处理不同的特定的异常。最多只有一个分支会被执行。

处理程序将只针对对应的try子句中的异常进行处理，而不是其他的 try 的处理程序中的异常。

一个except子句可以同时处理多个异常，这些异常将被放在一个括号里成为一个元组，例如:

except (RuntimeError, TypeError, NameError):

pass

最后一个except子句可以忽略异常的名称，它将被当作通配符使用。你可以使用这种方法打印一个错误信息，然后再次把异常抛出。

import sys

try:

f = open('myfile.txt')

s = f.readline()

i = int(s.strip())except OSError as err:

print("OS error: \{0\}".format(err))except ValueError:

print("Could not convert data to an integer.")except:

print("Unexpected error:", sys.exc\_info()\[0\])

raise

try except 语句还有一个可选的else子句，如果使用这个子句，那么必须放在所有的except子句之后。这个子句将在try子句没有发生任何异常的时候执行。例如:

for argin sys.argv\[1:\]:

try:

f  = open(arg, 'r')

except IOError:

print('cannot open', arg)

else:

print(arg, 'has', len(f.readlines()), 'lines')

f.close()

使用 else 子句比把所有的语句都放在 try 子句里面要好，这样可以避免一些意想不到的、而except又没有捕获的异常。

异常处理并不仅仅处理那些直接发生在try子句中的异常，而且还能处理子句中调用的函数（甚至间接调用的函数）里抛出的异常。例如:

>>> def this\_fails():

x  = 1/0

>>> try:

this\_fails()

except ZeroDivisionError as err:

print('Handling run-time error:', err)

Handling run\-time error: int divisionor modulo by zero

## **抛出异常** ##

Python 使用 raise 语句抛出一个指定的异常。例如:

>>> raise NameError('HiThere')Traceback (most recent call last):

File "<stdin>", line1, in ?NameError: HiThere

raise 唯一的一个参数指定了要被抛出的异常。它必须是一个异常的实例或者是异常的类（也就是 Exception 的子类）。

如果你只想知道这是否抛出了一个异常，并不想去处理它，那么一个简单的 raise 语句就可以再次把它抛出。

>>> try:

raise NameError('HiThere')

except NameError:

print('An exception flew by!')

raise

An exception flewby!Traceback (most recent calllast):

File "<stdin>", line2, in ?NameError: HiThere

## **用户自定义异常** ##

你可以通过创建一个新的exception类来拥有自己的异常。异常应该继承自 Exception 类，或者直接继承，或者间接继承，例如:

>>> class MyError(Exception):

def \_\_init\_\_(self, value):

self.value= value

def \_\_str\_\_(self):

return repr(self.value)

>>> try:

raise MyError(2\*2)

except MyError as e:

print('My exception occurred, value:', e.value)

My exception occurred, value: 4>>> raise MyError('oops!')Traceback (most recent call last):

File "<stdin>", line1, in ?

\_\_main\_\_.MyError: 'oops!'

在这个例子中，类 Exception 默认的 \_\_init\_\_() 被覆盖。

<p异常的类可以像其他的类一样做任何事情，但是通常都会比较简单，只提供一些错误相关的属性，并且允许处理异常的代码方便的获取这些信息。< p="" style="color: rgb(51, 51, 51); font-family: 'Open Sans', 'Helvetica Neue', Helvetica, Arial, STHeiti, 'Microsoft Yahei', sans-serif; font-size: 12px; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; line-height: normal; orphans: auto; text-align: start; text-indent: 0px; text-transform: none; white-space: normal; widows: 1; word-spacing: 0px; -webkit-text-stroke-width: 0px; background-color: rgb(255, 255, 255);">

当创建一个模块有可能抛出多种不同的异常时，一种通常的做法是为这个包建立一个基础异常类，然后基于这个基础类为不同的错误情况创建不同的子类:

class Error(Exception):

"""Base class for exceptions in this module."""

pass

class InputError(Error):

"""Exception raised for errors in the input.

Attributes:

expression -- input expression in which the error occurred

message -- explanation of the error

"""

def \_\_init\_\_(self, expression, message):

self.expression= expression

self.message= message

class TransitionError(Error):

"""Raised when an operation attempts a state transition that's not

allowed.

Attributes:

previous -- state at beginning of transition

next -- attempted new state

message -- explanation of why the specific transition is not allowed

"""

def \_\_init\_\_(self, previous, next, message):

self.previous= previous

self.next = next

self.message= message

大多数的异常的名字都以"Error"结尾，就跟标准的异常命名一样。

## **定义清理行为** ##

try 语句还有另外一个可选的子句，它定义了无论在任何情况下都会执行的清理行为。 例如:

>>> try:...     raise KeyboardInterrupt... finally:...     print('Goodbye, world!')... Goodbye, world!Traceback (most recent call last):

File "<stdin>", line2, in <module>KeyboardInterrupt

以上例子不管 try 子句里面有没有发生异常，finally 子句都会执行。

如果一个异常在 try 子句里（或者在 except 和 else 子句里）被抛出，而又没有任何的 except 把它截住，那么这个异常会在 finally 子句执行后再次被抛出。

下面是一个更加复杂的例子（在同一个 try 语句里包含 except 和 finally 子句）:

>>> def divide(x, y):

try:

result  = x / y

except ZeroDivisionError:

print("division by zero!")

else:

print("result is", result)

finally:

print("executing finally clause")

>>> divide(2, 1)

result is 2.0

executing  finally clause>>> divide(2, 0)

division  by zero!

executing  finally clause>>> divide("2", "1")

executing  finally clauseTraceback (most recent calllast):

File "<stdin>", line1, in ?

File "<stdin>", line3, in divideTypeError: unsupported operand type(s) for /: 'str' and 'str'

## **预定义的清理行为** ##

一些对象定义了标准的清理行为，无论系统是否成功的使用了它，一旦不需要它了，那么这个标准的清理行为就会执行。

这面这个例子展示了尝试打开一个文件，然后把内容打印到屏幕上:

for linein open("myfile.txt"):

print(line, end="")

以上这段代码的问题是，当执行完毕后，文件会保持打开状态，并没有被关闭。

关键词 with 语句就可以保证诸如文件之类的对象在使用完之后一定会正确的执行他的清理方法:

with open("myfile.txt") as f:

for linein f:

print(line, end="")

以上这段代码执行完毕后，就算在处理过程中出问题了，文件 f 总是会关闭

python异常(9)

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 python 异常

相关 python 异常

相关 Python学习笔记（9）-文件和异常

相关 python异常(9)

相关 python 异常

相关 Python 异常

相关 python入门day9（模块、异常处理）

相关 9.异常处理

相关 Python学习_9

相关 python 9*9乘法表