Python3 错误和异常

简介:




Python3 错误和异常

  • 语法错误

  • 异常

  • 异常处理

  • 抛出异常

  • 用户自定义异常

  • finally语句

  • 预定义的清理行为


异常处理机制概述: 
异常处理,是编程语言或计算机硬件里的一种机制,用于处理软件或信息系统中出现的异常状况(即超出程序正常执行流程的某些特殊条件)。通过异常处理,我们可以对用户在程序中的非法输入进行控制和提示,以防程序崩溃。 
就好比一个旅游景点,每到一个有可能出现问题情况的地方就会设置一个处理问题的处理点,不同的问题有不同的处理点,例如花粉过敏有花粉过敏的处理点,摔伤有摔伤的处理点等。程序也是如此会出现各种各样的错误,同理不同的异常错误有不同的异常错误处理方法。 
各种编程语言在处理异常方面具有非常显著的不同点(错误检测与异常处理区别在于:错误检测是在正常的程序流中,处理不可预见问题的代码,例如一个调用操作未能成功结束)。某些编程语言有这样的函数:当输入存在非法数据时不能被安全地调用,或者返回值不能与异常进行有效的区别。例如,C语言中的atoi函数(ASCII串到整数的转换)在输入非法时可以返回0。在这种情况下编程者需要另外进行错误检测(可能通过某些辅助全局变量如C的errno),或进行输入检验(如通过正则表达式),或者共同使用这两种方法。 
在python中我们可以通过try-except语句来捕捉异常,语法错误的话开发工具都会有提示的。


语法错误

语法错误或者称之为解析错误,是初学者经常碰到的,如下实例:

1
2
3
4
5
>>>  while  True  print ( 'Hello world' )
   File  "<stdin>" , line  1 in  ?
     while  True  print ( 'Hello world' )
                    ^
SyntaxError: invalid syntax

这个例子中,函数 print() 被检查到有错误,是它前面缺少了一个冒号( : )。 
解释器会指出了出错的一行,并且在最先找到的错误的位置标记了一个小小的箭头。


异常

即便代码的语法是正确的,但是在运行它的时候,也有可能发生错误。运行期间检测到的错误被称为异常,例如不能被0整除错误,或者空指针异常。 
大多数的异常都不会被程序处理,都以错误信息的形式展现在这里:

1
2
3
4
5
6
7
8
9
10
11
12
>>>  10  *  ( 1 / 0 )    # 不能被0整除异常
Traceback (most recent call last):
   File  "<stdin>" , line  1 in  ?
ZeroDivisionError: division by zero
>>>  4  +  spam * 3
Traceback (most recent call last):
   File  "<stdin>" , line  1 in  ?
NameError: name  'spam'  is  not  defined    # 变量未声明异常
>>>  '2'  +  2   # 类型异常
Traceback (most recent call last):
   File  "<stdin>" , line  1 in  ?
TypeError: Can 't convert ' int object  to  str  implicitly

异常会有不同的类型,这些类型都作为信息的一部分打印出来,以上例子中的类型有 ZeroDivisionError(不能被0整除异常),NameError( 变量未声明异常) 和 TypeError(类型异常),这些异常类型能提示开发人员发生的是什么样的异常,这样就可以分析错误发生在何处。 
错误信息的前面部分显示了异常发生的上下文,并以调用栈的形式显示具体信息。


异常处理

在python中通过try-except语句来处理异常,例如将可能会出现不能被0整除异常的代码写在try代码块里,try代码块里的代码执行过程中出现异常后,就会执行except代码块里的代码,代码示例:

1
2
3
4
5
6
# 会出现异常的代码写在try里
try :
     num = 10 / 0
     print (num)   # 如果上面的代码出现异常这句代码不会被执行
except :
     print ( "出现异常了!" )    # try里的代码出现异常后就会执行这里的代码

运行结果:

出现异常了!

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

  • 首先,执行try子句(在关键字try和关键字except之间的语句)

  • 如果没有异常发生,会忽略except子句,try子句执行后就结束。

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

  • 如果一个异常没有与任何的except匹配,那么这个异常将会被抛出。

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

