【Python】Python自动化运维基础

引言：从手工到智能——运维的演进与DevOps的兴起

信息技术的飞速发展，使得企业对IT系统的依赖性空前提高。系统的规模、复杂度以及变更频率的激增，给传统的IT运维带来了巨大的挑战。运维不再仅仅是“维持系统运行”，而是要确保业务的连续性、高效性、安全性与成本可控性。在这样的背景下，自动化运维应运而生，并逐渐成为现代IT运维的核心。而DevOps作为一种文化、一套实践方法和一系列工具的集合，进一步推动了开发（Development）与运维（Operations）的融合，旨在提升软件交付的速度与质量。

• 传统运维的痛点与挑战

  • 重复性劳动：大量的日常任务，如服务器部署、配置更新、应用发布、日志检查、备份恢复等，依赖人工操作，效率低下且易出错。
  • 响应速度慢：故障发生时，定位问题、协调资源、执行恢复操作的过程漫长，对业务影响大。
  • 变更风险高：手动变更缺乏标准化流程和有效验证，容易引入新的问题，导致“变更噩梦”。
  • 知识孤岛：运维经验和技能高度依赖资深工程师，难以传承和规模化。
  • 成本压力：随着系统规模扩大，人力成本、资源成本持续攀升。
  • 开发与运维的壁垒（“筒仓效应”）：开发团队关注快速交付新功能，运维团队关注系统稳定，目标不一致导致沟通不畅、协作困难。

• 自动化运维的价值与目标

  • 提升效率：将重复性、标准化的任务自动化，释放人力，让人专注于更有价值的工作。
  • 降低错误：程序化的执行过程减少了人为失误的可能性。
  • 加速交付：自动化部署、测试、发布流程，缩短软件上线周期。
  • 增强一致性：确保所有环境（开发、测试、生产）的配置和部署方式一致。
  • 提高可靠性与可用性：通过自动化监控、故障自愈等手段，提升系统稳定性。
  • 标准化与规范化：将运维操作流程化、脚本化，便于管理和审计。
  • 成本优化：提高资源利用率，减少不必要的人力投入。
  • 目标：实现“无人值守”或“少人值守”的运维模式，让系统具备自服务、自监控、自修复的能力。

• DevOps理念：文化、实践与工具

  • 文化 (Culture)：强调沟通、协作、共享责任和持续学习。打破开发与运维之间的壁垒，建立信任和共同目标。
    • Calm (Collaboration, Communication, Courage - 有时也指Culture)
    • Automation
    • Lean (精益思想，消除浪费)
    • Measurement (度量一切可度量的事物)
    • Sharing (知识共享、责任共担)
  • 实践 (Practices)：
    • 持续集成 (Continuous Integration, CI)：开发人员频繁地将其代码集成到主干，每次集成都通过自动化构建和测试来验证。
    • 持续交付 (Continuous Delivery, CD)：在CI的基础上，将构建产物自动化地部署到类生产环境，确保可以随时将软件部署到生产环境。
    • 持续部署 (Continuous Deployment, CD)：将通过所有自动化测试的构建产物自动部署到生产环境。
    • 基础设施即代码 (Infrastructure as Code, IaC)：使用代码来管理和配置基础设施（服务器、网络、存储等）。
    • 配置管理 (Configuration Management)：自动化地管理和维护系统配置的一致性。
    • 监控与日志 (Monitoring and Logging)：全面、实时地监控系统和应用状态，收集和分析日志。
    • 微服务架构 (Microservices)：将大型单体应用拆分为小型、独立部署的服务。
  • 工具 (Tools)：支持DevOps实践的各种工具链，如版本控制（Git）、CI/CD服务器（Jenkins, GitLab CI）、配置管理（Ansible, SaltStack）、容器化（Docker, Kubernetes）、监控（Prometheus, Zabbix）、日志（ELK Stack）等。

• Python在自动化运维与DevOps中的核心地位

  • 简洁易学，开发效率高：Python语法清晰，上手快，能够快速编写出可用的运维脚本和工具。
  • 强大的标准库和丰富的第三方库：
    • 操作系统交互：os, subprocess, shutil, platform
    • 网络编程：socket, requests, paramiko, ftplib
    • 数据处理：json, xml.etree.ElementTree, csv, yaml, re (正则表达式)
    • 系统监控：psutil
    • Web框架：Flask, Django (可用于构建运维平台、API服务)
    • 配置管理与部署：虽然有Ansible等专用工具，但Python可以作为其核心模块语言，或用于编写自定义模块，甚至直接通过Paramiko等库实现轻量级部署。
    • 与云平台SDK集成：boto3 (AWS), azure-sdk-for-python, google-cloud-python
    • 测试框架：unittest, pytest
    • 数据库连接：各种数据库的Python驱动
  • 跨平台性：一份Python脚本通常可以稍作修改或无需修改就在Windows, Linux, macOS等多种操作系统上运行。
  • 胶水语言特性：能够轻松地将不同语言编写的组件或系统服务粘合在一起。
  • 社区活跃，资源丰富：遇到问题容易找到解决方案，有大量的开源项目可供借鉴。
  • 可扩展性：可以方便地调用C/C++等编写的底层库，满足性能要求。

Python凭借其独特的优势，成为了自动化运维工程师和DevOps工程师手中不可或缺的利器。无论是编写简单的日常管理脚本，还是构建复杂的自动化运维平台，Python都能提供强大的支持。

7.1 Python自动化运维基础

本节将重点介绍Python中用于实现自动化运维任务的核心标准库和常用第三方库，并通过代码示例展示它们的基本用法。这些库是构建更复杂自动化系统的基石。

7.1.1 操作系统交互与管理

与底层操作系统进行交互是自动化运维最基本的需求之一，包括文件系统操作、进程管理、环境变量配置等。Python的os、subprocess、shutil和platform等模块为此提供了强大的支持。

A. os 模块：与操作系统功能的接口

os 模块提供了非常丰富的与操作系统进行交互的功能，它是进行文件系统操作、路径管理、进程信息获取等任务的基础。

• 文件和目录操作
  • os.getcwd(): 获取当前工作目录。
  • os.chdir(path): 改变当前工作目录。
  • os.listdir(path='.'): 列出指定目录下的所有文件和子目录名。
  • os.mkdir(path, mode=0o777): 创建单个目录。如果目录已存在，会抛出 FileExistsError。
  • os.makedirs(path, mode=0o777, exist_ok=False): 递归创建目录。如果 exist_ok 为 True，则目录已存在时不会报错。
  • os.remove(path): 删除一个文件。
  • os.rmdir(path): 删除一个空目录。
  • os.removedirs(path): 递归删除空目录。
  • os.rename(src, dst): 重命名文件或目录。
  • os.stat(path): 获取文件或目录的元数据（如大小、修改时间、权限等）。
    • st_mode: 文件类型和权限。
    • st_size: 文件大小（字节）。
    • st_atime: 最后访问时间（时间戳）。
    • st_mtime: 最后修改时间（时间戳）。
    • st_ctime: 创建时间（Windows）或元数据最后修改时间（Unix）。
  • os.path 子模块：包含大量路径操作函数。
    • os.path.abspath(path): 返回路径的绝对路径。
    • os.path.basename(path): 返回路径中的文件名部分。
    • os.path.dirname(path): 返回路径中的目录部分。
    • os.path.join(path, *paths): 智能地连接一个或多个路径部分。强烈推荐使用此函数来构造路径，因为它会自动处理不同操作系统下的路径分隔符。
    • os.path.exists(path): 判断路径是否存在。
    • os.path.isfile(path): 判断路径是否为一个文件。
    • os.path.isdir(path): 判断路径是否为一个目录。
    • os.path.getsize(path): 返回文件大小（字节）。
    • os.path.getmtime(path): 返回文件最后修改时间（时间戳）。

import os
import time # 用于处理时间戳

# 获取和改变当前工作目录
current_dir = os.getcwd()
print(f"当前工作目录: {
     current_dir}") # 中文解释: 打印当前的Python脚本的工作目录路径。

# 创建一个新目录 (为了演示，先检查是否存在)
new_dir_path = os.path.join(current_dir, "my_test_directory") # 中文解释: 使用 os.path.join 构造新目录的完整路径，确保跨平台兼容性。
if not os.path.exists(new_dir_path):
    os.mkdir(new_dir_path)
    print(f"目录 '{
     new_dir_path}' 已创建。") # 中文解释: 如果目录不存在，则创建它并打印提示。
else:
    print(f"目录 '{
     new_dir_path}' 已存在。") # 中文解释: 如果目录已存在，则打印提示。

# 在新目录中创建文件
file_path = os.path.join(new_dir_path, "test_file.txt")
with open(file_path, "w", encoding="utf-8") as f:
    f.write("这是Python自动化运维测试文件。\nHello from os module!")
    # 中文解释: 在新创建的目录中，创建一个名为 test_file.txt 的文件，并写入一些文本内容。
    # 使用 "w" 模式表示写入，如果文件不存在则创建，如果存在则覆盖。
    # encoding="utf-8" 确保中文字符正确写入。
print(f"文件 '{
     file_path}' 已创建并写入内容。")

# 列出新目录的内容
print(f"目录 '{
     new_dir_path}' 下的内容: {
     os.listdir(new_dir_path)}") # 中文解释: 列出 my_test_directory 目录下的所有文件和子目录名。

