Python從入門到精通 Python 2025-08-15 188 閱讀

第8章 異常處理

異常處理是Python編程中的重要概念，它讓我們能夠優雅地處理程序運行時可能出現的錯誤情況。掌握異常處理不僅能讓程序更加健壯，還能提供更好的用戶體驗。本章將深入探討Python中的異常處理機制，從基本概念到高級應用，幫助讀者全面掌握這一重要技能。

本系列文章所使用到的示例源碼：Python從入門到精通示例代碼

8.1 異常的概念與分類

異常的定義

異常（Exception）是程序在運行時遇到的錯誤情況。與語法錯誤不同，異常發生在程序語法正確但執行過程中出現問題的時候。

異常 vs 語法錯誤
- 語法錯誤：代碼不符合Python語法規則，程序無法啓動
- 異常：程序運行時遇到的錯誤，可以被捕獲和處理

# 語法錯誤示例（程序無法運行）
# print("Hello World"  # 缺少右括號

# 異常示例（程序可以運行，但會在執行時出錯）
print(1 / 0)  # ZeroDivisionError異常

異常的傳播機制

當異常發生時，Python會沿着調用棧向上傳播，直到找到合適的異常處理器或程序終止。

Python中的異常層次結構

Python中的所有異常都繼承自BaseException類，形成了一個層次結構：

BaseException
 +-- SystemExit
 +-- KeyboardInterrupt
 +-- GeneratorExit
 +-- Exception
      +-- StopIteration
      +-- ArithmeticError
      |    +-- ZeroDivisionError
      +-- LookupError
      |    +-- IndexError
      |    +-- KeyError
      +-- ValueError
      +-- TypeError
      +-- OSError
      |    +-- FileNotFoundError
      +-- AttributeError
      +-- ImportError

讓我們通過代碼來驗證這個層次結構：

# 查看異常的繼承關係
exceptions = [
    ZeroDivisionError(),
    ValueError(),
    TypeError(),
    IndexError(),
    KeyError(),
    FileNotFoundError(),
    AttributeError(),
    ImportError()
]

for exc in exceptions:
    print(f"{type(exc).__name__} -> {type(exc).__bases__[0].__name__}")

輸出結果：

ZeroDivisionError -> ArithmeticError
ValueError -> Exception
TypeError -> Exception
IndexError -> LookupError
KeyError -> LookupError
FileNotFoundError -> OSError
AttributeError -> Exception
ImportError -> Exception

常見的內置異常類型

以下是Python中最常見的內置異常類型：

  • ZeroDivisionError：除零錯誤
  • ValueError：值錯誤，參數類型正確但值不合適
  • TypeError：類型錯誤，參數類型不正確
  • IndexError：索引錯誤，序列索引超出範圍
  • KeyError：鍵錯誤，字典中不存在指定鍵
  • FileNotFoundError：文件未找到錯誤
  • AttributeError：屬性錯誤，對象沒有指定屬性
  • ImportError：導入錯誤，無法導入模塊
  • NameError：名稱錯誤，使用了未定義的變量

8.2 try-except語句

try-except的基本語法

try-except語句是Python中處理異常的基本結構：

try:
    # 可能出現異常的代碼
    pass
except ExceptionType:
    # 異常處理代碼
    pass

讓我們看一個基本的異常捕獲示例：

def test_basic_exception():
    print("基本異常捕獲示例")
    try:
        x = 1 / 0
    except ZeroDivisionError as e:
        print(f"捕獲到除零異常: {e}")

test_basic_exception()

輸出結果：

基本異常捕獲示例
捕獲到除零異常: division by zero

捕獲特定異常

指定異常類型

通過指定具體的異常類型，我們可以針對不同的錯誤情況進行不同的處理：