以上示例的是最简单的使用方式,能够捕获所有类型的异常,称之为通用异常陷阱。如果需要捕捉特定的异常,可以在except中声明异常的类型,那么这个陷阱就只能捕获你所声明的异常类型,但是可以在末尾写上一个通用异常陷阱,没有被特定的陷阱所捕获的异常最后就会被通用异常陷阱所捕获。如果你在except中声明了一个异常类型,可以通过as关键字赋值给一个变量,通过这个变量可以打印出错误信息,代码示例:

1
2
3
4
5
6
7
8
9
10
try :
     num  =  10  /  0
     print (num)
 
except  ZeroDivisionError as err:  # 赋值给err变量
     print ( "出现异常:" , err)
except  TypeError:   # 声明一个指定的异常类型
     print ( "出现类型异常!" )
except :     # 末尾可以使用一个通用异常
     print ( "出现异常了!" )

运行结果:

出现异常: division by zero

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

except (RuntimeError, TypeError, NameError):

使用raise关键字,可以将异常再次抛出,会抛出到解释器中,代码示例:

1
2
3
4
5
6
7
8
9
10
11
try :
     num  =  10  /  0
     print (num)
 
except  ZeroDivisionError as err:  # 赋值给err变量
     print ( "出现异常:" , err)
     raise
except  TypeError:   # 声明一个指定的异常类型
     print ( "出现类型异常!" )
except :     # 末尾可以使用一个通用异常
     print ( "出现异常了!" )

运行结果:

1
2
3
4
5
出现异常: division by zero
Traceback (most recent call last):
   File  "E:/PythonProject/TestExcept.py" , line  2 in  <module>
     num  =  10  /  0
ZeroDivisionError: division by zero

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

1
2
3
4
5
6
7
8
9
10
11
try :
     num  =  1 + 1
except  ZeroDivisionError as err:  # 赋值给err变量
     print ( "出现异常:" , err)
     raise
except  TypeError:   # 声明一个指定的异常类型
     print ( "出现类型异常!" )
except :     # 末尾可以使用一个通用异常
     print ( "出现异常了!" )
else  :
     print ( "没有出现异常!" )

运行结果:

没有出现异常!

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
def  errorTest():
     return  1 / 0
 
try :
     num  =  errorTest()
except  ZeroDivisionError as err:  # 赋值给err变量
     print ( "出现异常:" , err)
except  TypeError:   # 声明一个指定的异常类型
     print ( "出现类型异常!" )
except :     # 末尾可以使用一个通用异常
     print ( "出现异常了!" )
else  :
     print ( "没有出现异常!" )

运行结果:

出现异常: division by zero


抛出异常

上面示例也用到了raise 关键字,通过这个关键字可以抛出异常到外部。也可以使用此关键字在代码中抛出特定的异常,如果这个关键字写在except里,并且没有指定要抛出的异常,那么这个raise 就会抛出这个陷阱里的异常,代码示例:

1
2
3
4
try :
     num = 10 / 0
except  ZeroDivisionError:
     raise

运行结果:

1
2
3
4
Traceback (most recent call last):
   File  "E:/PythonProject/TestExcept.py" , line  3 in  <module>
     num = 10 / 0
ZeroDivisionError: division by zero

使用raise 关键字抛出指定的异常示例:

1
2
3
4
5
6
7
8
i = 0
j = 1
 
if  i! = 0 :
     k = j / i
else :
     print ( "抛出一个异常:" )
     raise  ZeroDivisionError

运行结果:

1
2
3
4
Traceback (most recent call last):
   File  "E:/PythonProject/TestExcept.py" , line  8 in  <module>
     raise  ZeroDivisionError
ZeroDivisionError

抛出的异常可以指定一个字符串类型的参数,这个参数也会随着异常信息打印出来,代码示例:

1
2
3
4
5
6
7
8
i = 0
j = 1
 
if  i! = 0 :
     k = j / i
else :
     print ( "抛出一个异常:" )
     raise  ZeroDivisionError( "我是异常" )

运行结果:

1
2
3
4
5
抛出一个异常:
Traceback (most recent call last):
   File  "E:/PythonProject/TestExcept.py" , line  9 in  <module>
     raise  ZeroDivisionError( "我是异常" )
ZeroDivisionError: 我是异常