# 获取文件信息
if os.path.exists(file_path):
    file_stat = os.stat(file_path)
    print(f"文件 '{
     os.path.basename(file_path)}' 的信息:") # 中文解释: 获取并打印文件名部分。
    print(f"  大小: {
     file_stat.st_size} 字节") # 中文解释: 打印文件大小。
    print(f"  最后修改时间: {
     time.ctime(file_stat.st_mtime)}") # 中文解释: 将时间戳转换为可读的日期时间格式并打印。
    print(f"  是否是文件: {
     os.path.isfile(file_path)}") # 中文解释: 检查路径是否指向一个文件。
    print(f"  是否是目录: {
     os.path.isdir(file_path)}")   # 中文解释: 检查路径是否指向一个目录。

# 重命名文件
renamed_file_path = os.path.join(new_dir_path, "renamed_test_file.txt")
if os.path.exists(file_path) and not os.path.exists(renamed_file_path):
    os.rename(file_path, renamed_file_path)
    print(f"文件已从 '{
     file_path}' 重命名为 '{
     renamed_file_path}'。") # 中文解释: 如果原文件存在且新文件名不存在，则重命名。
elif not os.path.exists(file_path) and os.path.exists(renamed_file_path):
    print(f"文件 '{
     os.path.basename(renamed_file_path)}' 已被重命名。")
else:
    print(f"重命名文件失败或文件状态异常。")


# 清理：删除文件和目录 (确保按正确顺序删除，先文件后目录)
if os.path.exists(renamed_file_path):
    os.remove(renamed_file_path)
    print(f"文件 '{
     renamed_file_path}' 已删除。") # 中文解释: 删除重命名后的文件。
elif os.path.exists(file_path): # 如果重命名失败，尝试删除原文件
    os.remove(file_path)
    print(f"文件 '{
     file_path}' 已删除。")


if os.path.exists(new_dir_path):
    if not os.listdir(new_dir_path): # 确保目录为空才能用 rmdir
        os.rmdir(new_dir_path)
        print(f"目录 '{
     new_dir_path}' 已删除。") # 中文解释: 删除之前创建的空目录。
    else:
        print(f"目录 '{
     new_dir_path}' 非空，无法使用 rmdir 删除。")

中文解释 (针对整个代码块)：
此代码块演示了os模块在文件和目录操作方面的基本功能。

1. os.getcwd(): 获取当前工作目录的路径。
2. os.path.join(): 安全地构造跨平台的路径字符串。这里用于构建new_dir_path和file_path。
3. os.path.exists(): 检查文件或目录是否存在，用于条件判断。
4. os.mkdir(): 创建一个单层目录。
5. open() 与 with 语句: Python推荐的文件操作方式，自动管理文件的打开和关闭。这里用于创建并写入一个测试文件。
6. os.listdir(): 列出指定目录下的内容。
7. os.stat(): 获取文件的详细元数据，如大小（st_size）和最后修改时间（st_mtime）。time.ctime()用于将时间戳转换为人类可读格式。
8. os.path.isfile() 和 os.path.isdir(): 判断路径类型。
9. os.rename(): 重命名文件。
10. os.remove(): 删除文件。
11. os.rmdir(): 删除空目录。在删除前检查目录是否为空是良好实践。

• 进程管理
  • os.getpid(): 获取当前进程的ID。
  • os.getppid(): 获取当前进程的父进程ID (Unix-like)。
  • os.kill(pid, sig): 向指定ID的进程发送信号 (Unix-like)。例如，signal.SIGTERM (终止), signal.SIGKILL (强制杀死), signal.SIGHUP (挂起后重启)。
  • os.system(command): 执行一个shell命令。这是一个简单的方法，但有安全风险（如命令注入），并且对命令的输出和返回码控制较弱。通常推荐使用 subprocess 模块替代。
  • os.environ: 一个表示环境变量的字典。可以读取和修改环境变量。
    • os.environ.get('VAR_NAME', 'default_value'): 获取环境变量，可指定默认值。
    • os.environ['VAR_NAME'] = 'new_value': 设置环境变量（仅对当前进程及其子进程有效）。

import os
import signal # 导入信号常量

# 环境变量
path_variable = os.environ.get('PATH')
print(f"\n当前用户的PATH环境变量的一部分: {
     path_variable[:100]}...") # 中文解释: 获取PATH环境变量，并打印其前100个字符。

# 设置一个临时环境变量 (仅对当前进程和它派生的子进程有效)
os.environ['MY_CUSTOM_VAR'] = 'HelloFromPythonOSModule'
custom_var = os.environ.get('MY_CUSTOM_VAR')
print(f"自定义环境变量 MY_CUSTOM_VAR: {
     custom_var}") # 中文解释: 设置并获取一个自定义的环境变量。

# 进程ID
pid = os.getpid()
print(f"当前Python脚本的进程ID (PID): {
     pid}") # 中文解释: 获取并打印当前运行此脚本的Python进程的ID。

# os.system() - 简单执行命令 (注意其局限性和风险)
# 在Linux/macOS上:
# return_code = os.system("echo '你好, 来自 os.system'") # 中文解释: 执行一个简单的shell命令 "echo..."。
# 在Windows上:
return_code = os.system("echo Hello from os.system") # 中文解释: 执行一个简单的shell命令 "echo..."。
print(f"os.system 的返回码: {
     return_code}") # 中文解释: 打印 os.system 命令执行后的返回码。0通常表示成功。

# 关于 os.kill() 的说明：
# os.kill(target_pid, signal.SIGTERM)
# 中文解释: 这行代码如果取消注释并给定一个有效的 target_pid，它会向该进程发送 SIGTERM 信号，
# 通常用于请求进程正常终止。在自动化脚本中，这可以用来控制其他进程的生命周期。
# 使用时需谨慎，确保你知道目标PID是什么，以及发送信号的后果。
# 在Windows上，os.kill() 的行为和信号有所不同，通常用 signal.CTRL_C_EVENT 或 signal.CTRL_BREAK_EVENT
# 或者 Taskkill 命令 (通过 subprocess 执行)。

中文解释 (针对整个代码块):
此代码块演示了os模块在环境变量和进程信息方面的功能。

1. os.environ.get(): 安全地获取环境变量的值。
2. os.environ['VAR_NAME'] = 'value': 设置环境变量。注意这只影响当前进程及其子进程。
3. os.getpid(): 获取当前Python脚本的进程ID。
4. os.system(): 执行一个shell命令。示例中执行了echo命令。需要注意，os.system()会将命令传递给系统的shell解释器，因此如果命令中包含用户输入，可能存在命令注入的风险。它的返回值是依赖于系统的，通常在Unix-like系统上是命令的退出状态码（如果命令正常执行），在Windows上是shell的退出状态码。对于更复杂的命令执行和交互，subprocess模块是更好的选择。
5. 注释中提到了os.kill()，这是Unix-like系统下向进程发送信号的函数，常用于进程管理，例如优雅地终止或强制结束进程。

B. subprocess 模块：管理子进程

subprocess 模块是Python中推荐的创建和管理子进程的标准方式，它比 os.system() 提供了更强大和灵活的控制能力，包括：

• 获取命令的输出 (stdout, stderr)。
• 获取命令的返回码。
• 向命令传递输入 (stdin)。
• 设置超时。
• 更安全，避免shell注入（当 shell=False 时）。

核心函数：

• subprocess.run(args, *, stdin=None, input=None, stdout=None, stderr=None, capture_output=False, shell=False, cwd=None, timeout=None, check=False, encoding=None, errors=None, text=None, env=None, universal_newlines=None, **other_popen_kwargs):

  • Python 3.5+ 推荐的运行子进程的主要接口。它会等待命令完成。
  • args: 命令及其参数，可以是列表（推荐，当shell=False）或字符串（当shell=True）。
  • capture_output=True: 捕获 stdout 和 stderr。结果在返回的 CompletedProcess 对象的 stdout 和 stderr 属性中。
  • text=True (或 universal_newlines=True): 以文本模式打开 stdout 和 stderr (自动解码)。
  • check=True: 如果命令返回非零退出码（表示错误），则抛出 CalledProcessError 异常。
  • shell=True: 通过系统的shell执行命令。一般不推荐，除非明确需要shell特性（如管道、通配符且无法用Python代码实现）并且命令是可信的。否则有安全风险。
  • timeout: 命令执行的超时时间（秒）。超时会抛出 TimeoutExpired。
  • 返回一个 CompletedProcess 对象，包含 args, returncode, stdout, stderr 属性。

• subprocess.Popen(args, ...): 更底层的接口，用于创建并管理子进程，不等待命令完成，可以进行更复杂的交互（如异步读写）。subprocess.run() 内部就是基于 Popen 实现的。

import subprocess

# 示例1: 运行简单命令并捕获输出
# 在Linux/macOS上:
# cmd_list = ["ls", "-lha"]
# 在Windows上:
cmd_list = ["cmd", "/c", "dir"] # 中文解释: 定义要在Windows的cmd shell中执行的命令列表。"/c" 表示执行完命令后关闭cmd。
# cmd_list = ["powershell", "-Command", "Get-ChildItem"] # 或者使用PowerShell

print(f"\n运行命令: {
     ' '.join(cmd_list)}")
