Python基礎常用模塊

本文系統整理 Python 基礎常用模塊，包含時間處理、隨機數生成、文件操作、系統交互、數據序列化、配置管理及安全哈希等核心功能，每個模塊均配備規範代碼示例與關鍵説明，便於學習與實際應用。

模塊大類	子模塊 / 核心功能	核心用途	關鍵特性 / 適用場景
時間處理模塊	time	時間戳轉換、結構化時間處理、時間格式化	基礎時間操作，支持時區轉換（本地 / UTC）
	datetime	時間運算（增減）、時間字段修改、高精度時間獲取	比 time 更直觀，支持 timedelta 時間差計算
隨機數模塊	random	生成隨機數 / 字符、隨機選擇、列表打亂	驗證碼生成、抽獎、模擬隨機場景
文件操作	open（內置函數）	文件讀 / 寫 / 追加、二進制文件操作	基礎文件 IO，支持上下文管理器（with）
文件與目錄操作模塊	os	目錄增刪、路徑處理、系統環境獲取、文件屬性查看	跨系統路徑兼容，基礎文件 / 目錄管理
	shutil	文件 / 目錄複製、遞歸刪除、壓縮包創建 / 解壓	基於 os 封裝，支持複雜文件操作
	subprocess	調用系統命令、捕獲命令輸出、管道通信	替代 os.system，安全靈活執行外部命令
系統交互模塊	sys	獲取 Python 解釋器信息、命令行參數處理、程序退出控制	命令行工具開發、系統參數獲取
數據序列化模塊	json	跨語言數據序列化 / 反序列化，支持基礎數據類型	多語言交互、接口數據傳輸
	pickle	Python 專屬序列化，支持所有數據類型（含自定義類）	本地數據持久化，不支持跨語言
	shelve	基於 pickle 的鍵值對式數據存儲	小規模數據持久化，操作類似字典
配置管理模塊	configparser	讀取 / 修改 ini 格式配置文件	項目參數配置（數據庫、程序設置）
安全哈希模塊	hashlib	生成數據哈希值（MD5/SHA256 等）、文件完整性校驗	密碼加密存儲、文件防篡改
	hmac	帶鹽值的哈希計算	更高安全性，防止彩虹表破解
二進制數據處理模塊	struct	Python 數據與二進制字節流互轉	網絡傳輸、二進制文件解析

一、時間處理模塊

time & datetime 用於時間戳轉換、時間格式化及時間運算，滿足日常時間相關開發需求。

1.1、time

• 基礎時間操作示例

  import time
  
  # 1. 獲取當前時間戳（從1970-01-01 00:00:00 UTC開始計算的秒數）
  print(time.time())  # 輸出示例：1730000000.123456
  
  # 2. 時間戳轉換為結構化時間（struct_time）
  # 默認轉換當前時間戳，也可指定具體時間戳（如1604969222）
  local_time = time.localtime()  # 本地時間（受時區影響）
  gm_time = time.gmtime()        # 格林威治時間（UTC時區）
  print("本地結構化時間:", local_time)  # 輸出包含年、月、日、時、分、秒等信息的元組
  print("格林威治結構化時間:", gm_time)
  
  # 3. 結構化時間格式化為字符串（常用格式符：%Y-年，%m-月，%d-日，%X-時分秒）
  local_str = time.strftime("%Y-%m-%d %X", local_time)
  gm_str = time.strftime("%Y-%m-%d %X", gm_time)
  print("本地格式化時間:", local_str)  # 輸出示例：2024-10-27 15:30:00
  print("格林威治格式化時間:", gm_str)  # 輸出示例：2024-10-27 07:30:00
  
  # 4. 結構化時間轉回時間戳
  print("本地時間轉時間戳:", time.mktime(local_time))  # 還原為原始時間戳
  

• 時間戳與指定時間互轉

  import time
  
  # 轉換步驟
  
  # 1. 字符串時間 → 結構化時間 → 時間戳
  time_str = "2025-12-01"
  struct_time = time.strptime(time_str, "%Y-%m-%d")  # 按指定格式解析字符串
  timestamp = time.mktime(struct_time)
  print(f"{time_str} 對應的時間戳:", timestamp)  # 輸出：1604764800.0
  
  # 2. 指定時間戳 → 結構化時間 → 格式化字符串
  target_timestamp = 1764579911
  struct_time = time.localtime(target_timestamp)
  formatted_time = time.strftime("%Y-%m-%d %X", struct_time)
  print(f"{target_timestamp} 對應的時間:", formatted_time)  # 輸出：2020-11-10 08:10:00
  

1.2、datetime

• 相比 time 模塊，datetime 提供更直觀的時間運算能力，支持時間增減與字段修改。

  import datetime
  import time
  
  # 1. 獲取當前時間（精確到微秒）
  current_time = datetime.datetime.now()
  print("當前時間:", current_time)  # 輸出示例：2025-12-01 14:49:47.463155
  
  # 2. 時間戳轉換為datetime對象
  timestamp = time.time()
  datetime_from_stamp = datetime.datetime.fromtimestamp(timestamp)
  print("時間戳轉datetime:", datetime_from_stamp)
  
  # 3. 時間運算（藉助timedelta，支持days/hours/minutes/seconds參數）
  three_days_later = current_time + datetime.timedelta(days=3)  # 3天后
  three_days_ago = current_time + datetime.timedelta(days=-3)   # 3天前
  print("3天后時間:", three_days_later)
  print("3天前時間:", three_days_ago)
  
  # 4. 修改時間字段（如年份、月份等）
  modified_time = current_time.replace(year=2025, month=1)  # 將年份改為2025，月份改為1
  print("修改後時間:", modified_time)  # 輸出示例：2025-01-27 15:35:22.123456
  

二、random

隨機數模塊，用於生成隨機小數、整數、隨機選擇及列表打亂，適用於驗證碼、抽獎等場景。