def test_specific_exceptions():
    # 測試不同類型的異常
    test_cases = [
        lambda: [1, 2, 3][10],  # IndexError
        lambda: int("abc"),     # ValueError
        lambda: "string" + 5    # TypeError
    ]

    for i, test_case in enumerate(test_cases):
        try:
            test_case()
        except IndexError:
            print(f"測試{i+1}: 捕獲到索引錯誤")
        except ValueError:
            print(f"測試{i+1}: 捕獲到值錯誤")
        except TypeError:
            print(f"測試{i+1}: 捕獲到類型錯誤")

捕獲多種異常

多個except塊

def test_multiple_exceptions():
    try:
        # 嘗試訪問不存在的列表索引
        my_list = [1, 2, 3]
        print(my_list[10])
    except IndexError as e:
        print(f"索引錯誤: {e}")
    except TypeError as e:
        print(f"類型錯誤: {e}")

    # 使用元組形式捕獲多種異常
    try:
        int("abc")
    except (ValueError, TypeError) as e:
        print(f"值錯誤或類型錯誤: {e}")

輸出結果：

索引錯誤: list index out of range
值錯誤或類型錯誤: invalid literal for int() with base 10: 'abc'

捕獲所有異常

使用Exception

def test_catch_all():
    try:
        # 嘗試執行一些可能出錯的代碼
        x = undefined_variable  # 未定義的變量
    except Exception as e:
        print(f"捕獲到異常: {type(e).__name__}: {e}")

輸出結果：

捕獲到異常: NameError: name 'undefined_variable' is not defined

注意：雖然可以使用裸except:來捕獲所有異常，但這是不推薦的做法，因爲它會捕獲包括SystemExit和KeyboardInterrupt在內的所有異常，可能導致程序無法正常退出。

8.3 finally子句

finally子句的作用

finally子句中的代碼無論是否發生異常都會執行，通常用於資源清理：

def test_finally():
    try:
        print("嘗試打開一個不存在的文件")
        with open("不存在的文件.txt", "r") as f:
            content = f.read()
    except FileNotFoundError as e:
        print(f"文件未找到: {e}")
    finally:
        print("無論是否發生異常，finally塊都會執行")

輸出結果：

嘗試打開一個不存在的文件
文件未找到: [Errno 2] No such file or directory: '不存在的文件.txt'
無論是否發生異常，finally塊都會執行

finally vs else子句

else子句只在沒有異常時執行：

def test_else():
    try:
        x = 10
        y = 2
        result = x / y
    except ZeroDivisionError:
        print("除數不能爲零!")
    else:
        print(f"計算結果: {result}")
    finally:
        print("finally塊總是執行")

輸出結果：

計算結果: 5.0
finally塊總是執行

try-except-finally的完整結構

def complete_exception_handling():
    try:
        # 可能出現異常的代碼
        result = 10 / 2
        print(f"計算結果: {result}")
    except ZeroDivisionError:
        # 異常處理代碼
        print("不能除以零")
    else:
        # 沒有異常時執行
        print("計算成功完成")
    finally:
        # 總是執行的清理代碼
        print("清理資源")

8.4 raise語句

主動拋出異常

使用raise語句可以主動拋出異常：

def test_raise():
    try:
        x = -5
        if x < 0:
            raise ValueError("不能使用負數")
    except ValueError as e:
        print(f"捕獲到值錯誤: {e}")

輸出結果：

捕獲到值錯誤: 不能使用負數

重新拋出異常

在except塊中使用raise可以重新拋出當前異常：

def process_data(data):
    try:
        return 1 / data
    except ZeroDivisionError:
        print("記錄錯誤日誌")
        raise  # 重新拋出異常

def main():
    try:
        result = process_data(0)
    except ZeroDivisionError:
        print("在主函數中處理異常")

異常鏈

使用raise ... from ...可以創建異常鏈，保留原始異常信息：