try:
    # capture_output=True 用于捕获标准输出和标准错误
    # text=True (或 universal_newlines=True) 使输出为字符串而非字节串
    # check=True 如果返回码非0，则抛出 CalledProcessError
    result = subprocess.run(cmd_list, capture_output=True, text=True, check=True, encoding='gbk' if os.name == 'nt' else 'utf-8') # Windows cmd可能用gbk
    # 中文解释: 执行命令。
    # cmd_list: 命令和参数的列表。
    # capture_output=True: 捕获命令的标准输出和标准错误。
    # text=True: 将捕获到的输出解码为文本字符串。
    # check=True: 如果命令的返回码非零（表示执行出错），则会抛出 CalledProcessError 异常。
    # encoding: 指定解码时使用的字符集，Windows cmd通常是'gbk'，Linux/macOS通常是'utf-8'。
    
    print("命令执行成功。")
    print(f"返回码: {
     result.returncode}") # 中文解释: 打印命令的返回码，0 通常表示成功。
    print("标准输出 (stdout):")
    print(result.stdout[:500] + "..." if len(result.stdout) > 500 else result.stdout) # 中文解释: 打印捕获到的标准输出内容（如果太长则截断）。
    if result.stderr:
        print("标准错误 (stderr):")
        print(result.stderr) # 中文解释: 如果有标准错误输出，则打印。

except FileNotFoundError:
    print(f"错误: 命令 '{
     cmd_list[0]}' 未找到。请确保它在系统的PATH中。") # 中文解释: 如果命令本身找不到（例如输错了 "ls"），会捕获此错误。
except subprocess.CalledProcessError as e:
    print(f"命令执行失败，返回码: {
     e.returncode}") # 中文解释: 如果命令执行了但返回了错误码（因为 check=True），会捕获此错误。
    print(f"命令: {
     e.cmd}")
    print(f"标准输出: {
     e.stdout}")
    print(f"标准错误: {
     e.stderr}")
except subprocess.TimeoutExpired:
    print(f"命令执行超时。") # 中文解释: 如果设置了timeout参数且命令执行超时，会捕获此错误。
except Exception as e:
    print(f"执行命令时发生未知错误: {
     e}") # 中文解释: 捕获其他可能的异常。


# 示例2: 使用 shell=True (谨慎使用)
# 注意：当使用 shell=True 时，命令可以是一个字符串，并且可以使用shell特性如管道。
# 但这可能带来安全风险，如命令注入。
# if os.name != 'nt': # Linux/macOS
#     shell_cmd = "echo '当前用户:' $USER && ls -l | wc -l"
# else: # Windows
#     shell_cmd = "echo 当前用户: %USERNAME% && dir /b | find /c /v \"\"" 
# 
# print(f"\n运行shell命令: {shell_cmd}")
# try:
#     # 在Windows的cmd中，可能需要 chcp 65001 来支持UTF-8，或在Python中正确处理gbk
#     result_shell = subprocess.run(shell_cmd, shell=True, capture_output=True, text=True, check=True, encoding='gbk' if os.name == 'nt' else 'utf-8')
#     # 中文解释: 使用 shell=True 执行一个包含shell特性的命令字符串。
#     # shell=True: 意味着命令将通过系统的shell（如bash或cmd.exe）来解释和执行。
#     # 这允许使用管道符 `|`、环境变量展开 `$USER` 或 `%USERNAME%` 等shell功能。
#     # 同样，capture_output, text, check, encoding 的作用与前例相同。
#     print("Shell命令执行成功。")
#     print(f"Stdout:\n{result_shell.stdout.strip()}") # 中文解释: 打印shell命令的标准输出，并去除首尾空白。
# except subprocess.CalledProcessError as e:
#     print(f"Shell命令执行失败，返回码: {e.returncode}")
#     print(f"Stderr:\n{e.stderr}")
# except Exception as e:
#     print(f"执行Shell命令时发生未知错误: {e}")


# 示例3: 与子进程交互 (Popen) - 例如，给一个需要输入的命令提供输入
if os.name != 'nt': # 这个例子在Unix-like系统上更常见
    print("\n与子进程交互 (Popen示例 - Unix-like):")
    process = None
    try:
        # 假设有一个脚本 `interactive_script.py` 内容如下:
        # #!/usr/bin/env python
        # name = input("请输入你的名字: ")
        # print(f"你好, {name}!")
        #
        # # 为了能独立运行此示例，我们模拟一个简单的命令
        # # cmd_interactive = ["python", "interactive_script.py"]
        cmd_interactive = ["grep", "你好"] # grep会从stdin读取输入
        
        process = subprocess.Popen(
            cmd_interactive,
            stdin=subprocess.PIPE, # 中文解释: 打开标准输入管道，以便我们可以向子进程写入数据。
            stdout=subprocess.PIPE, # 中文解释: 打开标准输出管道，以便我们可以读取子进程的输出。
            stderr=subprocess.PIPE, # 中文解释: 打开标准错误管道。
            text=True, # 中文解释: 使用文本模式进行I/O。
            encoding='utf-8' # 中文解释: 指定编码。
        )
        
        # 向子进程的stdin发送数据，并关闭stdin以表示输入结束
        # communicate() 会发送inputdata给stdin，然后读取所有stdout和stderr直到EOF，并等待进程结束。
        input_data = "第一行包含 你好\n第二行没有\n你好，这是第三行"
        stdout_data, stderr_data = process.communicate(input=input_data, timeout=5)
        # 中文解释: 向子进程的标准输入发送 input_data。
        # communicate() 方法会处理与子进程的交互：发送数据到stdin，然后读取stdout和stderr直到子进程结束。
        # 它返回一个包含 (stdout_data, stderr_data) 的元组。
        # timeout=5 设置了5秒的超时。
        
        print(f"交互式命令返回码: {
     process.returncode}") # 中文解释: 获取子进程的最终返回码。
        if stdout_data:
            print(f"交互式命令标准输出:\n{
     stdout_data.strip()}")
        if stderr_data:
            print(f"交互式命令标准错误:\n{
     stderr_data.strip()}")
            
    except subprocess.TimeoutExpired:
        if process: process.kill() # 中文解释: 如果 communicate() 超时，子进程可能仍在运行，需要手动杀死。
        stdout_data, stderr_data = process.communicate() if process else (None, None) # 清理管道
        print("与子进程交互超时。进程已被终止。")
        if stdout_data: print(f"超时前的Stdout:\n{
     stdout_data.strip()}")
        if stderr_data: print(f"超时前的Stderr:\n{
     stderr_data.strip()}")
    except FileNotFoundError:
        print(f"错误: 命令 '{
     cmd_interactive[0] if cmd_interactive else ''}' 未找到。")
    except Exception as e:
        print(f"与子进程交互时发生错误: {
     e}")
else:
    print("\nsubprocess.Popen 交互示例通常在Unix-like系统上更有代表性，Windows下的控制台交互可能有所不同。")

中文解释 (针对整个代码块):
此代码块深入演示了subprocess模块的用法。

1. 示例1 (subprocess.run):

   • 展示了如何使用推荐的subprocess.run()函数执行外部命令（Windows的dir或类Unix的ls -lha）。
   • cmd_list: 将命令及其参数作为列表传递，这是shell=False（默认且推荐）时的标准做法，可以避免命令注入风险。
   • capture_output=True: 捕获命令的标准输出和标准错误流。
   • text=True: 将捕获的字节流自动解码为字符串。
   • check=True: 如果命令执行后返回非零退出码，则会自动抛出CalledProcessError异常，简化了错误处理。
   • encoding: 指定解码输出时使用的字符编码，对Windows下的cmd（可能为gbk）和类Unix系统（通常为utf-8）做了区分。
   • 使用try...except块来处理可能发生的各种异常，如FileNotFoundError（命令未找到）、CalledProcessError（命令执行失败）、TimeoutExpired（命令执行超时，此处未设置但可添加timeout参数到run）。
   • 结果对象result包含returncode、stdout和stderr属性。

2. 示例2 (shell=True) - 已注释掉但有说明:

   • 解释了shell=True的用法和风险。当shell=True时，命令可以是一个包含shell特殊字符（如管道|、重定向>、环境变量$VAR或%VAR%）的字符串。
   • 强调了安全风险：如果命令字符串中包含任何来自不可信来源（如用户输入）的部分，可能导致命令注入攻击。应尽可能避免使用shell=True，或确保命令字符串是完全可信的。

3. 示例3 (subprocess.Popen 与交互):

   • 展示了如何使用更底层的subprocess.Popen类来创建一个子进程，并与其进行输入/输出交互。这对于需要向子进程提供输入数据或实时处理其输出的场景非常有用。
   • stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE: 这些参数告诉Popen为子进程的标准输入、标准输出和标准错误创建管道，使得父进程（Python脚本）可以读写这些管道。
   • process.communicate(input=input_data, timeout=5): 这是一个关键方法。它向子进程的stdin发送input_data，然后等待子进程完成，并一次性读取其所有的stdout和stderr数据。timeout参数可以防止无限期阻塞。
   • 如果communicate()超时，子进程可能仍在运行，需要显式调用process.kill()来终止它，然后再调用communicate()来清空管道并获取已有的输出。
   • 这个例子在类Unix系统上（如使用grep）更为直接。Windows上的控制台程序交互有时会更复杂一些。

C. shutil 模块：高级文件操作

shutil (shell utilities) 模块提供了许多对文件和文件集合的高级操作，这些操作通常在shell中通过命令完成，如复制、移动、删除整个目录树等。