字符類型	ASCII 編碼範圍	對應字母	示例（字母→編碼）
大寫字母	65（0x41）~ 90（0x5A）	A ~ Z	A=65、B=66、…、Z=90
小寫字母	97（0x61）~ 122（0x7A）	a ~ z	a=97、b=98、…、z=122

• 大小寫字母的偏移量 : 小寫+32

• 核心功能示例

  import random
  
  # 1. 生成[0.0, 1.0)之間的隨機小數
  print("隨機小數（0-1）:", random.random())  # 輸出示例：0.618234
  
  # 2. 生成指定範圍的隨機小數（如[1, 3)）
  print("隨機小數（1-3）:", random.uniform(1, 3))  # 輸出示例：2.842269
  
  # 3. 生成指定範圍的整數（包含起止值，如[1, 10]）
  print("隨機整數（1-10）:", random.randint(1, 10))  # 輸出示例：7
  
  # 4. 生成指定步長的整數（如[1, 100)，步長默認1）
  print("隨機整數（1-100）:", random.randrange(1, 100))  # 輸出示例：45
  
  # 5. 從序列中隨機選擇1個元素（序列可嵌套）
  seq = [1, 2, 3, ["a", "n", "c"]]
  print("隨機選擇1個元素:", random.choice(seq))  # 輸出示例：["a", "n", "c"]
  
  # 6. 從序列中隨機選擇指定個數的元素（不重複）
  print("隨機選擇2個元素:", random.sample([1, 2, 3, 4], 2))  # 輸出示例：[3, 1]
  
  # 7. 打亂列表（原地修改，無返回值）
  temp = ["a", "n", "c"]
  random.shuffle(temp)
  print("打亂後列表:", temp)  # 輸出示例：["n", "a", "c"]
  

• 實用案例：生成 6 位隨機驗證碼

  import random
  
  def generate_checkcode(length=6):
      """生成指定長度的隨機驗證碼（大小寫字母+數字）"""
      checkcode_list = []
      for _ in range(length):
          # 隨機選擇類型：0-大寫字母，1-小寫字母，2-數字
          char_type = random.choice([0, 1, 2])
          if char_type == 0:
              # 大寫字母（ASCII：65-90）
              char = chr(random.randint(65, 90))
          elif char_type == 1:
              # 小寫字母（ASCII：97-122）
              char = chr(random.randint(97, 122))
          else:
              # 數字（0-9）
              char = str(random.randint(0, 9))
          checkcode_list.append(char)
      return "".join(checkcode_list)
  
  # 生成並打印6位驗證碼
  print("隨機驗證碼:", generate_checkcode())  # 輸出示例：mAbLw1
  
  ######################################################
  import random
  import time
  
  ran_list=[]
  while True:
      get_num=random.randrange(1,123)
      if get_num in range(65,91):
          ran_list.append(chr(get_num))
      elif get_num in range(97,123):
          ran_list.append(chr(get_num))
      elif get_num in range(0,10):
          ran_list.append(str(get_num))
      else:
          continue
      if len(ran_list)>=6:
          break
  print("".join(ran_list))
  

三、文件操作-open

open是 Python 操作文件的入口，通過它獲取文件句柄後，可對文件進行讀、寫、追加等操作。

• 基礎語法

  文件句柄 = open(文件路徑, 打開模式, encoding=編碼格式)
  

  • 文件路徑：可以是相對路徑（如"a.txt"）或絕對路徑（如"C:/data/a.txt"）。
  • 打開模式：決定文件的操作權限（讀 / 寫 / 追加），必填。
  • encoding：文本文件的編碼格式（如utf-8），二進制模式（rb/wb）不需要指定。

• 常用打開模式

  模式	權限	對文件的影響	適用場景
  r	只讀	文件必須存在，否則報錯	讀取文本文件
  w	只寫	不存在則創建；存在則清空內容	覆蓋寫入新內容
  a	追加	不存在則創建；存在則在末尾追加	日誌記錄
  r+	讀寫	文件必須存在，指針在開頭	讀取 + 修改文件
  a+	讀寫（追加）	不存在則創建，指針在末尾	追加 + 讀取文件
  rb	二進制只讀	用於非文本文件（圖片 / 視頻）	讀取二進制文件
  wb	二進制只寫	用於非文本文件	寫入二進制文件
  ab+	二進制追加	文件存在指定在開頭，文件不存在則新增	追加 + 讀取文件
  rb+	二進制讀寫	指定在開頭	讀寫文件

• 示例

  • 讀取文件(r模式)

    # 讀取全部內容
    with open("test.txt", "r", encoding="utf-8") as f:
        content = f.read()  # 一次性讀入所有內容（小文件推薦）
        print(content)
    
    # 逐行讀取（大文件推薦，避免內存佔用過高）
    with open("test.txt", "r", encoding="utf-8") as f:
        for line in f:
            print(line.strip())  # strip() 去除換行符
    

  • 寫入文件（w模式）

    # 覆蓋寫入（原有內容會被清空）
    with open("test.txt", "w", encoding="utf-8") as f:
        f.write("第一行內容\n")
        f.write("第二行內容\n")  # 支持多次write
    
    # 批量寫入
    lines = ["Python", "Java", "C++"]
    with open("test.txt", "w", encoding="utf-8") as f:
        f.writelines([line + "\n" for line in lines])  # writelines需手動加換行
    

  • 追加內容（a模式）

    # 在文件末尾追加
    with open("test.txt", "a", encoding="utf-8") as f:
        f.write("追加的新內容\n")
    

  • 二進制文件操作（rb/wb）

    # 複製圖片（二進制讀+寫）
    with open("pic.jpg", "rb") as f_read, open("pic_copy.jpg", "wb") as f_write:
        f_write.write(f_read.read())  # 直接讀寫字節流
    

