526互联

【常用模块及方法】random_json_os_hashlib_time

发布时间 2024-01-09 22:04:52作者: Unlucky

【一】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提供的一个用于与操作系统进行交互的标准库。它提供了许多方法和函数，用于管理文件和目录、执行系统命令、获取系统信息等。

3.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

3.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

3.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

3.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__

3.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

3.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

3.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

3.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')

3.9 os.path.getsize() 获取文件大小

import os  

print(os.path.getsize(r'D:\Software\PyCharm_Pro\projects\Day_19\ATM\bin\__init__.py'))  # 9

3.10 os.mkdir 创建文件夹

import os  

directory_path = "new_directory"  
os.mkdir(directory_path)

3.11 os.makedirs创建多层目录（父目录不存在也一起创建）

import os 

directory_path = "new_directory/sub_directory" 
os.makedirs(directory_path)

3.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)

3.13 os.list 获取指定目录下的所有文件和文件夹

import os 

print(os.listdir('new_dir'))  # ['new_file.txt', 'sub_directory']（返回的是列表类型）

3.14 os.getcmd 获取当前工作目录的路径

import os 

print(os.getcwd())  # D:\Software\PyCharm_Pro\projects\Day_19

3.15 os.remove 删除文件

import os 

os.remove(r'D:\Software\PyCharm_Pro\projects\Day_19\new_dir\new_file_txt')

3.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加密数据的两种方式

4.1.1 hashlib.md5()

import hashlib  
  
data = "Hello, world!"
# 创建了一个MD5哈希对象，并将待加密的数据转换为字节类型后传入  
hash_object = hashlib.md5(data.encode())
# 调用hexdigest()方法计算MD5哈希值 
print(hash_object.hexdigest())  # 6cd3556deb0da54bca060b4c39479839

4.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

4.2 hashlib.md5与.update的区别

hashlib.md5(data.encode())和md5.update都是用于计算MD5哈希值的方法，但它们有一些区别：

  1. 参数类型：hashlib.md5(data.encode())中的data参数需要是一个字符串，而md5.update()中的data参数可以是任意类型的数据，如字符串、字节字符串或文件等。

  2. 更新方式：hashlib.md5(data.encode())会直接将data转换为字节字符串，然后计算其哈希值。而md5.update()可以在计算哈希值之前多次调用，每次传入不同的数据块，以更新哈希对象的输入。

  3. 返回值：hashlib.md5(data.encode())会直接返回计算得到的哈希值，而md5.update()不会返回哈希值，需要调用hexdigest()或digest()方法来获取最终的哈希值。

总结来说，hashlib.md5(data.encode())是一次性计算给定数据的MD5哈希值，而md5.update()可以在多次调用时逐步更新哈希值的输入，从而适用于处理较大的数据。

【五】time

time模块是Python的标准库之一，用于处理时间相关的操作。它提供了一些函数和类，可以用来获取当前时间、格式化时间、计算时间间隔等。

5.1 time.time 获取时间戳

时间戳是指一个特定时间点相对于某个固定的起点（通常是1970年1月1日午夜）所经过的秒数。在计算机领域中，时间戳通常用来表示和记录时间，特别是用于记录事件发生的时间顺序或计算时间间隔。

在Python中，可以使用time()函数来获取当前的时间戳，它返回的是从起点开始计算的秒数。时间戳在很多情况下非常有用，例如在日志记录、计时器、缓存过期等场景中都会用到。

import time  
  
print(time.time())  # 1702804274.902342

5.2 time.ctime 返回当前的系统时间，以可读的方式表示

这种时间显示方式是一种常见的时间格式，通常被称为"可读的时间格式"。它以星期几、月份、日期、小时、分钟和秒的顺序显示时间信息

import time

print(time.ctime())  # Sun Dec 17 17:13:15 2023

5.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)

5.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)

5.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解释器和运行时环境交互的函数和变量。它的作用包括但不限于以下几个方面：

  1. 提供了与命令行参数交互的功能，可以通过sys.argv获取在命令行中传递的参数。

  2. 提供了控制程序退出的功能，可以使用sys.exit()方法来退出程序的执行。

  3. 提供了与标准输入和标准输出流交互的功能，可以使用sys.stdin获取用户的输入，并使用sys.stdout打印输出。

  4. 提供了与解释器和运行环境相关的信息，如sys.version可以获取Python解释器的版本信息，sys.path可以获取模块搜索路径等。

6.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

6.2 sys.exit（退出程序）

import sys  
  
# 打印提示信息  
print("程序开始执行...")  
  
# 根据条件判断是否退出程序  
if 条件:  
    sys.exit()  
  
