ppt图片,Python3 过错和反常(Day18)-优德88客户端

admin 优德88手机客户端 2019-05-28 341 0

Python有两种过错很简略辨认:语法过错和反常。

语法过错

Python 的语法过错或许称之为解析错,是初学者常常碰到的,如下实例

>>>while True print('Hello world')
File "", line 1, in ?
while True print('Hello world')
^
SyntaxError: invalid syntax

这个比如中,函数 print() 被检查到有过错,是它前面缺少了一个冒号(:)。

语法分析器指出了犯错的一行,并且在最早找到的过错的方位标记了一个小小的箭头。

反常

即使Python程序的语法是正确的,在运转它的时分,也有或许发作过错。运转期检测到的过错被称为反常。

大多数的反常都不会被程序处理,都以过错信息的办法展现在这里:

>>>10 * (1/0)
Traceback (most recent call last):
File "", line 1, in ?
ZeroDivisionError: division by zero
>>> 4 + spam*3
Traceback (most recent call last):
File "", line 1, in ?
NameError: name 'spam' is not defined
>>> '2' + 2
Traceback (most recent call last):
File "", line 1, in ?
TypeError: Can't convert 'int' object to str implicitly

反常以不同的类型呈现,这些类型都作为信息的一部分打印出来: 比如中的类型有 ZeroDivisionError,NameError 和 TypeError。

过错信息的前面部分显现了反常发作的上下文,并以调用栈的办法显现详细信息。

反常处理

以下比如中,让用户输入一个合法的整数,可是答应用户中止这个程序(运用 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 arg in 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 division or modulo by zero

抛出反常

Python 运用 raise 句子抛出一个指定的反常。例如:

>>>raise NameError('HiThere')
Traceback (most recent call last):
File "", line 1, in ?
NameError: HiThere

raise 仅有的一个参数指定了要被抛出的反常。它有必要是一个反常的实例或许是反常的类(也便是 Exception 的子类)。

假如你只想知道这是否抛出了一个反常,并不想去处理它,那么一个简略的 raise 句子就能够再次把它抛出。

>>>try:
raise NameError('HiThere')
except NameError:
print('An exception flew by!')
raise

An exception flew by!
Traceback (most recent call last):
File "", line 2, in ?
NameError: HiThere

用户自界说反常

你能够经过创立一个新的反常类来具有自己的反常。反常类承继自 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 "", line 1, in ?
__main__.MyError: 'oops!'

在这个比如中,类 Exception 默许的 __init__() 被掩盖。

当创立一个模块有或许抛出多种不同的反常时,一种一般的做法是为这个包树立一个根底反常类,然后根据这个根底类为不同的过错状况创立不同的子类:

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 "", line 2, in
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 clause
Traceback (most recent call last):
File "", line 1, in ?
File "", line 3, in divide
TypeError: unsupported operand type(s) for /: 'str' and 'str'

预界说的整理行为

一些目标界说了规范的整理行为,不论体系是否成功的运用了它,一旦不需要它了,那么这个规范的整理行为就会履行。

这面这个比如展现了测验翻开一个文件,然后把内容打印到屏幕上:

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

以上这段代码的问题是,当履行结束后,文件会坚持翻开状况,并没有被封闭。

关键词 with 句子就能够确保比如文件之类的目标在运用完之后一定会正确的履行他的整理办法:

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

以上这段代码履行结束后,就算在处理进程中出问题了,文件 f 总是会封闭。

版权声明

本文仅代表作者观点,不代表本站立场。
本文系作者授权发表,未经许可,不得转载。

最近发表

    优德88客户端_优德88游戏_w88优德官网登录

    http://lcsjm.com/

    |

    Powered By

    使用手机软件扫描微信二维码

    关注我们可获取更多热点资讯

    w88出品