• 常用文件句柄方法

  方法	功能
  file.closed	（屬性）判斷文件是否已關閉，返回布爾值（True/False）
  file.flush()	立即將內存中未寫入硬盤的文件數據刷寫到硬盤（無需等待緩衝區）
  file.name	（屬性）返回打開文件的完整文件名（含路徑，若為絕對路徑打開）
  file.seek(offset, mode=0)	移動文件指針到指定位置，offset 為偏移量（字節），mode 為偏移參考系：<br />0：以文件開頭為參考（默認）<br />1：以當前指針位置為參考（需 b 模式）<br />2：以文件末尾為參考（需 b 模式，offset 為負）
  file.tell()	返回當前文件指針的位置（以字節為單位，Windows 換行符 \r\n 計 2 字節）
  file.truncate(size)	截斷文件，僅保留前 size 個字節的內容（寫操作，需打開模式支持寫入）
  read(n)	讀取 n 個字符（文本模式）/ 字節（二進制模式）
  readline()	讀取一行內容（讀取到換行符為止，包含換行符）
  seek(offset)	簡化版：移動文件指針到指定字節位置（默認以文件開頭為參考，等價於 seek (offset, 0)）

  • file.closed 示例

    # 打開文件後判斷關閉狀態
    f = open("test.txt", "r", encoding="utf-8")
    print(f.closed)  # 輸出：False（文件未關閉）
    f.close()
    print(f.closed)  # 輸出：True（文件已關閉）
    

  • file.flush () 示例

    # 強制將內存內容刷寫到硬盤，避免數據滯留
    with open("test.txt", "w", encoding="utf-8") as f:
        f.write("測試 flush 功能")
        f.flush()  # 無需等待緩衝區，立即寫入硬盤
    

  • file.name 示例

    # 相對路徑打開文件，獲取文件名
    f1 = open("test.txt", "r", encoding="utf-8")
    print(f1.name)  # 輸出：test.txt
    f1.close()
    
    # 絕對路徑打開文件，獲取完整路徑+文件名
    f2 = open("D:/docs/test.txt", "r", encoding="utf-8")
    print(f2.name)  # 輸出：D:/docs/test.txt
    f2.close()
    

  • file.seek (offset, mode=0) 示例

    # 示例1：mode=0（默認），從文件開頭偏移5個字節
    with open("test.txt", "rb") as f:
        f.seek(5)  # 指針移到第5字節位置
        print(f.tell())  # 輸出：5
    
    # 示例2：mode=1，相對當前位置偏移3個字節（需二進制模式）
    with open("test.txt", "rb") as f:
        f.read(2)       # 先讀取2字節，指針到第2字節
        f.seek(3, 1)    # 從當前位置再偏移3字節，指針到第5字節
        print(f.tell()) # 輸出：5
    
    # 示例3：mode=2，從文件末尾偏移-10個字節（需二進制模式）
    with open("test.txt", "rb") as f:
        f.seek(-10, 2)  # 指針移到文件末尾前10字節
        print(f.tell()) # 輸出：文件總字節數-10
    

  • file.tell () 示例

    # 獲取當前文件指針的字節位置
    with open("test.txt", "rb") as f:
        f.read(3)       # 讀取前3個字節
        pos = f.tell()  # 獲取指針位置
        print(pos)      # 輸出：3（指針移到第4字節開頭）
    

  • file.truncate (size) 示例

    # 文本模式：保留前10個字節內容，其餘刪除
    with open("test.txt", "r+", encoding="utf-8") as f:
        f.truncate(10)
    
    # 二進制模式（更精準）：保留前5個字節
    with open("test.txt", "wb") as f:
        f.write(b"1234567890abcdef")  # 寫入16字節內容
        f.truncate(5)                 # 僅保留前5字節（b"12345"）
    

  • read (n) 示例

    # 文本模式：讀取前10個字符
    with open("test.txt", "r", encoding="utf-8") as f:
        content = f.read(10)
        print(content)  # 輸出文件前10個字符
    
    # 二進制模式：讀取前10個字節
    with open("test.txt", "rb") as f:
        content = f.read(10)
        print(content)  # 輸出文件前10個字節的字節串
    

  • readline () 示例

    # 讀取文件單行內容，循環可逐行讀取大文件
    with open("test.txt", "r", encoding="utf-8") as f:
        line1 = f.readline()  # 讀取第一行（包含換行符）
        print(line1.strip())  # 去除換行符後輸出
        line2 = f.readline()  # 讀取第二行
        print(line2.strip())
    

  • seek (offset) 示例

    # 簡化版seek，默認從文件開頭偏移（等價於seek(offset, 0)）
    with open("test.txt", "r", encoding="utf-8") as f:
        f.seek(0)   # 指針回到文件開頭
        content = f.read()  # 讀取全部內容
        
        f.seek(20)  # 指針移到第20字節位置
        content_part = f.read()  # 讀取20字節後的內容
        print(content_part)
    

三、sys

系統交互模塊，用於獲取 Python 解釋器信息、系統參數及控制程序退出，常用於命令行參數處理。