• shutil.copy(src, dst, *, follow_symlinks=True): 复制文件 src 到文件或目录 dst。如果 dst 是一个目录，则在 dst 中创建一个与 src同名的文件。权限位会被复制，其他元数据（如创建和修改时间）不会。
• shutil.copy2(src, dst, *, follow_symlinks=True): 与 copy() 类似，但它会尝试复制所有的文件元数据（包括权限、时间戳）。
• shutil.copyfile(src, dst, *, follow_symlinks=True): 将 src 文件的内容复制到 dst 文件。如果 dst 不存在，则创建它。元数据不会被复制。dst 必须是完整的目标文件名。
• shutil.copymode(src, dst, *, follow_symlinks=True): 仅复制 src 的权限位到 dst。
• shutil.copystat(src, dst, *, follow_symlinks=True): 复制 src 的权限位、最后访问时间、最后修改时间以及标志到 dst。
• shutil.copytree(src, dst, symlinks=False, ignore=None, copy_function=copy2, ignore_dangling_symlinks=False, dirs_exist_ok=False):
  • 递归地复制整个目录树，从 src 到 dst。dst 必须是不存在的目录，除非 dirs_exist_ok=True (Python 3.8+)。
  • symlinks=True: 复制符号链接本身，而不是它们指向的文件。
  • ignore: 一个可调用对象（如shutil.ignore_patterns），用于指定哪些文件或目录应该被忽略。
  • dirs_exist_ok=True (Python 3.8+): 如果目标目录已存在且非空，则将源目录的内容合并到目标目录中，而不是引发错误。
• shutil.rmtree(path, ignore_errors=False, onerror=None): 递归地删除整个目录树。如果 ignore_errors 为 True，删除失败的错误将被忽略；否则，错误由 onerror 指定的处理函数处理，或者如果没有指定处理函数则抛出异常。这是一个非常危险的操作，请谨慎使用！
• shutil.move(src, dst, copy_function=copy2): 递归地移动文件或目录 src 到 dst。如果 dst 是一个已存在的目录，src 会被移动到该目录下。如果 src 和 dst 在同一个文件系统上，通常是原子性的重命名操作。否则，src 会被复制到 dst (使用 copy_function)，然后 src 被删除。
• shutil.disk_usage(path): 返回关于指定路径所在磁盘空间使用情况的命名元组，包含 total, used, free (字节)。(Python 3.3+)
• shutil.which(cmd, mode=os.F_OK | os.X_OK, path=None): 类似于Unix的 which 命令。查找可执行文件 cmd 的路径。 (Python 3.3+)

import shutil
import os # 需要os模块辅助路径操作和检查

# 准备用于 shutil 演示的目录和文件
base_dir_shutil = os.path.join(os.getcwd(), "shutil_demo")
src_dir = os.path.join(base_dir_shutil, "source_folder")
dst_dir_copy = os.path.join(base_dir_shutil, "destination_copy_folder")
dst_dir_move = os.path.join(base_dir_shutil, "destination_move_folder")
src_file = os.path.join(src_dir, "original_file.txt")
src_subdir = os.path.join(src_dir, "subfolder")
src_subdir_file = os.path.join(src_subdir, "another_file.log")

# 清理之前的运行残留 (如果存在)
if os.path.exists(base_dir_shutil):
    shutil.rmtree(base_dir_shutil) # 中文解释: 如果 shutil_demo 目录存在，则递归删除它及其所有内容。
    print(f"清理旧的 '{
     base_dir_shutil}' 目录。")

# 创建演示所需的源目录和文件结构
os.makedirs(src_subdir, exist_ok=True) # 中文解释: 创建源目录及其子目录。exist_ok=True 避免了目录已存在时的错误。
with open(src_file, "w", encoding="utf-8") as f:
    f.write("这是源文件中的内容。Shutil演示。") # 中文解释: 在源目录中创建并写入一个文件。
with open(src_subdir_file, "w", encoding="utf-8") as f:
    f.write("这是子目录中的日志文件。") # 中文解释: 在源子目录中创建并写入一个文件。
print(f"\n为shutil演示创建了源文件和目录结构于 '{
     src_dir}'。")

# 1. shutil.copy2() - 复制文件并保留元数据
copied_file_path = os.path.join(src_dir, "copied_file_via_copy2.txt")
if not os.path.exists(dst_dir_copy):
    os.makedirs(dst_dir_copy) # 中文解释: 如果目标复制目录不存在，则创建它。

shutil.copy2(src_file, copied_file_path) # 中文解释: 将 src_file 复制到 copied_file_path，并尝试保留元数据。
# shutil.copy2(src_file, dst_dir_copy) # 也可以直接复制到目录下，文件名不变
print(f"使用 shutil.copy2 将 '{
     src_file}' 复制到 '{
     copied_file_path}'。")
if os.path.exists(copied_file_path):
    print(f"  源文件修改时间: {
     time.ctime(os.path.getmtime(src_file))}")
    print(f"  复制后文件修改时间: {
     time.ctime(os.path.getmtime(copied_file_path))}") # 中文解释: 打印源文件和复制后文件的修改时间，验证copy2是否保留了时间戳。


# 2. shutil.copytree() - 递归复制目录树
try:
    shutil.copytree(src_dir, dst_dir_copy, dirs_exist_ok=True) # Python 3.8+
    # 对于旧版本 Python，dst_dir_copy 必须不存在，或者手动先删除。
    # 如果 dst_dir_copy 在上一步 copy2 时未创建，这会创建它。
    # dirs_exist_ok=True (Python 3.8+) 允许目标目录存在，并将源内容合并进去。
    # 中文解释: 递归地将 src_dir (及其所有内容) 复制到 dst_dir_copy。
    # dirs_exist_ok=True (需要Python 3.8+) 允许目标目录存在，并合并内容。
    # 如果不使用 dirs_exist_ok=True (或在Python < 3.8)，则 dst_dir_copy 必须是一个不存在的路径，copytree 会创建它。
    print(f"使用 shutil.copytree 将 '{
     src_dir}' 复制到 '{
     dst_dir_copy}'。")
    print(f"  目标目录 '{
     dst_dir_copy}' 下的内容: {
     os.listdir(dst_dir_copy)}")
    copied_subdir_file = os.path.join(dst_dir_copy, "subfolder", "another_file.log")
    if os.path.exists(copied_subdir_file):
        print(f"  子目录中的文件 '{
     copied_subdir_file}' 也已成功复制。")
except FileExistsError:
    print(f"shutil.copytree 错误: 目标目录 '{
     dst_dir_copy}' 已存在 (未使用 dirs_exist_ok=True 或 Python < 3.8)。")
except Exception as e:
    print(f"shutil.copytree 时发生错误: {
     e}")


# 3. shutil.move() - 移动文件或目录
moved_file_in_dst_move = os.path.join(dst_dir_move, os.path.basename(src_file))
if not os.path.exists(dst_dir_move):
    os.makedirs(dst_dir_move) # 中文解释: 如果目标移动目录不存在，则创建它。

# 先复制一个文件用于移动演示，因为src_file可能已被copytree处理
temp_file_to_move = os.path.join(src_dir, "temp_move_me.txt")
with open(temp_file_to_move, "w") as f: f.write("File to be moved.")

shutil.move(temp_file_to_move, dst_dir_move)
# 中文解释: 将 temp_file_to_move 文件移动到 dst_dir_move 目录中。
# 源文件 temp_file_to_move 将不再存在于原位置。
print(f"使用 shutil.move 将 '{
     temp_file_to_move}' 移动到 '{
     dst_dir_move}' 目录。")
if not os.path.exists(temp_file_to_move) and os.path.exists(os.path.join(dst_dir_move, "temp_move_me.txt")):
    print(f"  文件成功移动。源文件 '{
     temp_file_to_move}' 不再存在。")
else:
    print(f"  文件移动似乎未按预期进行。")

# 移动整个目录 (假设源目录还存在一些内容，或者我们用复制出来的目录做源)
# 我们用 dst_dir_copy (里面有之前复制的内容) 作为源，移动到 dst_dir_move 下的一个新子目录
src_for_move_tree = dst_dir_copy
dst_for_move_tree_target = os.path.join(dst_dir_move, "moved_tree_from_copy")

if os.path.exists(src_for_move_tree):
    shutil.move(src_for_move_tree, dst_for_move_tree_target)
    # 中文解释: 将整个 src_for_move_tree 目录（即之前复制内容的目录）移动到 dst_for_move_tree_target。
    # 源目录 src_for_move_tree 将不再存在。
    print(f"使用 shutil.move 将目录 '{
     src_for_move_tree}' 移动到 '{
     dst_for_move_tree_target}'。")
    if not os.path.exists(src_for_move_tree) and os.path.exists(dst_for_move_tree_target):
        print(f"  目录成功移动。")
else:
    print(f"用于移动树的源目录 '{
     src_for_move_tree}' 不存在，跳过此移动操作。")


