文章目錄

02-python 基礎語法知識-04-異常與錯誤處理

02-python 基礎語法知識-04-異常與錯誤處理

總體要講的大綱內容如下

循環- for while
流程中斷 continue break
邏輯操作 and ,or ,not
函數
常用內置函數 (todo)
python中的異常與錯誤處理

今天我們開始學習一個比較關鍵的一個概念叫異常。你可能沒有接觸過什麼叫異常,它是所有編程語言都比不可少的話題。程序有時候並沒有我們想象的那麼強大，有時候也會出現一些報錯，導致程序停止了。這些報錯我們就稱爲程序拋出了一個異常。

什麼是異常

簡單理解就是我們說在代碼執行的時候發生了錯誤，這個時候就產生了一個異常，程序就被迫中斷了。

不知道我們之前介紹的一些基礎的數據類型，我會說某某方法如果怎麼樣，就報錯 IndexError 。這些報錯就是異常，當異常發生的時候，如果我們採取任何措施，程序將會停止運行。

舉幾個常見的報錯的例子

>>> nums = ["one", "two", 'three', 'four', 'five']
>>> nums[10]
Traceback (most recent call last):
  File "<input>", line 1, in <module>
IndexError: list index out of range

IndexError 這裏就是一個異常，這個異常發生在訪問了一個不存在的位置，python 解釋器不知道如何做，所以就報錯了。

>>> 'frank'.index('name')
Traceback (most recent call last):
  File "<input>", line 1, in <module>
ValueError: substring not found

ValueError 是一個異常，這裏想在在字符串中尋找一個子串name 發現沒有找到，也報錯了。這裏就是拋出了一個異常 .

>>> 1/0
Traceback (most recent call last):
  File "<input>", line 1, in <module>
ZeroDivisionError: division by zero

ZeroDivisionError 這裏也報錯了，這裏很明顯 1 是不能除以0 的，這個一般人都知道。所以你強行給計算機算這個值，python解釋器也沒有辦法算出來。這個也會拋出異常。 ZeroDivisionError

>>> 
... person = {
...     'weight': 60,
...     'name': 'frank',
...     'height': 165,
...     'hobby': 'swimming'
... }
>>> 
>>> person['aaa']
Traceback (most recent call last):
  File "<input>", line 1, in <module>
KeyError: 'aaa'

在字典中強行訪問不存在的key , 這個時候 python 解釋器也不知道如何處理，然後也報錯了。這次報錯叫 KeyError .

上面的這些例子都叫異常。而且不同的報錯有不同的異常。也就是異常是可以分類的。就是有不同類型的異常，通過不同的異常，我們可以大概知道程序發生了什麼問題。方便我們更好的排查問題。

異常發生時會發生什麼？

當異常發生的時候，程序就會中斷，之後的代碼將不會執行。

def operate():
    print("operate begin")

    nums = ["one", "two", 'three', 'four', 'five']
    print(nums[1])

    # 這裏要發生異常
    print(nums[10])

    print(nums[-1])  #1
    print("operate end") #2


operate()

運行這段代碼看看會發生什麼，這個函數一開始先打印 index=1 元素，然後打印index=10的元素，顯然不存在，之後打印最後一個元素。最後輸出一句話代表函數結束了。

來看下運行結果

operate begin
two
Traceback (most recent call last):
  File "C:/Users/changfx/PycharmProjects/python-study/myerror.py", line 20, in <module>
    operate()
  File "C:/Users/changfx/PycharmProjects/python-study/myerror.py", line 14, in operate
    print(nums[10])
IndexError: list index out of range

Process finished with exit code 1

從結果可以看出開始正常打印，當發生 IndexError 的報錯後，程序就退出了。並沒有執行後面的語句。

沒有打印最後的結束語，也沒有打印最後一個元素。

總結一下：當異常發生的時候，如果我們沒有對異常進行處理。程序就中斷，然後程序就會異常的退出了。

如何處理異常

try except finally else

可以通過這個來捕獲可能發生的異常。

try:
    pass
	# 可能發生異常的代碼段
except IndexError as e:
    pass

來修改一下上面的函數

def operate():
    print("operate begin")

    nums = ["one", "two", 'three', 'four', 'five']
    print(nums[1])

    try:
        # 這裏要發生異常
        print(nums[10])
    except IndexError as e:
        print(e)

    print(nums[-1])
    print("operate end")


operate()

"""結果
operate begin
two
list index out of range
five
operate end

"""

再次運行這個代碼，發現已經可以正常運行了。程序正常退出了，這個時候當發生異常的時候我們可以嘗試捕獲這個異常，只要這個異常被捕獲了，那麼程序就可以正常運行了。

對於異常捕獲 try 語句還有其他的形式。簡單說一下

有時候我們並不知道哪些代碼段會發生異常，也有可能不發生異常。這個時候就要考慮用 try 把可能發生的異常進行捕獲。