用户自定义异常

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 这是一个自定义的异常类
>>>  class  MyError(Exception):   # 继承于Exception类
         def  __init__( self , value):   # 这是初始化方法,也就是构造器
             self .value  =  value   #这是这个类的属性
         def  __str__( self ):    # 类中的每个方法都需要有一个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>" , line  1 in  ?
__main__.MyError:  'oops!'

在这个例子中,类 Exception 默认的 _init_( ) 被覆盖。 
当创建一个模块有可能抛出多种不同的异常时,一种通常的做法是为这个包建立一个基础异常类,然后基于这个基础类为不同的错误情况创建不同的子类:

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
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”结尾,就跟标准的异常命名一样。


finally语句

try 语句还有另外一个可选的子句,这个语句无论在任何情况下都会执行,也就是所谓的最终执行块,这个代码块里的代码不管什么有没有发生异常都会被执行,一般用于执行close之类的关闭资源的语句。 例如:

1
2
3
4
5
6
7
try :
     filedata  =  open ( "E:/test.txt" )
except  IOError:
     print ( "文件打开失败!" )
finally :
     filedata.close()
     print ( "资源已关闭!" )

运行结果:

资源已关闭!

以上例子不管 try 子句里面有没有发生异常,finally 子句都会执行。 
如果一个异常在 try 子句里(或者在 except 和 else 子句里)被抛出,而又没有任何的 except 把它截住,那么这个异常会在 finally 子句执行后再次被抛出。 
代码示例:

1
2
3
4
5
6
7
8
try :
     filedata  =  open ( "E:/test.txt" )
     raise  ZeroDivisionError
except  IOError:
     print ( "文件打开失败!" )
finally :
     filedata.close()
     print ( "资源已关闭!" )

运行结果:

1
2
3
4
5
资源已关闭!
Traceback (most recent call last):
   File  "E:/PythonProject/TestExcept.py" , line  3 in  <module>
     raise  ZeroDivisionError
ZeroDivisionError


预定义的清理行为

一些对象定义了标准的清理行为,无论系统是否成功的使用了它,一旦不需要它了,那么这个标准的清理行为就会执行。 
这面这个例子展示了尝试打开一个文件,然后把内容打印到屏幕上:

1
2
for  line  in  open ( "myfile.txt" ):
     print (line, end = "")

以上这段代码的问题是,当执行完毕后,文件会保持打开状态,并没有被关闭。 
之前介绍过的关键词 with 语句就可以保证诸如文件之类的对象在使用完之后一定会正确的执行他的清理方法,这种就是预定义的清理行为:

1
2
3
with  open ( "myfile.txt" ) as f:
     for  line  in  f:
         print (line, end = "")

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



本文转自 ZeroOne01 51CTO博客,原文链接:http://blog.51cto.com/zero01/1981049,如需转载请自行联系原作者

相关文章
|
3月前
|
Python
Python学习 -- 异常堆栈追踪技术
Python学习 -- 异常堆栈追踪技术
27 0
|
3月前
|
Python
Python学习 -- 异常捕获技巧
Python学习 -- 异常捕获技巧
20 0
|
1月前
|
开发者 UED Python
怎么理解python中的错误和异常
怎么理解python中的错误和异常
24 0
|
1天前
|
Python
python面型对象编程进阶(继承、多态、私有化、异常捕获、类属性和类方法)(上)
python面型对象编程进阶(继承、多态、私有化、异常捕获、类属性和类方法)(上)
7 0
|
14天前
|
Python
Python中异常的抛出与捕获
4月更文挑战第3天,Python中的异常是处理错误的方式,当错误发生时,异常被触发,未被捕获则导致程序终止。通过`raise`可手动抛出异常,例如`raise ValueError("Invalid value provided")`或自定义异常。使用`try-except`捕获异常,避免程序意外结束。`try`块包含可能出错的代码,`except`块处理特定异常,`else`子句在无异常时执行,`finally`子句确保清理代码始终执行。
16 2
Python中异常的抛出与捕获
|
1月前
|
Python
在Python中文件异常
在Python中文件异常
13 1
|
1月前
|
Python
python-异常,模块与包
python-异常,模块与包
15 4