首页 > 代码库 > python异常介绍

python异常介绍

2024-07-03 06:29:22   229人阅读

?
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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
1、异常
 
                例如：
 
                def fetcher(obj,index):
 
                                return obj[index]
 
                def catcher():
 
                                try:
 
                                                fetcher(x,4)
 
                                except IndexError:
 
                                                print(‘got exception‘)
 
                                print(‘continuing‘)
 
2、引发异常
 
                raise IndexError
 
3、用户定义的异常: 用户定义的异常继承自内置异常类Exception
 
                class Bad(Exception):
 
                                pass
 
4、try/finally
 
                如果try部分没有发生异常，则finally中部分会执行，finally后面也会执行。如果try部分发生异常，则在finally中的部分会执行，finally后面部分不执行。
 
5、try/except/else语句
 
                try:
 
                                statement
 
                except name1:
 
                                statements
 
                except (name2,name3):
 
                                statements
 
                except name4 as data:
 
                                statements
 
                except :
 
                                statements
 
                else:  #没有发生异常时，执行这部分
 
                                statements
 
                解释
 
                except:   #捕获所有异常
 
                except name: 捕获特定异常
 
                except name,value:  捕获所列异常和额外的数据
 
                except (name1,name2): 捕获列出的异常
 
                except (name1,name2) value: 捕获列出的异常，并取得额外的数据
 
                else:  如果没有发生异常，就运行
 
                finally:  总是会运行此代码
 
                
 
                
 
                Exception的异常几乎与一个空的except具有相同的效果，但是忽略和系统退出相关的异常：
 
                try:
 
                                ation()
 
                except Exception:
 
                                ...
 
6、统一try/except/finally语句
 
                try:
 
                                main-action
 
                except Exception1:
 
                                handler1
 
                except Exception2:
 
                                handler2
 
                else:
 
                                else-block
 
                finally:
 
                                finally-block
 
                无论发生什么，当main-action代码完成时，而任何引发的异常都已处理后，finally-block就会被执行。事实上，即使异常处理器或者else-block内部有错误发生而引发的新的异常，finally-block内部代码依然会执行
 
                就像往常一样，finally字句并没有终止异常，当finally-block执行时，如果异常还在，就会在finally-block代码执行后继续传递。而控制权会跳至程序其他地方（到另外一个try，或者默认顶层处理器）如果finally执行时，没有异常处于激活状态，控制权就会在整个try语句之后继续执行。
 
7、raise语句
 
                raise <instance>  #抛出一个类的实例
 
                raise <class>     #产生一个类的实例并抛出
 
                raise                                        #重新抛出最近最常用的异常
 
                例如：
 
                raise  IndexError   #class (instance create)
 
                raise  IndexError               #instance（create in statement）
 
                
 
                如果一个try包含了一个名为except name as X：字句，变量x将会分配给引发中提供的实例：
 
                try :
 
                                ...
 
                except IndexError as X:  #x被赋予成IndexError的实例
 
                                ...
 
                利用raise传递异常
 
                raise语句不包括异常名称或额外数据值时，就是重新引发当前异常。如果需要捕捉异常和处理一个异常，又不希望异常在程序中死掉时，一般就会使用这种形式。
 
                例如：
 
                try:
 
                                raise IndexError(‘spam‘)
 
                except IndexError:
 
                                print(‘propagating‘)
 
                                raise
 
                通过这种方式执行raise时，会重新引发异常，并将其传递给更高层的处理器（或者顶层的默认处理器，他会停止程序，打印标准错误消息）     。
 
8、python3.0异常链：raise  from
 
                raise exception from otherexception
 
                当使用from的时候，第二个表达式指定了另一个异常类或实例，他会附加到引发异常的__cause__属性。如果引发的异常没有捕获，python把异常也作为标准出错信息的一部分打印出来。
 
9、assert语句
 
                assert <test>,<data>
 
                1、assert语句用来声明某个条件是真的。
 
                2、如果你非常确信某个你使用的列表中至少有一个元素，而你想要检验这一点，并且在它非真的时候引发一个错误，那么assert语句是应用在这种情形下的理想语句。
 
                3、当assert语句失败的时候，会引发一AssertionError。
 
10、with/as环境管理器
 
                在python2.6和python3.0中引入了一种新的异常相关的语句
 
                如果想在python2.5中使用的话，必须使用如下语句来激活
 
                from __future__ import with_statement
 
                基本使用
 
                with expression [as varible]:
 
                                with-block
 
11、环境管理协议
 
                1、计算表达式，所得到的对象称为环境管理器，它必须有__enter__和 __exit__方法
 
                2、环境管理器的__enter__方法会被调用，如果as字句存在，其返回值会赋值给as子句中的变量，否则抛弃。
 
                3、代码嵌套代码会执行
 
                4、如果with代码块引发异常，__exit__(type,value,traceback)方法会被调用.这些也是由sys.exc_info返回相同的值。否则 异常会终止。正常情况下异常应该重新引发，这样的话才能传递到with语句之外
 
                5、如果with代码没有引发异常，__exit__方法依然会被调用，其type，value以及traceback参数都会以 None传递
 
                例如：
 
                class TraceBlock:
 
                                def         message(self,arg):
 
                                                print(‘running‘,arg)
 
                                def __enter__(self):
 
                                                print(‘starting with block‘)
 
                                                return self
 
                                def __exit__(self,exc_type,exc_value,exc_tb):
 
                                                if exc_type is None:
 
                                                                print(‘exited normally\n‘)
 
                                                else:
 
                                                                print(‘raise an exception!‘,exc_type)
 
                                                                return False
 
                with TraceBlock() as action:
 
                                action.message(‘test 1‘)
 
                                print(reached)
 
                with TraceBlock() as action:
 
                                action.message(‘test 2‘)
 
                                raise TypeError
 
                                print(‘not reached‘)
 
12、内置Exception类
 
                BaseException   异常的顶级根类。这个类不能当作用户定义的类直接继承（使用Exception）。它提供了子类所继承的默认的打印和状态保持行为。如果在这个类的一个实例上调用str内置函数时，该类返回创建实例的时候所传递的构造函数的显示字符串（如果没有参数的话，返回一个空字符串），此外除非子类替换了这个类的构造函数，在实例构造时候传递给这个类的所有参数都将作为一个元组存储在args属性中
 
                Exception            与应用相关的异常的顶层超类。这是BaseException的一个直接子类，并且是所有其他内置异常类的超类，除了系统退出实践之类(SystemExit.KeyboardInterrupt和GenatorExit)。几乎所有用户定义的类都应该继承自这个类，而不是BaseException。当遵循这个惯例的时候，在一条try预计的处理器中指名Exception，确保你的程序将捕获出系统退出事件之外的所有异常，通常该事件是允许通过的。实际上，Exception变成了try预计中的一个全捕获，并且比一条空的Except更精确。
 
                ArithmeticError   所有数值错误的超类（并且是Exception的一个子类）
 
                OverflowError   识别特定数值错误的子类

　　


联系
我们