比如下面的函數，我想訪問下標爲10 的元素，但是這個array 是作爲一個函數的參數傳入進來，我並不知道這個array 是否有下標爲10 的元素，所以我用 try 嘗試捕獲異常。這裏我使用這種結構 .

try:
	pass
except IndexError as e:
	pass
else:
	pass

這裏 else 語句代表如果沒有發生異常，會執行 else 語句的內容，如果發生了異常則不會執行else 語句的內容。

def print_nums(array: list):
    print('print_nums begin')
    try:
        print(array[10])
    except IndexError as e:
        print(f"e={e}")
    else:
        print('end')

在console演示一下：

>>> def print_nums(array: list):
...     print('print_nums begin')
...     try:
...         print(array[10])
...     except IndexError as e:
...         print(f"e={e}")
...     else:
...         print('end')
... 

>>> array = list(range(5))
>>> print_nums(array)  # 發生異常
print_nums begin
e=list index out of range

>>> array2 = list(range(11))
>>> print_nums(array2) #沒有發生異常 
print_nums begin
10
end

發生的異常的時候 else 的語句沒有被執行，如果沒有發生異常， else 的語句正常執行了。這個就是else 語句的作用。只有當 try 的代碼段沒有發生異常的時候， else 的語句纔會被執行。

在介紹一種異常捕獲的形式

finally 子句，這裏 finally 的語句代表無論 try 捕獲這段代碼是否發生異常， finally 永遠被執行。這裏一般會做一些資源釋放，數據庫關閉連接之類的操作。

def print_nums(array: list):
    print('print_nums begin')
    try:
        # 可能發生的異常的代碼段
        print(array[10])
    except IndexError as e:
        print(f"e={e}")
    else:
        print('else end')
    finally:
        print("print_nums end")

在 console 演示

>>> def print_nums(array: list):
...     print('print_nums begin')
...     try:
...         # 可能發生的異常的代碼段
...         print(array[10])
...     except IndexError as e:
...         print(f"e={e}")
...     else:
...         print('else end')
...     finally:
...         print("print_nums end")
...         
>>> 

>>> print_nums(array=list(range(11)))  # 不會發生異常
print_nums begin
10
else end
print_nums end


>>> print_nums(array=list(range(5)))  # 會發生異常
print_nums begin
e=list index out of range
print_nums end

可以看出無論發生或者不發生異常，都會執行 finally 子句的代碼段。這個就是 finally 的作用。

如何自己主動拋出一個異常

可以使用 raise 語句拋出一個異常. 這裏可以用來檢測一些用戶輸入，如果輸入了一些不合法的值，我們就可以主動拋出一個異常。給出用戶一些錯誤提示信息。

raise IndexError("xxxxxxx")

手動拋出一個異常，比如人的年齡不可能超過 100,和小於0 。這裏手動拋出一個 ValueError 的異常

>>> 
>>> 
... age = 150
... if age > 100 or age < 0:
...     raise ValueError("age >100 or age<0 ")
... 
Traceback (most recent call last):
  File "<input>", line 4, in <module>
ValueError: age >100 or age<0

你注意到了嗎? 這裏我拋出的異常是 ValueError , 而不是 KeyError ,IndexError 。所以這裏要提醒一下，異常是有分類的，每一種異常都有特定的含義，你需要了解這些特定含義，才進行拋出特定的異常。因爲異常信息是用來幫助我們來排查程序出現的問題，所以拋出異常信息要儘量準確，這樣才能方便排查問題。

異常的分類

在python3 中內置很多的異常，並且異常也是可以通過繼承的。繼承的概念屬於面向對象的概念。如果不是很理解，簡單理解的子承父業差不多，下面以及的異常肯定含有上面異常的所有的東西。之後我會單獨解釋面向對象的知識。

