一、Python 脚本的基础认知

1.1 什么是 Python 脚本

Python 脚本是指使用 Python 编程语言编写的、可直接执行的文本文件，它通常以.py为后缀名，能够完成特定的自动化任务或数据处理需求。与传统的编译型语言（如 C++、Java）不同，Python 脚本采用解释执行的方式，不需要提前编译成机器码，而是由 Python 解释器逐行读取代码并实时执行，这使得 Python 脚本具有开发速度快、跨平台性强、调试便捷等显著优势。

从应用场景来看，Python 脚本的用途极为广泛。在日常办公中，它可以实现 Excel 数据的批量处理、Word 文档的自动生成、邮件的定时发送等功能，大幅提升办公效率；在运维领域，能够完成服务器状态监控、日志分析、自动化部署等工作，减少人工操作的失误；在数据分析领域，可用于数据清洗、数据可视化、简单的统计分析等任务，为决策提供数据支持。例如，一个简单的 Python 脚本可以批量读取多个 Excel 文件中的数据，进行汇总计算后生成新的报表，原本需要几小时的人工操作，通过脚本可能只需几分钟就能完成。

1.2 Python 脚本与其他程序的区别

首先，从执行方式来看，Python 脚本是解释执行，而 C++、Java 等编译型语言需要先将源代码编译成机器码，再运行机器码文件。这种差异使得 Python 脚本在开发过程中更加灵活，修改代码后无需重新编译，直接运行即可看到结果，大大缩短了开发周期。但同时，由于解释执行的特性，Python 脚本的运行速度通常比编译型语言编写的程序慢一些，不过对于大多数自动化任务和数据处理场景来说，这种速度差异基本可以忽略不计。

其次，在语法简洁性方面，Python 脚本具有明显优势。Python 语言采用缩进式语法，代码结构清晰，可读性强，减少了冗余的语法符号（如分号、大括号等）。例如，实现一个简单的循环打印功能，C++ 代码需要包含#include头文件、main函数、for循环的大括号等，而 Python 脚本只需几行简洁的代码就能完成。这种简洁性降低了学习门槛，也使得开发者能够更专注于业务逻辑的实现，而不是语法细节的纠结。

另外，Python 脚本具有强大的生态系统支持，拥有丰富的第三方库和模块，开发者在编写脚本时可以直接调用这些库，无需从零开始开发。例如，处理 Excel 文件可以使用pandas和openpyxl库，发送网络请求可以使用requests库，进行数据可视化可以使用matplotlib和seaborn库等。而一些其他语言虽然也有相应的库，但在库的数量、易用性和社区支持方面，往往不如 Python 丰富。

二、Python 脚本开发环境配置

2.1 Python 解释器的安装与配置

要编写和运行 Python 脚本，首先需要安装 Python 解释器。Python 官方提供了不同版本的解释器，目前主要分为 Python 2.x 和 Python 3.x 两个系列，由于 Python 2.x 已经停止维护，现在推荐使用 Python 3.x 版本（如 Python 3.8、Python 3.10 等）。

2.1.1 Windows 系统安装 Python 解释器
  1. 访问 Python 官方网站（https://www.python.org/），在首页的 “Downloads” 栏目中选择适合 Windows 系统的 Python 3.x 版本（通常有 32 位和 64 位两种，根据电脑系统选择对应的版本）。
  1. 下载完成后，双击安装文件进入安装界面。在安装界面中，需要注意勾选 “Add Python 3.x to PATH” 选项，这一步非常重要，它可以将 Python 解释器的路径添加到系统环境变量中，使得在命令提示符（CMD）中可以直接通过python命令调用解释器。
  1. 点击 “Install Now” 进行默认安装，或者选择 “Customize Installation” 进行自定义安装（如选择安装路径、是否安装额外的组件等）。
  1. 安装完成后，验证安装是否成功。打开命令提示符（CMD），输入python --version命令，如果能够显示 Python 的版本信息（如Python 3.10.12），则说明 Python 解释器安装成功。
2.1.2 Linux 系统安装 Python 解释器

大多数 Linux 系统（如 Ubuntu、CentOS 等）默认已经安装了 Python，但可能安装的是 Python 2.x 版本，需要手动安装 Python 3.x 版本。

  1. 对于 Ubuntu 系统，打开终端，首先更新软件包列表：sudo apt update。
  1. 安装 Python 3.x：sudo apt install python3。
  1. 安装完成后，验证安装：在终端中输入python3 --version，如果显示 Python 3.x 的版本信息，则安装成功。
  1. （可选）设置 Python 3 为默认解释器：由于系统中可能同时存在 Python 2 和 Python 3，为了方便使用，可以通过alias python=python3命令设置默认使用 Python 3，但这只是临时设置，重启终端后会失效。如果需要永久设置，可以将该命令添加到~/.bashrc或~/.bash_profile文件中，然后执行source ~/.bashrc使设置生效。
2.1.3 MacOS 系统安装 Python 解释器

MacOS 系统默认也安装了 Python，但同样可能是 Python 2.x 版本，需要安装 Python 3.x。

  1. 方法一：通过官方网站下载安装。访问 Python 官方网站，下载适合 MacOS 的 Python 3.x 版本，双击安装文件，按照提示完成安装，安装过程中会自动将 Python 3 添加到系统环境变量中。
  1. 方法二：通过 Homebrew 安装。如果已经安装了 Homebrew（MacOS 的包管理工具），可以在终端中输入brew install python3命令进行安装，安装完成后，通过python3 --version验证安装。

2.2 代码编辑器的选择与使用

安装好 Python 解释器后，还需要选择一款合适的代码编辑器来编写脚本。常用的 Python 代码编辑器有很多，不同的编辑器具有不同的特点，开发者可以根据自己的需求和习惯进行选择。

2.2.1 VS Code（Visual Studio Code）

VS Code 是由微软开发的一款轻量级、跨平台的代码编辑器，它支持多种编程语言，包括 Python，并且拥有丰富的插件生态系统，是目前非常流行的 Python 脚本开发工具。

  1. 安装 VS Code：访问 VS Code 官方网站（https://code.visualstudio.com/），下载适合自己操作系统的版本并安装。
  1. 安装 Python 插件：打开 VS Code，在左侧的 “扩展” 面板中搜索 “Python”，找到由 Microsoft 开发的 “Python” 插件并安装，该插件提供了代码补全、语法检查、调试支持等功能。
  1. 配置 Python 解释器：安装完 Python 插件后，点击 VS Code 右下角的 “选择解释器”，在弹出的列表中选择已经安装的 Python 3.x 解释器，这样 VS Code 就能正确识别 Python 环境，提供相应的开发支持。
  1. 编写和运行脚本：在 VS Code 中新建一个以.py为后缀名的文件（如test.py），输入 Python 代码后，点击右上角的 “运行” 按钮或使用快捷键Ctrl+F5（Windows/Linux）、Cmd+F5（MacOS）运行脚本，运行结果会在终端中显示。
2.2.2 PyCharm