# 4. shutil.disk_usage() - 获取磁盘空间信息
try:
    usage = shutil.disk_usage(os.getcwd()) # 中文解释: 获取当前工作目录所在分区的磁盘使用情况。
    print(f"\n当前分区磁盘使用情况 ({
     os.getcwd()}):")
    print(f"  总空间: {
     usage.total // (1024**3)} GB") # 中文解释: 打印总磁盘空间，转换为GB。
    print(f"  已用空间: {
     usage.used // (1024**3)} GB") # 中文解释: 打印已用磁盘空间，转换为GB。
    print(f"  可用空间: {
     usage.free // (1024**3)} GB") # 中文解释: 打印可用磁盘空间，转换为GB。
except Exception as e:
    print(f"获取磁盘空间信息失败: {
     e}")

# 5. shutil.which() - 查找可执行文件路径
python_executable_path = shutil.which("python") # 或者 "python3", "pip" 等
# 中文解释: 查找名为 "python" 的可执行文件在系统PATH中的完整路径。
# 这类似于Unix/Linux下的 `which python` 命令。
print(f"\nshutil.which('python') 的结果: {
     python_executable_path}")
if python_executable_path:
    print(f"  这意味着 'python' 命令指向: {
     os.path.realpath(python_executable_path)}") # 中文解释: 如果找到，打印其真实路径。

# 清理演示目录 (非常重要，避免积累垃圾文件)
if os.path.exists(base_dir_shutil):
    shutil.rmtree(base_dir_shutil) # 中文解释: 递归删除整个 shutil_demo 目录及其所有内容。
    print(f"\n演示完毕，已清理 '{
     base_dir_shutil}' 目录。")

中文解释 (针对整个代码块):
此代码块演示了shutil模块提供的高级文件和目录操作功能。

1. 准备工作：

   • 定义了用于演示的源目录(src_dir)、目标复制目录(dst_dir_copy)和目标移动目录(dst_dir_move)的路径。
   • 在脚本开始时，如果演示的根目录(base_dir_shutil)已存在，则使用shutil.rmtree()将其彻底删除，以确保每次运行都是一个干净的环境。
   • 使用os.makedirs()创建源目录结构，包括一个子目录，并使用open()在其中创建示例文件。

2. shutil.copy2(src_file, copied_file_path):

   • 将src_file复制到copied_file_path。copy2的特性是它会尝试复制文件的所有元数据，包括权限和时间戳（如最后修改时间）。
   • 代码随后比较了源文件和复制后文件的修改时间，以验证元数据是否被保留。

3. shutil.copytree(src_dir, dst_dir_copy, dirs_exist_ok=True):

   • 递归地复制整个src_dir目录树（包括其下的所有文件和子目录）到dst_dir_copy。
   • dirs_exist_ok=True (Python 3.8+): 这是一个重要的参数。如果为True，即使目标目录dst_dir_copy已经存在，copytree也会将源目录的内容合并到目标目录中。如果目标目录中已存在同名文件，它们可能会被覆盖。如果为False（或在Python < 3.8中，此参数不存在，行为等同于False），则dst_dir_copy必须是一个不存在的路径，copytree会创建它；如果已存在，则会抛出FileExistsError。
   • 代码随后列出了目标目录的内容，并检查了子目录中的文件是否也成功复制，以验证其递归性。

4. shutil.move(src, dst):

   • 首先，创建了一个临时文件temp_file_to_move，然后将其移动到dst_dir_move目录中。源文件在移动后将不复存在。
   • 接着，演示了移动整个目录：将之前通过copytree创建的dst_dir_copy目录（现在作为源src_for_move_tree）移动到一个新的目标路径dst_for_move_tree_target。源目录在移动后也将不复存在。

5. shutil.disk_usage(path):

   • 获取指定路径（这里是当前工作目录os.getcwd()）所在文件系统的磁盘空间使用情况。
   • 返回一个包含total（总空间）、used（已用空间）和free（可用空间）属性的命名元组，单位是字节。代码中将其转换为GB以便阅读。

6. shutil.which(cmd):

   • 查找名为cmd（这里是"python"）的可执行文件在系统的PATH环境变量所指定的路径中的完整路径。
   • 这对于确定某个命令行工具是否可用以及它的具体位置非常有用。

7. 清理工作：

   • 在演示结束时，再次使用shutil.rmtree(base_dir_shutil)彻底删除所有为演示创建的目录和文件，保持环境整洁。shutil.rmtree()是一个非常强大的命令，使用时务必小心，确认路径正确，以免误删重要数据。

D. platform 模块：获取系统平台信息

platform 模块用于获取底层平台的标识数据，如操作系统名称、版本、硬件架构等。这对于编写需要根据不同平台特性执行不同逻辑的跨平台脚本非常有用。

• platform.system(): 返回操作系统名称，如 'Linux', 'Windows', 'Darwin' (macOS), 'Java'。
• platform.release(): 返回操作系统的发行版本，如 '5.4.0-100-generic' (Linux), '10' (Windows 10), '19.6.0' (macOS Catalina)。
• platform.version(): 返回操作系统的版本信息，可能更详细。
• platform.platform(aliased=False, terse=False): 返回一个单字符串，包含尽可能多的有用平台信息。
• platform.machine(): 返回机器类型/处理器架构，如 'x86_64', 'AMD64', 'arm64'。
• platform.processor(): 返回真实的处理器名称（可能不准确或为空）。
• platform.node(): 返回计算机的网络名称（主机名）。
• platform.python_implementation(): 返回Python解释器的实现，如 'CPython', 'Jython', 'IronPython', 'PyPy'。
• platform.python_version(): 返回Python版本字符串，如 '3.9.7'。
• platform.python_version_tuple(): 返回Python版本元组，如 ('3', '9', '7')，方便版本比较。

import platform

print("\n--- platform 模块演示 ---")
print(f"操作系统名称 (system): {
     platform.system()}") # 中文解释: 获取并打印操作系统的通用名称，如'Windows', 'Linux', 'Darwin'。
print(f"操作系统发行版本 (release): {
     platform.release()}") # 中文解释: 获取并打印操作系统的具体发行版本号。
print(f"操作系统版本 (version): {
     platform.version()}") # 中文解释: 获取并打印更详细的操作系统版本信息。
print(f"平台详细信息 (platform): {
     platform.platform()}") # 中文解释: 获取并打印一个包含多种平台信息的整合字符串。
print(f"计算机网络名称 (node): {
     platform.node()}") # 中文解释: 获取并打印计算机在网络上的名称（主机名）。
print(f"机器类型/架构 (machine): {
     platform.machine()}") # 中文解释: 获取并打印CPU的架构类型，如 'x86_64'。
print(f"处理器名称 (processor): {
     platform.processor()}") # 中文解释: 尝试获取CPU的具体型号名称（可能不总是准确或可用）。

print(f"Python 实现 (python_implementation): {
     platform.python_implementation()}") # 中文解释: 获取Python解释器的具体实现类型，如'CPython'。
print(f"Python 版本字符串 (python_version): {
     platform.python_version()}") # 中文解释: 获取Python解释器的版本号字符串。
py_version_tuple = platform.python_version_tuple()
print(f"Python 版本元组 (python_version_tuple): {
     py_version_tuple}") # 中文解释: 获取Python版本号的元组形式，如 ('3', '9', '7')。

# 根据平台执行不同逻辑的示例
current_os = platform.system()
if current_os == "Windows":
    print("当前运行在 Windows 系统上。可以执行Windows特定命令，如 'ipconfig'")
    # subprocess.run(["ipconfig", "/all"], capture_output=True, text=True)
elif current_os == "Linux":
    print("当前运行在 Linux 系统上。可以执行Linux特定命令，如 'ifconfig' 或 'ip addr'")
    # subprocess.run(["ip", "addr"], capture_output=True, text=True)
elif current_os == "Darwin":
    print("当前运行在 macOS 系统上。可以执行macOS特定命令，如 'ifconfig'")
    # subprocess.run(["ifconfig"], capture_output=True, text=True)
else:
    print(f"当前运行在未特别处理的系统: {
     current_os}")

# 根据Python版本执行不同逻辑的示例
if int(py_version_tuple[0]) >= 3 and int(py_version_tuple[1]) >= 8:
    print("当前Python版本 >= 3.8，可以使用 dirs_exist_ok=True 等新特性。") # 中文解释: 检查Python主版本号和次版本号，判断是否大于等于3.8。
else:
    print("当前Python版本 < 3.8，注意某些新特性可能不可用。")

中文解释 (针对整个代码块):
此代码块演示了platform模块的常用功能，用于获取运行Python脚本的软硬件平台信息。

1. platform.system(): 返回操作系统的通用名称（例如 “Windows”, “Linux”, “Darwin” for macOS）。
2. platform.release(): 返回操作系统的发行版本号。
3. platform.version(): 返回更详细的操作系统版本字符串。
4. platform.platform(): 返回一个简洁的、人类可读的平台摘要字符串。
5. platform.node(): 返回计算机的网络名称（主机名）。
6. platform.machine(): 返回CPU的体系结构（例如 “x86_64”, “AMD64”）。
7. platform.processor(): 尝试返回CPU的名称（可能不总是准确或提供详细信息）。
8. platform.python_implementation(): 返回Python解释器的具体实现（例如 “CPython”, “PyPy”）。
9. platform.python_version(): 返回Python的版本号字符串（例如 “3.9.7”）。
10. platform.python_version_tuple(): 返回一个包含主版本、次版本、补丁版本号的元组（例如 ('3', '9', '7')）。这个元组对于进行版本比较非常有用，因为可以直接比较元组元素（转换为整数后）。

代码的后半部分展示了如何利用platform.system()和platform.python_version_tuple()的输出来实现条件逻辑，使得脚本能够根据其运行的操作系统或Python版本采取不同的行为。这是编写具有良好跨平台兼容性或需要利用特定版本特性的Python脚本时的常见做法。

7.1.3 数据处理与格式化

在自动化运维和DevOps的实践中，经常需要处理各种格式的数据，例如：

• 配置文件（JSON, YAML, INI, XML）
• API响应（通常是JSON或XML）
• 日志文件（纯文本，可能需要正则解析）
• 监控数据（可能是CSV或需要自定义格式）
• 系统命令的输出（文本，需要解析）

Python 提供了强大的内置模块和第三方库来有效地处理这些数据。

A. JSON (json 模块)

JSON (JavaScript Object Notation) 是一种轻量级的数据交换格式，易于人阅读和编写，也易于机器解析和生成。它是现代Web API中最常用的数据格式。Python的json模块提供了序列化（将Python对象转换为JSON字符串）和反序列化（将JSON字符串解析为Python对象）的功能。

Python对象与JSON类型的映射关系：

Python	JSON
dict	object (JSON对象)
list, tuple	array (JSON数组)
str	string
int, float	number
True	true
False	false
None	null

核心函数：

• 序列化 (Python -> JSON String):

  • json.dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw): 将Python对象 obj 序列化为JSON格式的字符串。
    • indent: 如果是一个非负整数或字符串，则JSON数组元素和对象成员将使用该缩进级别进行美化打印。例如 indent=4 或 indent="\t"。
    • ensure_ascii=True (默认): 将所有非ASCII字符转义（如 \uXXXX）。如果设为 False，则非ASCII字符会按原样输出（对于UTF-8编码的JSON很有用）。
    • sort_keys=False (默认): 如果设为 True，则字典（JSON对象）的键会按字母顺序排序后输出。这对于比较JSON或生成一致的输出很有用。
    • separators=(item_separator, key_separator): 用于自定义分隔符，默认为 (', ', ': ')。设为 (',', ':') 可以产生更紧凑的JSON。
  • json.dump(obj, fp, *, skipkeys=False, ...): 将Python对象 obj 序列化为JSON格式，并将其写入一个文件类对象 fp (例如通过 open() 打开的文件)。参数与dumps类似。

• 反序列化 (JSON String -> Python):

  • json.loads(s, *, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw): 将包含JSON文档的字符串 s 反序列化为Python对象。
    • object_hook: 一个可选函数，用于处理解码后的JSON对象（dict）。可以用于自定义对象的创建。
    • object_pairs_hook: 类似于object_hook，但它接收一个有序的键值对列表 [(key, value), ...] 作为参数，可以用于在反序列化时保持JSON对象中键的原始顺序（如果需要的话，配合collections.OrderedDict）。
  • json.load(fp, *, cls=None, ...): 从文件类对象 fp (包含JSON文档) 读取并反序列化为Python对象。参数与loads类似。

import json
import os

print("\n--- json 模块数据处理演示 ---")

# 1. Python对象到JSON字符串 (序列化 - dumps)
python_data = {
   
    "name": "自动化运维脚本",
    "version": 1.2,
    "active": True,
    "owner": None,
    "tags": ["python", "devops", "automation"],
    "config": {
   
        "retries": 3,
        "timeout_seconds": 60,
        "log_level": "INFO"
    },
    "unicode_example": "你好，世界！" # 包含中文字符
}

# 基本序列化
json_string_basic = json.dumps(python_data)
# 中文解释: 将 python_data 字典序列化为JSON格式的字符串。
# 默认情况下，非ASCII字符（如中文）会被转义 (ensure_ascii=True)。
print("\n基本JSON字符串 (ensure_ascii=True):")
print(json_string_basic)

# 序列化并美化输出 (indent) 和保留非ASCII字符 (ensure_ascii=False)
json_string_pretty_utf8 = json.dumps(python_data, indent=4, ensure_ascii=False, sort_keys=True)
# 中文解释: 序列化 python_data。
# indent=4: 使用4个空格进行缩进，使输出更易读。
# ensure_ascii=False: 允许非ASCII字符（如中文）直接输出，而不是转义为 \uXXXX 形式。这在处理UTF-8编码的JSON时很有用。
# sort_keys=True: JSON对象（Python字典）的键会按字母顺序排序后输出。
print("\n美化后的JSON字符串 (indent=4, ensure_ascii=False, sort_keys=True):")
print(json_string_pretty_utf8)

# 2. JSON字符串到Python对象 (反序列化 - loads)
json_to_parse = '''
{
    "serviceName": "OrderProcessing",
    "instanceId": "instance-001",
    "port": 8080,
    "isHealthy": true,
    "dependencies": [
        {"name": "DatabaseService", "version": "5.7"},
        {"name": "MessagingQueue", "type": "RabbitMQ"}
    ],
    "metadata": null
}
'''
parsed_python_object = json.loads(json_to_parse)
# 中文解释: 将 json_to_parse 字符串（它是一个有效的JSON文档）反序列化为Python对象（这里会是一个字典）。
print("\n从JSON字符串解析得到的Python对象:")
print(type(parsed_python_object)) # <class 'dict'>
print(parsed_python_object)
print(f"  服务名: {
     parsed_python_object['serviceName']}")
print(f"  第一个依赖的名称: {
     parsed_python_object['dependencies'][0]['name']}")

# 3. 将Python对象写入JSON文件 (dump)
json_file_path = "config_output.json"
try:
    with open(json_file_path, "w", encoding="utf-8") as f:
        json.dump(python_data, f, indent=4, ensure_ascii=False, sort_keys=True)
        # 中文解释: 将 python_data 字典序列化并以美化格式写入到名为 config_output.json 的文件中。
        # "w": 以写模式打开文件。
        # encoding="utf-8": 确保文件以UTF-8编码保存，与 ensure_ascii=False 配合使用，保证中文字符正确存储。
    print(f"\nPython对象已写入JSON文件: '{
     json_file_path}'")
    # 验证文件内容 (可选)
    # with open(json_file_path, "r", encoding="utf-8") as f_read:
    #     print("文件内容预览:\n", f_read.read(200) + "...")

except IOError as e:
    print(f"写入JSON文件时发生错误: {
     e}")


# 4. 从JSON文件读取Python对象 (load)
if os.path.exists(json_file_path):
    try:
        with open(json_file_path, "r", encoding="utf-8") as f:
            loaded_data_from_file = json.load(f)
            # 中文解释: 从 config_output.json 文件中读取JSON数据，并将其反序列化为Python对象。
            # "r": 以读模式打开文件。
            # encoding="utf-8": 以UTF-8编码读取文件。
        print(f"\n从JSON文件 '{
     json_file_path}' 读取并解析得到的Python对象:")
        # print(loaded_data_from_file)
        if loaded_data_from_file.get("name") == python_data.get("name"):
            print(f"  数据成功加载，名称匹配: '{
     loaded_data_from_file['name']}'")
            
    except json.JSONDecodeError as e:
        print(f"解析JSON文件 '{
     json_file_path}' 时发生错误: {
     e}")
    except IOError as e:
        print(f"读取JSON文件时发生错误: {
     e}")
    finally:
        # 清理演示文件
        if os.path.exists(json_file_path):
            os.remove(json_file_path)
            print(f"已清理演示JSON文件: '{
     json_file_path}'")
else:
    print(f"\nJSON文件 '{
     json_file_path}' 未找到，跳过读取演示。")


# 处理可能无效的JSON
invalid_json_string = '{"key": "value", "malformed": true,' # 缺少右花括号
print("\n尝试解析无效的JSON字符串:")
try:
    json.loads(invalid_json_string)
except json.JSONDecodeError as e:
    print(f"  捕获到JSON解析错误: {
     e}") # 中文解释: json.loads() 在遇到无效JSON时会抛出 JSONDecodeError。
    print(f"  错误位置: 行 {
     e.lineno}, 列 {
     e.colno}")
    print(f"  错误消息: {
     e.msg}")

中文解释 (针对整个代码块):
此代码块演示了Python内置json模块的核心功能，用于JSON数据的序列化和反序列化。

1. Python对象到JSON字符串 (序列化 - json.dumps):

   • 创建了一个名为python_data的Python字典，其中包含各种数据类型（字符串、数字、布尔值、None、列表、嵌套字典以及中文字符）。
   • json.dumps(python_data): 将python_data转换为JSON格式的字符串。默认情况下，ensure_ascii=True，所以中文字符会被转义成\uXXXX的形式。
   • json.dumps(python_data, indent=4, ensure_ascii=False, sort_keys=True):
     • indent=4: 生成的JSON字符串会进行美化，使用4个空格进行缩进，使其更易读。
     • ensure_ascii=False: 使得中文字符（或其他非ASCII字符）在JSON字符串中保持原样，而不是被转义。这在处理UTF-8编码的JSON时非常有用。
     • sort_keys=True: JSON对象（对应Python字典）中的键会按照字母顺序排序后输出。这对于生成一致的、可比较的JSON输出很有帮助。

2. JSON字符串到Python对象 (反序列化 - json.loads):

   • 定义了一个多行字符串json_to_parse，它是一个有效的JSON文档。
   • json.loads(json_to_parse): 将这个JSON字符串解析成相应的Python对象（在这个例子中，是一个字典）。
   • 代码随后访问了解析后Python字典中的一些元素，以验证其正确性。

3. 将Python对象写入JSON文件 (json.dump):

   • 定义了输出文件名json_file_path。
   • with open(json_file_path, "w", encoding="utf-8") as f:: 以写入模式 ("w") 和UTF-8编码打开文件。
   • json.dump(python_data, f, indent=4, ensure_ascii=False, sort_keys=True): 将python_data序列化，并以美化的、UTF-8友好的格式直接写入到打开的文件对象f中。

4. 从JSON文件读取Python对象 (json.load):

   • 首先检查上一步创建的JSON文件是否存在。
   • with open(json_file_path, "r", encoding="utf-8") as f:: 以读取模式 ("r") 和UTF-8编码打开文件。
   • json.load(f): 从文件对象f中读取JSON数据，并将其反序列化为Python对象。
   • 代码简单验证了加载的数据。
   • 在finally块中，删除了为演示而创建的JSON文件。

5. 处理无效JSON:

   • 定义了一个invalid_json_string，它故意缺少一个右花括号，因此不是一个有效的JSON。
   • 使用try...except json.JSONDecodeError as e:块来捕获解析无效JSON时json.loads()抛出的JSONDecodeError异常。
   • 异常对象e包含了关于错误的详细信息，如错误发生在哪一行 (e.lineno)、哪一列 (e.colno)以及错误消息 (e.msg)。这对于调试JSON解析问题非常有用。

json模块是Python标准库的一部分，无需安装，功能强大且易于使用，是处理JSON数据的首选工具。

B. YAML (PyYAML 库)

YAML (YAML Ain’t Markup Language) 是一种人类可读的数据序列化语言。它通常用于配置文件、对象持久化以及消息传递。相比JSON，YAML的语法对人类更友好（例如，使用缩进表示层级，支持注释）。

Python标准库中没有内置的YAML处理模块，最常用的第三方库是 PyYAML。

安装：pip install PyYAML

核心函数（与json模块类似）：

• yaml.dump(data, stream=None, Dumper=yaml.SafeDumper, **kwds): 将Python对象 data 序列化为YAML格式。
  • stream: 一个文件类对象，用于写入YAML数据。如果为None（默认），则返回YAML字符串。
  • Dumper=yaml.SafeDumper (或 yaml.CSafeDumper 更快): 强烈推荐使用 SafeDumper 或 CSafeDumper，因为默认的yaml.Dumper (或 yaml.CDumper) 存在安全风险，它可以执行任意Python代码（如果YAML数据包含特定的Python对象标签）。
  • indent: 缩进空格数。
  • sort_keys=True/False: 是否对字典的键进行排序。
  • allow_unicode=True: 允许Unicode字符直接输出。
• yaml.load(stream, Loader=yaml.SafeLoader): 将YAML格式的流或字符串 stream 反序列化为Python对象。
  • Loader=yaml.SafeLoader (或 yaml.CSafeLoader 更快): 强烈推荐使用 SafeLoader 或 CSafeLoader，以避免执行任意代码的安全风险。
  • yaml.load_all(stream, Loader=yaml.SafeLoader): 如果一个YAML流包含多个文档（用---分隔），此函数会返回一个生成器，逐个解析文档。

Python对象与YAML类型的映射（常见）：

Python	YAML (常见表示)
dict	Mapping (键值对)
list	Sequence (通常用 - 开头)
str	Scalar (字符串)
int, float	Scalar (数字)
True, False	Scalar (true, false)
None	Scalar (null 或 ~)

import yaml # 需要 pip install PyYAML
import os

print("\n--- PyYAML 模块数据处理演示 ---")

# 使用与JSON示例相同的Python数据
python_data_for_yaml = {
   
    "application": "InventoryManager",
    "version": "2.1-beta",
    "settings": {
   
        "database": {
   
            "type": "postgresql",
            "host": "db.example.com",
            "port": 5432,
            "user": "inv_user",
            "credentials_source": None # YAML中会是 null 或 ~
        },
        "features_enabled": [
            "realtime_stock_update",
            "multi_warehouse_support",
            "api_access"
        ],
        "debug_mode": False
    },
    "contact_email": "support@example.com",
    "description": "这是一个\n多行描述\n用于演示YAML。" # 多行字符串
}

# 1. Python对象到YAML字符串 (序列化 - dump)
# 使用 SafeDumper 避免安全风险
yaml_string = yaml.dump(python_data_for_yaml, Dumper=yaml.SafeDumper, indent=2, sort_keys=False, allow_unicode=True)
# 中文解释: 将 python_data_for_yaml 字典序列化为YAML格式的字符串。
# Dumper=yaml.SafeDumper: 使用安全的Dumper，防止执行任意代码。这是最佳实践。
# indent=2: 设置缩进为2个空格。
# sort_keys=False: 不对字典的键进行排序（保持原始顺序，如果Dumper支持且数据结构有序）。
# allow_unicode=True: 允许Unicode字符（如中文，如果数据中有的话）直接输出。
print("\nPython对象序列化为YAML字符串 (SafeDumper):")
print(yaml_string)

# 2. YAML字符串到Python对象 (反序列化 - load)
yaml_to_parse = """
server_config:
  host: my.server.local
  port: 9000
  timeout: 30 # 连接超时时间 (秒)
  retry_attempts: 5
  enabled: true
  backup_paths:
    - /data/important_stuff
    - /mnt/backup_drive/archive
  metadata:
    owner: admin_team
    last_reviewed: 2023-10-26
    # 这是一个注释，不会被解析
"""
# 使用 SafeLoader 避免安全风险
parsed_from_yaml_string = yaml.load(yaml_to_parse, Loader=yaml.SafeLoader)
# 中文解释: 将 yaml_to_parse 字符串（一个有效的YAML文档）反序列化为Python对象。
# Loader=yaml.SafeLoader: 使用安全的Loader，防止执行任意代码。这是最佳实践。
print("\n从YAML字符串解析得到的Python对象 (SafeLoader):")
print(type(parsed_from_yaml_string)) # 通常是 <class 'dict'>
print(parsed_from_yaml_string)
if parsed_from_yaml_string: # 检查是否成功解析
    print(f"  服务器主机: {parsed_from_yaml_string.get('server_config', {}).get('host')}")
    print(f"  第一个备份路径: {parsed_from_yaml_string.get('server_config', {}).get('backup_paths', [])[0]}")


# 3. 将Python对象写入YAML文件 (dump 到文件流)
yaml_file_path = "app_config.yaml"
try:
    with open(yaml_file_path, "w", encoding="utf-8") as f:
        yaml.dump(python_data_for_yaml, f, Dumper=yaml.SafeDumper, indent=2, sort_keys=False, allow_unicode=True)
        # 中文解释: 将 python_data_for_yaml 字典序列化并以YAML格式写入到名为 app_config.yaml 的文件中。
        # 使用 SafeDumper，设置缩进、不排序键、允许Unicode。
    print(f"\nPython对象已写入YAML文件: '{
     yaml_file_path}'")
    # 验证文件内容 (可选)
    # with open(yaml_file_path, "r", encoding="utf-8") as f_read:
    #     print("YAML文件内容预览:\n", f_read.read(300) + "...")
except IOError as e:
    print(f"写入YAML文件时发生错误: {
     e}")
except yaml.YAMLError as e:
    print(f"序列化到YAML文件时发生PyYAML错误: {
     e}")


# 4. 从YAML文件读取Python对象 (load 从文件流)
if os.path.exists(yaml_file_path):
    try:
        with open(yaml_file_path, "r", encoding="utf-8") as f:
            loaded_data_from_yaml_file = yaml.load(f, Loader=yaml.SafeLoader)
            # 中文解释: 从 app_config.yaml 文件中读取YAML数据，并将其反序列化为Python对象。
            # 使用 SafeLoader。
        print(f"\n从YAML文件 '{
     yaml_file_path}' 读取并解析得到的Python对象:")
        # print(loaded_data_from_yaml_file)
        if loaded_data_from_yaml_file and loaded_data_from_yaml_file.get("application") == python_data_for_yaml.get("application"):
            print(f"  YAML数据成功加载，应用名称匹配: '{
     loaded_data_from_yaml_file['application']}'")
            
    except yaml.YAMLError as e: # 包括解析错误，如 MarkedYAMLError
        print(f"解析YAML文件 '{
     yaml_file_path}' 时发生PyYAML错误: {
     e}")
    except IOError as e:
        print(f"读取YAML文件时发生错误: {
     e}")
    finally:
        # 清理演示文件
        if os.path.exists(yaml_file_path):
            os.remove(yaml_file_path)
            print(f"已清理演示YAML文件: '{
     yaml_file_path}'")