• 核心功能示例

  import sys
  import os
  
  # 1. 獲取Python版本信息
  print("Python版本:", sys.version)  # 輸出示例：3.9.6 (default, Jun 29 2021, ...)
  
  # 2. 獲取命令行參數（sys.argv是列表，第一個元素為腳本路徑）
  # 運行方式：python script.py arg1 arg2
  print("命令行參數列表:", sys.argv)  # 輸出示例：['script.py', 'arg1', 'arg2']
  
  # 3. 獲取模塊搜索路徑（PYTHONPATH）
  print("模塊搜索路徑:", sys.path)  # 列表形式，包含默認路徑與自定義路徑
  
  # 4. 獲取操作系統平台
  print("操作系統平台:", sys.platform)  # 輸出：win32（Windows）/ linux（Linux）/ darwin（Mac）
  
  # 5. 程序退出控制（exit(0)正常退出，非0為異常退出）
  def file_copy(source_file, dest_file):
      """文件複製函數，若目標文件存在則異常退出"""
      if os.path.isfile(dest_file):
          print("錯誤：目標文件已存在！")
          sys.exit(100)  # 非0退出碼錶示異常
      with open(source_file, "rb") as read_f, \
           open(dest_file, "wb") as write_f:
          # 分塊讀取寫入（避免大文件內存溢出）
          while chunk := read_f.read(1024):  # 每次讀取1024字節
              write_f.write(chunk)
      print("文件複製成功！")
  
  # 調用文件複製函數
  file_copy(
      source_file=r"C:/Users/xiong/xxx/模塊/z04-sys實現cp功能.py",
      dest_file=r"z04-sys實現cp功能1.py"
  )
  

• 實用擴展：進度條實現：結合 sys 與 time 模塊，實現命令行進度條，直觀展示任務進度。

  import time
  
  def show_progress(percent, width=50):
      """
      顯示進度條
      :param percent: 進度百分比（0-1）
      :param width: 進度條總長度（字符數）
      """
      # 確保進度不超過100%
      percent = min(percent, 1.0)
      # 計算已完成的字符數
      done_width = int(percent * width)
      # 構造進度條字符串（\r表示回到行首，end=""避免換行）
      progress_str = f"\r[{'#' * done_width}{' ' * (width - done_width)}] {int(percent * 100)}%"
      print(progress_str, end="", flush=True)  # flush=True強制刷新輸出
  
  # 模擬文件下載進度
  total_size = 20480  # 模擬總文件大小（20KB）
  downloaded_size = 0
  
  while downloaded_size < total_size:
      # 模擬每次下載1024字節
      downloaded_size += 1024
      # 計算進度百分比（保留2位小數）
      progress_percent = round(downloaded_size / total_size, 2)
      # 顯示進度條
      show_progress(progress_percent)
      # 模擬下載延遲
      time.sleep(0.1)
  
  # 進度完成後換行
  print("\n下載完成！")
  

四、文件與目錄操作模塊

文件與目錄操作模塊

4.1、os

os 模塊：基礎文件 / 目錄交互、提供與操作系統無關的文件路徑處理、目錄操作、系統環境獲取等功能。

1. 核心方法分類

   功能類別	方法	説明
   目錄查看	os.getcwd()	獲取當前工作目錄路徑
   	os.listdir(path)	列出指定路徑下所有文件 / 子目錄（含隱藏文件），返回列表
   目錄切換	os.chdir(path)	切換當前工作目錄（類似 shell 的 cd 命令）
   路徑屬性	os.sep	操作系統特定路徑分隔符（Windows：\，Linux：/）
   	os.pathsep	路徑分隔符（Windows：;，Linux：:）
   目錄創建	os.mkdir(path)	創建單級目錄（目錄已存在會報錯）
   	os.makedirs(path)	遞歸創建多級目錄（如a/b/c）
   目錄 / 文件刪除	os.rmdir(path)	刪除單級空目錄（非空目錄報錯）
   	os.removedirs(path)	遞歸刪除空目錄（上級目錄為空則一併刪除）
   	os.remove(path)	刪除指定文件（目錄不可用）
   文件修改	os.rename(old_path, new_path)	重命名文件 / 目錄
   狀態獲取	os.stat(path)	獲取文件 / 目錄詳細信息（大小、修改時間等）
   	os.name	查看操作系統類型（Windows：nt，Linux：posix）
   	os.environ	獲取系統環境變量（返回字典）

2. 路徑處理核心方法

   import os
   
   # 1. 規範化絕對路徑（處理../、//等符號）
   path = "c://windows\\System32\\../Temp/"
   normalized_path = os.path.normpath(path)
   print("規範化路徑:", normalized_path)  # 輸出：c:\windows\Temp
   
   # 2. 分割路徑為“目錄+文件名”（返回元組）
   full_path = "/Users/jieli/test1/a1/aa.py"
   dir_path, file_name = os.path.split(full_path)
   print("目錄路徑:", dir_path)    # 輸出：/Users/jieli/test1/a1
   print("文件名:", file_name)     # 輸出：aa.py
   
   # 3. 單獨獲取目錄或文件名
   print("單獨獲取目錄:", os.path.dirname(full_path))  # 同dir_path
   print("單獨獲取文件名:", os.path.basename(full_path))  # 同file_name
   
   # 4. 路徑有效性判斷
   print("路徑是否存在:", os.path.exists(full_path))  # True/False
   print("是否為絕對路徑:", os.path.isabs(full_path))  # True
   print("是否為文件:", os.path.isfile(full_path))    # True/False
   print("是否為目錄:", os.path.isdir(full_path))     # True/False
   
   # 5. 拼接路徑（自動適配操作系統分隔符）
   new_path = os.path.join("/Users/jieli", "test1", "new_file.py")
   print("拼接路徑:", new_path)  # 輸出：/Users/jieli/test1/new_file.py
   
   # 6. 獲取文件屬性
   if os.path.isfile(full_path):
       print("文件大小（字節）:", os.path.getsize(full_path))
       print("最後修改時間:", os.path.getmtime(full_path))  # 時間戳格式
   

4.2、shutil

基於 os 模塊封裝，支持文件複製、遞歸目錄操作、壓縮包創建與解壓。