PyCharm 是由 JetBrains 公司开发的一款专门用于 Python 开发的集成开发环境（IDE），它功能强大，提供了完整的代码编辑、调试、测试、版本控制等功能，适合开发大型 Python 项目和复杂的脚本。

  1. 安装 PyCharm：访问 PyCharm 官方网站（PyCharm: The only Python IDE you need），PyCharm 分为社区版（免费）和专业版（收费，有试用期），对于大多数脚本开发需求，社区版已经足够。下载对应的版本并安装。
  1. 配置 Python 环境：打开 PyCharm，在创建新项目或打开现有项目时，会提示选择 Python 解释器，选择已经安装的 Python 3.x 解释器即可。如果没有自动识别到，可以手动添加解释器路径。
  1. 编写和运行脚本：在 PyCharm 中新建 Python 文件，输入代码后，右键点击文件，选择 “Run ' 文件名 '” 或使用快捷键Shift+F10运行脚本，运行结果会在下方的 “Run” 面板中显示。PyCharm 的调试功能非常强大，可以设置断点、单步执行、查看变量值等，方便排查脚本中的错误。
2.2.3 Sublime Text

Sublime Text 是一款轻量级的代码编辑器，它启动速度快、界面简洁，支持多种编程语言，通过安装插件也可以很好地支持 Python 脚本开发。

  1. 安装 Sublime Text：访问 Sublime Text 官方网站（Sublime Text - Text Editing, Done Right），下载并安装适合自己操作系统的版本。
  1. 安装 Package Control：Package Control 是 Sublime Text 的插件管理工具，通过它可以方便地安装各种插件。打开 Sublime Text，按Ctrl+（Windows/Linux）或Cmd+（MacOS）打开控制台，输入对应的安装命令（可以在 Package Control 官方网站查询最新命令），等待安装完成。
  1. 安装 Python 相关插件：打开 Package Control（Ctrl+Shift+P或Cmd+Shift+P），输入 “Install Package”，搜索并安装 “Anaconda”（提供 Python 代码补全、语法检查等功能）、“SublimeREPL”（用于在 Sublime Text 中运行 Python 脚本）等插件。
  1. 运行脚本：安装好 SublimeREPL 插件后，打开 Python 文件，通过 “Tools -> SublimeREPL -> Python -> Python - Run current file” 运行脚本，运行结果会在新的面板中显示。

三、Python 基础语法知识

3.1 变量与数据类型

变量是 Python 脚本中用于存储数据的容器，在使用变量之前不需要提前声明变量的类型，直接赋值即可，Python 会根据赋值自动推断变量的类型。

3.1.1 变量的定义与赋值

Python 中变量的定义非常简单，语法格式为：变量名 = 变量值。其中，变量名需要遵循一定的命名规则：只能由字母、数字和下划线组成，且不能以数字开头；区分大小写；不能使用 Python 的关键字（如if、for、while等）作为变量名。

例如：



# 定义整数类型变量


age = 25


# 定义字符串类型变量


name = "Alice"


# 定义浮点数类型变量


height = 1.65


# 定义布尔类型变量


is_student = True


在 Python 中，还可以同时为多个变量赋值，例如：




# 同时为多个变量赋相同的值


a = b = c = 10


# 同时为多个变量赋不同的值


x, y, z = 1, 2, "hello"


3.1.2 常见的数据类型


    
 
  1. 整数（int）：用于表示没有小数部分的数字，包括正整数、负整数和零。例如：10、-5、0等。Python 支持任意大小的整数，不受位数限制，例如可以表示非常大的整数：123456789012345678901234567890。
    2. 



    
 
  1. 浮点数（float）：用于表示带有小数部分的数字，例如：3.14、-0.5、2.0等。需要注意的是，浮点数在计算机中存储时可能存在精度问题，例如：
    2. 





print(0.1 + 0.2) # 输出结果为0.30000000000000004，而不是0.3


