Python3 错误和异常

一、语法错误

• 初学者经常碰到 语法错误或者解析错误

# 该实例演示 print() 函数被检查到有错误，是因为它前面缺少了一个冒号 :
>>>while True print('Hello world')
  File "", line 1, in ?
    while True print('Hello world')
                   ^
SyntaxError: invalid syntax

二、异常

• 即便程序的 语法是正确的 ，在运行它的时候，也有可能发生错误
• 运行期检测到的错误被称为 异常 ，大多数的异常都 不会 被程序处理，都以错误信息的形式展现

>>>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

三、异常处理

• 一个 try 语句可能包含 多个 except 子句，分别来处理不同的特定的异常，最多只有一个分支 会被执行
• 一个 except 子句可以 同时处理 多个异常 ，这些异常将被放在一个括号里成为 一个元组
• 异常处理并不仅仅处理 直接发生 在 try 子句中的异常，而且还能处理子句中 调用的函数里 抛出的异常

except (RuntimeError, TypeError, NameError):
        pass

# 该实例演示完整语法格式
>>>while True:
        try:
            x = int(input("Please enter a number: "))
            break
        except ValueError:
            print("Oops!  That was no valid number.  Try again   ")

# 最后一个 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 语句有一个可选的 else 子句，它定义了 在 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 又没有捕获的异常

>>>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 语句唯一的一个参数指定了要被抛出的异常，它 必须是 一个异常的实例或者是异常的类

>>>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!'

• 当创建一个模块 有可能抛出多种不同的异常时 ，一种通常的做法是 为这个包建立一个基础异常类
• 基于这个基础类为不同的错误情况创建不同的子类，大多数的异常的名字都以 Error 结尾

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

六、定义清理行为

• try 语句还有另外一个可选的 finally 子句，它定义了 无论在任何情况下都会执行的清理行为

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

• 如果一个异常在 try 子句里 或者在 except 和 else 子句里被抛出，而又没有任何的 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="")

# 该实例演示使用 with 语句优化代码
temp = os.open('test_text.txt', os.O_RDWR | os.O_CREAT)
temp_file = os.fdopen(temp, 'r')
print(str(temp_file.read()))
os.close(temp)

with open('test_text.txt', 'r') as f:
    print(f.read())