• 核心功能示例

  import shutil
  import os
  
  # 1. 文件內容複製（需打開文件對象）
  with open("./src/a.txt", "r", encoding="utf-8") as read_f, \
       open("./desc/b.txt", "w", encoding="utf-8") as write_f:
      shutil.copyfileobj(read_f, write_f)  # 從read_f讀取內容寫入write_f
  
  # 2. 直接複製文件（無需打開文件）
  shutil.copyfile("./src/a.txt", "./desc/c.txt")  # 目標文件不存在則創建
  
  # 3. 複製文件權限/狀態（內容不變）
  # 注意：目標文件需提前存在
  shutil.copymode("./src/a.txt", "./desc/b.txt")  # 僅複製權限（讀寫執行）
  shutil.copystat("./src/a.txt", "./desc/b.txt")  # 複製權限+修改時間+訪問時間
  
  # 4. 複製文件+權限/狀態
  shutil.copy("./src/a.txt", "./desc/d.txt")  # 複製文件內容+權限
  shutil.copy2("./src/a.txt", "./desc/e.txt") # 複製文件內容+完整狀態（含修改時間）
  
  # 5. 遞歸複製目錄（支持忽略指定文件）
  # 目標目錄需不存在，ignore參數指定忽略規則（如*.pyc、*tmp）
  shutil.copytree(
      src="./src/",
      dst="./desc/src",
      ignore=shutil.ignore_patterns("*.pyc", "*tmp")
  )
  
  # 6. 遞歸刪除目錄（無論是否為空，謹慎使用！）
  shutil.rmtree("./desc/src")
  
  # 7. 遞歸移動/重命名目錄（類似mv命令）
  shutil.move("./desc/src/", "./desc/rename_src/")  # 目錄重命名為rename_src
  
  # 8. 創建壓縮包（支持zip、tar、gztar等格式）
  # base_name：壓縮包路徑+名稱，format：壓縮格式，root_dir：待壓縮目錄
  shutil.make_archive(
      base_name="./desc/archive",  # 壓縮包最終路徑：./desc/archive.tar.gz
      format="gztar",              # 壓縮格式：gzip壓縮的tar包
      root_dir="../"               # 待壓縮的根目錄
  )
  

• 實用案例：歸檔文件備份

  import os
  import shutil
  
  def backup_dir(source_dir, backup_dir, ignore_patterns=None):
      """
      備份目錄到指定路徑，生成tar壓縮包後刪除臨時目錄
      :param source_dir: 待備份源目錄
      :param backup_dir: 備份壓縮包保存目錄
      :param ignore_patterns: 忽略的文件規則（如["*.log", "wrapper.*"]）
      """
      # 1. 創建臨時備份目錄
      temp_backup_dir = os.path.join(backup_dir, "temp_backup")
      if not os.path.exists(temp_backup_dir):
          os.makedirs(temp_backup_dir)
      
      # 2. 複製源目錄到臨時目錄（忽略指定文件）
      shutil.copytree(
          src=source_dir,
          dst=temp_backup_dir,
          ignore=shutil.ignore_patterns(*ignore_patterns) if ignore_patterns else None
      )
      
      # 3. 生成壓縮包（名稱含當前時間，避免重複）
      import datetime
      current_time = datetime.datetime.now().strftime("%Y%m%d%H%M%S")
      archive_name = os.path.join(backup_dir, f"backup_{current_time}")
      shutil.make_archive(base_name=archive_name, format="tar", root_dir=temp_backup_dir)
      
      # 4. 刪除臨時目錄
      shutil.rmtree(temp_backup_dir)
      print(f"備份完成！壓縮包路徑：{archive_name}.tar")
  
  # 調用備份函數
  backup_dir(
      source_dir="/opt/drs/ccu",
      backup_dir="/tmp/ccu_backup",
      ignore_patterns=["wrapper.*", "*.log"]
  )
  

• 壓縮包解壓示例

  import tarfile
  import zipfile
  
  # 1. 解壓tar/gztar壓縮包
  with tarfile.open("./desc/archive.tar.gz", "r:gz") as tar_f:
      tar_f.extractall(path="./desc/tar_extract")  # 解壓到指定目錄
  
  # 2. 解壓zip壓縮包
  with zipfile.ZipFile("./desc/archive.zip", "r") as zip_f:
      zip_f.extractall(path="./desc/zip_extract")  # 解壓到指定目錄
  

4.3、subprocess

系統命令調用模塊，

• 核心功能：替代os.system，提供安全靈活的外部命令調用接口，支持輸出捕獲、管道通信。

• 典型場景：調用系統工具（如git、ffmpeg）、批量執行腳本。

  import subprocess
  # 執行git狀態命令並捕獲輸出
  result = subprocess.run(
      ["git", "status"],
      capture_output=True,  # 捕獲stdout/stderr
      text=True,  # 輸出轉為字符串
      cwd="/project/path"  # 指定工作目錄
  )
  print("命令輸出：", result.stdout)
  print("錯誤信息：", result.stderr)
  

五、sys

系統交互模塊，用於獲取 Python 解釋器信息、系統參數及控制程序退出，常用於命令行參數處理。

• 核心功能示例

  import sys
  import os
  
  # 1. 獲取Python版本信息
  print("Python版本:", sys.version)  # 輸出示例：3.9.6 (default, Jun 29 2021, ...)
  
  # 2. 獲取命令行參數（sys.argv是列表，第一個元素為腳本路徑）
  # 運行方式：python script.py arg1 arg2
  print("命令行參數列表:", sys.argv)  # 輸出示例：['script.py', 'arg1', 'arg2']
  
  # 3. 獲取模塊搜索路徑（PYTHONPATH）
  print("模塊搜索路徑:", sys.path)  # 列表形式，包含默認路徑與自定義路徑
  
  # 4. 獲取操作系統平台
  print("操作系統平台:", sys.platform)  # 輸出：win32（Windows）/ linux（Linux）/ darwin（Mac）
  
  # 5. 程序退出控制（exit(0)正常退出，非0為異常退出）
  def file_copy(source_file, dest_file):
      """文件複製函數，若目標文件存在則異常退出"""
      if os.path.isfile(dest_file):
          print("錯誤：目標文件已存在！")
          sys.exit(100)  # 非0退出碼錶示異常
      with open(source_file, "rb") as read_f, \
           open(dest_file, "wb") as write_f:
          # 分塊讀取寫入（避免大文件內存溢出）
          while chunk := read_f.read(1024):  # 每次讀取1024字節
              write_f.write(chunk)
      print("文件複製成功！")
  
  # 調用文件複製函數
  file_copy(
      source_file=r"C:/Users/xiong/xxx/模塊/z04-sys實現cp功能.py",
      dest_file=r"z04-sys實現cp功能1.py"
  )
  