else:
    print(f"\nYAML文件 '{
     yaml_file_path}' 未找到，跳过读取演示。")


# 处理包含多个YAML文档的流 (load_all)
multi_doc_yaml_string = """
---
document: 1
type: user
name: Alice
---
document: 2
type: group
name: developers
members: [Alice, Bob]
---
document: 3
type: config
setting: verbose
value: true
"""
print("\n解析包含多个文档的YAML字符串 (load_all):")
try:
    documents = yaml.load_all(multi_doc_yaml_string, Loader=yaml.SafeLoader)
    # 中文解释: yaml.load_all 用于解析包含一个或多个YAML文档的流（文档之间用 '---' 分隔）。
    # 它返回一个生成器，可以迭代地获取每个解析后的Python对象。
    for i, doc in enumerate(documents):
        print(f"  文档 {
     i+1}: {
     doc}")
except yaml.YAMLError as e:
    print(f"  解析多文档YAML时发生错误: {
     e}")

中文解释 (针对整个代码块):
此代码块演示了如何使用流行的第三方库PyYAML来处理YAML数据格式。

1. Python对象到YAML字符串 (序列化 - yaml.dump):

   • 创建了一个名为python_data_for_yaml的Python字典，其结构适合用YAML表示（包含嵌套、列表、布尔值、None以及多行字符串）。
   • yaml.dump(python_data_for_yaml, Dumper=yaml.SafeDumper, indent=2, sort_keys=False, allow_unicode=True):
     • Dumper=yaml.SafeDumper: 这是至关重要的安全措施。PyYAML的默认Dumper (和 Loader) 存在安全漏洞，如果处理不可信的YAML数据，可能会导致任意代码执行。SafeDumper（以及对应的SafeLoader）禁用了这些危险功能。
     • indent=2: 生成的YAML会使用2个空格进行缩进，使其结构清晰。
     • sort_keys=False: 默认情况下，PyYAML的SafeDumper会尝试保持字典键的插入顺序（如果Python版本支持，如Python 3.7+的dict）。设置为True则会按字母顺序排序键。
     • allow_unicode=True: 允许Unicode字符直接输出到YAML字符串中。