def test_exception_chaining():
    try:
        try:
            1 / 0
        except ZeroDivisionError as e:
            # 引發新異常，保留原始異常信息
            raise ValueError("計算過程中出現錯誤") from e
    except ValueError as e:
        print(f"捕獲到值錯誤: {e}")
        # 打印異常鏈信息
        if e.__cause__:
            print(f"原始異常: {e.__cause__}")

輸出結果：

捕獲到值錯誤: 計算過程中出現錯誤
原始異常: division by zero

8.5 自定義異常

自定義異常類的創建

創建自定義異常類需要繼承Exception類：

class MyCustomError(Exception):
    """自定義異常類"""
    def __init__(self, message, error_code=None):
        self.message = message
        self.error_code = error_code
        super().__init__(self.message)

    def __str__(self):
        if self.error_code:
            return f"{self.message} (錯誤代碼: {self.error_code})"
        return self.message

def test_custom_exception():
    try:
        raise MyCustomError("這是一個自定義異常", 1001)
    except MyCustomError as e:
        print(f"捕獲到自定義異常: {e}")
        print(f"錯誤代碼: {e.error_code}")

輸出結果：

捕獲到自定義異常: 這是一個自定義異常 (錯誤代碼: 1001)
錯誤代碼: 1001

異常類的層次設計

對於複雜的應用，建議設計異常類的層次結構：

# 基礎異常類
class ApplicationError(Exception):
    """應用程序基礎異常"""
    pass

# 具體異常類
class ValidationError(ApplicationError):
    """數據驗證異常"""
    pass

class DatabaseError(ApplicationError):
    """數據庫操作異常"""
    pass

class NetworkError(ApplicationError):
    """網絡連接異常"""
    pass

# 使用示例
def validate_user_input(data):
    if not data:
        raise ValidationError("輸入數據不能爲空")
    if len(data) < 3:
        raise ValidationError("輸入數據長度不能少於3個字符")

8.6 異常處理最佳實踐

異常處理的原則

  1. 具體異常優於通用異常
  2. 早發現，早處理
  3. 不要忽略異常
  4. 異常信息要有意義

異常處理的模式

EAFP vs LBYL

Python推崇EAFP（Easier to Ask for Forgiveness than Permission）模式，而不是LBYL（Look Before You Leap）模式。

# LBYL方式：先檢查再執行
def lbyl_example(my_dict, key):
    if key in my_dict:
        return my_dict[key]
    else:
        return None

# EAFP方式：直接嘗試，出錯再處理
def eafp_example(my_dict, key):
    try:
        return my_dict[key]
    except KeyError:
        return None

性能考慮

讓我們通過實際測試來比較兩種方式的性能：

import time

def performance_test():
    data = {str(i): i for i in range(1000)}
    existing_keys = [str(i) for i in range(500)]
    missing_keys = [str(i+1000) for i in range(500)]

    # 測試存在鍵的情況
    start = time.time()
    for _ in range(1000):
        for key in existing_keys:
            if key in data:  # LBYL
                value = data[key]
    lbyl_time = time.time() - start

    start = time.time()
    for _ in range(1000):
        for key in existing_keys:
            try:  # EAFP
                value = data[key]
            except KeyError:
                pass
    eafp_time = time.time() - start

    print(f"鍵存在時 - LBYL: {lbyl_time:.6f}秒, EAFP: {eafp_time:.6f}秒")

根據我們的測試結果：

場景1: 所有鍵都存在
LBYL方式耗時: 0.036063秒
EAFP方式耗時: 0.027617秒
LBYL/EAFP比率: 1.31

場景2: 所有鍵都不存在
LBYL方式耗時: 0.016593秒
EAFP方式耗時: 0.084059秒
LBYL/EAFP比率: 0.20

場景3: 混合情況(一半鍵存在，一半不存在)
LBYL方式耗時: 0.024595秒
EAFP方式耗時: 0.062052秒
LBYL/EAFP比率: 0.40

從測試結果可以看出：
- 當異常很少發生時，EAFP方式性能更好
- 當異常頻繁發生時，LBYL方式性能更好
- 在實際應用中，通常異常是少數情況，所以EAFP是更好的選擇

