Python错误和异常

错误和异常

语法错误

解析错误，是因为不符合python语法。

SyntaxError: invalid syntax

异常

即在语句和表达式在语法上是正确的，但是在执行时，它还是可能发生错误。这种执行中检测到的错误成为“异常”。

错误信息的最后一行告诉我们程序遇到了什么类型的错误。

处理异常

可以编写处理所选异常的程序。

try ... except....

while True:
    try:
        x = int(input("请输入一个整数："))
        break
    except ValueError:
        print("错误！请输入一个整数。再试一次...")

try 语句的工作原理如下。

• 首先，执行 try 子句 （try 和 except 关键字之间的（多行）语句）。
• 如果没有异常发生，则跳过 except 子句 并完成 try 语句的执行。
• 如果在执行try 子句时发生了异常，则跳过该子句中剩下的部分。然后，如果异常的类型和 except 关键字后面的异常匹配，则执行 except 子句 ，然后继续执行 try 语句之后的代码。
• 如果发生的异常和 except 子句中指定的异常不匹配，则将其传递到外部的 try 语句中；如果没有找到处理程序，则它是一个 未处理异常，执行将停止并显示如上所示的消息。

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

except (RuntimeError, TypeError, NameError):
    pass

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

for arg in sys.argv[1:]:
    try:
        f = open(arg, 'r')
    except OSError:
        print('cannot open', arg)
    else:
        print(arg, 'has', len(f.readlines()), 'lines')
        f.close()

抛出异常raise

raise语句可以强制发生指定的异常。

>>>raise NameError('HiThere')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
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 <module>
NameError: HiThere

异常判断assert

断言

assert 判断表达式
# 若表达为真时，继续执行下面代码
# 若表达为假时，抛出异常。
# 等同于：
if not 判断表达式:
    raise AssertionError

用户自定义异常

定义清理操作

try语句中可选子句finally，用于定义必须在所有情况下执行的清理操作。

如果存在 finally 子句，则 finally 子句将作为 try 语句结束前的最后一项任务被执行。 finally 子句不论 try 语句是否产生了异常都会被执行。 以下几点讨论了当异常发生时一些更复杂的情况：

• 如果在执行 try 子句期间发生了异常，该异常可由一个 except 子句进行处理。 如果异常没有被某个 except 子句所处理，则该异常会在 finally 子句执行之后被重新引发。
• 异常也可能在 except 或 else 子句执行期间发生。 同样地，该异常会在 finally 子句执行之后被重新引发。
• 如果在执行 try 语句时遇到一个 break, continue 或 return 语句，则 finally 子句将在执行 break, continue 或 return 语句之前被执行。
• 如果 finally 子句中包含一个 return 语句，则返回值将来自 finally 子句的某个 return 语句的返回值，而非来自 try 子句的 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 <module>
  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也始终会关闭。和文件一样，提供预定义清理操作的对象将在其文档中指出这一点。