【一】random(随机数模块)
random模块是Python中用于生成随机数的一个标准库模块。它提供了各种生成随机数的函数和方法,可以用于生成随机数、随机选择、随机排列等。通过使用random模块,你可以在Python程序中实现随机性和不确定性,以及进行各种随机相关的操作。例如,可以使用random模块来生成随机的整数、浮点数、随机选择列表中的元素、随机排列列表等。
random模块提供了多种方法来生成随机数,以下是一些常用的示例:
1.1 random.random
生成随机小数
import random
print(random.random()) # 0.13170228880290313
1.2 random.uniform
生成指定区间内的随机小数
import random
print(random.uniform(1, 3)) # 1.5486377820945014
1.3 random.randrange
步长
import random
print(random.randrange(1, 10, 2)) # 奇数 3 .....
print(random.randrange(2, 10, 2)) # 偶数 2 .....
1.4 random.randint
生成随机整数
import random
print(random.randint(1,10)) # 输出1-10之间的随机数(包括1和10)
1.5 random.choice
随机选择列表中的元素
# 随机返回任意元素
import random
list1 = [1, 2, 3, 4, 5]
print(random.choice(list1)) # 随机返回任意元素
1.6 random.sample
返回随机元素的指定的个数
import random
list1 = ['name', 'age', 'gender', 'addr']
print(random.sample(list1, 2)) # ['age', 'addr'] (返回的是列表)
1.7 random.shuffle
打乱顺序
import random
list1 = ['name', 'age', 'gender', 'addr']
print(list1) # ['addr', 'age', 'name', 'gender'] (打乱的是源列表顺序,无法直接打印)
【二】json模块(将Python对象与JSON格式字符串相互转换)
json模块主要用于处理JSON(JavaScript Object Notation)数据,它提供了将Python对象转换为JSON格式字符串的方法,以及将JSON格式字符串转换为Python对象的方法。
json模块主要用于处理JSON数据,它提供了将Python对象转换为JSON格式字符串的方法,以及将JSON格式字符串转换为Python对象的方法。
在Python中,可以使用json模块将Python对象(如字典、列表)转换为JSON格式的字符串,以便在网络传输或存储到文件中。同样地,也可以使用json模块将JSON格式的字符串转换为Python对象,方便在程序中进行处理和操作。
总之,json模块提供了将Python对象和JSON格式字符串之间相互转换的功能,方便处理和传输JSON数据。
2.1 json.dumps
将Python对象(字典)转换为字符串
import json
data = {
"name": "John",
"age": 30,
"city": "New York"
}
print(json.dumps(data), type(json.dumps(data)))
# {"name": "John", "age": 30, "city": "New York"} <class 'str'>
2.2 json.loads
将JSON格式的字符串转换为Python对象(字典)
import json
json_str = '{"name": "John", "age": 30, "city": "New York"}'
print(json.loads(json_str), type(json.loads(json_str)))
# {'name': 'John', 'age': 30, 'city': 'New York'} <class 'dict'>
2.3 json.dump
将Python对象转换为JSON格式的字符串,并将其写入文件中
import json
data = {
"name": "John",
"age": 30,
"city": "New York"
}
with open("data.json", "w") as file:
json.dump(data, file)
2.4 json.load
从文件中读取JSON格式的字符串,并将其转换为Python对象
import json
with open("data.json", "r") as file:
data = json.load(file)
print(data) # {'name': 'John', 'age': 30, 'city': 'New York'}
【二】 os
(文件操作、路径)
os模块是Python提供的一个用于与操作系统进行交互的标准库。它提供了许多方法和函数,用于管理文件和目录、执行系统命令、获取系统信息等。
2.1 os.path.abspath
获取指定文件或文件夹路径
import os
res = os.path.abspath(__file__)
print(res) # D:\Software\PyCharm_Pro\projects\Day_19\practice.py
res = os.path.abspath('bin')
print(res) # D:\Software\PyCharm_Pro\projects\Day_19\bin
2.2 os.path.dirname
获取路径的父目录
import os
file_path = r'D:\Software\PyCharm_Pro\projects\Day_19\bin'
print(os.path.dirname(file_path)) # D:\Software\PyCharm_Pro\projects\Day_19
2.3 os.path.exists
判断文件或文件夹是否存在
import os
file_path = r'D:\Software\PyCharm_Pro\projects\Day_19\ATM\bin'
print(os.path.exists(file_path)) # True
2.4 os.path.join
拼接路径
import os
file_path = r'D:\Software\PyCharm_Pro\projects\Day_19\ATM\bin'
print(os.path.join(file_path,'__init__')) # D:\Software\PyCharm_Pro\projects\Day_19\ATM\bin\__init__
2.5 os.path.basename
返回路径中的文件名或目录名
import os
file_path = r'D:\Software\PyCharm_Pro\projects\Day_19\ATM\bin'
print(os.path.basename(file_path)) # bin
file_path = r'D:\Software\PyCharm_Pro\projects\Day_19\ATM\bin\__init__.py'
print(os.path.basename(file_path)) # __init__.py
2.6 os.path.isfile
判断是否是文件
import os
file_path = r'D:\Software\PyCharm_Pro\projects\Day_19\ATM\bin'
print(os.path.basename(file_path)) # bin
file_path = r'D:\Software\PyCharm_Pro\projects\Day_19\ATM\bin\__init__.py'
print(os.path.basename(file_path)) # __init__.py
2.7 os.path.isdir
判断是否是文件夹
import os
file_path = r'D:\Software\PyCharm_Pro\projects\Day_19\ATM\bin\__init__.py'
print(os.path.isdir(file_path)) # False
file_path = r'D:\Software\PyCharm_Pro\projects\Day_19\ATM\bin'
print(os.path.isdir(file_path)) # True
2.8 os.path.split
分离路径中的文件名和文件扩展名,返回一个元组
import os
file_path = r'D:\Software\PyCharm_Pro\projects\Day_19\ATM\bin\__init__.py'
print(os.path.split(file_path))
# ('D:\\Software\\PyCharm_Pro\\projects\\Day_19\\ATM\\bin', '__init__.py')
2.9 os.path.getsize()
获取文件大小
import os
print(os.path.getsize(r'D:\Software\PyCharm_Pro\projects\Day_19\ATM\bin\__init__.py')) # 9
2.10 os.mkdir
创建文件夹
import os
directory_path = "new_directory"
os.mkdir(directory_path)
2.11 os.makedirs
创建多层目录(父目录不存在也一起创建)
import os
directory_path = "new_directory/sub_directory"
os.makedirs(directory_path)
2.12 os.rename
重命名文件夹或文件
# 重命名文件夹
import os
old_file_path = "old_dir"
new_file_path = "new_dir"
os.rename(old_file_path, new_file_path)
# 重命名文件
import os
old_file_path = r"new_dir\old_file.txt"
new_file_path = r"new_dir\new_file.txt"
os.rename(old_file_path, new_file_path)
2.13 os.list
获取指定目录下的所有文件和文件夹
import os
print(os.listdir('new_dir')) # ['new_file.txt', 'sub_directory'](返回的是列表类型)
2.14 os.getcmd
获取当前工作目录的路径
import os
print(os.getcwd()) # D:\Software\PyCharm_Pro\projects\Day_19
2.15 os.remove
删除文件
import os
os.remove(r'D:\Software\PyCharm_Pro\projects\Day_19\new_dir\new_file_txt')
2.16 os.rmdir
删除文件夹
import os
os.rmdir(r'new_dir\sub_directory')
PS:只有当目录为空(即没有任何文件或子目录)时,才能成功删除。
如果要删除非空目录,可以使用shutil模块中的shutil.rmtree()方法
【三】hashlib(数据加密)
hashlib模块是Python标准库中的一个模块,用于提供多种哈希算法的实现。哈希算法可以将任意长度的数据转换为固定长度的字符串,该字符串通常称为哈希值或摘要。
hashlib模块包含了常见的哈希算法,如MD5、SHA1、SHA256等。它提供了简单易用的接口,可以方便地计算字符串或文件的哈希值。
使用hashlib模块,可以对数据进行加密、数据完整性校验、密码存储等操作。常见的应用场景包括密码加密、文件校验、数字签名等。
用md5加密数据的两种方式
3.1.1 hashlib.md5()
import hashlib
data = "Hello, world!"
# 创建了一个MD5哈希对象,并将待加密的数据转换为字节类型后传入
hash_object = hashlib.md5(data.encode())
# 调用hexdigest()方法计算MD5哈希值
print(hash_object.hexdigest()) # 6cd3556deb0da54bca060b4c39479839
3.1.2 .update
(更新哈希对象的输入)
import hashlib
data = "Hello, world!"
hashlib_object = hashlib.md5() # 创建一个MD5哈希对象
hashlib_object.update(data.encode('utf_8')) # 更新哈希对象的输入
print(hashlib_object.hexdigest()) # 6cd3556deb0da54bca060b4c39479839
3.2 hashlib.md5
与.update
的区别
hashlib.md5(data.encode())
和md5.update
都是用于计算MD5哈希值的方法,但它们有一些区别:
-
参数类型:
hashlib.md5(data.encode())
中的data
参数需要是一个字符串,而md5.update()
中的data
参数可以是任意类型的数据,如字符串、字节字符串或文件等。 -
更新方式:
hashlib.md5(data.encode())
会直接将data
转换为字节字符串,然后计算其哈希值。而md5.update()
可以在计算哈希值之前多次调用,每次传入不同的数据块,以更新哈希对象的输入。 -
返回值:
hashlib.md5(data.encode())
会直接返回计算得到的哈希值,而md5.update()
不会返回哈希值,需要调用hexdigest()
或digest()
方法来获取最终的哈希值。
总结来说,hashlib.md5(data.encode())
是一次性计算给定数据的MD5哈希值,而md5.update()
可以在多次调用时逐步更新哈希值的输入,从而适用于处理较大的数据。
【四】time
time模块是Python的标准库之一,用于处理时间相关的操作。它提供了一些函数和类,可以用来获取当前时间、格式化时间、计算时间间隔等。
4.1 time.time
获取时间戳
时间戳是指一个特定时间点相对于某个固定的起点(通常是1970年1月1日午夜)所经过的秒数。在计算机领域中,时间戳通常用来表示和记录时间,特别是用于记录事件发生的时间顺序或计算时间间隔。
在Python中,可以使用time()
函数来获取当前的时间戳,它返回的是从起点开始计算的秒数。时间戳在很多情况下非常有用,例如在日志记录、计时器、缓存过期等场景中都会用到。
import time
print(time.time()) # 1702804274.902342
4.2 time.ctime
返回当前的系统时间,以可读的方式表示
这种时间显示方式是一种常见的时间格式,通常被称为"可读的时间格式"。它以星期几、月份、日期、小时、分钟和秒的顺序显示时间信息
import time
print(time.ctime()) # Sun Dec 17 17:13:15 2023
4.3 gmtime
返回一个表示当前时间的结构化对象,以UTC(协调世界时)为基准
import time
time.gmtime
# (tm_year=2023, tm_mon=12, tm_mday=17, tm_hour=9, tm_min=17, tm_sec=42, tm_wday=6, tm_yday=351, tm_isdst=0)
4.4 localtime
返回一个表示当前时间的结构化对象,以本地时区为基准
import time
print(time.localtime())
# time.struct_time(tm_year=2023, tm_mon=12, tm_mday=17, tm_hour=17, tm_min=23, tm_sec=6, tm_wday=6, tm_yday=351, tm_isdst=0)
4.5 strftime
将时间按照指定的格式转换为字符串
import time
now = time.strftime('%Y-%m-%d')
print(now) # 2023-12-17
now_new = time.strftime('%Y-%m-%d %H-%M-%S')
print(now_new) # 2023-12-17 17-29-47
【五】sys模块
sys
模块是Python中的一个内置模块,它提供了与Python解释器和运行时环境交互的函数和变量。它的作用包括但不限于以下几个方面:
-
提供了与命令行参数交互的功能,可以通过
sys.argv
获取在命令行中传递的参数。 -
提供了控制程序退出的功能,可以使用
sys.exit()
方法来退出程序的执行。 -
提供了与标准输入和标准输出流交互的功能,可以使用
sys.stdin
获取用户的输入,并使用sys.stdout
打印输出。 -
提供了与解释器和运行环境相关的信息,如
sys.version
可以获取Python解释器的版本信息,sys.path
可以获取模块搜索路径等。
5.1 sys.argv
(获取命令行参数)
import sys
args = sys.argv
# 打印命令行参数
for arg in args:
print(arg)
通过cmd执行python文件结果:
PS D:\Software\PyCharm_Pro\projects\Day_19> python .\practice.py arg1 arg2 arg3
.\practice.py
arg1
arg2
arg3
5.2 sys.exit
(退出程序)
import sys
# 打印提示信息
print("程序开始执行...")
# 根据条件判断是否退出程序
if 条件:
sys.exit()
# 程序继续执行
print("程序执行完毕...")
5.3 sys.stdin
(获取用户输入,仅能获取一行)
import sys
# 从标准输入中读取用户输入
input_data = sys.stdin.readline()
# 打印用户输入
print("用户输入:", input_data)
输入测试内容并输出结果:
测试测试!
用户输入: 测试测试!
5.4 sys.stdout
(将输出重定向到文件)
sys.stdout
是sys
模块中的一个变量,它表示标准输出流。标准输出是程序向屏幕或控制台打印输出的地方。通过修改sys.stdout
的值,我们可以改变标准输出的目标,例如将输出重定向到文件中。在第四个示例中,通过将sys.stdout
重定向到文件output.txt
,程序中的输出将被写入到该文件中,而不是显示在屏幕上。这样可以方便地将程序的输出保存到文件中,或者将输出传递给其他程序进行处理。
import sys
# 将输出重定向到文件
sys.stdout = open("output.txt", "w")
# 打印输出
print("Hello, World!")
# 恢复标准输出
sys.stdout = sys.__stdout__
【六】subprocess()
subprocess
模块是Python中用于创建新进程、管理子进程的模块。它提供了一些常用的方法来执行外部命令、控制子进程的输入输出等。
6.1 subprocess.call
调用操作系统执行dos命令
import subprocess
subprocess.call('dir', shell=True)
输出结果如下:
2023/12/20 17:04 <DIR> .
2023/12/16 10:34 <DIR> ..
2023/12/20 17:00 <DIR> .idea
2023/12/19 21:50 <DIR> ATM
【七】datetime
datetime
是Python内置的日期和时间处理模块,它提供了处理日期、时间、时间间隔和日期时间操作的功能。
datetime
模块中最常用的类是datetime
类,它表示一个具体的日期和时间。
7.1 datetime.now()
打印当前时间
from datetime import datetime
print(datetime.now()) # 2023-12-20 17:11:32.620934
7.2 datetime.strftime
格式化输出时间
from datetime import datetime
current_time = datetime.now()
formatted_time = current_time.strftime('%Y/%m/%d %X') # 2023/12/20 17:17:18
print(formatted_time)
7.3 time.delta
时间间隔
timedelta
表示一个时间间隔,它可以用来进行日期和时间的加减运算。通过创建一个timedelta
对象,可以对日期和时间进行增加或减少指定的时间间隔。例如,可以使用timedelta
来计算两个日期之间的时间差,或者将一个日期加上一定的时间间隔得到新的日期。
from datetime import datetime, timedelta
current_datetime = datetime.now()
# 这行代码创建了一个datetime对象current_datetime,并使用datetime.now()方法获取当前的日期和时间。
time1 = timedelta(weeks=1, days=1, seconds=60)
# 这行代码创建了一个timedelta对象one_day
next_day = current_datetime + time1
# 这行代码将current_datetime和one_day相加,得到一个新的datetime对象next_day,表示当前日期加上一天后的日期。
print(next_day)
# 这行代码将next_day打印输出,显示加上一天后的日期和时间。
【八】logging
8.1 配置日志字典
LOGGING_DIC = {
'version': 1,
'disable_existing_loggers': False,
'formatters': {
'standard': {
'format': '[%(asctime)s]-[%(threadName)s:%(thread)d]-[task_id:%(name)s]-[%(filename)s:%(lineno)d]-[%(levelname)s]-[%(message)s]'
},
'simple': {
'format': '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'
}
},
'handlers': {
'console': {
'level': 'DEBUG',
'class': 'logging.StreamHandler',
'formatter': 'simple'
},
'file': {
'level': 'DEBUG',
'class': 'logging.handlers.RotatingFileHandler',
'formatter': 'standard',
'filename': r'D:\Software\PyCharm_Pro\projects\Day_19\ATM\log\pipelining_information.log',
'maxBytes': 1024 * 1024 * 5,
'backupCount': 5,
'encoding': 'utf-8'
},
},
'loggers': {
'logger1': {
'level': 'DEBUG',
'handlers': ['file', 'console'],
'propagate': False
},
}
}
8.2 logging日志使用方法
# 导入日志模块
import logging.config
# 指定使用的日志配置字典
logging.config.dictConfig(LOGGING_DIC)
# 指定使用的日志处理器
logger1 = logging.getLogger('logger1')
# 指定日志等级(debug)
logger1.debug(f'{username_input}|减少余额:{withdrawal_amount}')
【九】re
(正则)
正则表达式(Regular Expression,简称 Regex 或 RE)是一种文本模式匹配工具,用于在字符串中查找、提取或替换符合特定规则的子字符串。它由一系列字符和特殊符号组成,可以用来检测文本中是否有符合指定规则的子字符串,或者将符合指定规则的子字符串替换成其他字符串。
正则表达式在各种编程语言中都有支持,例如 Python、Java、JavaScript、C++ 等。
正则表达式的常见用途包括:
- 验证输入:正则表达式可以用来验证用户输入是否符合特定的格式,例如电子邮件地址、电话号码、身份证号码等。
- 文本搜索和替换:正则表达式可以用来在文本中搜索和替换符合特定规则的子字符串。
- 数据提取:正则表达式可以用来从文本中提取特定格式的数据,例如从 HTML 代码中提取链接地址、从日志文件中提取错误信息等。
- 文本处理:正则表达式可以用来对文本进行各种处理,例如删除多余的空格、提取特定单词或短语、将文本转换为其他格式等。
9.1 字符组
正则字符组主要有以下几种:
- 字符集:匹配指定范围内的单个字符,例如
[a-z]
匹配所有小写字母,[0-9]
匹配所有数字。 - 取反字符集:匹配不在指定范围内的单个字符,例如
[^a-z]
匹配所有非小写字母,[^0-9]
匹配所有非数字。 - 交集字符集:匹配同时属于两个指定范围内的单个字符,例如
[a-z&&[^aeiou]]
匹配所有小写辅音字母。 - 并集字符集:匹配属于两个或多个指定范围内的单个字符,例如
[a-z|[0-9]]
匹配所有小写字母或数字。 - 重复字符集:匹配指定次数的单个字符,例如
[a]{3}
匹配连续出现 3 次的字母a
。 - 范围字符集:匹配指定范围内的单个字符或字符序列,例如
[a-zA-Z]
匹配所有字母,[0-9a-fA-F]
匹配所有十六进制数字。
9.2 元字符
正则元字符主要有以下几种:
- 句点(.):匹配除换行符(\n)之外的任何单个字符。
- 脱字符(^):匹配字符串的开头。
- 美元符号($):匹配字符串的结尾。
- 方括号 [ ]:匹配指定范围内的单个字符或字符序列。
- 大括号 { }:指定重复次数。
- 问号 ?:匹配前面字符出现一次或零次。
- 星号 *:匹配前面字符出现零次或多次。
- 加号 +:匹配前面字符出现一次或多次。
- 竖线 |:匹配指定范围内的多个字符或字符序列。
- 反斜杠 \:转义字符,用于取消元字符的特殊含义。
- \d :匹配数字字符,相当于 [0-9]。
- \D :匹配非数字字符,相当于[^0-9]。
- \w :匹配单词字符,相当于 [a-zA-Z0-9_]。
- \W :匹配非单词字符,相当于 [^a-zA-Z0-9_]。
- \s :匹配空白字符,包括空格、制表符、换行符等。
- \S :匹配非空白字符。
- \t :匹配制表符。
9.3 量词
正则表达式中的量词主要有以下几种:
- 问号(?):匹配前面字符出现一次或零次。
- 星号(*):匹配前面字符出现零次或多次。
- 加号(+):匹配前面字符出现一次或多次。
- 大括号({}):指定重复次数。
大括号({})的用法如下:
{n}
:匹配前面字符出现 n 次。{m,n}
:匹配前面字符出现 m 到 n 次。{m,}
:匹配前面字符出现至少 m 次。
例如:
ab?
:匹配字符串 "a" 后面跟一个可选的字符串 "b"。ab*
:匹配字符串 "a" 后面跟零个或多个字符串 "b"。ab+
:匹配字符串 "a" 后面跟一个或多个字符串 "b"。a{2}
:匹配字符串 "a" 出现两次。a{2,4}
:匹配字符串 "a" 出现 2 到 4 次。a{2,}
:匹配字符串 "a" 出现至少 2 次。
9.4 贪婪匹配
贪婪匹配是指正则表达式引擎在匹配字符串时,总是尽可能多地匹配字符。例如,以下正则表达式:
.*
会匹配字符串中的所有字符,直到字符串的结尾。
贪婪匹配的问题在于,它可能会导致正则表达式引擎匹配到不想要的内容。例如,以下正则表达式:
<.*>
旨在匹配 HTML 标签中的内容。然而,由于贪婪匹配,该正则表达式可能会匹配到整个 HTML 文档,而不是标签中的内容。
解决贪婪匹配问题的方法是使用 非贪婪匹配。非贪婪匹配是指正则表达式引擎在匹配字符串时,总是尽可能少地匹配字符。要使用非贪婪匹配,可以在量词后面加上一个问号(?)。例如,以下正则表达式:
.*?
会匹配字符串中的所有字符,直到第一个匹配的字符为止。
以下正则表达式:
<.*?>
会匹配 HTML 标签中的内容,而不匹配整个 HTML 文档。
示例:
文本:123abc456def789
正则表达式:.*
匹配结果:123abc456def789
正则表达式:.*?
匹配结果:123
从示例中可以看到,贪婪匹配会匹配到整个字符串,而非贪婪匹配只匹配到第一个匹配的字符。
9.5 re.compile(pattern)
编译正则表达式模式,返回一个正则表达式对象
import re
pattern = re.compile(r'\d+')
string = '123abc456def789'
match = re.findall(pattern, string)
print(match) # ['123', '456', '789']
9.6 re.match(pattern, string)
:尝试匹配整个字符串,如果匹配成功,返回一个匹配对象;否则,返回 None
import re
pattern = re.compile(r'Hello, (.*)!')
string = 'Hello, John!'
match = re.match(pattern, string)
print(match.group(1)) # John
9.7 re.search(pattern, string)
:扫描字符串,查找第一个匹配项,如果匹配成功,返回一个匹配对象;否则,返回 None
import re
pattern = re.compile(r'^1(.*)d$')
string = '123abcd'
match = re.search(pattern, string)
print(match.group(0)) # 123abcd
print(match.group(1)) # 23abc
9.8 re.findall(pattern, string)
:查找字符串中所有匹配项,并返回一个列表
import re
string = '123abc456def789'
pattern = re.compile(r'\d+')
matches = re.findall(pattern, string)
print(matches) # ['123', '456', '789']
9.9 re.finditer(pattern, string)
:查找字符串中所有匹配项,并返回一个迭代器
- 获取匹配字符方法1
import re
pattern = re.compile(r'\d+')
string = 'Today is 10th August 2021. The temperature is 32 degrees Celsius.'
# 查找所有匹配的子串
matches = re.finditer(pattern, string)
# 打印匹配的子串
for i in matches:
print(i.group())
#输出结果:
10
2021
32
- 获取匹配字符方法2
import re
pattern = re.compile(r'\d+')
string = 'Today is 10th August 2021. The temperature is 32 degrees Celsius.'
# 查找所有匹配的子串
matches = re.finditer(pattern, string)
# 打印匹配的子串
print(next(matches).group()) # 10
print(next(matches).group()) # 2021
print(next(matches).group()) # 32
9.10 re.sub(pattern, repl, string)
:用字符串 repl 替换字符串 string 中所有匹配 pattern 的子串,并返回替换后的字符串
import re
string = '123abc456def789'
res = re.sub(r'\d+', 'xxx', string, 3)
print(res) # xxxabcxxxdefxxx
9.11 re.split
将一个字符串按照指定的模式分割为多个子字符串,并返回一个列表
import re
# 创建一个正则表达式匹配模式
pattern = r'\d+'
# 创建一个要分割的字符串
text = 'Hello0World0!!!'
# 使用re.split函数进行字符串分割
split_text = re.split(pattern, text)
# 输出分割后的结果
print(split_text) # ['Hello', 'World', '!!!']
【十】pickle
pickle
模块是 Python 的标准库之一,用于序列化(即将对象转换为字节流)和反序列化(即将字节流转换为对象)。它可以将 Python 对象转换为可存储或传输的格式,以便在需要时可以重新创建相同的对象。
pickle
模块的主要作用是实现对象的持久化存储和恢复。通过 pickle
,你可以将 Python 对象保存到文件中,然后在需要时从文件中加载并重新创建对象。这对于保存和恢复程序状态、缓存计算结果、以及在分布式系统中进行对象传输等场景非常有用。
下面是一个简单的示例,演示了如何使用 pickle
进行对象的序列化和反序列化:
import pickle
# 定义一个对象
data = {'name': 'Alice', 'age': 25, 'city': 'New York'}
# 将对象序列化为字节流
serialized_data = pickle.dumps(data)
# 将字节流保存到文件
with open('data.pickle', 'wb') as file:
file.write(serialized_data)
# 从文件中读取字节流
with open('data.pickle', 'rb') as file:
loaded_data = file.read()
# 将字节流反序列化为对象
deserialized_data = pickle.loads(loaded_data)
print(deserialized_data) # {'name': 'Alice', 'age': 25, 'city': 'New York'}
(10.1) dumps
将对象序列化为字节流
pickle.dumps
用于将对象序列化为字节流,它可以将 Python 对象转换为可以存储或传输的字节流格式,而无需将其写入文件.
import pickle
# 定义一个对象
data = {'name': 'Alice', 'age': 25, 'city': 'New York'}
# 将对象序列化为字节流
serialized_data = pickle.dumps(data)
print(serialized_data) # 输出: b'\x80\x04\x95\x16\x00\x00\x00\x00\x00\x00\x00}\x94\x8c\x04name\x94\x8c\x05Alice\x94\x8c\x03age\x94K\x19\x8c\x04city\x94\x8c\nNew York\x94s.'
(10.2)loads
将序列化的字节流反序列化为对象
pickle.loads
用于将序列化的字节流反序列化为对象,它可以将之前使用 pickle.dumps()
方法序列化的字节流转换回原始的 Python 对象。
import pickle
# 序列化的字节流
serialized_data = b'\x80\x04\x95\x16\x00\x00\x00\x00\x00\x00\x00}\x94\x8c\x04name\x94\x8c\x05Alice\x94\x8c\x03age\x94K\x19\x8c\x04city\x94\x8c\nNew York\x94s.'
# 将字节流反序列化为对象
deserialized_data = pickle.loads(serialized_data)
print(deserialized_data) # 输出: {'name': 'Alice', 'age': 25, 'city': 'New York'}
(10.3)dump
将 Python 对象序列化并保存到文件中
pickle.dump
用于将 Python 对象序列化并保存到文件中,它可以将对象转换为字节流,并将字节流写入文件,以便后续可以使用 pickle.load()
方法将其加载回原始对象。
import pickle
# 要序列化的对象
data = {'name': 'Alice', 'age': 25, 'city': 'New York'}
# 将对象序列化并保存到文件
with open('data.pickle', 'wb') as file:
pickle.dump(data, file)
(10.4)load
从文件中加载并反序列化对象
pickle.load
用于从文件中加载并反序列化对象。它可以将之前使用 pickle.dump()
方法保存到文件中的序列化数据加载回原始的 Python 对象。
import pickle
# 从文件中加载并反序列化对象
with open('data.pickle', 'rb') as file:
loaded_data = pickle.load(file)
print(loaded_data) # 输出: {'name': 'Alice', 'age': 25, 'city': 'New York'}