日誌記錄

在異常處理中記錄日誌是很重要的實踐：

import logging

# 配置日誌
logging.basicConfig(level=logging.INFO, 
                   format='%(asctime)s - %(levelname)s - %(message)s')

def process_file(filename):
    try:
        with open(filename, 'r') as f:
            content = f.read()
            return content
    except FileNotFoundError:
        logging.error(f"文件未找到: {filename}")
        raise
    except PermissionError:
        logging.error(f"沒有權限訪問文件: {filename}")
        raise
    except Exception as e:
        logging.error(f"處理文件時發生未知錯誤: {filename}, 錯誤: {e}")
        raise

異常處理的反模式

避免以下不良實踐：

  1. 空的except塊
# 錯誤做法
try:
    risky_operation()
except:
    pass  # 忽略所有異常
  1. 過於寬泛的異常捕獲
# 錯誤做法
try:
    specific_operation()
except Exception:  # 捕獲所有異常
    print("出錯了")
  1. 異常作爲控制流
# 錯誤做法
try:
    while True:
        item = get_next_item()
        process(item)
except StopIteration:
    pass  # 用異常來結束循環

文件操作中的異常處理實例

讓我們通過一個完整的文件操作示例來展示異常處理的最佳實踐：

def safe_file_operations():
    """安全的文件操作示例"""
    filename = "test_file.txt"

    # 寫入文件
    try:
        with open(filename, 'w', encoding='utf-8') as f:
            f.write("這是測試文件的內容\n")
            f.write("第二行內容")
        print("文件寫入成功")
    except PermissionError:
        print(f"沒有權限寫入文件: {filename}")
        return
    except OSError as e:
        print(f"寫入文件時發生系統錯誤: {e}")
        return

    # 讀取文件
    try:
        with open(filename, 'r', encoding='utf-8') as f:
            content = f.read()
            print(f"文件內容:\n{content}")
    except FileNotFoundError:
        print(f"文件不存在: {filename}")
    except PermissionError:
        print(f"沒有權限讀取文件: {filename}")
    except UnicodeDecodeError:
        print(f"文件編碼錯誤: {filename}")
    except Exception as e:
        print(f"讀取文件時發生未知錯誤: {e}")
    finally:
        # 清理工作（如果需要）
        print("文件操作完成")

safe_file_operations()

總結

異常處理是Python編程中不可或缺的技能。通過本章的學習，我們瞭解了：

  1. 異常的基本概念：異常是程序運行時的錯誤，可以被捕獲和處理
  2. 異常層次結構：Python中的異常形成了清晰的繼承層次
  3. try-except語句：異常處理的基本語法和各種用法
  4. finally和else子句：用於資源清理和條件執行
  5. raise語句：主動拋出異常和異常鏈
  6. 自定義異常：創建符合應用需求的異常類
  7. 最佳實踐：EAFP模式、日誌記錄、避免反模式

掌握這些知識點，能夠幫助我們編寫更加健壯和用戶友好的Python程序。記住，好的異常處理不僅能讓程序在出錯時優雅地處理問題，還能爲調試和維護提供有價值的信息。

在實際開發中，建議遵循以下原則：
- 捕獲具體的異常類型，而不是使用通用的Exception
- 在異常處理中提供有意義的錯誤信息
- 使用日誌記錄異常信息，便於調試
- 在適當的時候重新拋出異常，讓上層調用者處理
- 使用finally子句進行資源清理

通過合理使用異常處理機制，我們可以構建出既穩定又易於維護的Python應用程序。

相關文章

Python2實現簡單的爬蟲 2018-04-10 雙目攝像頭測量距離 2020-05-14 Python實現常見的排序算法 2020-05-16 基於Pytorch實現的聲音分類 2021-08-20 給語音識別文本加上標點符號 2022-01-13
小夜