-
2021-04-26 16:47:44
assert是断言的意思,解释为:我断定这个程序执行之后或者之前会有这样的结果,如果不是,那就扔出一个错误。
语法:
assert expression [, arguments]
assert 表达式 [, 参数]
举例:
def foo(s):
n = int(s)
assert n != 0, 'n is zero!'
return 10 / n
def main():
foo('0')
>Traceback (most recent call last):
...
AssertionError: n is zero!
assert的意思是,表达式n != 0应该是True,否则,根据程序运行的逻辑,后面的代码肯定会出错。
如果断言失败,assert语句本身就会抛出AssertionError:
启动Python解释器时可以用-O参数来关闭assert
补充知识:python中assertion异常
python中的assert是一种最简单的异常机制
assert的基本语法是:
"assert" expression1 ["," expression2]
expression1用于判断生成布尔值,当expression1为假的时候,则抛出异常,[]中的内容可选,即用户可以选择异常的提示值:
>>>a=23
>>>assert a==23
>>>a=a-1
>>>assert a==23
Traceback (most recent call last):
File "", line 1, in
AssertionError
>>>assert a==23 , "error1"
Traceback (most recent call last):
File "", line 1, in
AssertionError: error1
以上这篇python 错误处理 assert详解就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持聚米学院。
更多相关内容 -
python 错误处理
2020-11-28 23:07:03在程序运行的过程中,如果发生了错误,可以事先约定返回一个错误代码,这样,就可以知道是否有错,以及出错的原因。在操作系统提供的调用中,返回错误码非常常见。比如打开文件的函数open(),成功时返回文件描述符...在程序运行的过程中,如果发生了错误,可以事先约定返回一个错误代码,这样,就可以知道是否有错,以及出错的原因。在操作系统提供的调用中,返回错误码非常常见。比如打开文件的函数open(),成功时返回文件描述符(就是一个整数),出错时返回-1。
用错误码来表示是否出错十分不便,因为函数本身应该返回的正常结果和错误码混在一起,造成调用者必须用大量的代码来判断是否出错:
def foo():
r = some_function()
if r==(-1):
return (-1)
# do something
return r
def bar():
r = foo()
if r==(-1):
print 'Error'
else:
pass
一旦出错,还要一级一级上报,直到某个函数可以处理该错误(比如,给用户输出一个错误信息)。
所以高级语言通常都内置了一套try...except...finally...的错误处理机制,Python也不例外。
try
让我们用一个例子来看看try的机制:
try:
print 'try...'
r = 10 / 0
print 'result:', r
except ZeroDivisionError, e:
print 'except:', e
finally:
print 'finally...'
print 'END'
当我们认为某些代码可能会出错时,就可以用try来运行这段代码,如果执行出错,则后续代码不会继续执行,而是直接跳转至错误处理代码,即except语句块,执行完except后,如果有finally语句块,则执行finally语句块,至此,执行完毕。
上面的代码在计算10 / 0时会产生一个除法运算错误:
try...
except: integer division or modulo by zero
finally...
END
从输出可以看到,当错误发生时,后续语句print 'result:', r不会被执行,except由于捕获到ZeroDivisionError,因此被执行。最后,finally语句被执行。然后,程序继续按照流程往下走。
如果把除数0改成2,则执行结果如下:
try...
result: 5
finally...
END
由于没有错误发生,所以except语句块不会被执行,但是finally如果有,则一定会被执行(可以没有finally语句)。
你还可以猜测,错误应该有很多种类,如果发生了不同类型的错误,应该由不同的except语句块处理。没错,可以有多个except来捕获不同类型的错误:
try:
print 'try...'
r = 10 / int('a')
print 'result:', r
except ValueError, e:
print 'ValueError:', e
except ZeroDivisionError, e:
print 'ZeroDivisionError:', e
finally:
print 'finally...'
print 'END'
int()函数可能会抛出ValueError,所以我们用一个except捕获ValueError,用另一个except捕获ZeroDivisionError。
此外,如果没有错误发生,可以在except语句块后面加一个else,当没有错误发生时,会自动执行else语句:
try:
print 'try...'
r = 10 / int('a')
print 'result:', r
except ValueError, e:
print 'ValueError:', e
except ZeroDivisionError, e:
print 'ZeroDivisionError:', e
else:
print 'no error!'
finally:
print 'finally...'
print 'END'
Python的错误其实也是class,所有的错误类型都继承自BaseException,所以在使用except时需要注意的是,它不但捕获该类型的错误,还把其子类也“一网打尽”。比如:
try:
foo()
except StandardError, e:
print 'StandardError'
except ValueError, e:
print 'ValueError'
第二个except永远也捕获不到ValueError,因为ValueError是StandardError的子类,如果有,也被第一个except给捕获了。
Python所有的错误都是从BaseException类派生的,常见的错误类型和继承关系看这里:
使用try...except捕获错误还有一个巨大的好处,就是可以跨越多层调用,比如函数main()调用foo(),foo()调用bar(),结果bar()出错了,这时,只要main()捕获到了,就可以处理:
def foo(s):
return 10 / int(s)
def bar(s):
return foo(s) * 2
def main():
try:
bar('0')
except StandardError, e:
print 'Error!'
finally:
print 'finally...'
也就是说,不需要在每个可能出错的地方去捕获错误,只要在合适的层次去捕获错误就可以了。这样一来,就大大减少了写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()
执行,结果如下:
$ python err.py
Traceback (most recent call last):
File "err.py", line 11, in
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: integer division or modulo by zero
出错并不可怕,可怕的是不知道哪里出错了。解读错误信息是定位错误的关键。我们从上往下可以看到整个错误的调用函数链:
错误信息第1行:
Traceback (most recent call last):
告诉我们这是错误的跟踪信息。
第2行:
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时出错,至此,找到错误源头。
记录错误
如果不捕获错误,自然可以让Python解释器来打印出错误堆栈,但程序也被结束了。既然我们能捕获错误,就可以把错误堆栈打印出来,然后分析错误原因,同时,让程序继续执行下去。
Python内置的logging模块可以非常容易地记录错误信息:
# err.py
import logging
def foo(s):
return 10 / int(s)
def bar(s):
return foo(s) * 2
def main():
try:
bar('0')
except StandardError, e:
logging.exception(e)
main()
print 'END'
同样是出错,但程序打印完错误信息后会继续执行,并正常退出:
$ python err.py
ERROR:root:integer division or modulo by zero
Traceback (most recent call last):
File "err.py", line 12, in main
bar('0')
File "err.py", line 8, in bar
return foo(s) * 2
File "err.py", line 5, in foo
return 10 / int(s)
ZeroDivisionError: integer division or modulo by zero
END
通过配置,logging还可以把错误记录到日志文件里,方便事后排查。
抛出错误
因为错误是class,捕获一个错误就是捕获到该class的一个实例。因此,错误并不是凭空产生的,而是有意创建并抛出的。Python的内置函数会抛出很多类型的错误,我们自己编写的函数也可以抛出错误。
如果要抛出错误,首先根据需要,可以定义一个错误的class,选择好继承关系,然后,用raise语句抛出一个错误的实例:
# err.py
class FooError(StandardError):
pass
def foo(s):
n = int(s)
if n==0:
raise FooError('invalid value: %s' % s)
return 10 / n
执行,可以最后跟踪到我们自己定义的错误:
$ python err.py
Traceback (most recent call last):
...
__main__.FooError: invalid value: 0
只有在必要的时候才定义我们自己的错误类型。如果可以选择Python已有的内置的错误类型(比如ValueError,TypeError),尽量使用Python内置的错误类型。
最后,我们来看另一种错误处理的方式:
# err.py
def foo(s):
n = int(s)
return 10 / n
def bar(s):
try:
return foo(s) * 2
except StandardError, e:
print 'Error!'
raise
def main():
bar('0')
main()
在bar()函数中,我们明明已经捕获了错误,但是,打印一个Error!后,又把错误通过raise语句抛出去了,这不有病么?
其实这种错误处理方式不但没病,而且相当常见。捕获错误目的只是记录一下,便于后续追踪。但是,由于当前函数不知道应该怎么处理该错误,所以,最恰当的方式是继续往上抛,让顶层调用者去处理。
raise语句如果不带参数,就会把当前错误原样抛出。此外,在except中raise一个Error,还可以把一种类型的错误转化成另一种类型:
try:
10 / 0
except ZeroDivisionError:
raise ValueError('input error!')
只要是合理的转换逻辑就可以,但是,决不应该把一个IOError转换成毫不相干的ValueError。
小结
Python内置的try...except...finally用来处理错误十分方便。出错时,会分析错误信息并定位错误发生的代码位置才是最关键的。
程序也可以主动抛出错误,让调用者来处理相应的错误。但是,应该在文档中写清楚可能会抛出哪些错误,以及错误产生的原因。
-
Python 错误处理
2018-03-22 14:12:47错误处理 在程序运行的过程中,如果发生了错误,可以事先约定返回一个错误代码,这样,就可以知道是否有错,以及出错的原因。在操作系统提供的调用中,返回错误码非常常见。比如打开文件的函数open(),成功时返回...错误处理
在程序运行的过程中,如果发生了错误,可以事先约定返回一个错误代码,这样,就可以知道是否有错,以及出错的原因。在操作系统提供的调用中,返回错误码非常常见。比如打开文件的函数
open()
,成功时返回文件描述符(就是一个整数),出错时返回-1
。用错误码来表示是否出错十分不便,因为函数本身应该返回的正常结果和错误码混在一起,造成调用者必须用大量的代码来判断是否出错:
def foo(): r = some_function() if r==(-1): return (-1) # do something return r def bar(): r = foo() if r==(-1): print('Error') else: pass
一旦出错,还要一级一级上报,直到某个函数可以处理该错误(比如,给用户输出一个错误信息)。
所以高级语言通常都内置了一套
try...except...finally...
的错误处理机制,Python
也不例外。try
让我们用一个例子来看看
try
的机制:try: print('try...') r = 10 / 0 print('result:', r) except ZeroDivisionError as e: print('except:', e) finally: print('finally...') print('END')
当我们认为某些代码可能会出错时,就可以用
try
来运行这段代码,如果执行出错,则后续代码不会继续执行,而是直接跳转至错误处理代码,即except
语句块,执行完except
后,如果有finally
语句块,则执行finally
语句块,至此,执行完毕。上面的代码在计算
10 / 0
时会产生一个除法运算错误:try... except: division by zero finally... END
从输出可以看到,当错误发生时,后续语句
print('result:', r)
不会被执行,except
由于捕获到ZeroDivisionError
,因此被执行。最后,finally
语句被执行。然后,程序继续按照流程往下走。如果把除数
0
改成2
,则执行结果如下:try... result: 5 finally... END
由于没有错误发生,所以
except
语句块不会被执行,但是finally
如果有,则一定会被执行(可以没有finally
语句)。你还可以猜测,错误应该有很多种类,如果发生了不同类型的错误,应该由不同的
except
语句块处理。没错,可以有多个except
来捕获不同类型的错误:try: print('try...') r = 10 / int('a') print('result:', r) except ValueError as e: print('ValueError:', e) except ZeroDivisionError as e: print('ZeroDivisionError:', e) finally: print('finally...') print('END')
int()
函数可能会抛出ValueError
,所以我们用一个except
捕获ValueError
,用另一个except
捕获ZeroDivisionError
。此外,如果没有错误发生,可以在
except
语句块后面加一个else
,当没有错误发生时,会自动执行else
语句:try: print('try...') r = 10 / int('2') print('result:', r) except ValueError as e: print('ValueError:', e) except ZeroDivisionError as e: print('ZeroDivisionError:', e) else: print('no error!') finally: print('finally...') print('END')
Python的错误其实也是
class
,所有的错误类型都继承自BaseException
,所以在使用except
时需要注意的是,它不但捕获该类型的错误,还把其子类也“一网打尽”。比如:try: foo() except ValueError as e: print('ValueError') except UnicodeError as e: print('UnicodeError')
第二个
except
永远也捕获不到UnicodeError
,因为UnicodeError
是ValueError
的子类,如果有,也被第一个except
给捕获了Python所有的错误都是从
BaseException
类派生的,常见的错误类型和继承关系看这里:https://docs.python.org/3/library/exceptions.html#exception-hierarchy
使用
try...except
捕获错误还有一个巨大的好处,就是可以跨越多层调用,比如函数main()
调用foo()
,foo()
调用bar()
,结果bar()
出错了,这时,只要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:', e) finally: print('finally...')
也就是说,不需要在每个可能出错的地方去捕获错误,只要在合适的层次去捕获错误就可以了。这样一来,就大大减少了写
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()
执行,结果如下:
$ 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行:
Traceback (most recent call last):
告诉我们这是错误的跟踪信息。
第2~3行:
File "err.py", line 11, in <module> 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
时出错,至此,找到错误源头。出错的时候,一定要分析错误的调用栈信息,才能定位错误的位置。
记录错误
如果不捕获错误,自然可以让Python解释器来打印出错误堆栈,但程序也被结束了。既然我们能捕获错误,就可以把错误堆栈打印出来,然后分析错误原因,同时,让程序继续执行下去。
Python内置的
logging
模块可以非常容易地记录错误信息:# err_logging.py 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')
同样是出错,但程序打印完错误信息后会继续执行,并正常退出:
$ 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
通过配置,
logging
还可以把错误记录到日志文件里,方便事后排查。抛出错误
因为错误是
class
,捕获一个错误就是捕获到该class
的一个实例。因此,错误并不是凭空产生的,而是有意创建并抛出的。Python的内置函数会抛出很多类型的错误,我们自己编写的函数也可以抛出错误。如果要抛出错误,首先根据需要,可以定义一个错误的class,选择好继承关系,然后,用
raise
语句抛出一个错误的实例:# err_raise.py class FooError(ValueError): pass def foo(s): n = int(s) if n==0: raise FooError('invalid value: %s' % s) return 10 / n foo('0')
执行,可以最后跟踪到我们自己定义的错误:
$ python3 err_raise.py Traceback (most recent call last): File "err_throw.py", line 11, in <module> foo('0') File "err_throw.py", line 8, in foo raise FooError('invalid value: %s' % s) __main__.FooError: invalid value: 0
只有在必要的时候才定义我们自己的错误类型。如果可以选择Python已有的内置的错误类型(比如
ValueError
,TypeError
),尽量使用Python
内置的错误类型。最后,我们来看另一种错误处理的方式:
# 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()
在
bar()
函数中,我们明明已经捕获了错误,但是,打印一个ValueError
!后,又把错误通过raise
语句抛出去了,这不有病么?其实这种错误处理方式不但没病,而且相当常见。捕获错误目的只是记录一下,便于后续追踪。但是,由于当前函数不知道应该怎么处理该错误,所以,最恰当的方式是继续往上抛,让顶层调用者去处理。好比一个员工处理不了一个问题时,就把问题抛给他的老板,如果他的老板也处理不了,就一直往上抛,最终会抛给CEO去处理。
raise
语句如果不带参数,就会把当前错误原样抛出。此外,在except
中raise
一个Error
,还可以把一种类型的错误转化成另一种类型:try: 10 / 0 except ZeroDivisionError: raise ValueError('input error!')
只要是合理的转换逻辑就可以,但是,决不应该把一个
IOError
转换成毫不相干的ValueError
。参考源码
do_try.py
#!/usr/bin/env python3 # -*- coding: utf-8 -*- try: print('try...') r = 10 / 0 print('result:', r) except ZeroDivisionError as e: print('except:', e) finally: print('finally...') print('END')
err.py
# err.py def foo(s): return 10 / int(s) def bar(s): return foo(s) * 2 def main(): bar('0') main()
err_logging.py
# err_logging.py 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')
err_raise.py
# err_raise.py class FooError(ValueError): pass def foo(s): n = int(s) if n==0: raise FooError('invalid value: %s' % s) return 10 / n foo('0')
err_reraise.py
# 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()
-
Python常见的错误处理方法
2020-12-24 07:08:00一、python的错误处理在程序运行的过程中,如果发生了错误,可以事先约定返回一个错误代码,这样,就可以知道是否有错以及出错的原因。在操作系统提供的调用中,返回错误码非常常见。比如打开文件的函数open(),成功...一、python的错误处理
在程序运行的过程中,如果发生了错误,可以事先约定返回一个错误代码,这样,就可以知道是否有错以及出错的原因。
在操作系统提供的调用中,返回错误码非常常见。比如打开文件的函数open(),成功时返回文件的描述符(就是一个整数),出错时返回-1
用错误码来表示是否出错十分不便,因为函数本身应该返回的正常结果和错误码混在一起,造成调用者必须大量的代码来判断是否出错:
def foo():
r = somefunction()
if r == (-1):
return (-1)
return r
def bar():
r = foo()
if r == (-1):
print("Error")
else:
pass
一旦出错,还要一级一级上报,直到某个函数可以处理该错误(比如,给用户输出一个错误信息)
所以,高级语言通常都内置了一套try...except...finally...的错误处理机制,python也不例外。
try
让我们用一个例子来看看try的机制
try:
print("try....")
r = 10 / 0
print("result", r)
except ZeroDivisionError as e:
print("except:", e)
finally:
print("finally...")
print("END....")
当我们认为某些代码可能会出错时,就可以用try来运行这段代码,如果执行出错,则后续代码不会继续执行
而是直接跳转至错误处理代码,即except语句块
执行完except后,如果有finally语句块,则执行finally语句块,至此,执行完毕。
上面的代码在计算10 / 0时 会产生一个除法运算错误:
try....
except: division by zero
finally...
END....
从输出可以看到,当错误发生时,后续语句print("result:", r)不会被执行,except由于捕获到ZeroDivisionError因此被执行。
最后,finally语句被执行。然后,程序继续按照流程往下走。
如果把除数0 变成2,则执行结果如下
try....
result 5.0
finally...
END....
由于没有错误发生,所以except语句块不会被执行,但是finally如果有则一定会被执行,当然finally也可以没有
你还可以猜测,错误应该有很多种类,日过发生了不同类型的错误,应该由不同的except语句块处理。
没错,可以有多个except来捕获不同类型的错误:
try:
print("try.....")
r = 10 / int("a")
print("result:", r)
except ValueError as e:
print("ValueError:", e)
except ZeroDivisionError as e:
print("ZeroDivisionError:", e)
finally:
print("finally...")
print("END...")
int()函数可能会抛出ValueError,所以我们用一个except捕获ValueError,用另一个except捕获ZeroDivisionError
此外,如果没有错误发生,可以再except语句块后面加一个else,当没有错误发生时,会自动执行else语句。
try:
print("try...")
r = 10 / int("2")
print("result:", r)
except ValueError as e:
print("ValueError:", e)
except ZeroDivisionError as e:
print("ZeroDivisionError:", e)
else:
print("No error!")
finally:
print("finally...")
print("END")
python的错误其实也是class,所有的错误类型都继承自BaseException,
所以在使用except时需要注意的是,它不但捕获该类型的错误,还把其子类也“一网打尽”。
比如:
try:
foo()
except ValueError as e:
print("ValueError")
except UnicodeError as e:
print("UnicodeError")
第二个except永远也捕获不到UnicodeError, 因为UnicodeError是ValueError的子类
如果有,也是被第一个except给捕获了。
python所有的错误都是BaseException类派生的。
所有常见的错误类型和继承关系看这里:
https://docs.python.org/3/library/exceptions.html#exception-hierarchy
使用try...exccept捕获错误还有一个巨大的好处,就是可以跨越多层调用,比如函数main()调用foo()
foo()调用bar(),结果bar()出错了,这时,只要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:", e)
finally:
print("finally...")
也就是说,不需要在每个可能出错的地方去捕获异常,只要在合适的层次去捕获就可以了。
这样一来,就大大减少了写 try...except...finally的麻烦。
二、调用堆栈
如果错误没有被捕获,他就会一直往上抛,最后被python解释器捕获,打印一个错误信息,然后程序退出。
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 "C:/Python36/test.py", line 10, in
main()
File "C:/Python36/test.py", line 8, in main
bar("0")
File "C:/Python36/test.py", line 5, in bar
return foo(s) * 2
File "C:/Python36/test.py", line 2, in foo
return 10 / int(s)
ZeroDivisionError: division by zero
出错并不可怕,可怕的时不知道哪里出错了。解读错误信息时定位错误的关键。
我们从上往下可以看到整个错误的调用函数链。
错误第一行:
Traceback (most recent call last):
这告诉我们的是错误的跟踪信息。
File "C:/Python36/test.py", line 10, in
main()
说明调用main()出错了,在代码文件test.py中第10行,但是原因是第8行:
File"C:/Python36/test.py", line8, in main
bar("0")
调用bar("0")出错了,在代码文件test.py中第8行,但原因是第5行:
File"C:/Python36/test.py", line5, in bar
return foo(s) * 2
调用return foo(s) * 2时出错了,在test.py中第5行,但原因是第2行
File "C:/Python36/test.py", line 2, in foo
return 10 / int(s)
ZeroDivisionError: division by zero
这时我们找到了源头,原来在第2行调用return 10 / int(s)出错了,错误为ZeroDivisionError
三、记录错误
如果不捕获错误,自然可以让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 "C:/Python36/test.py", line 12, in main
bar("0")
File "C:/Python36/test.py", line 8, in bar
return foo(s) * 2
File "C:/Python36/test.py", line 5, in foo
return 10 / int(s)
ZeroDivisionError: division by zero
END
同样是出错,但程序打印完错误信息后会继续执行,并正常退出。
通过配置,logging还可以把错误记录到日志文件里,方便事后排查。
四、抛出错误
因为错误是class,捕获一个错误就是捕获到该class的一个实例。
因此,错误并不是凭空产生的,而是有意创建并抛出的。
python的内置函数会抛出很多类型的错误,我们自己编写的函数也可以抛出错误。
如果要抛出错误,首先根据需要,可以定义一个错误的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")
输出结果:
Traceback (most recent call last):
File "C:/Python36/test.py", line 10, in
foo("0")
File "C:/Python36/test.py", line 7, in foo
raise FooError("invalid value: %s" % s)
FooError: invalid value: 0
只有在必要的时候才定义我们自己的错误类型。
如果可以选择python已有的内置错误类型(比如ValueError, TypeError),尽量使用python内置的错误类型。
最后,我们来看另一种错误处理方式:
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("ValieError")
raise
bar()
在bar()函数中,我们明明已经捕获了错误,但是,打印一个ValueError之后
又通过raise语句抛出去了。这不是有病吗
其实,这种错误处理方式不但没病,而且相当常见。
捕获错误目的只是记录一下,便于或许追踪。
但是,由于当前函数不知道应该怎么处理该错误,所以,最恰当的方式是继续往上抛,让顶层调用者去处理。
好比一个员工处理不了一个问题时,就把问题一直往上抛,最终会抛给CEO去解决。
注意:raise语句如果不带参数,就会把当前错误原样抛出。
此外,在except中raise一个Error,还可以改写错误类型
try:
/ 0
except ZeroDivisionError:
raise ValueError("do not input zero!")
输出结果:
Traceback (most recent call last):
File "C:/Python36/test.py", line 4, in
raise ValueError("do not input zero!")
ValueError: do not input zero!
只要是合理的转换逻辑就可以,但是,绝不应该把一个IOError转成毫不相干的valueError.
总结:
python内置的 try...except...finally 用来处理错误十分方便。
出错时,会分析错误信息并定位错误发生的代码位置才是关键的。
程序也可以主动抛出错误,让调用者来处理相应的错误。
但是应该在文档中写清楚可能会抛出哪些错误,以及错误产生的原因。
-
python错误处理—try…catch…finally、调用栈分析
2020-11-28 13:51:30高级语言包括python一般都内置了一套try…catch…finally的错误处理机制:>>> try:...print('try...')... r= 10 /0...print('result:', r)...exceptZeroDivisionError as e:...print('except:', e)...finally:...... -
python常见错误-新手常见Python错误及异常解决处理方案
2020-11-01 13:16:44如何处理Python错误和异常?1.语法错误可能是初学者最常遇到的,如下面熟悉的画面:SyntaxError: invalid syntax语法错误又称解析错误,又有老哥会问什么是解析错误?简单来说是基本语法结构写错了,如:多任务写... -
python异常处理
2021-02-10 05:10:56异常捕获的语法1,try/except语句用来检测try语句块中的错误,从而让except语句捕获异常信息并处理2,一个try语句可以对应多个expect语句,但只能对应一个finally子句,或是一个try-expect-finally复合语句3,可以... -
Python异常及处理方法总结
2021-08-31 10:02:48Python异常及处理方法总结一、错误与异常1.什么是错误2.什么是异常3.回溯信息二、常见异常常见异常类三.异常处理1.异常处理2.简单的异常处理格式3.执行顺序4.except分支可以有多个5.执行顺序6.else子句:没有发生... -
python 错误处理 assert
2017-12-19 23:01:36Python assert -
python错误处理记录完整的异常堆栈信息
2017-10-24 17:38:16import logging LOG_FILENAME = '/tmp/logging_example.out' logging.basicConfig(filename=LOG_FILENAME,level=logging.DEBUG,) logging.debug('This message should go to the log file') try: ... -
python的错误处理——try语句
2021-02-05 09:05:53python的错误处理——try语句最近开始整理python的资料,博主建立了一个qq群,希望给大家提供一个交流的同平台:78486745 。当我们认为某些代码可能会出错时,就可以用try来运行这段代码,如果执行出错,则后续代码... -
Python异常处理
2020-11-29 19:35:55(1)通过try可以避免简单的错误data = input('请输入内容:')try :num = int(data)#如果该语句出现了错误,下面的语句不会被执行,会执行except的语句print(num)except IndexError as e:#出现异常会执行该语句,... -
图解 Python 编程(24) | 错误与异常处理(附要点速查表·完结)
2022-02-23 16:28:19在实际编程过程中,经常会看到一些报错信息,在python中也有专门的方式去处理错误和异常,保证全局流程顺畅。 -
python 爬虫 处理429错误
2021-01-27 11:31:49http代码429表示访问过快。 服务器在温柔地提示你,可以爬,但是爬慢一些。 控制访问的速度就可以了。 有些服务器会在返回的头部中添加"Retry-After",告诉你多久之后重试。...获取这个值,然后sleep就可以了。...... -
python错误异常处理try except Error
2019-08-21 14:30:08使用try: except ValueError:语法进行错误分析 判断一个数是正数,负数,或者是0,如果输入一个符号,则抛出异常处理 while True: try: num = float(input('please input one number:')) if num<0: print('... -
python异常处理(一)
2020-12-02 13:41:41Python的异常处理能力是很强大的,可向用户准确反馈出错信息。在Python中,异常也是对象,可对它进行操作。所有异常都是基类Exception的成员。所有异常都从基类Exception继承,而且都在exceptions模块中定义。Python... -
python常见的错误处理——try语句
2019-01-23 21:21:31python的错误处理——try语句 最近开始整理python的资料,博主建立了一个qq群,希望给大家提供一个交流的同平台:78486745 。 当我们认为某些代码可能会出错时,就可以用try来运行这段代码,如果执行出错,则后续... -
python异常处理(十分钟彻底搞定!)
2021-08-16 17:13:48出现错误的处理 try尝试 下方填写要尝试的密码,不确定能不能够正常执行的代码 except 如果不是,下方填写尝试失败的代码 例子: 简单的异常捕获演练–要求用户输入整数 try: #不能确定争取执行的代码 #提示用户... -
python中如何捕获错误
2020-12-23 10:50:16python标准错误处理: try: 可能出错的地方 except: 错误捕获,出错时要执行的代码 else: 没有错误时要执行代码 finally: 不管有没有错误都要执行的代码 以上语句只能在代码出错时,输出自己定义的语句,但并... -
Python并行处理
2017-11-02 14:37:36原文:Parallel Processing in Python 作者:Frank Hofmann 翻译:Diwei 简介当你在机器上启动某个程序时,它只是在自己的“bubble”里面运行,这个气泡的作用就是用来将同一时刻运行的所有程序进行分离。这个...