# 程序继续执行  
print("程序执行完毕...")

6.3 sys.stdin（获取用户输入，仅能获取一行）

import sys  
  
# 从标准输入中读取用户输入  
input_data = sys.stdin.readline()  
  
# 打印用户输入  
print("用户输入：", input_data)

输入测试内容并输出结果：

测试测试！
用户输入： 测试测试！

6.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中用于创建新进程、管理子进程的模块。它提供了一些常用的方法来执行外部命令、控制子进程的输入输出等。

7.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类，它表示一个具体的日期和时间。

8.1 datetime.now() 打印当前时间

from datetime import datetime  
  
print(datetime.now())  # 2023-12-20 17:11:32.620934

8.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)

8.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

9.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  
        },  
    }  
}

9.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 代码中提取链接地址、从日志文件中提取错误信息等。
  • 文本处理：正则表达式可以用来对文本进行各种处理，例如删除多余的空格、提取特定单词或短语、将文本转换为其他格式等。

正则表达式在线测试 - 站长工具 (chinaz.com)

10.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] 匹配所有十六进制数字。

10.2 元字符

正则元字符主要有以下几种：

  • 句点（.）：匹配除换行符（\n)之外的任何单个字符。
  • 脱字符（^）：匹配字符串的开头。
  • 美元符号（$）：匹配字符串的结尾。
  • 方括号 [ ]：匹配指定范围内的单个字符或字符序列。
  • 大括号 { }：指定重复次数。
  • 问号 ?：匹配前面字符出现一次或零次。
  • 星号 *：匹配前面字符出现零次或多次。
  • 加号 +：匹配前面字符出现一次或多次。
  • 竖线 |：匹配指定范围内的多个字符或字符序列。
  • 反斜杠 \：转义字符，用于取消元字符的特殊含义。
  • \d ：匹配数字字符，相当于 [0-9]。
  • \D ：匹配非数字字符，相当于[^0-9]。
  • \w ：匹配单词字符，相当于 [a-zA-Z0-9_]。
  • \W ：匹配非单词字符，相当于 [^a-zA-Z0-9_]。
  • \s ：匹配空白字符，包括空格、制表符、换行符等。
  • \S ：匹配非空白字符。
  • \t ：匹配制表符。

10.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 次。

10.4 贪婪匹配

贪婪匹配是指正则表达式引擎在匹配字符串时，总是尽可能多地匹配字符。例如，以下正则表达式：

.*

会匹配字符串中的所有字符，直到字符串的结尾。

贪婪匹配的问题在于，它可能会导致正则表达式引擎匹配到不想要的内容。例如，以下正则表达式：

<.*>

旨在匹配 HTML 标签中的内容。然而，由于贪婪匹配，该正则表达式可能会匹配到整个 HTML 文档，而不是标签中的内容。

解决贪婪匹配问题的方法是使用 非贪婪匹配。非贪婪匹配是指正则表达式引擎在匹配字符串时，总是尽可能少地匹配字符。要使用非贪婪匹配，可以在量词后面加上一个问号（?）。例如，以下正则表达式：

.*?

会匹配字符串中的所有字符，直到第一个匹配的字符为止。

以下正则表达式：

<.*?>

会匹配 HTML 标签中的内容，而不匹配整个 HTML 文档。

示例：

文本：123abc456def789

正则表达式：.*
匹配结果：123abc456def789

正则表达式：.*?
匹配结果：123

从示例中可以看到，贪婪匹配会匹配到整个字符串，而非贪婪匹配只匹配到第一个匹配的字符。

10.5 re.compile(pattern)编译正则表达式模式，返回一个正则表达式对象

import re  
  
pattern = re.compile(r'\d+')  
string = '123abc456def789'  
  
match = re.findall(pattern, string)  
  
print(match)  # ['123', '456', '789']

10.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

10.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

10.8 re.findall(pattern, string)：查找字符串中所有匹配项，并返回一个列表

import re  
string = '123abc456def789'  
pattern = re.compile(r'\d+')  
matches = re.findall(pattern, string)  
print(matches)  # ['123', '456', '789']

10.9 re.finditer(pattern, string)：查找字符串中所有匹配项，并返回一个迭代器

  1. 获取匹配字符方法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
  1. 获取匹配字符方法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

10.10 re.sub(pattern, repl, string)：用字符串 repl 替换字符串 string 中所有匹配 pattern 的子串，并返回替换后的字符串

import re  
  
string = '123abc456def789'  
  
res = re.sub(r'\d+', 'xxx', string, 3)  
print(res)  # xxxabcxxxdefxxx

10.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'}

（11.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.'

（11.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'}

（11.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)

（11.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'}