BaseException
 +-- SystemExit
 +-- KeyboardInterrupt
 +-- GeneratorExit
 +-- Exception
      +-- StopIteration
      +-- StopAsyncIteration
      +-- ArithmeticError
      |    +-- FloatingPointError
      |    +-- OverflowError
      |    +-- ZeroDivisionError
      +-- AssertionError
      +-- AttributeError
      +-- BufferError
      +-- EOFError
      +-- ImportError
      |    +-- ModuleNotFoundError
      +-- LookupError
      |    +-- IndexError
      |    +-- KeyError
      +-- MemoryError
      +-- NameError
      |    +-- UnboundLocalError
      +-- OSError
      |    +-- BlockingIOError
      |    +-- ChildProcessError
      |    +-- ConnectionError
      |    |    +-- BrokenPipeError
      |    |    +-- ConnectionAbortedError
      |    |    +-- ConnectionRefusedError
      |    |    +-- ConnectionResetError
      |    +-- FileExistsError
      |    +-- FileNotFoundError
      |    +-- InterruptedError
      |    +-- IsADirectoryError
      |    +-- NotADirectoryError
      |    +-- PermissionError
      |    +-- ProcessLookupError
      |    +-- TimeoutError
      +-- ReferenceError
      +-- RuntimeError
      |    +-- NotImplementedError
      |    +-- RecursionError
      +-- SyntaxError
      |    +-- IndentationError
      |         +-- TabError
      +-- SystemError
      +-- TypeError
      +-- ValueError
      |    +-- UnicodeError
      |         +-- UnicodeDecodeError
      |         +-- UnicodeEncodeError
      |         +-- UnicodeTranslateError
      +-- Warning
           +-- DeprecationWarning
           +-- PendingDeprecationWarning
           +-- RuntimeWarning
           +-- SyntaxWarning
           +-- UserWarning
           +-- FutureWarning
           +-- ImportWarning
           +-- UnicodeWarning
           +-- BytesWarning
           +-- ResourceWarning

所有的異常都是由 BaseException 派生出來的。然後對應 4個平級的異常，我們通常情況只是從 Exception 中繼承來重寫自己定義的異常。這裏我們經常遇見的也就10 來種左右。作爲了解知道即可。

SystemExit
KeyboardInterrupt
GeneratorExit
Exception

自定義異常

我們有時候可能不需要系統系統的異常，或者滿足不了我們的需要。我們通常的做法是繼承 Exception 來實現自己的異常。

1.如何自定義自己的異常對象

大部分情況我們只要繼承 Exception 即可。有一個關鍵字 class 還記得我說的，異常實際上一個類。所以我們想要實現自己的異常，一般會寫一個 class 然後繼承 Exception 即可。

class InvalidAge(Exception):
    pass


age = int(input("請輸入你的年齡： "))
if age > 100 or age < 0:
    raise InvalidAge("你的年齡應該是 [0-100] 之間 ")

>>> class InvalidAge(Exception):
...     pass
... 
... 
... age = int(input("請輸入你的年齡： "))
... if age > 100 or age < 0:
...     raise InvalidAge("你的年齡應該是 [0-100] 之間 ")
... 
請輸入你的年齡： >? 123
Traceback (most recent call last):
  File "<input>", line 7, in <module>
InvalidAge: 你的年齡應該是 [0-100] 之間

異常是什麼？異常是不是一種例外情況呢？

爲了更好的解釋異常，我舉兩個數字相除的例子。來看下面的兩個函數

def divide(number, divisor):
    try:
        print(f"{number} / {divisor} = {number / divisor}")
    except ZeroDivisionError:
        print("You can't divide by zero ")


        
def divide2(number, divisor):
    if divisor == 0:
        print("You can't divide by zero ")
        return

    print(f"{number} / {divisor} = {number / divisor}")

這兩個函數功能是相同的，計算兩個數相除。應該知道除數不能作爲分母。第一種方式通過捕獲這個異常來提示用戶不要把除數變成0 ，第二種方式是直接判斷除數是否爲0 。

第二種方法好不好呢？其實我不能告訴你這樣做好不好。

但是對於Python 程序員更加細化追隨 請求諒解，而不是許可的原則。就是說 python鼓勵程序員先去做，然後在去解決問題。顯然 python 是鼓勵大家勇於嘗試的語言，實際上看內置的庫，也是遵守這個原則的。

當然還有另一種原則三思而後行的原則 這種做法也有一定好處，第一減少了不必要的cpu 的開銷，減少了一些不必要執行的代碼。這裏對於例外情況是非常有效的。

比如說舉個例子，在一個超市銷售系統裏面，有一個貨物賣完了，顯然這個時候我們應該返回什麼呢？

空，缺貨的字符串，一個負數？我們通過if 語句判斷或取得數量顯然這個邏輯寫起來比較繁瑣。

爲啥這個時候我們不可以自定義一個異常呢？

class OutOfStack(Exception):
    pass

只要在每次用戶調用購買的時候，我們try 進行捕獲這段購買的邏輯。然後在購買的時候，如果判斷缺貨了，直接拋出這個我們自定義的異常。這樣的話，是不是看起來更加好一點呢。

這裏你可能對面向對象不理解，之後我們慢慢解釋一下什麼是面向對象編程。

class OutOfStack(Exception):
    pass

class Goods:

    def __init__(self, stock: int):
        self.stock = stock

    def purchase(self):
        if self.stock == 0:
            raise OutOfStack("庫存爲0,無法購買了!")
        self.stock = self.stock - 1
        print(f"購買成功。 當前庫存容量：{self.stock}")

在控制檯執行

