452 lines
14 KiB
Markdown
452 lines
14 KiB
Markdown
---
|
||
title: 错误和异常
|
||
date: 2020-10-02 11:20:10
|
||
tags: [Python]
|
||
categories: [Python]
|
||
author: Anges黎梦
|
||
---
|
||
|
||
### 语法错误
|
||
|
||
语法错误又称解析错误，可能是你在学习Python 时最容易遇到的错误:
|
||
|
||
```python
|
||
>>> while True print('Hello world')
|
||
File "<stdin>", line 1
|
||
while True print('Hello world')
|
||
^
|
||
SyntaxError: invalid syntax
|
||
```
|
||
|
||
解析器会输出出现语法错误的那一行，并显示一个“箭头”，指向这行里面检测到的第一个错误。
|
||
|
||
错误是由箭头指示的位置 上面 的 token 引起的（或者至少是在这里被检测出的）：在示例中，在 print() 这个函数中检测到了错误，因为在它前面少了个冒号 (':') 。
|
||
|
||
文件名和行号也会被输出，以便输入来自脚本文件时你能知道去哪检查。
|
||
|
||
### 异常
|
||
|
||
即使语句或表达式在语法上是正确的，但在尝试执行时，它仍可能会引发错误。
|
||
|
||
在执行时检测到的错误被称为*异常*，
|
||
|
||
异常不一定会导致严重后果：你将很快学会如何在Python程序中处理它们。
|
||
|
||
但是，大多数异常并不会被程序处理，此时会显示如下所示的错误信息:
|
||
|
||
```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。
|
||
|
||
作为异常类型打印的字符串是发生的内置异常的名称。
|
||
|
||
对于所有内置异常都是如此，但对于用户定义的异常则不一定如此（虽然这是一个有用的规范）。
|
||
|
||
标准的异常类型是内置的标识符（而不是保留关键字）。
|
||
|
||
这一行的剩下的部分根据异常类型及其原因提供详细信息。
|
||
|
||
错误消息的开头部分以堆栈回溯的形式显示发生异常的上下文。
|
||
|
||
通常它会包含列出源代码行的堆栈回溯；但是，它将不会显示从标准输入读取的行。
|
||
|
||
[内置异常](https://docs.python.org/zh-cn/3/library/exceptions.html#bltin-exceptions) 列出了内置异常和它们的含义。
|
||
|
||
### 处理异常
|
||
|
||
```python
|
||
try:
|
||
# 需要捕获异常的内容
|
||
a = "str" + 1
|
||
print(a)
|
||
except Exception as ex: # 捕获的异常名称，可使用as 别名
|
||
# except配合try使用
|
||
# 发生异常执行的内容
|
||
print(ex)
|
||
else:
|
||
# 没有发现异常的话，执行的内容
|
||
print(222222)
|
||
finally:
|
||
# 不管有没有异常，都会执行的内容
|
||
print(33333333)
|
||
|
||
print(1111111)
|
||
```
|
||
|
||
`try 语句的工作原理如下：`
|
||
|
||
- 首先，执行 try 子句 （try 和 except 关键字之间的（多行）语句）。
|
||
|
||
- 如果没有异常发生，则跳过 except 子句 并完成 try 语句的执行。
|
||
|
||
- 如果在执行 try 子句时发生了异常，则跳过该子句中剩下的部分。
|
||
|
||
然后，如果异常的类型和 except 关键字后面的异常匹配，则执行 except 子句，然后继续执行 try 语句之后的代码。
|
||
|
||
- 如果发生的异常和 except 子句中指定的异常不匹配，则将其传递到外部的 try 语句中；
|
||
|
||
如果没有找到处理程序，则它是一个 未处理异常，执行将停止并显示如上所示的消息。
|
||
|
||
|
||
一个 try 语句可能有多个 except 子句，以指定不同异常的处理程序。
|
||
|
||
最多会执行一个处理程序。 处理程序只处理相应的 try 子句中发生的异常，而不处理同一 try 语句内其他处理程序中的异常。
|
||
|
||
一个 except 子句可以将多个异常命名为带括号的元组，例如:
|
||
|
||
```python
|
||
... except (RuntimeError, TypeError, NameError):
|
||
... pass
|
||
```
|
||
如果发生的异常和 except 子句中的类是同一个类或者是它的基类，则异常和 except 子句中的类是兼容的（但反过来则不成立 --- 列出派生类的 except 子句与基类不兼容）。
|
||
|
||
例如，下面的代码将依次打印 B, C, D
|
||
|
||
```python
|
||
class B(Exception):
|
||
pass
|
||
|
||
class C(B):
|
||
pass
|
||
|
||
class D(C):
|
||
pass
|
||
|
||
for cls in [B, C, D]:
|
||
try:
|
||
raise cls()
|
||
except D:
|
||
print("D")
|
||
except C:
|
||
print("C")
|
||
except B:
|
||
print("B")
|
||
```
|
||
|
||
请注意如果 except 子句被颠倒（把 except B 放到第一个），它将打印 B，B，B --- 即第一个匹配的 except 子句被触发。
|
||
|
||
最后的 except 子句可以省略异常名，以用作通配符。
|
||
|
||
但请谨慎使用，因为以这种方式很容易掩盖真正的编程错误！
|
||
|
||
它还可用于打印错误消息，然后重新引发异常（同样允许调用者处理异常）:
|
||
|
||
```python
|
||
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 子句不引发异常时必须执行的代码来说很有用。 例如:
|
||
|
||
```python
|
||
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()
|
||
```
|
||
使用 else 子句比向 try 子句添加额外的代码要好，因为它避免了意外捕获由 try ... except 语句保护的代码未引发的异常。
|
||
|
||
发生异常时，它可能具有关联值，也称为异常 参数 。参数的存在和类型取决于异常类型。
|
||
|
||
except 子句可以在异常名称后面指定一个变量。
|
||
|
||
这个变量和一个异常实例绑定，它的参数存储在 instance.args 中。
|
||
|
||
为了方便起见，异常实例定义了 __str__() ，因此可以直接打印参数而无需引用 .args 。
|
||
|
||
也可以在抛出之前首先实例化异常，并根据需要向其添加任何属性。:
|
||
|
||
```python
|
||
>>> 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)
|
||
... print('y =', y)
|
||
...
|
||
<class 'Exception'>
|
||
('spam', 'eggs')
|
||
('spam', 'eggs')
|
||
x = spam
|
||
y = eggs
|
||
```
|
||
如果异常有参数，则它们将作为未处理异常的消息的最后一部分（'详细信息'）打印。
|
||
|
||
异常处理程序不仅处理 try 子句中遇到的异常，还处理 try 子句中调用（即使是间接地）的函数内部发生的异常。例如:
|
||
|
||
```python
|
||
>>> def this_fails():
|
||
... x = 1/0
|
||
...
|
||
>>> try:
|
||
... this_fails()
|
||
... except ZeroDivisionError as err:
|
||
... print('Handling run-time error:', err)
|
||
...
|
||
Handling run-time error: division by zero
|
||
```
|
||
|
||
### 抛出异常
|
||
|
||
raise 语句允许程序员强制发生指定的异常。例如:
|
||
|
||
```python
|
||
>>> raise NameError('HiThere')
|
||
Traceback (most recent call last):
|
||
File "<stdin>", line 1, in <module>
|
||
NameError: HiThere
|
||
```
|
||
|
||
raise 唯一的参数就是要抛出的异常。
|
||
|
||
这个参数必须是一个异常实例或者是一个异常类（派生自 Exception 的类）。
|
||
|
||
如果传递的是一个异常类，它将通过调用没有参数的构造函数来隐式实例化:
|
||
|
||
```python
|
||
raise ValueError # shorthand for 'raise ValueError()'
|
||
```
|
||
|
||
如果你需要确定是否引发了异常但不打算处理它，则可以使用更简单的 raise 语句形式重新引发异常
|
||
|
||
```python
|
||
>>> 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
|
||
```
|
||
|
||
### 异常链
|
||
|
||
raise 语句允许可选的 from 子句，它通过设置所引发异常的 __cause__ 属性来启用异常链。 例如:
|
||
|
||
```python
|
||
raise RuntimeError from OSError
|
||
```
|
||
|
||
这在你要转换异常时很有用。 例如:
|
||
|
||
```python
|
||
>>> def func():
|
||
... raise IOError
|
||
...
|
||
>>> try:
|
||
... func()
|
||
... except IOError as exc:
|
||
... raise RuntimeError('Failed to open database') from exc
|
||
...
|
||
Traceback (most recent call last):
|
||
File "<stdin>", line 2, in <module>
|
||
File "<stdin>", line 2, in func
|
||
OSError
|
||
|
||
The above exception was the direct cause of the following exception:
|
||
|
||
Traceback (most recent call last):
|
||
File "<stdin>", line 4, in <module>
|
||
RuntimeError
|
||
```
|
||
跟在 from 之后的表达式必须是一个异常或为 None。
|
||
|
||
当在一个异常处理程序或 finally 子句中又引发了一个异常时异常链将自动生成。
|
||
|
||
异常链可使用 from None 形式来禁用:
|
||
|
||
```python
|
||
try:
|
||
open('database.sqlite')
|
||
except IOError:
|
||
raise RuntimeError from None
|
||
|
||
Traceback (most recent call last):
|
||
File "<stdin>", line 4, in <module>
|
||
RuntimeError
|
||
```
|
||
|
||
### 用户自定义异常
|
||
|
||
程序可以通过创建新的异常类来命名它们自己的异常。
|
||
|
||
异常通常应该直接或间接地从 Exception 类派生。
|
||
|
||
可以定义异常类，它可以执行任何其他类可以执行的任何操作，但通常保持简单，只提供一些属性，这些属性允许处理程序为异常提取有关错误的信息。
|
||
|
||
在创建可能引发多个不同错误的模块时，通常的做法是为该模块定义的异常创建基类，并为不同错误条件创建特定异常类的子类:
|
||
|
||
```python
|
||
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 语句有另一个可选子句，用于定义必须在所有情况下执行的清理操作。例如:
|
||
|
||
```python
|
||
>>> try:
|
||
... raise KeyboardInterrupt
|
||
... finally:
|
||
... print('Goodbye, world!')
|
||
...
|
||
Goodbye, world!
|
||
KeyboardInterrupt
|
||
Traceback (most recent call last):
|
||
File "<stdin>", line 2, in <module>
|
||
```
|
||
|
||
如果存在 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 语句的返回值。
|
||
|
||
例如:
|
||
|
||
```python
|
||
>>> def bool_return():
|
||
... try:
|
||
... return True
|
||
... finally:
|
||
... return False
|
||
...
|
||
>>> bool_return()
|
||
False
|
||
```
|
||
|
||
一个更为复杂的例子:
|
||
|
||
```python
|
||
>>> 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 子句对于释放外部资源（例如文件或者网络连接）非常有用，无论是否成功使用资源。
|
||
|
||
### 常见的异常
|
||
|
||
TypeError:类型不合适，引发的异常
|
||
|
||
NameError：尝试访问一个没有声明的变量引发的异常
|
||
|
||
IndexError：索引超出序列范围引发的异常
|
||
|
||
IndentationError：锁进异常
|
||
|
||
ValueError：传入值异常
|
||
|
||
KeyError：请求一个不存在的字典关键字引发的异常
|
||
|
||
IOError：输入输出引发的异常（文件不存在之类的也包含）
|
||
|
||
ImportError：无法找到引入的内容引发的异常
|
||
|
||
AttributeError：尝试访问未知的对象属性引发的异常
|
||
|
||
MemoryError：内存不足
|