2. YAML字符串到Python对象 (反序列化 - yaml.load):

   • 定义了一个多行字符串yaml_to_parse，它是一个有效的YAML文档，包含了注释、不同数据类型和层级结构。
   • yaml.load(yaml_to_parse, Loader=yaml.SafeLoader):
     • Loader=yaml.SafeLoader: 同样是关键的安全措施，用于安全地解析YAML数据。
     • 将YAML字符串解析成相应的Python对象（通常是字典和列表的组合）。
   • 代码随后访问了解析后对象的一些内容。

3. 将Python对象写入YAML文件 (yaml.dump 到文件流):

   • 定义了输出文件名yaml_file_path。
   • with open(yaml_file_path, "w", encoding="utf-8") as f:: 以写入模式和UTF-8编码打开文件。
   • yaml.dump(python_data_for_yaml, f, ...): 将Python对象序列化为YAML格式，并直接写入到打开的文件对象f中。参数与前面dump到字符串时类似。

4. 从YAML文件读取Python对象 (yaml.load 从文件流):

   • 检查上一步创建的YAML文件是否存在。
   • with open(yaml_file_path, "r", encoding="utf-8") as f:: 以读取模式和UTF-8编码打开文件。
   • loaded_data_from_yaml_file = yaml.load(f, Loader=yaml.SafeLoader): 从文件对象f中读取YAML数据，并将其安全地反序列化为Python对象。
   • 简单验证加载的数据，并在finally块中清理演示文件。