如果需要高精度的小数计算，可以使用 Python 的decimal模块。


    
 
  1. 字符串（str）：用于表示文本数据，由字符组成，需要用单引号（'）、双引号（"）或三引号（'''或"""）包裹。例如：'hello'、"Python"、'''这是一个多行字符串'''等。
    2. 



字符串支持多种操作，例如：


# 字符串拼接

str1 = "Hello"

str2 = "World"

str3 = str1 + " " + str2

print(str3) # 输出：Hello World

# 字符串重复

str4 = "Python "

print(str4 * 3) # 输出：Python Python Python

# 字符串切片（获取字符串中的部分字符）

str5 = "Python Script"

print(str5[0:6]) # 输出：Python（从索引0开始，到索引6结束，不包含索引6）

print(str5[7:]) # 输出：Script（从索引7开始，到字符串末尾）

print(str5[:6]) # 输出：Python（从字符串开头，到索引6结束）




    
 
  1. 布尔类型（bool）：只有两个取值：True（真）和False（假），主要用于逻辑判断。布尔类型可以参与逻辑运算，例如：
    2. 





a = True

b = False

print(a and b) # 逻辑与运算，输出：False

print(a or b) # 逻辑或运算，输出：True

print(not a) # 逻辑非运算，输出：False


    
 
  1. 列表（list）：是一种有序、可变的集合，可以存储不同类型的数据，元素之间用逗号分隔，用方括号（[]）包裹。例如：[1, 2, "hello", 3.14, True]。
    2. 



列表支持多种操作，例如：




# 定义列表

my_list = [10, 20, 30, 40, 50]

# 访问列表元素（通过索引，索引从0开始）

print(my_list[0]) # 输出：10

print(my_list[-1]) # 输出：50（负索引表示从列表末尾开始，-1表示最后一个元素）

# 添加元素

my_list.append(60) # 在列表末尾添加元素

print(my_list) # 输出：[10, 20, 30, 40, 50, 60]

# 插入元素

my_list.insert(2, 25) # 在索引2的位置插入元素25

print(my_list) # 输出：[10, 20, 25, 30, 40, 50, 60]

# 删除元素

del my_list[3] # 删除索引3的元素

print(my_list) # 输出：[10, 20, 25, 40, 50, 60]

# 修改元素

my_list[1] = 15 # 将索引1的元素修改为15

print(my_list) # 输出：[10, 15, 25, 40, 50, 60]


    
 
  1. 字典（dict）：是一种无序、可变的集合，由键值对（key-value）组成，键（key）必须是唯一的，且只能是不可变类型（如整数、字符串、元组），值（value）可以是任意类型的数据，用大括号（{}）包裹。例如：{"name": "Alice", "age": 25, "height": 1.65}。
    2. 



字典的常用操作：




# 定义字典

my_dict = {"name": "Alice", "age": 25, "height": 1.65}

# 访问字典的值（通过键）

print(my_dict["name"]) # 输出：Alice

print(my_dict.get("age")) # 输出：25（使用get方法，如果键不存在，返回None，而不是报错）

# 添加键值对

my_dict["gender"] = "female"

print(my_dict) # 输出：{"name": "Alice", "age": 25, "height": 1.65, "gender": "female"}

# 修改值

my_dict["age"] = 26

print(my_dict) # 输出：{"name": "Alice", "age": 26, "height": 1.65, "gender": "female"}

# 删除键值对

del my_dict["height"]

print(my_dict) # 输出：{"name": "Alice", "age": 26, "gender": "female"}

# 遍历字典（遍历键）

for key in my_dict:

print(key, my_dict[key])

# 输出：

# name Alice

# age 26

# gender female


3.2 运算符


Python 中的运算符用于对数据进行操作，主要包括算术运算符、赋值运算符、比较运算符、逻辑运算符、成员运算符等。


3.2.1 算术运算符


算术运算符用于进行基本的数学运算，包括加（+）、减（-）、乘（*）、除（/）、整除（//）、取余（%）、幂运算（**）。


例如：




a = 10

b = 3

print(a + b) # 加法，输出：13

print(a - b) # 减法，输出：7

print(a * b) # 乘法，输出：30

print(a / b) # 除法，输出：3.3333333333333335

print(a // b) # 整除，输出：3（取商的整数部分）

print(a % b) # 取余，输出：1（取除法运算后的余数）

print(a ** b) # 幂运算，输出：1000（10的3次方）


3.2.2 赋值运算符


赋值运算符用于将值赋给变量，除了基本的赋值运算符（=）外，还有复合赋值运算符，如加赋值（+=）、减赋值（-=）、乘赋值（*=）、除赋值（/=）等。


例如：




x = 5

x += 3 # 等价于 x = x + 3，结果x = 8

print(x)

x -= 2 # 等价于 x = x - 2，结果x = 6

print(x)

x *= 4 # 等价于 x = x * 4，结果x = 24

print(x)

x /= 3 # 等价于 x = x / 3，结果x = 8.0

print(x)


3.2.3 比较运算符


比较运算符用于比较两个值的大小或是否相等，返回布尔类型的结果（True或False），包括等于（==）、不等于（!=）、大于（>）、小于（<）、大于等于（>=）、小于等于（<=）。


例如：




m = 7

n = 5

print(m == n) # 等于，输出：False

print(m != n) # 不等于，输出：True

print(m > n) # 大于，输出：True

print(m < n) # 小于，输出：False

print(m >= n) # 大于等于，输出：True

print(m <= n) # 小于等于，输出：False


3.2.4 逻辑运算符


逻辑运算符用于进行逻辑运算，包括逻辑与（and）、逻辑或（or）、逻辑非（not），操作数通常是布尔类型，返回结果也是布尔类型。


    
 
  • and：只有当所有操作数都为True时，结果才为True；否则为False。
    • 



    
 
  • or：只要有一个操作数为True，结果就为True；只有所有操作数都为False时，结果才为False。
    • 



    
 
  • not：对操作数取反，如果操作数为True，结果为False；如果操作数为False，结果为True。
    • 



例如：




p = True

q = False

print(p and q) # 输出：False

print(p or q) # 输出：True

print(not p) # 输出：False

print(not q) # 输出：True


3.2.5 成员运算符


成员运算符用于判断一个元素是否在某个集合（如列表、字典、字符串等）中，包括in（如果元素在集合中，返回True）和not in（如果元素不在集合中，返回True）。


例如：




# 列表中的成员判断

my_list = [10, 20, 30, 40]

print(20 in my_list) # 输出：True

print(25 in my_list) # 输出：False

print(50 not in my_list) # 输出：True

# 字符串中的成员判断

my_str = "Python"

print("y" in my_str) # 输出：True

print("z" in my_str) # 输出：False

# 字典中的成员判断（判断的是键，不是值）

my_dict = {"name": "Alice", "age": 25}

print("name" in my_dict) # 输出：True

print(25 in my_dict) # 输出：False


3.3 流程控制语句


流程控制语句用于控制 Python 脚本的执行顺序，主要包括条件语句（if-elif-else）、循环语句（for循环、while循环）和跳转语句（break、continue、pass）。


3.3.1 条件语句（if-elif-else）


条件语句用于根据不同的条件执行不同的代码块。语法格式如下：




if 条件1:

# 条件1为True时执行的代码块

elif 条件2:

# 条件1为False，条件2为True时执行的代码块

elif 条件3:

# 前面的条件都为False，条件3为True时执行的代码块

...

else:

# 所有前面的条件都为False时执行的代码块


需要注意的是，elif和else部分是可选的，并且 Python 使用缩进（通常是 4 个空格）来区分代码块的范围，缩进相同的代码属于同一个代码块。


例如：根据学生的成绩判断等级




score = 85

if score >= 90:

print("优秀")

elif score >= 80:

print("良好")

elif score >= 60:

print("及格")

else:

print("不及格")

# 输出：良好


再例如：判断一个数是否为正数、负数或零




num = -5

if num > 0:

print(f"{num}是正数")

elif num < 0:

print(f"{num}是负数")

else:

print(f"{num}是零")

# 输出：-5是负数


3.3.2 循环语句


3.3.2.1 for 循环


for循环主要用于遍历可迭代对象（如列表、元组、字符串、字典等），或者执行固定次数的循环。语法格式如下：




for 变量 in 可迭代对象:

# 循环体代码（每次遍历到一个元素，执行一次代码块）


例如：遍历列表




fruits = ["apple", "banana", "orange", "grape"]

for fruit in fruits:

print(f"I like {fruit}")

# 输出：

# I like apple

# I like banana

# I like orange

# I like grape


遍历字符串：




my_str = "Python"

for char in my_str:

print(char)

# 输出：

# P

# y

# t

# h

# o

# n


使用range()函数执行固定次数的循环：range()函数可以生成一个整数序列，语法为range(start, end, step)，其中start是起始值（默认 0），end是结束值（不包含），step是步长（默认 1）。




# 循环10次，打印0到9

for i in range(10):

print(i)

# 循环从2开始，到10结束（不包含10），步长为2，打印2、4、6、8

for i in range(2, 10, 2):

print(i)


3.3.2.2 while 循环


while循环用于在条件为True时重复执行代码块，直到条件变为False为止。语法格式如下：




while 条件:


# 循环体代码（条件为True时执行）

# 通常需要在循环体中修改条件相关的变量，避免无限循环


例如：计算 1 到 100 的和




sum_result = 0

i = 1

while i <= 100:

sum_result += i

i += 1 # 修改变量i的值，避免无限循环

print(f"1到100的和为：{sum_result}") # 输出：1到100的和为：5050


再例如：猜数字游戏，直到猜对为止




import random

target_num = random.randint(1, 100) # 生成1到100之间的随机数

guess_num = 0

while guess_num != target_num:

guess_num = int(input("请猜一个1到100之间的数字："))

if guess_num > target_num:

print("猜大了，再试试！")

elif guess_num < target_num:

print("猜小了，再试试！")

else:

print("恭喜你，猜对了！")


3.3.3 跳转语句


3.3.3.1 break 语句


break语句用于跳出当前所在的循环（for循环或while循环），不再执行循环体中剩余的代码，直接继续执行循环后面的代码。


例如：在列表中查找某个元素，找到后立即跳出循环




fruits = ["apple", "banana", "orange", "grape"]

target_fruit = "orange"

for fruit in fruits:

if fruit == target_fruit:

print(f"找到目标水果：{target_fruit}")

break # 找到后跳出循环

print(f"当前水果：{fruit}")

# 输出：

# 当前水果：apple

# 当前水果：banana

# 找到目标水果：orange


3.3.3.2 continue 语句


continue语句用于跳过当前循环体中剩余的代码，直接开始下一次循环。


例如：打印 1 到 10 之间的奇数




for i in range(1, 11):

if i % 2 == 0:

continue # 如果是偶数，跳过当前循环，开始下一次循环

print(i)

# 输出：

# 1

# 3

# 5

# 7

# 9


3.3.3.3 pass 语句


pass语句是一个空语句，不执行任何操作，主要用于在语法上需要有语句但逻辑上不需要执行任何代码的地方（如if语句块、循环体、函数定义中），避免语法错误。


例如：




age = 18

if age >= 18:

pass # 暂时不写具体逻辑，用pass占位，避免语法错误

else:

print("未成年")

# 定义一个空函数，用pass占位

def my_function():

pass


3.4 函数


函数是 Python 脚本中用于封装可重用代码块的机制，它可以接收输入参数，执行特定的操作，并返回结果。使用函数可以使代码结构更清晰、更易于维护和复用。


3.4.1 函数的定义与调用


函数的定义使用def关键字，语法格式如下：




def 函数名(参数列表):

"""函数文档字符串（用于描述函数的功能、参数、返回值等）"""

# 函数体代码（函数的具体逻辑）

return 返回值 # 可选，如果没有return语句，函数默认返回None


函数的调用：通过函数名加括号的方式调用函数，如果函数有参数，需要在括号中传入相应的参数。


例如：定义一个计算两个数之和的函数




def add(a, b):

"""计算两个数的和

