Python8.错误和异常

8.1. 语法错误¶

语法错误又称解析错误，可能是你在学习Python 时最容易遇到的错误:

>>> whileTrueprint('Hello world')
  File "<stdin>", line 1
whileTrueprint('Hello world')
^
SyntaxError: invalid syntax

解析器会输出出现语法错误的那一行，并显示一个“箭头”，指向这行里面检测到的第一个错误。 错误是由箭头指示的位置 上面 的 token 引起的（或者至少是在这里被检测出的）：在示例中，在 print() 这个函数中检测到了错误，因为在它前面少了个冒号 (':') 。文件名和行号也会被输出，以便输入来自脚本文件时你能知道去哪检查。

8.2. 异常¶

即使语句或表达式在语法上是正确的，但在尝试执行时，它仍可能会引发错误。 在执行时检测到的错误被称为 异常，异常不一定会导致严重后果：你将很快学会如何在 Python 程序中处理它们。 但是，大多数异常并不会被程序处理，此时会显示如下所示的错误信息:

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

错误信息的最后一行告诉我们程序遇到了什么类型的错误。异常有不同的类型，而其类型名称将会作为错误信息的一部分中打印出来：上述示例中的异常类型依次是：ZeroDivisionError， NameError 和 TypeError。作为异常类型打印的字符串是发生的内置异常的名称。对于所有内置异常都是如此，但对于用户定义的异常则不一定如此（虽然这是一个有用的规范）。标准的异常类型是内置的标识符（而不是保留关键字）。

这一行的剩下的部分根据异常类型及其原因提供详细信息。

错误信息的前一部分以堆栈回溯的形式显示发生异常时的上下文。通常它包含列出源代码行的堆栈回溯；但是它不会显示从标准输入中读取的行。

内置异常 列出了内置异常和它们的含义。

8.3. 处理异常¶

可以编写处理所选异常的程序。请看下面的例子，它会要求用户一直输入，直到输入的是一个有效的整数，但允许用户中断程序（使用 Control-C 或操作系统支持的其他操作）；请注意用户引起的中断可以通过引发 KeyboardInterrupt 异常来指示。:

>>> whileTrue:
... try:
... x=int(input("Please enter a number: "))
... break
... exceptValueError:
... print("Oops!  That was no valid number.  Try again...")
...

try 语句的工作原理如下：

• 首先，执行 try 子句 （try 和 except 关键字之间的（多行）语句）。

• 如果没有异常发生，则跳过 except 子句 并完成 try 语句的执行。

• 如果在执行 try 子句时发生了异常，则跳过该子句中剩下的部分。 然后，如果异常的类型和 except 关键字后面的异常匹配，则执行 except 子句，然后继续执行 try 语句之后的代码。

• 如果发生的异常和 except 子句中指定的异常不匹配，则将其传递到外部的 try 语句中；如果没有找到处理程序，则它是一个 未处理异常，执行将停止并显示如上所示的消息。

一个 try 语句可能有多个 except 子句，以指定不同异常的处理程序。 最多会执行一个处理程序。 处理程序只处理相应的 try 子句中发生的异常，而不处理同一 try 语句内其他处理程序中的异常。 一个 except 子句可以将多个异常命名为带括号的元组，例如:

...except(RuntimeError,TypeError,NameError):
...pass

如果发生的异常和 except 子句中的类是同一个类或者是它的基类，则异常和 except 子句中的类是兼容的（但反过来则不成立 --- 列出派生类的 except 子句与基类不兼容）。 例如，下面的代码将依次打印 B, C, D

classB(Exception):
pass
classC(B):
pass
classD(C):
pass
forclsin[B,C,D]:
try:
raisecls()
exceptD:
print("D")
exceptC:
print("C")
exceptB:
print("B")

请注意如果 except 子句被颠倒（把 exceptB 放到第一个），它将打印 B，B，B --- 即第一个匹配的 except 子句被触发。

最后的 except 子句可以省略异常名，以用作通配符。但请谨慎使用，因为以这种方式很容易掩盖真正的编程错误！它还可用于打印错误消息，然后重新引发异常（同样允许调用者处理异常）:

importsys
try:
f=open('myfile.txt')
s=f.readline()
i=int(s.strip())
exceptOSErroraserr:
print("OS error: {0}".format(err))
exceptValueError:
print("Could not convert data to an integer.")
except:
print("Unexpected error:",sys.exc_info()[0])
raise

try ... except 语句有一个可选的 else 子句，在使用时必须放在所有的 except 子句后面。对于在 try 子句不引发异常时必须执行的代码来说很有用。 例如:

forarginsys.argv[1:]:
try:
f=open(arg,'r')
exceptOSError:
print('cannot open',arg)
else:
print(arg,'has',len(f.readlines()),'lines')
f.close()

使用 else 子句比向 try 子句添加额外的代码要好，因为它避免了意外捕获非 try ... except 语句保护的代码引发的异常。

发生异常时，它可能具有关联值，也称为异常 参数 。参数的存在和类型取决于异常类型。

except 子句可以在异常名称后面指定一个变量。这个变量和一个异常实例绑定，它的参数存储在 instance.args 中。为了方便起见，异常实例定义了 __str__() ，因此可以直接打印参数而无需引用 .args 。也可以在抛出之前首先实例化异常，并根据需要向其添加任何属性。:

>>> try:
... raiseException('spam','eggs')
... exceptExceptionasinst:
... print(type(inst))# the exception instance
... print(inst.args)# arguments stored in .args
... print(inst)# __str__ allows args to be printed directly,
... # but may be overridden in exception subclasses
... x,y=inst.args# unpack args
... print('x =',x)
... print('y =',y)
...
<class 'Exception'>
('spam', 'eggs')
('spam', 'eggs')
x = spam
y = eggs

如果异常有参数，则它们将作为未处理异常的消息的最后一部分（'详细信息'）打印。

异常处理程序不仅处理 try 子句中遇到的异常，还处理 try 子句中调用（即使是间接地）的函数内部发生的异常。例如:

>>> defthis_fails():
... x=1/0
...
>>> try:
... this_fails()
... exceptZeroDivisionErroraserr:
... print('Handling run-time error:',err)
...
Handling run-time error: division by zero

>>> raiseNameError('HiThere')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: HiThere

raiseValueError# shorthand for 'raise ValueError()'

>>> try:
... raiseNameError('HiThere')
... exceptNameError:
... print('An exception flew by!')
... raise
...
An exception flew by!
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
NameError: HiThere

classError(Exception):
"""Base class for exceptions in this module."""
pass
classInputError(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
classTransitionError(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

>>> try:
... raiseKeyboardInterrupt
... finally:
... print('Goodbye, world!')
...
Goodbye, world!
KeyboardInterrupt
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>

>>> defbool_return():
... try:
... returnTrue
... finally:
... returnFalse
...
>>> bool_return()
False

>>> defdivide(x,y):
... try:
... result=x/y
... exceptZeroDivisionError:
... 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 "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in divide
TypeError: unsupported operand type(s) for /: 'str' and 'str'

forlineinopen("myfile.txt"):
print(line,end="")

withopen("myfile.txt")asf:
forlineinf:
print(line,end="")