• 實用擴展：進度條實現：結合 sys 與 time 模塊，實現命令行進度條，直觀展示任務進度。

  import time
  
  def show_progress(percent, width=50):
      """
      顯示進度條
      :param percent: 進度百分比（0-1）
      :param width: 進度條總長度（字符數）
      """
      # 確保進度不超過100%
      percent = min(percent, 1.0)
      # 計算已完成的字符數
      done_width = int(percent * width)
      # 構造進度條字符串（\r表示回到行首，end=""避免換行）
      progress_str = f"\r[{'#' * done_width}{' ' * (width - done_width)}] {int(percent * 100)}%"
      print(progress_str, end="", flush=True)  # flush=True強制刷新輸出
  
  # 模擬文件下載進度
  total_size = 20480  # 模擬總文件大小（20KB）
  downloaded_size = 0
  
  while downloaded_size < total_size:
      # 模擬每次下載1024字節
      downloaded_size += 1024
      # 計算進度百分比（保留2位小數）
      progress_percent = round(downloaded_size / total_size, 2)
      # 顯示進度條
      show_progress(progress_percent)
      # 模擬下載延遲
      time.sleep(0.1)
  
  # 進度完成後換行
  print("\n下載完成！")
  

六、數據序列化模塊

json & pickle & shelve、將內存中的數據結構（如字典、列表）轉換為可存儲 / 傳輸的格式，或反向轉換，實現數據持久化與跨平台交互。

• 序列化核心概念

  術語	説明
  序列化	內存數據結構 → 中間格式（如字符串、字節流），用於存儲 / 傳輸
  反序列化	中間格式 → 內存數據結構，用於後續數據操作

6.1、json 模塊

優點：支持多語言解析，體積小；缺點：僅支持 Python 部分基礎類型（dict、list、str、int、float、bool、None）。

1. json 與 Python 類型對應關係

   JSON 類型	Python 類型
   {}	dict
   []	list
   "string"	str
   123.56	int/float
   true/false	True/False
   null	None

2. 核心方法：dumps/loads & dump/load

   import json
   
   # 待序列化的字典數據
   data = {"name": "xiong", "age": 100, "sex": "male", "is_student": False, "hobbies": ["reading", "coding"]}
   
   # ------------------------------
   # 方法1：dumps（序列化）與loads（反序列化）→ 基於字符串
   # ------------------------------
   # 1. 字典 → JSON字符串（dumps）
   json_str = json.dumps(data, ensure_ascii=False, indent=2)  
   # ensure_ascii=False：支持中文；indent=2：格式化輸出（便於閲讀）
   print("JSON字符串:", json_str)
   print("類型:", type(json_str))  # 輸出：<class 'str'>
   
   # 2. JSON字符串 → 字典（loads）
   parsed_data = json.loads(json_str)
   print("解析後數據:", parsed_data)
   print("類型:", type(parsed_data))  # 輸出：<class 'dict'>
   print("獲取name字段:", parsed_data["name"])  # 輸出：xiong
   
   # 3. 存儲JSON字符串到文件
   with open("data.json", "w", encoding="utf-8") as f:
       f.write(json_str)
   
   # 4. 從文件讀取JSON字符串並解析
   with open("data.json", "r", encoding="utf-8") as f:
       file_json_str = f.read()
   file_parsed_data = json.loads(file_json_str)
   print("從文件解析的數據:", file_parsed_data)
   
   # ------------------------------
   # 方法2：dump（序列化）與load（反序列化）→ 直接操作文件
   # ------------------------------
   # 1. 字典 → 直接寫入文件（dump）
   with open("data_direct.json", "w", encoding="utf-8") as f:
       json.dump(data, f, ensure_ascii=False, indent=2)
   
   # 2. 直接從文件讀取並解析（load）
   with open("data_direct.json", "r", encoding="utf-8") as f:
       direct_parsed_data = json.load(f)
   print("直接從文件解析的數據:", direct_parsed_data)
   

6.2、pickle 模塊

優點：支持 Python 所有數據類型（包括自定義類、函數）；缺點：僅 Python 可解析，不支持跨語言。

• 核心方法示例

  import pickle
  
  # 1. 序列化：內存數據 → 字節流（dump/dumps）
  data = {"name": "xiong", "age": 100, "hobbies": ["reading"]}
  
  # 方法1：dumps → 生成字節流
  pickle_bytes = pickle.dumps(data)
  print("Pickle字節流:", pickle_bytes)  # 輸出二進制數據
  print("類型:", type(pickle_bytes))  # 輸出：<class 'bytes'>
  
  # 方法2：dump → 直接寫入文件（需用二進制模式"wb"）
  with open("data.pkl", "wb") as f:
      pickle.dump(data, f)
  
  # 2. 反序列化：字節流 → 內存數據（load/loads）
  # 方法1：loads → 解析字節流
  parsed_data = pickle.loads(pickle_bytes)
  print("解析字節流後的數據:", parsed_data)
  
  # 方法2：load → 直接從文件讀取（需用二進制模式"rb"）
  with open("data.pkl", "rb") as f:
      file_parsed_data = pickle.load(f)
  print("從Pickle文件解析的數據:", file_parsed_data)
  

6.3、shelve 模塊

基於 pickle 實現，以鍵值對形式存儲數據，操作類似字典，適合小規模數據持久化。

