12-Python3 錯誤和異常

時間 2020-07-07

標籤 python3 python 錯誤異常欄目 Python 简体版

原文原文鏈接

Python3 錯誤和異常

做爲 Python 初學者，在剛學習 Python 編程時，常常會看到一些報錯信息，在前面咱們沒有說起，這章節咱們會專門介紹。express

Python 有兩種錯誤很容易辨認：語法錯誤和異常。編程

Python assert（斷言）用於判斷一個表達式，在表達式條件爲 false 的時候觸發異常。ide

語法錯誤

Python 的語法錯誤或者稱之爲解析錯，是初學者常常碰到的，以下實例函數

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

這個例子中，函數 print() 被檢查到有錯誤，是它前面缺乏了一個冒號 : 。oop

語法分析器指出了出錯的一行，而且在最早找到的錯誤的位置標記了一個小小的箭頭。學習

異常

即使 Python 程序的語法是正確的，在運行它的時候，也有可能發生錯誤。運行期檢測到的錯誤被稱爲異常。this

大多數的異常都不會被程序處理，都以錯誤信息的形式展示在這裏:spa

實例

>>> 10 * (1/0)     # 0 不能做爲除數，觸發異常
Traceback (most recent call last):
File "<stdin>", line 1, in ?
ZeroDivisionError: division by zero
>>> 4 + spam*3     # spam 未定義，觸發異常
Traceback (most recent call last):
File "<stdin>", line 1, in ?
NameError: name 'spam' is not defined
>>> '2' + 2     # int 不能與 str 相加，觸發異常
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: can only concatenate str (not "int") to str

異常以不一樣的類型出現，這些類型都做爲信息的一部分打印出來: 例子中的類型有 ZeroDivisionError，NameError 和 TypeError。操作系統

錯誤信息的前面部分顯示了異常發生的上下文，並以調用棧的形式顯示具體信息。code

異常處理

try/except

異常捕捉可使用 try/except 語句。

如下例子中，讓用戶輸入一個合法的整數，可是容許用戶中斷這個程序（使用 Control-C 或者操做系統提供的方法）。用戶中斷的信息會引起一個 KeyboardInterrupt 異常。

while True:
  try:
x = int(input("請輸入一個數字: "))
  break
  except ValueError:
  print("您輸入的不是數字，請再次嘗試輸入！")

try 語句按照以下方式工做；

首先，執行 try 子句（在關鍵字 try 和關鍵字 except 之間的語句）。
若是沒有異常發生，忽略 except 子句，try 子句執行後結束。
若是在執行 try 子句的過程當中發生了異常，那麼 try 子句餘下的部分將被忽略。若是異常的類型和 except 以後的名稱相符，那麼對應的 except 子句將被執行。
若是一個異常沒有與任何的 except 匹配，那麼這個異常將會傳遞給上層的 try 中。

一個 try 語句可能包含多個except子句，分別來處理不一樣的特定的異常。最多隻有一個分支會被執行。

處理程序將只針對對應的 try 子句中的異常進行處理，而不是其餘的 try 的處理程序中的異常。

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

try/except 語句還有一個可選的 else 子句，若是使用這個子句，那麼必須放在全部的 except 子句以後。

else 子句將在 try 子句沒有發生任何異常的時候執行。

如下實例在 try 語句中判斷文件是否能夠打開，若是打開文件時正常的沒有發生異常則執行 else 部分的語句，讀取文件內容：

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 又沒法捕獲的異常。

異常處理並不只僅處理那些直接發生在 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

try-finally 語句

try-finally 語句不管是否發生異常都將執行最後的代碼。

如下實例中 finally 語句不管異常是否發生都會執行：

實例

try:
runoob()
except AssertionError as error:
  print(error)
else:
  try:
  with open('file.log') as file:
read_data = file.read()
  except FileNotFoundError as fnf_error:
  print(fnf_error)
finally:
  print('這句話，不管異常是否發生都會執行。')

拋出異常

Python 使用 raise 語句拋出一個指定的異常。

raise語法格式以下：

raise [Exception [, args [, traceback]]]

如下實例若是 x 大於 5 就觸發異常:

x = 10
if x > 5:
raise Exception('x 不能大於 5。x 的值爲: {}'.format(x))

執行以上代碼會觸發異常：

Traceback (most recent call last): File "test.py", line 3, in <module> raise Exception('x 不能大於 5。x 的值爲: {}'.format(x)) Exception: x 不能大於 5。x 的值爲: 10

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

在這個例子中，類 Exception 默認的 __init__() 被覆蓋。

<p異常的類能夠像其餘的類同樣作任何事情，可是一般都會比較簡單，只提供一些錯誤相關的屬性，而且容許處理異常的代碼方便的獲取這些信息。< p="">

當建立一個模塊有可能拋出多種不一樣的異常時，一種一般的作法是爲這個包創建一個基礎異常類，而後基於這個基礎類爲不一樣的錯誤狀況建立不一樣的子類:

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 語句還有另一個可選的子句，它定義了不管在任何狀況下都會執行的清理行爲。例如:

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

以上例子無論 try 子句裏面有沒有發生異常，finally 子句都會執行。

若是一個異常在 try 子句裏（或者在 except 和 else 子句裏）被拋出，而又沒有任何的 except 把它截住，那麼這個異常會在 finally 子句執行後被拋出。

下面是一個更加複雜的例子（在同一個 try 語句裏包含 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 "<stdin>", line 1, in ?
File "<stdin>", line 3, in divide
TypeError: unsupported operand type(s) for /: 'str' and 'str'