python14：错误和异常

在编程的过程中，总是无法避免处理异常的情况，这些异常也有可能是错误，也有可能是一些偶现的异常，Python中提供了处理这些情况的有效机制。

语法错误

语法错误，即解析错误，也许会是你学习Python的过程中遇到最多的错误：

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

解析器会指定文件名和错误的行，并且使用一个'^'指向出现错误的位置：在这个例子中，错误被探测在函数print()，由于它之前缺少了':'。

异常

即使语句在语法上是正确的，当执行它的时候任然可能引起一个错误。执行期间的错误叫做异常，后面将讲述在Python中怎么处理异常。下面展示了一些异常的信息：

>>> 10 * (1/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、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语句按下面的方式工作：
    1）首先try和except间的语句块将被执行；
    2）如果没有异常出现，except子句将被略过，try语句块执行完成；
    3）如果try语句块执行时出现异常，语句块的其余部分被略过，如果异常的类型匹配except对应的异常名，except子句将被执行；
    4）如果异常出现，并且在except子句中没有匹配的异常名，它将被传递到外层的try语句块中；如果没有处理器被发现，它就是一个未处理的异常，执行将停止并打印异常信息。
try语句可以有多个except子句，对不同的异常提供不同的处理器，一次最多一个处理器被执行。一个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()

当一个异常出现时，它可以有一个关联的值，称之为异常参数。参数的残在和类型取决于异常类型。
异常子句可以在异常名后指定一个变量，这个变量绑定到一个异常实例，并且将异常参数值保存在instance.args。异常实例定义了__str__()以方便直接打印参数。也可以实例化一个异常，然后抛出它，并且为它添加希望的属性：

>>> try:
		raise Exception('spam', 'eggs')
	except Exception as inst:
		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)

<class 'Exception'>
('spam', 'eggs')
('spam', 'eggs')
x = spam

如果一个异常有参数，如果该异常未被处理，则参数将被打印作为信息的最后部分。
异常字块不仅能处理try子句中出现的异常，也能处理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

raise子句

使用raise可以抛出一个指定的异常，例如：

>>> raise NameError('HiThere')
Traceback (most recent call last):
  File "<stdin>", 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 "<stdin>", 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 "<stdin>", line 1, in ?
__main__.MyError: 'oops!'

在这个例子中，异常默认的__init__()方法被重载，新的行为创建一个value属性，这代替了args属性的默认行为。
异常类能做其它类做的任何事情，但是最好保持异常类的简单，通常仅定义能够反映错误的必要信息。当创建一个能抛出多种不同异常的模块时，一个惯例是创建一个异常的基类，然后其它子类来分别代表不同的错误。

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

有另一个可选的子句是finally子句，用于定义在任何情况下都会执行的代码，通常用于做清理操作，例如：

>>> try:
        raise KeyboardInterrupt
    finally:
        print('Goodbye, world!')
   
Goodbye, world!
KeyboardInterrupt

finally子句总是在离开try块钱执行，无论是否出现了异常。当一个异常出现在try块中，并且没有被except子句处理（或者出现在except或else子句中），它将在finally子句被执行后重新抛出。finally子句在try块由于break、continue或return退出时也会被执行。下面是一个更复杂点的例子：

>>> 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 "<stdin>", line 1, in ?
  File "<stdin>", line 3, in divide
TypeError: unsupported operand type(s) for /: 'str' and 'str'

正如你看到的，finally子句在任何情况下都会被执行。两个字符串相除导致的TypeError没有被except子句处理，因此在finally执行后重新被抛出。
在实际的应用中，finally子句是非常有用的，通常用于释放资源（如文件或者网络连接），不用担心资源的使用中出现异常。

预定义清理行为

一些对象定义标准的清理行为，当对象不再被需要时调用，不关心使用对象的操作是否成功。看下面的例子，尝试打开一个文件并打印它的内容：

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

这个代码的问题是代码执行完成后没有关闭文件，在简单的脚本中，这不是问题，但是在大型应用中则会带来问题。with子句可以确保文件（或者其它资源）在使用后总是被关闭：

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

语句在执行完成后，文件f总是会被关闭，即使在执行期间出现了异常。像文件这种提供了预定义清理行为对象会在文档中说明。