>>> class OutOfStack(Exception):
...     pass
... 
... 
... class Goods:
... 
...     def __init__(self, stock: int):
...         self.stock = stock
... 
...     def purchase(self):
...         if self.stock == 0:
...             raise OutOfStack("庫存爲0,無法購買了!")
...         self.stock = self.stock - 1
...         print(f"購買成功。 當前庫存容量：{self.stock}")
... 
>>> 
>>> goods = Goods(3)
>>> goods.purchase()
購買成功。 當前庫存容量：2
>>> goods.purchase()
購買成功。 當前庫存容量：1
>>> goods.purchase()
購買成功。 當前庫存容量：0
>>> goods.purchase()
Traceback (most recent call last):
  File "<input>", line 1, in <module>
  File "<input>", line 12, in purchase
OutOfStack: 庫存爲0,無法購買了!

當前庫存爲0 ，然後程序拋出一個異常。告訴用戶庫存不夠了。

用異常來進行流程控制可以完成一些非常好用的程序設計。還有要明白，發生異常的時候並不意味着你要努力阻止這個這種情況發生。相反，它是一種無法直接交流的代碼進行信息溝通的方式而已。

如何安裝第三方的包？

什麼是第三方包，就是一些別人覺得非常有用的功能，寫成一個工具包，這樣我們遇到類似問題的時候，就不要重頭開始寫這些工具包，直接別人寫好的工具就可以了。是不是很好啊，直接竊取別人的勞動果實。哈哈，其實這就是一種開源精神。每個有追求的程序員都應該有這份追求。

那麼問題來了如何尋找這些工具包呢？

有一個網站 pypi.org 所有python的第三方包都會放到這個網站上面，可以自行搜索查找。

下面我們來安裝一下這幾個包

celery attrs requests redis

首先你要知道這些包的名稱，然後安裝它。

第一種方法使用pip 工具安裝

pip install package_name

打開git bash ,找到你的項目路徑

$ cd python-study/
(venv)
CHANGFX@xxxxxxx ~/PycharmProjects/python-study
$ pwd
/c/Users/changfx/PycharmProjects/python-study
(venv)
CHANGFX@xxxxxx ~/PycharmProjects/python-study

# 這裏是激活 虛擬環境
$ source venv/Scripts/activate
(venv)
CHANGFX@xxxxxx ~/PycharmProjects/python-study
$
(venv)
CHANGFX@xxxxxx  ~/PycharmProjects/python-study
$ pip install redis
$ pip install requests

第二種是pycharm 自帶的安裝工具

導航欄中 File > Settings

找到 Project 然後點擊 Project ，看到下面的畫面，點擊下圖中的加號

直接在搜索欄搜索 redis , 就能夠看到 redis 相關的package ，點擊 install package 就可以下載了。

同理可以下載 ,把下面四個包下載一下，注意不要下載錯了哦。

celery attrs requests redis

查看第三方包自定義的異常

當你安裝完成後，你可以查看自己的venv 這個目錄下面就會發現已經有下面的路徑了。

我讓你安裝這些包，主要讓你看下，別人如何定義自己的異常的。然後感受一下。

當下載完成之後要自己查看一下這些文件，可以看到都有自己定義一些異常類。

主要看下面的文件，都是第三方包自己定義的一些異常。

venv/Lib/site-packages/celery/exceptions.py

venv/Lib/site-packages/attr/exceptions.py

venv/Lib/site-packages/requests/exceptions.py

venv/Lib/site-packages/redis/exceptions.py

總結

今天主要講解了 python 中的異常，一些概念。異常實際上是一個對象。我們根據自己的需要定義自己的異常，方便我們更好的定位問題，查找錯誤等。異常是一個非常好的工具，之後慢慢體會。先要明白如何處理異常，如何定義異常等。加油！

參考文檔

exceptions

Python3 錯誤和異常

python3 面向對象編程

分享快樂,留住感動. 2020-04-03 21:08:48 --frank

02-python 基礎語法知識-04-異常與錯誤處理

文章目錄

02-python 基礎語法知識-04-異常與錯誤處理

什麼是異常

異常發生時會發生什麼？

如何處理異常

如何自己主動拋出一個異常

異常的分類

自定義異常

如何安裝第三方的包？

查看第三方包自定義的異常

總結

參考文檔

測試人員都是畫畫大神，讓我看看誰還不會用代碼圖？

01-Python 中的數據類型-01-數字類型

00-陪你一起學python系列

python3 如何獲取一個文件的目錄,獲取上一級目錄

python3中的特性property介紹

02-python 基礎語法知識-03-內置函數

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

02-python 基礎語法知識-04-異常與錯誤處理

文章目錄

02-python 基礎語法知識-04-異常與錯誤處理

什麼是異常

異常發生時會發生什麼？

如何處理異常

如何自己主動拋出一個異常

異常的分類

自定義異常

如何安裝 第三方的包？

查看第三方包 自定義的異常

總結

參考文檔

如何安裝第三方的包？

查看第三方包自定義的異常