Args:

a: 第一个数

b: 第二个数

Returns:

两个数的和

"""

result = a + b

return result

# 调用函数

sum_result = add(3, 5)

print(sum_result) # 输出：8

# 再次调用函数，传入不同的参数

sum_result2 = add(10, 20)

print(sum_result2) # 输出：30


再例如：定义一个打印问候语的函数，没有返回值




def greet(name):

"""打印问候语

Args:

name: 人名

"""

print(f"Hello, {name}!")

# 调用函数

greet("Alice") # 输出：Hello, Alice!

greet("Bob") # 输出：Hello, Bob!

# 查看函数的返回值

result = greet("Charlie")

print(result) # 输出：None（因为函数没有return语句）


3.4.2 函数的参数类型


Python 函数的参数类型丰富，主要包括位置参数、关键字参数、默认参数、可变长度参数等。


3.4.2.1 位置参数


位置参数是最基本的参数类型，调用函数时，参数的传入顺序必须与函数定义时参数的顺序一致，且参数的数量必须与函数定义时的参数数量相同。


例如：




def print_info(name, age):

"""打印个人信息（位置参数示例）"""

print(f"姓名：{name}，年龄：{age}")

# 正确调用：参数顺序与函数定义一致

print_info("Alice", 25) # 输出：姓名：Alice，年龄：25

# 错误调用：参数顺序颠倒，会导致信息错误

print_info(25, "Alice") # 输出：姓名：25，年龄：Alice

# 错误调用：参数数量不足，会报错

# print_info("Bob") # 报错：TypeError: print_info() missing 1 required positional argument: 'age'


3.4.2.2 关键字参数


关键字参数是在调用函数时，通过 “参数名 = 参数值” 的方式传入参数，这种方式不需要考虑参数的顺序，只要参数名正确即可。


例如：




def print_info(name, age):

"""打印个人信息（关键字参数示例）"""

print(f"姓名：{name}，年龄：{age}")

# 使用关键字参数调用，顺序可以任意

print_info(age=25, name="Alice") # 输出：姓名：Alice，年龄：25

print_info(name="Bob", age=30) # 输出：姓名：Bob，年龄：30


在调用函数时，也可以混合使用位置参数和关键字参数，但位置参数必须在关键字参数之前。




# 正确：位置参数在前，关键字参数在后

print_info("Charlie", age=28) # 输出：姓名：Charlie，年龄：28

# 错误：关键字参数在前，位置参数在后，会报错

# print_info(age=28, "Charlie") # 报错：SyntaxError: positional argument follows keyword argument


3.4.2.3 默认参数


默认参数是在函数定义时为参数指定默认值，调用函数时，如果没有传入该参数，函数会使用默认值；如果传入了该参数，函数会使用传入的值。默认参数必须放在位置参数的后面。


例如：




def print_info(name, age=18):

"""打印个人信息（默认参数示例），age的默认值为18"""

print(f"姓名：{name}，年龄：{age}")

# 调用时不传入age参数，使用默认值18

print_info("Alice") # 输出：姓名：Alice，年龄：18

# 调用时传入age参数，使用传入的值25

print_info("Bob", 25) # 输出：姓名：Bob，年龄：25

# 使用关键字参数传入age参数

print_info("Charlie", age=30) # 输出：姓名：Charlie，年龄：30


需要注意的是，默认参数的值只在函数定义时计算一次，如果默认参数是可变类型（如列表、字典等），则可能会出现意外的结果。例如：




def add_item(item, items=[]):

items.append(item)

return items

# 第一次调用，使用默认的空列表

print(add_item("apple")) # 输出：["apple"]

# 第二次调用，由于默认列表已经被修改，会继续添加元素

print(add_item("banana")) # 输出：["apple", "banana"]

# 解决方法：将默认参数设置为None，在函数内部创建可变类型

def add_item_fixed(item, items=None):

if items is None:

items = []

items.append(item)

return items

print(add_item_fixed("apple")) # 输出：["apple"]

print(add_item_fixed("banana")) # 输出：["banana"]


3.4.2.4 可变长度参数


可变长度参数用于处理参数数量不确定的情况，主要包括*args和**kwargs两种。


    
 
  • *args：用于接收任意数量的位置参数，将这些参数打包成一个元组（tuple）。
    • 



    
 
  • **kwargs：用于接收任意数量的关键字参数，将这些参数打包成一个字典（dict）。
    • 



例如：使用*args接收任意数量的位置参数，计算它们的和




def calculate_sum(*args):

"""计算任意数量数字的和（*args示例）"""

sum_result = 0

for num in args:

sum_result += num

return sum_result

# 传入2个参数

print(calculate_sum(1, 2)) # 输出：3

# 传入5个参数

print(calculate_sum(1, 2, 3, 4, 5)) # 输出：15

# 传入列表，需要在列表前加*，将列表元素拆分为位置参数

my_list = [10, 20, 30]

print(calculate_sum(*my_list)) # 输出：60


使用**kwargs接收任意数量的关键字参数，打印参数信息




def print_kwargs(**kwargs):

"""打印任意数量的关键字参数（**kwargs示例）"""

for key, value in kwargs.items():

print(f"{key}: {value}")

# 传入2个关键字参数

print_kwargs(name="Alice", age=25)

# 输出：

# name: Alice

# age: 25

# 传入3个关键字参数

print_kwargs(name="Bob", gender="male", height=1.80)

# 输出：

# name: Bob

# gender: male

# height: 1.80

# 传入字典，需要在字典前加**，将字典的键值对拆分为关键字参数

my_dict = {"name": "Charlie", "age": 30, "city": "Beijing"}

print_kwargs(**my_dict)

# 输出：

# name: Charlie

# age: 30

# city: Beijing


*args和**kwargs可以同时使用，但*args必须在**kwargs之前。




def print_all(*args, **kwargs):

print("位置参数：", args)

print("关键字参数：", kwargs)

print_all(1, 2, 3, name="Alice", age=25)

# 输出：

# 位置参数： (1, 2, 3)

# 关键字参数： {'name': 'Alice', 'age': 25}


3.4.3 函数的返回值


函数的返回值使用return语句实现，return语句可以返回一个值，也可以返回多个值（多个值之间用逗号分隔，实际上是返回一个元组）。如果函数中没有return语句，或者return语句后没有值，则函数默认返回None。


例如：返回一个值




def square(x):

"""计算一个数的平方并返回"""

return x ** 2

result = square(5)

print(result) # 输出：25


返回多个值：




def calculate(a, b):

"""计算两个数的和、差、积、商并返回"""

sum_result = a + b

diff_result = a - b

product_result = a * b

quotient_result = a / b if b != 0 else None

return sum_result, diff_result, product_result, quotient_result

# 接收多个返回值

sum_r, diff_r, product_r, quotient_r = calculate(10, 3)

print(f"和：{sum_r}，差：{diff_r}，积：{product_r}，商：{quotient_r}")

# 输出：和：13，差：7，积：30，商：3.3333333333333335

# 如果只接收部分返回值，可以用_忽略不需要的值

sum_r2, _, product_r2, _ = calculate(8, 2)

print(f"和：{sum_r2}，积：{product_r2}") # 输出：和：10，积：16


3.5 模块与包


在 Python 脚本开发中，当代码量较大时，为了提高代码的可维护性和复用性，通常会将代码按照功能拆分成不同的模块（.py文件），多个相关的模块又可以组成一个包（包含__init__.py文件的文件夹）。


3.5.1 模块的导入与使用


模块是一个包含 Python 定义和语句的.py文件，通过导入模块，可以使用模块中定义的函数、类、变量等。Python 提供了多种导入模块的方式。


3.5.1.1 导入整个模块


使用import 模块名的方式导入整个模块，导入后通过 “模块名。函数名 / 类名 / 变量名” 的方式使用模块中的内容。


例如，创建一个名为math_operations.py的模块，内容如下：




# math_operations.py

PI = 3.1415926535

def add(a, b):

"""计算两个数的和"""

return a + b

def multiply(a, b):

"""计算两个数的积"""

return a * b

def circle_area(radius):

"""计算圆的面积"""

return PI * radius ** 2


在另一个 Python 文件中导入并使用这个模块：




# main.py

import math_operations

# 使用模块中的变量

print(f"圆周率PI：{math_operations.PI}") # 输出：圆周率PI：3.1415926535

# 使用模块中的函数

sum_result = math_operations.add(3, 5)

print(f"3 + 5 = {sum_result}") # 输出：3 + 5 = 8

product_result = math_operations.multiply(4, 6)

print(f"4 * 6 = {product_result}") # 输出：4 * 6 = 24

circle_area_result = math_operations.circle_area(2)

print(f"半径为2的圆的面积：{circle_area_result}") # 输出：半径为2的圆的面积：12.566370614


3.5.1.2 导入模块中的特定内容


使用from 模块名 import 函数名/类名/变量名的方式导入模块中的特定内容，导入后可以直接使用这些内容，不需要加模块名前缀。


例如：




# main.py

from math_operations import PI, add, circle_area

# 直接使用导入的变量和函数

print(f"圆周率PI：{PI}") # 输出：圆周率PI：3.1415926535

sum_result = add(3, 5)

print(f"3 + 5 = {sum_result}") # 输出：3 + 5 = 8

circle_area_result = circle_area(2)

print(f"半径为2的圆的面积：{circle_area_result}") # 输出：半径为2的圆的面积：12.566370614


也可以使用from 模块名 import *的方式导入模块中的所有内容，但这种方式不推荐，因为可能会导致命名冲突，并且不利于代码的可读性。




# main.py

from math_operations import *

print(f"圆周率PI：{PI}") # 输出：圆周率PI：3.1415926535

sum_result = add(3, 5)

print(f"3 + 5 = {sum_result}") # 输出：3 + 5 = 8


3.5.1.3 为模块或导入的内容指定别名


使用import 模块名 as 别名为模块指定别名，或者使用from 模块名 import 内容 as 别名为导入的内容指定别名，这样可以简化代码的书写，特别是当模块名或内容名较长时。


例如：




# 为模块指定别名

import math_operations as mo

print(f"圆周率PI：{mo.PI}") # 输出：圆周率PI：3.1415926535

sum_result = mo.add(3, 5)

print(f"3 + 5 = {sum_result}") # 输出：3 + 5 = 8

# 为导入的内容指定别名

from math_operations import circle_area as ca

circle_area_result = ca(2)

print(f"半径为2的圆的面积：{circle_area_result}") # 输出：半径为2的圆的面积：12.566370614


3.5.2 包的创建与使用


包是一个包含__init__.py文件的文件夹，用于组织多个相关的模块。__init__.py文件可以是空文件，也可以包含一些初始化代码，用于指定包的公共接口等。


3.5.2.1 创建包


例如，创建一个名为my_package的包，包的结构如下：




my_package/

__init__.py

math_operations.py

string_operations.py


其中，string_operations.py模块的内容如下：




# string_operations.py

def reverse_string(s):

"""反转字符串"""

return s[::-1]

def count_vowels(s):

"""统计字符串中的元音字母数量（a、e、i、o、u，不区分大小写）"""

vowels = {"a", "e", "i", "o", "u"}

count = 0

for char in s.lower():

if char in vowels:

count += 1

return count


__init__.py文件的内容（可以指定包的公共接口，方便外部导入）：




# __init__.py

# 从子模块中导入常用的函数，方便外部直接从包导入

from .math_operations import add, multiply, circle_area

from .string_operations import reverse_string, count_vowels


3.5.2.2 导入包中的模块或内容


导入包中的模块或内容有多种方式：


    
 
  1. 导入包中的整个模块：
    2. 





# main.py

import my_package.math_operations as mo

import my_package.string_operations as so

sum_result = mo.add(3, 5)

print(f"3 + 5 = {sum_result}") # 输出：3 + 5 = 8

reversed_str = so.reverse_string("Python")

print(f"反转后的字符串：{reversed_str}") # 输出：反转后的字符串：nohtyP


    
 
  1. 导入包中模块的特定内容：
    2. 





# main.py

from my_package.math_operations import circle_area

from my_package.string_operations import count_vowels

circle_area_result = circle_area(2)

print(f"半径为2的圆的面积：{circle_area_result}") # 输出：半径为2的圆的面积：12.566370614

vowel_count = count_vowels("Hello World")

print(f"字符串'Hello World'中的元音字母数量：{vowel_count}") # 输出：字符串'Hello World'中的元音字母数量：3


    
 
  1. 由于__init__.py文件中已经导入了常用函数，所以可以直接从包中导入这些函数：
    2. 





# main.py

from my_package import add, reverse_string

sum_result = add(3, 5)

print(f"3 + 5 = {sum_result}") # 输出：3 + 5 = 8

reversed_str = reverse_string("Python")

print(f"反转后的字符串：{reversed_str}") # 输出：反转后的字符串：nohtyP


四、Python 脚本常用模块


Python 拥有丰富的标准库和第三方库，这些库为脚本开发提供了强大的支持。在编写 Python 脚本时，合理使用这些模块可以大幅提高开发效率，实现各种复杂的功能。


4.1 标准库模块


标准库是 Python 自带的模块集合，不需要额外安装，直接导入即可使用。以下是一些脚本开发中常用的标准库模块。


4.1.1 os 模块


os模块提供了与操作系统交互的功能，如文件和目录操作、环境变量操作、系统命令执行等，是脚本开发中处理文件和目录的常用模块。


4.1.1.1 文件和目录操作


    
 
  1. 获取当前工作目录：os.getcwd()
    2. 





import os

current_dir = os.getcwd()

print(f"当前工作目录：{current_dir}")


    
 
  1. 改变当前工作目录：os.chdir(path)
    2. 





# 改变当前工作目录到指定路径

os.chdir("D:/PythonScripts")

print(f"改变后的工作目录：{os.getcwd()}")


    
 
  1. 创建目录：
    2. 



    
 
  • 
  
      
   
    • os.mkdir(path)：创建单个目录，如果父目录不存在，会报错。
      • 
  
    • 



    
 
  • 
  
      
   
    • os.makedirs(path, exist_ok=False)：创建多层目录，如果父目录不存在，会自动创建；exist_ok=True表示如果目录已存在，不会报错。
      • 
  
    • 





# 创建单个目录

os.mkdir("test_dir")

# 创建多层目录

os.makedirs("parent_dir/child_dir", exist_ok=True)


    
 
  1. 删除目录：
    2. 



    
 
  • 
  
      
   
    • os.rmdir(path)：删除空目录，如果目录不为空，会报错。
      • 
  
    • 



    
 
  • 
  
      
   
    • os.removedirs(path)：删除多层空目录，如果目录不为空，会报错。
      • 
  
    • 





# 删除单个空目录

os.rmdir("test_dir")

# 删除多层空目录

os.removedirs("parent_dir/child_dir") # 如果parent_dir为空，也会被删除


    
 
  1. 列出目录内容：os.listdir(path)，返回指定目录下的所有文件和目录的列表。
    2. 





dir_contents = os.listdir("D:/PythonScripts")

print("目录内容：")

for item in dir_contents:

print(item)


    
 
  1. 判断路径是否存在：os.path.exists(path)
    2. 





path = "D:/PythonScripts/test.py"

if os.path.exists(path):

print(f"路径 {path} 存在")

else:

print(f"路径 {path} 不存在")


    
 
  1. 判断是否为文件或目录：
    2. 



    
 
  • 
  
      
   
    • os.path.isfile(path)：判断路径是否为文件。
      • 
  
    • 



    
 
  • 
  
      
   
    • os.path.isdir(path)：判断路径是否为目录。
      • 
  
    • 





path1 = "D:/PythonScripts/test.py"

path2 = "D:/PythonScripts"

print(f"{path1} 是否为文件：{os.path.isfile(path1)}") # 输出：True

print(f"{path2} 是否为目录：{os.path.isdir(path2)}") # 输出：True


    
 
  1. 获取文件的绝对路径：os.path.abspath(path)
    2. 





relative_path = "test.py"

absolute_path = os.path.abspath(relative_path)

print(f"相对路径 {relative_path} 的绝对路径：{absolute_path}")


    
 
  1. 拼接路径：os.path.join(path1, path2, ...)，自动根据操作系统添加路径分隔符（Windows 使用\，Linux 和 MacOS 使用/）。
    2. 





dir_path = "D:/PythonScripts"

file_name = "test.py"

file_path = os.path.join(dir_path, file_name)

print(f"拼接后的文件路径：{file_path}") # 输出：D:/PythonScripts/test.py


    
 
  1. 删除文件：os.remove(path)
    2. 





file_path = "D:/PythonScripts/test.txt"

if os.path.exists(file_path):

os.remove(file_path)

print(f"文件 {file_path} 已删除")

else:

print(f"文件 {file_path} 不存在")


4.1.1.2 环境变量操作


    
 
  1. 获取环境变量：os.environ是一个字典，包含所有的环境变量；os.getenv(key, default=None)用于获取指定环境变量的值，如果不存在，返回默认值。
    2. 





# 获取所有环境变量（只打印部分）

print("环境变量：")

for key, value in os.environ.items():

if key in ["PATH", "PYTHONPATH"]:

print(f"{key}: {value}")

# 获取指定环境变量

path_env = os.getenv("PATH")

print(f"\nPATH环境变量：{path_env}")

# 获取不存在的环境变量，返回默认值

test_env = os.getenv("TEST_ENV", "default_value")

print(f"TEST_ENV环境变量：{test_env}") # 输出：default_value


    
 
  1. 设置环境变量：os.environ[key] = value
    2. 





os.environ["TEST_ENV"] = "test_value"

print(f"设置后的TEST_ENV环境变量：{os.getenv('TEST_ENV')}") # 输出：test_value


4.1.1.3 执行系统命令


os.system(command)用于执行系统命令，返回命令的退出状态码（0 表示执行成功，非 0 表示执行失败）。




# 在Windows系统中执行dir命令，查看当前目录内容

os.system("dir")

# 在Linux/MacOS系统中执行ls命令

# os.system("ls")

# 执行创建文件的命令

os.system("echo 'Hello World' > test.txt")


4.1.2 sys 模块


sys模块提供了与 Python 解释器相关的功能，如命令行参数获取、Python 版本信息、标准输入输出控制、模块路径管理等。


4.1.2.1 获取命令行参数


sys.argv是一个列表，包含了命令行参数，其中sys.argv[0]是脚本文件名，sys.argv[1:]是传递给脚本的参数。




import sys

print(f"脚本文件名：{sys.argv[0]}")

print(f"命令行参数列表：{sys.argv}")

print(f"传递给脚本的参数：{sys.argv[1:]}")

# 示例：在命令行中执行 python test.py arg1 arg2 arg3

# 输出：

# 脚本文件名：test.py

# 命令行参数列表：['test.py', 'arg1', 'arg2', 'arg3']

# 传递给脚本的参数：['arg1', 'arg2', 'arg3']


4.1.2.2 获取 Python 版本信息


sys.version返回 Python 的版本字符串，sys.version_info返回一个元组，包含 Python 的主版本号、次版本号、微版本号等信息。




print(f"Python版本字符串：{sys.version}")

print(f"Python版本信息：{sys.version_info}")

print(f"Python主版本号：{sys.version_info.major}")

print(f"Python次版本号：{sys.version_info.minor}")


4.1.2.3 标准输入输出


sys.stdin、sys.stdout、sys.stderr分别表示标准输入、标准输出、标准错误流，可以用于读取输入、输出内容等。




# 从标准输入读取内容

print("请输入内容：")

input_content = sys.stdin.readline()

print(f"你输入的内容：{input_content}")

# 向标准输出写入内容（与print函数类似）

sys.stdout.write("这是通过sys.stdout输出的内容\n")

# 向标准错误流写入内容

sys.stderr.write("这是通过sys.stderr输出的错误信息\n")


4.1.2.4 模块路径管理


sys.path是一个列表，包含了 Python 解释器查找模块的路径，通过修改sys.path可以添加自定义的模块路径。




print(f"Python模块查找路径：{sys.path}")

# 添加自定义的模块路径

custom_path = "D:/MyModules"

if custom_path not in sys.path:

sys.path.append(custom_path)

print(f"添加后的模块查找路径：{sys.path}")


4.1.2.5 退出程序


sys.exit(status)用于退出 Python 程序，status是退出状态码，0 表示正常退出，非 0 表示异常退出。




# 正常退出

# sys.exit(0)

# 异常退出

# sys.exit(1)


4.1.3 datetime 模块


datetime模块提供了处理日期和时间的功能，包括日期和时间的创建、格式化、计算等，是脚本开发中处理时间相关任务的常用模块。


4.1.3.1 获取当前日期和时间


    
 
  1. 获取当前日期和时间：datetime.datetime.now()
    2. 





from datetime import datetime

current_datetime = datetime.now()

print(f"当前日期和时间：{current_datetime}") # 输出：2025-08-26 15:30:45.123456


    
 
  1. 获取当前日期：datetime.date.today()或datetime.now().date()
    2. 





from datetime import date

current_date = date.today()

print(f"当前日期：{current_date}") # 输出：2025-08-26

current_date2 = datetime.now().date()

print(f"当前日期（另一种方式）：{current_date2}") # 输出：2025-08-26


    
 
  1. 获取当前时间：datetime.now().time()
    2. 





current_time = datetime.now().time()

print(f"当前时间：{current_time}") # 输出：15:30:45.123456


4.1.3.2 创建指定的日期和时间


    
 
  1. 创建日期：datetime.date(year, month, day)
    2. 





specific_date = date(2025, 12, 31)

print(f"指定日期：{specific_date}") # 输出：2025-12-31


    
 
  1. 创建时间：datetime.time(hour, minute, second, microsecond)
    2. 





specific_time = datetime.time(23, 59, 59)

print(f"指定时间：{specific_time}") # 输出：23:59:59


    
 
  1. 创建日期时间：datetime.datetime(year, month, day, hour, minute, second)
    2. 





specific_datetime = datetime(2025, 12, 31, 23, 59, 59)

print(f"指定日期时间：{specific_datetime}") # 输出：2025-12-31 23:59:59


4.1.3.3 日期时间的格式化


使用strftime(format)方法将日期时间对象格式化为字符串，format是格式化字符串，常用的格式化符号如下：


    
 
  • %Y：4 位年份（如 2025）
    • 



    
 
  • %m：2 位月份（01-12）
    • 



    
 
  • %d：2 位日期（01-31）
    • 



    
 
  • %H：24 小时制小时（00-23）
    • 



    
 
  • %M：分钟（00-59）
    • 



    
 
  • %S：秒（00-59）
    • 



    
 
  • %w：星期几（0-6，0 表示星期日）
    • 



    
 
  • %W：一年中的第几周（00-53）
    • 



例如：




current_datetime = datetime.now()

# 格式化为"年-月-日 时:分:秒"

formatted_datetime1 = current_datetime.strftime("%Y-%m-%d %H:%M:%S")

print(f"格式化日期时间1：{formatted_datetime1}") # 输出：2025-08-26 15:30:45

# 格式化为"年/月/日 星期几 时:分"

formatted_datetime2 = current_datetime.strftime("%Y/%m/%d 星期%w %H:%M")

print(f"格式化日期时间2：{formatted_datetime2}") # 输出：2025/08/26 星期2 15:30

# 格式化为"YYYYMMDDHHMMSS"（常用于生成文件名）

formatted_datetime3 = current_datetime.strftime("%Y%m%d%H%M%S")

print(f"格式化日期时间3：{formatted_datetime3}") # 输出：20250826153045


使用strptime(date_string, format)方法将字符串解析为日期时间对象。




date_string = "2025-12-31 23:59:59"

parsed_datetime = datetime.strptime(date_string, "%Y-%m-%d %H:%M:%S")

print(f"解析后的日期时间：{parsed_datetime}") # 输出：2025-12-31 23:59:59

print(f"解析后的日期时间类型：{type(parsed_datetime)}") # 输出：<class 'datetime.datetime'>


4.1.3.4 日期时间的计算


datetime模块中的timedelta类用于表示时间间隔，可以用于日期时间的加减计算。


    
 
  1. 创建时间间隔：datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)
    2. 





from datetime import timedelta

# 创建1天的时间间隔

one_day = timedelta(days=1)

print(f"1天的时间间隔：{one_day}") # 输出：1 day, 0:00:00

# 创建2小时30分钟的时间间隔

two_hours_thirty_minutes = timedelta(hours=2, minutes=30)

print(f"2小时30分钟的时间间隔：{two_hours_thirty_minutes}") # 输出：2:30:00


    
 
  1. 日期时间的加法：在日期时间对象上加上时间间隔，得到新的日期时间。
    2. 





current_datetime = datetime.now()

# 计算明天的这个时间

next_day = current_datetime + one_day

print(f"明天的这个时间：{next_day}")

# 计算3小时后的时间

three_hours_later = current_datetime + timedelta(hours=3)

print(f"3小时后的时间：{three_hours_later}")


    
 
  1. 日期时间的减法：两个日期时间对象相减，得到时间间隔；在日期时间对象上减去时间间隔，得到新的日期时间。
    2. 





current_datetime = datetime.now()

future_datetime = datetime(2025, 12, 31, 23, 59, 59)

# 计算两个日期时间之间的间隔

time_diff = future_datetime - current_datetime

print(f"从现在到2025年12月31日23:59:59的时间间隔：{time_diff}")

print(f"相差的天数：{time_diff.days}")

print(f"相差的秒数（不包含天数）：{time_diff.seconds}")

print(f"相差的总秒数：{time_diff.total_seconds()}")

# 计算昨天的这个时间

last_day = current_datetime - one_day

print(f"昨天的这个时间：{last_day}")


4.1.4 json 模块


json模块提供了 JSON（JavaScript Object Notation）数据的编码（将 Python 对象转换为 JSON 字符串）和解码（将 JSON 字符串转换为 Python 对象）功能，是脚本开发中处理 JSON 数据的常用模块，广泛应用于 API 接口数据交互、配置文件存储等场景。


4.1.4.1 JSON 编码（Python 对象转 JSON 字符串）


使用json.dumps(obj, indent=None, ensure_ascii=True, ...)方法将 Python 对象转换为 JSON 字符串。


    
 
  • obj：要转换的 Python 对象（支持字典、列表、元组、字符串、整数、浮点数、布尔值、None）。
    • 



    
 
  • indent：指定缩进的空格数，用于格式化输出，使 JSON 字符串更易读。
    • 



    
 
  • ensure_ascii：默认值为True，表示将非 ASCII 字符编码为 Unicode 转义序列；设置为False，可以保留非 ASCII 字符。
    • 



例如：




import json

# Python字典

data = {

"name": "Alice",

"age": 25,

"gender": "female",

"is_student": False,

"hobbies": ["reading", "traveling", "coding"],

"address": {

"city": "Beijing",

"street": "Main Street"

},

"birthday": "1999-01-01"

}

# 将Python字典转换为JSON字符串（无缩进）

json_str1 = json.dumps(data)

print(f"JSON字符串（无缩进）：{json_str1}")

# 将Python字典转换为JSON字符串（有缩进，保留非ASCII字符）

json_str2 = json.dumps(data, indent=4, ensure_ascii=False)

print(f"\nJSON字符串（有缩进）：{json_str2}")

# 将Python列表转换为JSON字符串

my_list = ["apple", "banana", "orange"]

json_str3 = json.dumps(my_list, indent=2)

print(f"\n列表转换为JSON字符串：{json_str3}")


使用json.dump(obj, fp, ...)方法将 Python 对象转换为 JSON 字符串并直接写入文件对象fp。




# 将Python对象写入JSON文件

with open("data.json", "w", encoding="utf-8") as f:

json.dump(data, f, indent=4, ensure_ascii=False)

print("Python对象已写入data.json文件")


4.1.4.2 JSON 解码（JSON 字符串转 Python 对象）


使用json.loads(json_str)方法将 JSON 字符串转换为 Python 对象。




# JSON字符串

json_str = '''

{

"name": "Bob",

"age": 30,

"gender": "male",

"is_student": true,

"hobbies": ["sports", "music"],

"address": {

"city": "Shanghai",

"street": "Second Street"

},

"birthday": "1994-05-15"

}

'''

# 将JSON字符串转换为Python对象

python_obj = json.loads(json_str)

print(f"转换后的Python对象：{python_obj}")

print(f"Python对象类型：{type(python_obj)}") # 输出：<class 'dict'>

print(f"姓名：{python_obj['name']}")

print(f"爱好：{python_obj['hobbies']}")

print(f"城市：{python_obj['address']['city']}")


使用json.load(fp)方法从文件对象fp中读取 JSON 字符串并转换为 Python 对象。




# 从JSON文件中读取数据并转换为Python对象

with open("data.json", "r", encoding="utf-8") as f:

python_obj_from_file = json.load(f)

print(f"\n从文件读取的Python对象：{python_obj_from_file}")

print(f"姓名：{python_obj_from_file['name']}")

print(f"年龄：{python_obj_from_file['age']}")


需要注意的是，JSON 数据类型与 Python 数据类型存在一定的对应关系：



 
  

   
    
JSON 数据类型

   
    
Python 数据类型

  

  

   
    
object

   
    
dict

  

  

   
    
array

   
    
list

  

  

   
    
string

   
    
str

  

  

   
    
number（int）

   
    
int

  

  

   
    
number（float）

   
    
float

  

  

   
    
true

   
    
True

  

  

   
    
false

   
    
False

  

  

   
    
null

   
    
None

  

 



4.2 第三方库模块


除了标准库外，Python 还有大量的第三方库，这些库需要通过包管理工具（如pip）安装后才能使用。以下是一些脚本开发中常用的第三方库。


4.2.1 requests 库


requests库是 Python 中用于发送 HTTP 请求的第三方库，它简化了 HTTP 请求的发送过程，支持 GET、POST、PUT、DELETE 等多种 HTTP 方法，并且提供了丰富的功能，如 Cookie 处理、文件上传、会话保持等，是脚本开发中与 API 接口交互、爬取网页数据的常用工具。


4.2.1.1 安装 requests 库


使用pip命令安装：




pip install requests


4.2.1.2 发送 GET 请求


GET 请求通常用于从服务器获取数据，参数可以通过 URL 的查询字符串传递。


    
 
  1. 基本的 GET 请求：
    2. 





import requests

# 发送GET请求

url = "https://httpbin.org/get"

response = requests.get(url)

# 查看响应状态码（200表示请求成功）

print(f"响应状态码：{response.status_code}")

# 查看响应内容（文本形式）

print(f"\n响应内容（文本）：{response.text}")

# 查看响应内容（JSON形式，适用于响应数据为JSON的情况）

if response.status_code == 200:

json_data = response.json()

print(f"\n响应内容（JSON）：{json_data}")

print(f"请求方法：{json_data['method']}")

print(f"客户端IP：{json_data['origin']}")


    
 
  1. 带参数的 GET 请求：
    2. 



可以通过params参数传递查询参数，requests库会自动将参数拼接成 URL 的查询字符串。




import requests

url = "https://httpbin.org/get"

# 定义查询参数

params = {

"name": "Alice",

"age": 25,

"hobbies": ["reading", "traveling"]

}

# 发送带参数的GET请求

response = requests.get(url, params=params)

# 查看最终的请求URL

print(f"最终请求URL：{response.url}") # 输出：https://httpbin.org/get?name=Alice&age=25&hobbies=reading&hobbies=traveling

# 查看响应内容

if response.status_code == 200:

json_data = response.json()

print(f"\n响应中的args参数：{json_data['args']}")


    
 
  1. 设置请求头：
    2. 



有些网站或 API 接口需要特定的请求头（如User-Agent、Referer等）才能正常响应，可以通过headers参数设置请求头。




import requests

url = "https://httpbin.org/get"

# 设置请求头

headers = {

"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36 Edg/139.0.0.0",

"Referer": "https://httpbin.org/"

}

</doubaocanvas>


 
  

        # 信息可视化
      
  
 
 Logo 
AI Agent技术社区
 
Agent 垂直技术社区，欢迎活跃、内容共建。
 
 
  
更多推荐
  
 
SeedVR2终极指南：如何用单步扩散模型实现专业级视频修复
 
还在为老旧视频的模糊画质而烦恼吗？面对抖动严重的监控录像或褪色的家庭影像，你是否曾希望有一种简单高效的修复方案？SeedVR2正是为解决这些痛点而生的一站式视频修复工具。作为字节跳动推出的先进视频修复模型，它能够在单步推理中实现专业级的视频质量提升，彻底改变了传统视频修复的工作流程。## 核心价值：为什么选择SeedVR2进行视频修复？**传统视频修复的三大瓶颈**：1. **计算成本高
 
avatar AI Agent技术社区
 
 
深度解析Amlogic S9xxx电视盒子Armbian系统：从闲置设备到Linux服务器的终极实战指南
 
你是否拥有一台闲置的Amlogic S9xxx系列电视盒子？想让它摆脱单一的视频播放功能，变身为功能强大的Linux服务器、开发平台或家庭媒体中心？本指南将为你详细解析如何通过Armbian系统实现这一转变，让你的电视盒子重获新生，成为高性能的Linux设备。Armbian系统基于Debian/Ubuntu构建，专为ARM芯片优化，提供了完整的Linux生态支持。## 🎯 核心价值与独特优势
 
avatar AI Agent技术社区
 
 
CANN/runtime Event管理API
 
本章节描述 CANN Runtime 的 Event 管理接口，用于事件的创建、记录、同步、计时及 IPC 跨进程共享。- [`aclError aclrtCreateEvent(aclrtEvent *event)`](#aclrtCreateEvent)：创建Event，创建出来的Event可用于统计两个Event之间的耗时、多Stream之间的任务同步等场景。- [`aclError
 
avatar AI Agent技术社区