• 核心功能示例

  import shelve
  
  # 1. 打開/創建shelve文件（會生成3個文件：.bak、.dat、.dir）
  # writeback=True：開啓寫回模式（修改嵌套數據需開啓）
  db = shelve.open("user_db", writeback=True)
  
  # 2. 存儲數據（類似字典賦值）
  db["xiong"] = {"username": "xiong", "pwd": "123", "age": 100, "sex": "male"}
  db["li"] = {"username": "li", "pwd": "456", "age": 25}
  
  # 3. 讀取數據（類似字典取值）
  print("獲取xiong的信息:", db["xiong"])  # 輸出：{"username": "xiong", ...}
  print("獲取li的密碼:", db["li"]["pwd"])  # 輸出：456
  
  # 4. 修改數據（需開啓writeback=True）
  db["xiong"]["pwd"] = "654321"  # 修改密碼
  print("修改後xiong的信息:", db["xiong"])  # 輸出：{"pwd": "654321", ...}
  
  # 5. 刪除數據（類似字典del）
  del db["li"]
  print("刪除li後，是否存在:", "li" in db)  # 輸出：False
  
  # 6. 關閉shelve文件（必須關閉，否則可能數據丟失）
  db.close()
  
  # 7. 重新打開驗證數據
  db_new = shelve.open("user_db")
  print("重新打開後xiong的信息:", db_new["xiong"])
  db_new.close()
  

七、configparser

用於讀取、修改 ini 格式配置文件，適用於項目參數配置（如數據庫連接信息、程序設置）。

• ini 配置文件格式

  # jdbc.cfg（示例配置文件）
  [conf1]  # section（配置段）
  user = "xiong"  # option（配置項，鍵值對）
  pwd = 123
  version = 1.0
  
  [conf2]
  host = 127.0.0.1
  port = 3306
  database = test_db
  

• 核心功能示例

  import configparser
  
  # 1. 創建ConfigParser對象並讀取配置文件
  conf = configparser.ConfigParser()
  # 讀取ini文件（支持多文件傳入，如conf.read(["jdbc.cfg", "other.cfg"])）
  conf.read("jdbc.cfg", encoding="utf-8")
  
  # 2. 查看配置信息
  # （1）查看所有section（返回列表）
  print("所有配置段:", conf.sections())  # 輸出：['conf1', 'conf2']
  
  # （2）查看指定section的所有option（返回列表）
  print("conf1的所有配置項:", conf.options("conf1"))  # 輸出：['user', 'pwd', 'version']
  
  # （3）查看指定section的所有鍵值對（返回列表，元素為元組）
  conf1_items = conf.items("conf1")
  print("conf1的鍵值對:", conf1_items)  # 輸出：[('user', '"xiong"'), ('pwd', '123'), ('version', '1.0')]
  
  # （4）獲取指定option的值（默認返回字符串，支持類型轉換）
  # 方式1：直接獲取（字符串類型）
  user = conf.get("conf1", "user")
  print("user（字符串）:", user, type(user))  # 輸出："xiong" <class 'str'>
  
  # 方式2：按類型獲取（int/float/boolean）
  pwd = conf.getint("conf1", "pwd")  # 轉換為int
  version = conf.getfloat("conf1", "version")  # 轉換為float
  print("pwd（int）:", pwd, type(pwd))  # 輸出：123 <class 'int'>
  print("version（float）:", version, type(version))  # 輸出：1.0 <class 'float'>
  
  # 3. 修改配置信息（新增、修改、刪除）
  # （1）新增section（若已存在會報錯）
  if not conf.has_section("conf3"):  # 判斷section是否存在
      conf.add_section("conf3")
  
  # （2）新增/修改option（section不存在會報錯）
  conf.set("conf3", "user", "new_user")  # 新增option
  conf.set("conf1", "pwd", "456")        # 修改已有option（字符串形式賦值）
  
  # （3）刪除option
  if conf.has_option("conf2", "database"):  # 判斷option是否存在
      conf.remove_option("conf2", "database")
  
  # （4）刪除section
  if conf.has_section("conf2"):
      conf.remove_section("conf2")
  
  # 4. 保存修改到配置文件（必須執行，否則修改僅在內存中）
  with open("jdbc.cfg", "w", encoding="utf-8") as f:
      conf.write(f)
  
  # 5. 新建ini配置文件示例
  new_conf = configparser.ConfigParser()
  # 直接賦值創建section與option
  new_conf["default"] = {
      "user": "admin",
      "pwd": "admin123",
      "timeout": 30
  }
  # 分步創建section與option
  new_conf["test"] = {}
  new_conf["test"]["host"] = "192.168.1.1"
  new_conf["test"]["port"] = "8080"
  
  # 保存到新文件
  with open("new_config.ini", "w", encoding="utf-8") as f:
      new_conf.write(f)
  

八、hashlib & hmac

用於生成數據的哈希值，實現密碼加密存儲、文件完整性校驗等安全需求。

8.1 hashlib 模塊

支持 MD5、SHA1、SHA256 等算法，哈希值具有不可逆性（無法從哈希值反推原始數據）和唯一性（原始數據相同則哈希值必相同）。

