一文读懂 Python 写脚本应具备的知识_python写脚本需要学什么
一、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 解释器
- 访问 Python 官方网站(https://www.python.org/),在首页的 “Downloads” 栏目中选择适合 Windows 系统的 Python 3.x 版本(通常有 32 位和 64 位两种,根据电脑系统选择对应的版本)。
- 下载完成后,双击安装文件进入安装界面。在安装界面中,需要注意勾选 “Add Python 3.x to PATH” 选项,这一步非常重要,它可以将 Python 解释器的路径添加到系统环境变量中,使得在命令提示符(CMD)中可以直接通过python命令调用解释器。
- 点击 “Install Now” 进行默认安装,或者选择 “Customize Installation” 进行自定义安装(如选择安装路径、是否安装额外的组件等)。
- 安装完成后,验证安装是否成功。打开命令提示符(CMD),输入python --version命令,如果能够显示 Python 的版本信息(如Python 3.10.12),则说明 Python 解释器安装成功。
2.1.2 Linux 系统安装 Python 解释器
大多数 Linux 系统(如 Ubuntu、CentOS 等)默认已经安装了 Python,但可能安装的是 Python 2.x 版本,需要手动安装 Python 3.x 版本。
- 对于 Ubuntu 系统,打开终端,首先更新软件包列表:sudo apt update。
- 安装 Python 3.x:sudo apt install python3。
- 安装完成后,验证安装:在终端中输入python3 --version,如果显示 Python 3.x 的版本信息,则安装成功。
- (可选)设置 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。
- 方法一:通过官方网站下载安装。访问 Python 官方网站,下载适合 MacOS 的 Python 3.x 版本,双击安装文件,按照提示完成安装,安装过程中会自动将 Python 3 添加到系统环境变量中。
- 方法二:通过 Homebrew 安装。如果已经安装了 Homebrew(MacOS 的包管理工具),可以在终端中输入brew install python3命令进行安装,安装完成后,通过python3 --version验证安装。
2.2 代码编辑器的选择与使用
安装好 Python 解释器后,还需要选择一款合适的代码编辑器来编写脚本。常用的 Python 代码编辑器有很多,不同的编辑器具有不同的特点,开发者可以根据自己的需求和习惯进行选择。
2.2.1 VS Code(Visual Studio Code)
VS Code 是由微软开发的一款轻量级、跨平台的代码编辑器,它支持多种编程语言,包括 Python,并且拥有丰富的插件生态系统,是目前非常流行的 Python 脚本开发工具。
- 安装 VS Code:访问 VS Code 官方网站(https://code.visualstudio.com/),下载适合自己操作系统的版本并安装。
- 安装 Python 插件:打开 VS Code,在左侧的 “扩展” 面板中搜索 “Python”,找到由 Microsoft 开发的 “Python” 插件并安装,该插件提供了代码补全、语法检查、调试支持等功能。
- 配置 Python 解释器:安装完 Python 插件后,点击 VS Code 右下角的 “选择解释器”,在弹出的列表中选择已经安装的 Python 3.x 解释器,这样 VS Code 就能正确识别 Python 环境,提供相应的开发支持。
- 编写和运行脚本:在 VS Code 中新建一个以.py为后缀名的文件(如test.py),输入 Python 代码后,点击右上角的 “运行” 按钮或使用快捷键Ctrl+F5(Windows/Linux)、Cmd+F5(MacOS)运行脚本,运行结果会在终端中显示。
2.2.2 PyCharm
PyCharm 是由 JetBrains 公司开发的一款专门用于 Python 开发的集成开发环境(IDE),它功能强大,提供了完整的代码编辑、调试、测试、版本控制等功能,适合开发大型 Python 项目和复杂的脚本。
- 安装 PyCharm:访问 PyCharm 官方网站(PyCharm: The only Python IDE you need),PyCharm 分为社区版(免费)和专业版(收费,有试用期),对于大多数脚本开发需求,社区版已经足够。下载对应的版本并安装。
- 配置 Python 环境:打开 PyCharm,在创建新项目或打开现有项目时,会提示选择 Python 解释器,选择已经安装的 Python 3.x 解释器即可。如果没有自动识别到,可以手动添加解释器路径。
- 编写和运行脚本:在 PyCharm 中新建 Python 文件,输入代码后,右键点击文件,选择 “Run \' 文件名 \'” 或使用快捷键Shift+F10运行脚本,运行结果会在下方的 “Run” 面板中显示。PyCharm 的调试功能非常强大,可以设置断点、单步执行、查看变量值等,方便排查脚本中的错误。
2.2.3 Sublime Text
Sublime Text 是一款轻量级的代码编辑器,它启动速度快、界面简洁,支持多种编程语言,通过安装插件也可以很好地支持 Python 脚本开发。
- 安装 Sublime Text:访问 Sublime Text 官方网站(Sublime Text - Text Editing, Done Right),下载并安装适合自己操作系统的版本。
- 安装 Package Control:Package Control 是 Sublime Text 的插件管理工具,通过它可以方便地安装各种插件。打开 Sublime Text,按Ctrl+(Windows/Linux)或Cmd+(MacOS)打开控制台,输入对应的安装命令(可以在 Package Control 官方网站查询最新命令),等待安装完成。
- 安装 Python 相关插件:打开 Package Control(Ctrl+Shift+P或Cmd+Shift+P),输入 “Install Package”,搜索并安装 “Anaconda”(提供 Python 代码补全、语法检查等功能)、“SublimeREPL”(用于在 Sublime Text 中运行 Python 脚本)等插件。
- 运行脚本:安装好 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 常见的数据类型
- 整数(int):用于表示没有小数部分的数字,包括正整数、负整数和零。例如:10、-5、0等。Python 支持任意大小的整数,不受位数限制,例如可以表示非常大的整数:123456789012345678901234567890。
- 浮点数(float):用于表示带有小数部分的数字,例如:3.14、-0.5、2.0等。需要注意的是,浮点数在计算机中存储时可能存在精度问题,例如:
print(0.1 + 0.2) # 输出结果为0.30000000000000004,而不是0.3
如果需要高精度的小数计算,可以使用 Python 的decimal模块。
- 字符串(str):用于表示文本数据,由字符组成,需要用单引号(\')、双引号(\")或三引号(\'\'\'或\"\"\")包裹。例如:\'hello\'、\"Python\"、\'\'\'这是一个多行字符串\'\'\'等。
字符串支持多种操作,例如:
# 字符串拼接str1 = \"Hello\"str2 = \"World\"str3 = str1 + \" \" + str2print(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结束)
- 布尔类型(bool):只有两个取值:True(真)和False(假),主要用于逻辑判断。布尔类型可以参与逻辑运算,例如:
a = Trueb = Falseprint(a and b) # 逻辑与运算,输出:Falseprint(a or b) # 逻辑或运算,输出:Trueprint(not a) # 逻辑非运算,输出:False
- 列表(list):是一种有序、可变的集合,可以存储不同类型的数据,元素之间用逗号分隔,用方括号([])包裹。例如:[1, 2, \"hello\", 3.14, True]。
列表支持多种操作,例如:
# 定义列表my_list = [10, 20, 30, 40, 50]# 访问列表元素(通过索引,索引从0开始)print(my_list[0]) # 输出:10print(my_list[-1]) # 输出:50(负索引表示从列表末尾开始,-1表示最后一个元素)# 添加元素my_list.append(60) # 在列表末尾添加元素print(my_list) # 输出:[10, 20, 30, 40, 50, 60]# 插入元素my_list.insert(2, 25) # 在索引2的位置插入元素25print(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的元素修改为15print(my_list) # 输出:[10, 15, 25, 40, 50, 60]
- 字典(dict):是一种无序、可变的集合,由键值对(key-value)组成,键(key)必须是唯一的,且只能是不可变类型(如整数、字符串、元组),值(value)可以是任意类型的数据,用大括号({})包裹。例如:{\"name\": \"Alice\", \"age\": 25, \"height\": 1.65}。
字典的常用操作:
# 定义字典my_dict = {\"name\": \"Alice\", \"age\": 25, \"height\": 1.65}# 访问字典的值(通过键)print(my_dict[\"name\"]) # 输出:Aliceprint(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\"] = 26print(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 = 10b = 3print(a + b) # 加法,输出:13print(a - b) # 减法,输出:7print(a * b) # 乘法,输出:30print(a / b) # 除法,输出:3.3333333333333335print(a // b) # 整除,输出:3(取商的整数部分)print(a % b) # 取余,输出:1(取除法运算后的余数)print(a ** b) # 幂运算,输出:1000(10的3次方)
3.2.2 赋值运算符
赋值运算符用于将值赋给变量,除了基本的赋值运算符(=)外,还有复合赋值运算符,如加赋值(+=)、减赋值(-=)、乘赋值(*=)、除赋值(/=)等。
例如:
x = 5x += 3 # 等价于 x = x + 3,结果x = 8print(x)x -= 2 # 等价于 x = x - 2,结果x = 6print(x)x *= 4 # 等价于 x = x * 4,结果x = 24print(x)x /= 3 # 等价于 x = x / 3,结果x = 8.0print(x)
3.2.3 比较运算符
比较运算符用于比较两个值的大小或是否相等,返回布尔类型的结果(True或False),包括等于(==)、不等于(!=)、大于(>)、小于(=)、小于等于(<=)。
例如:
m = 7n = 5print(m == n) # 等于,输出:Falseprint(m != n) # 不等于,输出:Trueprint(m > n) # 大于,输出:Trueprint(m = n) # 大于等于,输出:Trueprint(m <= n) # 小于等于,输出:False
3.2.4 逻辑运算符
逻辑运算符用于进行逻辑运算,包括逻辑与(and)、逻辑或(or)、逻辑非(not),操作数通常是布尔类型,返回结果也是布尔类型。
- and:只有当所有操作数都为True时,结果才为True;否则为False。
- or:只要有一个操作数为True,结果就为True;只有所有操作数都为False时,结果才为False。
- not:对操作数取反,如果操作数为True,结果为False;如果操作数为False,结果为True。
例如:
p = Trueq = Falseprint(p and q) # 输出:Falseprint(p or q) # 输出:Trueprint(not p) # 输出:Falseprint(not q) # 输出:True
3.2.5 成员运算符
成员运算符用于判断一个元素是否在某个集合(如列表、字典、字符串等)中,包括in(如果元素在集合中,返回True)和not in(如果元素不在集合中,返回True)。
例如:
# 列表中的成员判断my_list = [10, 20, 30, 40]print(20 in my_list) # 输出:Trueprint(25 in my_list) # 输出:Falseprint(50 not in my_list) # 输出:True# 字符串中的成员判断my_str = \"Python\"print(\"y\" in my_str) # 输出:Trueprint(\"z\" in my_str) # 输出:False# 字典中的成员判断(判断的是键,不是值)my_dict = {\"name\": \"Alice\", \"age\": 25}print(\"name\" in my_dict) # 输出:Trueprint(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 = 85if score >= 90:print(\"优秀\")elif score >= 80:print(\"良好\")elif score >= 60:print(\"及格\")else:print(\"不及格\")# 输出:良好
再例如:判断一个数是否为正数、负数或零
num = -5if 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到9for i in range(10):print(i)# 循环从2开始,到10结束(不包含10),步长为2,打印2、4、6、8for i in range(2, 10, 2):print(i)
3.3.2.2 while 循环
while循环用于在条件为True时重复执行代码块,直到条件变为False为止。语法格式如下:
while 条件:
# 循环体代码(条件为True时执行)# 通常需要在循环体中修改条件相关的变量,避免无限循环
例如:计算 1 到 100 的和
sum_result = 0i = 1while i <= 100:sum_result += ii += 1 # 修改变量i的值,避免无限循环print(f\"1到100的和为:{sum_result}\") # 输出:1到100的和为:5050
再例如:猜数字游戏,直到猜对为止
import randomtarget_num = random.randint(1, 100) # 生成1到100之间的随机数guess_num = 0while 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 = 18if 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 + breturn 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,年龄:25print_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参数,使用默认值18print_info(\"Alice\") # 输出:姓名:Alice,年龄:18# 调用时传入age参数,使用传入的值25print_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 itemsprint(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 = 0for num in args:sum_result += numreturn 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 ** 2result = square(5)print(result) # 输出:25
返回多个值:
def calculate(a, b):\"\"\"计算两个数的和、差、积、商并返回\"\"\"sum_result = a + bdiff_result = a - bproduct_result = a * bquotient_result = a / b if b != 0 else Nonereturn 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.pyPI = 3.1415926535def add(a, b):\"\"\"计算两个数的和\"\"\"return a + bdef multiply(a, b):\"\"\"计算两个数的积\"\"\"return a * bdef circle_area(radius):\"\"\"计算圆的面积\"\"\"return PI * radius ** 2
在另一个 Python 文件中导入并使用这个模块:
# main.pyimport 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 = 8product_result = math_operations.multiply(4, 6)print(f\"4 * 6 = {product_result}\") # 输出:4 * 6 = 24circle_area_result = math_operations.circle_area(2)print(f\"半径为2的圆的面积:{circle_area_result}\") # 输出:半径为2的圆的面积:12.566370614
3.5.1.2 导入模块中的特定内容
使用from 模块名 import 函数名/类名/变量名的方式导入模块中的特定内容,导入后可以直接使用这些内容,不需要加模块名前缀。
例如:
# main.pyfrom math_operations import PI, add, circle_area# 直接使用导入的变量和函数print(f\"圆周率PI:{PI}\") # 输出:圆周率PI:3.1415926535sum_result = add(3, 5)print(f\"3 + 5 = {sum_result}\") # 输出:3 + 5 = 8circle_area_result = circle_area(2)print(f\"半径为2的圆的面积:{circle_area_result}\") # 输出:半径为2的圆的面积:12.566370614
也可以使用from 模块名 import *的方式导入模块中的所有内容,但这种方式不推荐,因为可能会导致命名冲突,并且不利于代码的可读性。
# main.pyfrom math_operations import *print(f\"圆周率PI:{PI}\") # 输出:圆周率PI:3.1415926535sum_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 moprint(f\"圆周率PI:{mo.PI}\") # 输出:圆周率PI:3.1415926535sum_result = mo.add(3, 5)print(f\"3 + 5 = {sum_result}\") # 输出:3 + 5 = 8# 为导入的内容指定别名from math_operations import circle_area as cacircle_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__.pymath_operations.pystring_operations.py
其中,string_operations.py模块的内容如下:
# string_operations.pydef reverse_string(s):\"\"\"反转字符串\"\"\"return s[::-1]def count_vowels(s):\"\"\"统计字符串中的元音字母数量(a、e、i、o、u,不区分大小写)\"\"\"vowels = {\"a\", \"e\", \"i\", \"o\", \"u\"}count = 0for char in s.lower():if char in vowels:count += 1return count
__init__.py文件的内容(可以指定包的公共接口,方便外部导入):
# __init__.py# 从子模块中导入常用的函数,方便外部直接从包导入from .math_operations import add, multiply, circle_areafrom .string_operations import reverse_string, count_vowels
3.5.2.2 导入包中的模块或内容
导入包中的模块或内容有多种方式:
- 导入包中的整个模块:
# main.pyimport my_package.math_operations as moimport my_package.string_operations as sosum_result = mo.add(3, 5)print(f\"3 + 5 = {sum_result}\") # 输出:3 + 5 = 8reversed_str = so.reverse_string(\"Python\")print(f\"反转后的字符串:{reversed_str}\") # 输出:反转后的字符串:nohtyP
- 导入包中模块的特定内容:
# main.pyfrom my_package.math_operations import circle_areafrom my_package.string_operations import count_vowelscircle_area_result = circle_area(2)print(f\"半径为2的圆的面积:{circle_area_result}\") # 输出:半径为2的圆的面积:12.566370614vowel_count = count_vowels(\"Hello World\")print(f\"字符串\'Hello World\'中的元音字母数量:{vowel_count}\") # 输出:字符串\'Hello World\'中的元音字母数量:3
- 由于__init__.py文件中已经导入了常用函数,所以可以直接从包中导入这些函数:
# main.pyfrom my_package import add, reverse_stringsum_result = add(3, 5)print(f\"3 + 5 = {sum_result}\") # 输出:3 + 5 = 8reversed_str = reverse_string(\"Python\")print(f\"反转后的字符串:{reversed_str}\") # 输出:反转后的字符串:nohtyP
四、Python 脚本常用模块
Python 拥有丰富的标准库和第三方库,这些库为脚本开发提供了强大的支持。在编写 Python 脚本时,合理使用这些模块可以大幅提高开发效率,实现各种复杂的功能。
4.1 标准库模块
标准库是 Python 自带的模块集合,不需要额外安装,直接导入即可使用。以下是一些脚本开发中常用的标准库模块。
4.1.1 os 模块
os模块提供了与操作系统交互的功能,如文件和目录操作、环境变量操作、系统命令执行等,是脚本开发中处理文件和目录的常用模块。
4.1.1.1 文件和目录操作
- 获取当前工作目录:os.getcwd()
import oscurrent_dir = os.getcwd()print(f\"当前工作目录:{current_dir}\")
- 改变当前工作目录:os.chdir(path)
# 改变当前工作目录到指定路径os.chdir(\"D:/PythonScripts\")print(f\"改变后的工作目录:{os.getcwd()}\")
- 创建目录:
-
- 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)
- 删除目录:
-
- os.rmdir(path):删除空目录,如果目录不为空,会报错。
-
- os.removedirs(path):删除多层空目录,如果目录不为空,会报错。
# 删除单个空目录os.rmdir(\"test_dir\")# 删除多层空目录os.removedirs(\"parent_dir/child_dir\") # 如果parent_dir为空,也会被删除
- 列出目录内容:os.listdir(path),返回指定目录下的所有文件和目录的列表。
dir_contents = os.listdir(\"D:/PythonScripts\")print(\"目录内容:\")for item in dir_contents:print(item)
- 判断路径是否存在:os.path.exists(path)
path = \"D:/PythonScripts/test.py\"if os.path.exists(path):print(f\"路径 {path} 存在\")else:print(f\"路径 {path} 不存在\")
- 判断是否为文件或目录:
-
- os.path.isfile(path):判断路径是否为文件。
-
- os.path.isdir(path):判断路径是否为目录。
path1 = \"D:/PythonScripts/test.py\"path2 = \"D:/PythonScripts\"print(f\"{path1} 是否为文件:{os.path.isfile(path1)}\") # 输出:Trueprint(f\"{path2} 是否为目录:{os.path.isdir(path2)}\") # 输出:True
- 获取文件的绝对路径:os.path.abspath(path)
relative_path = \"test.py\"absolute_path = os.path.abspath(relative_path)print(f\"相对路径 {relative_path} 的绝对路径:{absolute_path}\")
- 拼接路径:os.path.join(path1, path2, ...),自动根据操作系统添加路径分隔符(Windows 使用\\,Linux 和 MacOS 使用/)。
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
- 删除文件:os.remove(path)
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 环境变量操作
- 获取环境变量:os.environ是一个字典,包含所有的环境变量;os.getenv(key, default=None)用于获取指定环境变量的值,如果不存在,返回默认值。
# 获取所有环境变量(只打印部分)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
- 设置环境变量:os.environ[key] = value
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 sysprint(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 获取当前日期和时间
- 获取当前日期和时间:datetime.datetime.now()
from datetime import datetimecurrent_datetime = datetime.now()print(f\"当前日期和时间:{current_datetime}\") # 输出:2025-08-26 15:30:45.123456
- 获取当前日期:datetime.date.today()或datetime.now().date()
from datetime import datecurrent_date = date.today()print(f\"当前日期:{current_date}\") # 输出:2025-08-26current_date2 = datetime.now().date()print(f\"当前日期(另一种方式):{current_date2}\") # 输出:2025-08-26
- 获取当前时间:datetime.now().time()
current_time = datetime.now().time()print(f\"当前时间:{current_time}\") # 输出:15:30:45.123456
4.1.3.2 创建指定的日期和时间
- 创建日期:datetime.date(year, month, day)
specific_date = date(2025, 12, 31)print(f\"指定日期:{specific_date}\") # 输出:2025-12-31
- 创建时间:datetime.time(hour, minute, second, microsecond)
specific_time = datetime.time(23, 59, 59)print(f\"指定时间:{specific_time}\") # 输出:23:59:59
- 创建日期时间:datetime.datetime(year, month, day, hour, minute, second)
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:59print(f\"解析后的日期时间类型:{type(parsed_datetime)}\") # 输出:
4.1.3.4 日期时间的计算
datetime模块中的timedelta类用于表示时间间隔,可以用于日期时间的加减计算。
- 创建时间间隔:datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)
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
- 日期时间的加法:在日期时间对象上加上时间间隔,得到新的日期时间。
current_datetime = datetime.now()# 计算明天的这个时间next_day = current_datetime + one_dayprint(f\"明天的这个时间:{next_day}\")# 计算3小时后的时间three_hours_later = current_datetime + timedelta(hours=3)print(f\"3小时后的时间:{three_hours_later}\")
- 日期时间的减法:两个日期时间对象相减,得到时间间隔;在日期时间对象上减去时间间隔,得到新的日期时间。
current_datetime = datetime.now()future_datetime = datetime(2025, 12, 31, 23, 59, 59)# 计算两个日期时间之间的间隔time_diff = future_datetime - current_datetimeprint(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_dayprint(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)}\") # 输出: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 的查询字符串传递。
- 基本的 GET 请求:
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\']}\")
- 带参数的 GET 请求:
可以通过params参数传递查询参数,requests库会自动将参数拼接成 URL 的查询字符串。
import requestsurl = \"https://httpbin.org/get\"# 定义查询参数params = {\"name\": \"Alice\",\"age\": 25,\"hobbies\": [\"reading\", \"traveling\"]}# 发送带参数的GET请求response = requests.get(url, params=params)# 查看最终的请求URLprint(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\']}\")
- 设置请求头:
有些网站或 API 接口需要特定的请求头(如User-Agent、Referer等)才能正常响应,可以通过headers参数设置请求头。
import requestsurl = \"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/\"}