5. 处理包含多个YAML文档的流 (yaml.load_all):

   • YAML规范允许在一个文件中或流中包含多个独立的YAML文档，它们之间用三个短划线 (---) 分隔。
   • multi_doc_yaml_string演示了这样一个包含三个文档的字符串。
   • yaml.load_all(multi_doc_yaml_string, Loader=yaml.SafeLoader):
     • load_all函数用于处理这种情况。它返回一个生成器 (generator)。
     • 可以迭代这个生成器，每次迭代得到一个已解析的Python对象，对应于流中的一个YAML文档。
   • 代码中捕获了可能的yaml.YAMLError，这是PyYAML在解析或序列化过程中可能抛出的通用错误基类。

PyYAML是Python中处理YAML数据的标准选择。其可读性强的语法使其非常适合用作配置文件格式。再次强调，始终使用SafeLoader和SafeDumper（或对应的C版本CSafeLoader和CSafeDumper以获得更好性能）来避免潜在的安全风险。

C. CSV (csv 模块)

CSV (Comma-Separated Values) 是一种非常常见的纯文本格式，用于存储表格数据（数字和文本）。每行代表一条记录，记录中的每个字段（列）通常用逗号分隔。

Python的csv模块用于处理CSV文件。

核心类：

• csv.reader(csvfile, dialect='excel', **fmtparams): 返回一个reader对象，该对象将迭代 csvfile（任何支持迭代器协议并每次迭代返回字符串的对象，通常是文件对象）中的行。
  • dialect: 可以是预定义的方言（如'excel', 'excel-tab', 'unix')或自定义的Dialect对象，用于指定分隔符、引用字符等格式。
  • delimiter: 字段分隔符（默认为 ,）。
  • quotechar: 用于包围包含特殊字符（如分隔符或换行符）的字段的引用字符（默认为 "）。
  • skipinitialspace: 如果为 True，则分隔符后的空格会被忽略（默认为 False）。
• csv.writer(csvfile, dialect='excel', **fmtparams): 返回一个writer对象，负责将用户数据转换为带分隔符的字符串并写入 csvfile。
  • writerow(row): 将 row (一个可迭代对象，如列表或元组) 写入writer的文件对象，按当前方言格式化。
  • writerows(rows): 将 rows (一个可迭代的row对象) 中的所有元素写入writer的文件对象。
• csv.DictReader(f, fieldnames=None, restkey=None, restval=None, dialect='excel', *args, **kwds): 类似于reader，但将每行映射为一个字典，其键由fieldnames参数给出，或者（如果fieldnames为None）从CSV文件的第一行（表头）自动推断。
• csv.DictWriter(f, fieldnames, restval='', extrasaction='raise', dialect='excel', *args, **kwds): 类似于writer，但其方法（如writerow）接收字典而不是列表。
  • fieldnames: 一个序列，指定字典中值的顺序，这些值将按此顺序写入CSV文件。必须提供。
  • writeheader(): 将包含字段名的表头行写入输出文件。

import csv
import os

print("\n--- csv 模块数据处理演示 ---")

# 准备CSV数据 (列表的列表形式)
csv_data_list = [
    ["Hostname", "IPAddress", "OS", "Status"],
    ["server01", "192.168.1.101", "Ubuntu 20.04", "Running"],
    ["db01", "192.168.1.105", "CentOS 7", "Maintenance"],
    ["web_app_server_frontend_instance_001_new-york", "10.0.5.23", "Debian 11", "Critical"], # 包含逗号的字段会被正确处理
    ["fileserver_alpha", "192.168.2.50", "Windows Server 2019", "Running"]
]

csv_file_path = "servers_list.csv"

# 1. 将数据写入CSV文件 (csv.writer)
try:
    with open(csv_file_path, mode="w", newline="", encoding="utf-8") as f:
        # 中文解释: 以写模式 ("w") 打开CSV文件。
        # newline="": 这是写入CSV文件时的重要参数。它防止在Windows上出现空行 (因为csv模块自己处理行结束符)。
        # encoding="utf-8": 指定文件编码。
        
        writer = csv.writer(f, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL)
        # 中文解释: 创建一个 csv.writer 对象。
        # delimiter=',': 指定字段分隔符为逗号。
        # quotechar='"': 指定引用字符为双引号。
        # quoting=csv.QUOTE_MINIMAL: 指定引用策略。QUOTE_MINIMAL 表示仅当字段包含分隔符、引用字符或行结束符时才引用。
        # 其他选项有 csv.QUOTE_ALL (所有字段都引用), csv.QUOTE_NONNUMERIC (所有非数字字段引用), csv.QUOTE_NONE (不引用，可能导致问题)。

        # 写入所有行
        writer.writerows(csv_data_list)
        # 中文解释: 使用 writerows() 方法一次性将 csv_data_list (一个列表的列表) 中的所有行写入文件。
        # 也可以使用 writer.writerow(row) 逐行写入。
        
    print(f"\n列表数据已写入CSV文件: '{
     csv_file_path}'")

    # 验证文件内容 (可选)
    # with open(csv_file_path, "r", encoding="utf-8") as f_read:
    #     print("CSV文件内容预览:\n", f_read.read())

except IOError as e:
    print(f"写入CSV文件时发生错误: {
     e}")


# 2. 从CSV文件读取数据 (csv.reader)
if os.path.exists(csv_file_path):
    try:
        print(f"\n从CSV文件 '{
     csv_file_path}' 读取数据 (csv.reader):")
        with open(csv_file_path, mode="r", newline="", encoding="utf-8") as f:
            reader = csv.reader(f, delimiter=',', quotechar='"')
            # 中文解释: 创建一个 csv.reader 对象来迭代CSV文件中的行。
            # 参数与writer类似。
            
            header = next(reader) # 中文解释: 读取第一行作为表头。next(reader) 会获取迭代器的下一个元素。
            print(f"  表头: {
     header}")
            
            print("  数据行:")
            for i, row in enumerate(reader): # reader 是一个迭代器，每行是一个字段列表
                # 中文解释: 迭代 reader 对象，每一行 (row) 是一个包含该行所有字段的字符串列表。
                print(f"    行 {
     i+1}: {
     row}")
                # 示例访问特定字段:
                # if len(row) >= 2: print(f"      主机名: {row[0]}, IP: {row[1]}")
                
    except FileNotFoundError:
        print(f"CSV文件 '{
     csv_file_path}' 未找到。")
    except csv.Error as e: # csv模块可能抛出的通用错误
        print(f"读取或解析CSV文件时发生csv错误: {
     e}")
    except IOError as e:
        print(f"读取CSV文件时发生IO错误: {
     e}")
else:
    print(f"\nCSV文件 '{
     csv_file_path}' 未创建成功，跳过读取演示。")


# 准备用于 DictReader/DictWriter 的数据 (字典列表)
csv_data_dict_list = [
    {
   'ID': '101', 'Product Name': 'Laptop Pro', 'Category': 'Electronics', 'Price': '1200.50', 'In Stock': 'Yes'},
    {
   'ID': '102', 'Product Name': 'Office Chair, Ergonomic', 'Category': 'Furniture', 'Price': '250.00', 'In Stock': 'No'},
    {
   'ID': '103', 'Product Name': 'Coffee Maker "Deluxe"', 'Category': 'Appliances', 'Price': '75.99', 'In Stock': 'Yes'}
]
dict_csv_file_path = "products_list.csv"
field_names = ['ID', 'Product Name', 'Category', 'Price', 'In Stock'] # 表头/字段名顺序

# 3. 将字典列表写入CSV文件 (csv.DictWriter)
try:
    with open(dict_csv_file_path, mode="w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=field_names, delimiter=';', quotechar="'"