• 核心功能示例

  import hashlib
  
  # 1. 創建哈希對象（選擇算法：md5/sha256/sha512等）
  md5_obj = hashlib.md5()    # MD5算法（哈希值32位十六進制）
  sha256_obj = hashlib.sha256()  # SHA256算法（64位）
  sha512_obj = hashlib.sha512()  # SHA512算法（128位）
  
  # 2. 更新哈希數據（需傳入bytes類型，字符串需用encode()轉換）
  # 方式1：單次更新
  md5_obj.update("hello world".encode("utf-8"))
  
  # 方式2：多次更新（結果與單次拼接相同，適合大文件分塊計算）
  sha256_obj.update("hello ".encode("utf-8"))
  sha256_obj.update("world".encode("utf-8"))  # 等同於更新"hello world"
  
  # 3. 獲取哈希值（兩種格式）
  # （1）十六進制字符串（常用，便於存儲和傳輸）
  md5_hex = md5_obj.hexdigest()
  sha256_hex = sha256_obj.hexdigest()
  sha512_hex = sha512_obj.hexdigest()
  
  print("MD5哈希值（32位）:", md5_hex)
  print("SHA256哈希值（64位）:", sha256_hex)
  print("SHA512哈希值（128位）:", sha512_hex)
  
  # （2）原始字節流（較少用）
  md5_bytes = md5_obj.digest()
  print("MD5原始字節流:", md5_bytes)
  
  # 4. 實用場景：文件完整性校驗（計算文件哈希值）
  def calculate_file_hash(file_path, algorithm="md5"):
      """
      計算文件的哈希值
      :param file_path: 文件路徑
      :param algorithm: 哈希算法（md5/sha256）
      :return: 十六進制哈希值
      """
      hash_obj = hashlib.new(algorithm)
      # 分塊讀取大文件（避免內存溢出）
      with open(file_path, "rb") as f:
          while chunk := f.read(4096):  # 每次讀取4KB
              hash_obj.update(chunk)
      return hash_obj.hexdigest()
  
  # 計算文件哈希值並校驗
  file_path = "test.txt"
  file_md5 = calculate_file_hash(file_path, "md5")
  print(f"{file_path}的MD5校驗值:", file_md5)
  # 校驗邏輯：對比計算出的哈希值與官方提供的校驗值是否一致
  

8.2 hmac

在 hashlib 基礎上增加 “鹽值”（secret key），相同原始數據若鹽值不同，哈希值也不同，安全性更高（防止彩虹表破解）。

• 核心功能示例

  import hmac
  
  # 1. 創建HMAC對象（需指定鹽值和哈希算法，鹽值需為bytes類型）
  # 方式1：默認使用MD5算法
  hmac_obj1 = hmac.new(
      key="my_secret_key".encode("utf-8"),  # 鹽值（自定義，需保密）
      msg="user_password".encode("utf-8"),  # 待加密數據（如用户密碼）
      digestmod="md5"  # 可選，指定哈希算法
  )
  
  # 方式2：分步更新數據（支持多次更新）
  hmac_obj2 = hmac.new(key="my_secret_key".encode("utf-8"), digestmod="sha256")
  hmac_obj2.update("user_".encode("utf-8"))
  hmac_obj2.update("password".encode("utf-8"))  # 等同於更新"user_password"
  
  # 2. 獲取HMAC哈希值（十六進制字符串）
  hmac_hex1 = hmac_obj1.hexdigest()
  hmac_hex2 = hmac_obj2.hexdigest()
  
  print("HMAC-MD5哈希值:", hmac_hex1)
  print("HMAC-SHA256哈希值:", hmac_hex2)
  
  # 3. 關鍵特性：鹽值不同則哈希值不同
  hmac_obj3 = hmac.new(key="other_secret_key".encode("utf-8"), msg="user_password".encode("utf-8"))
  print("不同鹽值的HMAC-MD5:", hmac_obj3.hexdigest())  # 與hmac_hex1不同
  

九、struct

二進制數據處理模塊，用於 Python 數據與二進制字節流的轉換，適用於網絡傳輸、二進制文件解析等場景（如將 int 轉換為 4 字節二進制）。

• 核心函數與格式符

  • 核心函數

    函數	功能
    struct.pack(fmt, v1, v2, ...)	按格式fmt將數據打包為二進制字節流
    struct.unpack(fmt, bytes)	按格式fmt解析二進制字節流，返回元組
    struct.calcsize(fmt)	計算格式fmt對應的字節長度

  • 常用格式符

    格式符	C 語言類型	Python 類型	字節數
    i	int	int	4
    I	unsigned int	int	4
    f	float	float	4
    d	double	float	8
    s	char[]	str	自定義（如5s表示 5 字節字符串）

• 核心功能示例

  import struct
  
  # 1. 打包數據（int → 4字節二進制）
  # 格式符"i"表示打包為int類型（4字節）
  packed_int = struct.pack("i", 123)
  print("int(123)打包後:", packed_int)  # 輸出：b'\x7b\x00\x00\x00'（小端序）
  print("打包後字節長度:", len(packed_int))  # 輸出：4
  print("通過calcsize計算長度:", struct.calcsize("i"))  # 輸出：4
  
  # 2. 解析數據（二進制 → int）
  unpacked_int = struct.unpack("i", packed_int)
  print("解析後的數據:", unpacked_int)  # 輸出：(123,)（返回元組，需取第一個元素）
  print("解析後int值:", unpacked_int[0])  # 輸出：123
  
  # 3. 多數據打包與解析（int + float）
  # 格式符"if"表示：int（4字節） + float（4字節）
  packed_data = struct.pack("if", 456, 3.14)
  print("多數據打包後:", packed_data)  # 二進制字節流
  print("多數據打包長度:", len(packed_data))  # 輸出：8（4+4）
  
  unpacked_data = struct.unpack("if", packed_data)
  print("多數據解析後:", unpacked_data)  # 輸出：(456, 3.140000104904175)
  print("解析後的int:", unpacked_data[0])  # 輸出：456
  print("解析後的float:", unpacked_data[1])  # 輸出：3.140000104904175
  
  # 4. 字符串打包（需指定長度，如"5s"表示5字節字符串）
  packed_str = struct.pack("5s", "hello".encode("utf-8"))
  print("字符串打包後:", packed_str)  # 輸出：b'hello'
  unpacked_str = struct.unpack("5s", packed_str)
  print("字符串解析後:", unpacked_str[0].decode("utf-8"))  # 輸出：hello