序列化相关模块

将原本的字典、列表等内容转换成一个字符串的过程就叫做序列化

序列化的目的

1. 以某种存储形式使自定义对象持久化；
2. 将对象从一个地方传递到另一个地方。
3. 使程序更具维护性。

python可序列化的数据类型，序列化出来之后的结果如下:

json模块

Python 的 json 模块用于处理 JSON（JavaScript Object Notation）数据格式。JSON 是一种轻量级的数据交换格式，易于人类阅读和编写，同时也易于机器解析和生成。json 模块提供了简单的方法来编码（序列化）和解码（反序列化）JSON数据。

常用功能

1. 序列化：将 Python 数据类型转换为 JSON 格式。
2. 反序列化：将 JSON 格式的数据转换为 Python 数据类型。

基本用法

1. 导入模块

首先需要导入 json 模块：

import json

1. 序列化 Python 对象为 JSON 字符串

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

data = {
    "name": "Alice",
    "age": 30,
    "is_student": False,
    "courses": ["Math", "Science"]
}

json_string = json.dumps(data)
print(json_string)

输出：

{"name": "Alice", "age": 30, "is_student": false, "courses": ["Math", "Science"]}

1. 反序列化 JSON 字符串为 Python 对象

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

json_string = '{"name": "Alice", "age": 30, "is_student": false, "courses": ["Math", "Science"]}'
data = json.loads(json_string)

print(data)
print(data['name'])  # 访问字典中的值

输出：

{'name': 'Alice', 'age': 30, 'is_student': False, 'courses': ['Math', 'Science']}
Alice

1. 从文件读取 JSON 数据

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

# 假设 json_data.json 文件内容是上面的 JSON 字符串
with open('json_data.json', 'r') as file:
    data = json.load(file)
    print(data)

1. 将 Python 对象写入 JSON 文件

使用 json.dump() 方法将 Python 对象写入 JSON 文件。

data = {
    "name": "Bob",
    "age": 25,
    "is_student": True,
    "courses": ["English", "History"]
}

with open('output.json', 'w') as file:
    json.dump(data, file)

自定义序列化

可以通过自定义函数来处理复杂对象。

import json

data = {'name': 'Alice', 'age': 30, 'is_student': False, 'courses': ['Math', 'Science']}
json_dic2 = json.dumps(data,sort_keys=True,indent=2,separators=(',',':'),ensure_ascii=False)
print(json_dic2)

输出：

{
  "age":30,
  "courses":[
    "Math",
    "Science"
  ],
  "is_student":false,
  "name":"Alice"
}

pickle模块

Python 的 pickle 模块用于对象的序列化（将对象转换为字节流）和反序列化（将字节流转换回对象）。这使得在程序之间传递对象或将对象保存到文件中变得非常方便。

json模块和picle模块都有 dumps、dump、loads、load四种方法，而且用法一样。

不同的是json模块序列化出来的是通用格式，其它编程语言都认识，就是普通的字符串，而picle模块序列化出来的只有python可以认识，其他编程语言不认识的，表现为乱码。甚至pickle还可以序列化函数。

基本用法

1. 序列化对象

import pickle

data = {
    'name': 'Alice',
    'age': 30,
    'is_student': False,
    'courses': ['Math', 'Science']
}

# 将对象序列化并写入文件
with open('data.pkl', 'wb') as file:
    pickle.dump(data, file)

# 将对象序列化为字节串
data_bytes = pickle.dumps(data)
print(data_bytes)

1. 反序列化对象

import pickle

# 从文件中读取对象
with open('data.pkl', 'rb') as file:
    loaded_data = pickle.load(file)
    print(loaded_data)

data_bytes = b'\x80\x04\x95I\x00\x00\x00\x00\x00\x00\x00}\x94(\x8c\x04name\x94\x8c\x05Alice\x94\x8c\x03age\x94K\x1e\x8c\nis_student\x94\x89\x8c\x07courses\x94]\x94(\x8c\x04Math\x94\x8c\x07Science\x94eu.'
# 从字节串中反序列化
loaded_data_from_bytes = pickle.loads(data_bytes)
print(loaded_data_from_bytes)

shelve模块

Python 的 shelve 模块提供了一种简单的持久化存储方式，类似于字典（dictionary），但它可以将数据持久化到文件中。shelve 模块允许将 Python 对象存储在文件中，以便在后续的程序运行中重新加载。

基本用法

1. 导入模块

首先，需要导入 shelve 模块：

import shelve

1. 打开一个 shelve 文件

使用 shelve.open() 打开一个 shelve 文件。该文件可以被视为一个持久化的字典。

shelf = shelve.open('my_shelf.db')

1. 存储数据

可以通过键值对的方式将数据存储到 shelve 中，类似于字典的使用。

shelf['name'] = 'Alice'
shelf['age'] = 30
shelf['courses'] = ['Math', 'Science']

1. 读取数据

可以通过键来读取存储的数据。

print(shelf['name'])   # 输出: Alice
print(shelf['age'])    # 输出: 30
print(shelf['courses']) # 输出: ['Math', 'Science']

1. 更新和删除数据

可以像操作字典一样更新和删除数据。

shelf['age'] = 31  # 更新年龄
del shelf['courses']  # 删除课程

1. 关闭 shelve 文件

在完成操作后，务必关闭 shelve 文件，以确保数据被写入和释放资源。

shelf.close()

完整示例

以下是一个完整的示例，展示了如何使用 shelve 模块：

import shelve

# 打开 shelve 文件
with shelve.open('my_shelf.db') as shelf:
    # 存储数据
    shelf['name'] = 'Alice'
    shelf['age'] = 30
    shelf['courses'] = ['Math', 'Science']

    # 读取数据
    print(shelf['name'])   # 输出: Alice
    print(shelf['age'])    # 输出: 30
    print(shelf['courses']) # 输出: ['Math', 'Science']

    # 更新数据
    shelf['age'] = 31
    print(shelf['age'])    # 输出: 31

    # 删除数据
    del shelf['courses']

# 再次打开 shelve 文件以读取数据
with shelve.open('my_shelf.db') as shelf:
    print(shelf.get('courses', 'No courses found'))  # 输出: No courses found

hashlib模块

Python 的 hashlib 模块提供了多种安全哈希和消息摘要算法的接口。这些算法用于生成数据的唯一哈希值，广泛应用于数据完整性校验、密码存储和数字签名等领域。

什么是摘要算法呢？摘要算法又称哈希算法、散列算法。它通过一个函数，把任意长度的数据转换为一个长度固定的数据串（通常用16进制的字符串表示）。

摘要算法就是通过摘要函数f()对任意长度的数据data计算出固定长度的摘要digest，目的是为了发现原始数据是否被人篡改过。

摘要算法之所以能指出数据是否被篡改过，就是因为摘要函数是一个单向函数，计算f(data)很容易，但通过digest反推data却非常困难。而且，对原始数据做一个bit的修改，都会导致计算出的摘要完全不同。

hashlib 支持多种哈希算法，包括：

• MD5
• SHA-1
• SHA-224
• SHA-256
• SHA-384
• SHA-512
• BLAKE2

基本用法

1. 导入模块

首先需要导入 hashlib 模块：

import hashlib

1. 创建哈希对象

可以使用不同的算法创建哈希对象。以下是一些常见算法的示例：

# 创建一个 SHA-256 哈希对象
sha256_hash = hashlib.sha256()

# 创建一个 MD5 哈希对象
md5_hash = hashlib.md5()

1. 更新哈希对象

使用 update() 方法将数据传递给哈希对象。可以多次调用 update() 方法以添加更多数据。

data = b"Hello, World!"
sha256_hash.update(data)
md5_hash.update(data)

1. 获取哈希值

使用 hexdigest() 方法获取哈希值的十六进制字符串表示。

sha256_digest = sha256_hash.hexdigest()
md5_digest = md5_hash.hexdigest()

print("SHA-256:", sha256_digest)
print("MD5:", md5_digest)

完整示例

以下是一个完整的示例，展示了如何使用 hashlib 模块：

import hashlib

# 要哈希的数据
data = b"Hello, World!"

# 使用 SHA-256 算法
sha256_hash = hashlib.sha256()
sha256_hash.update(data)
print("SHA-256:", sha256_hash.hexdigest())

# 使用 MD5 算法
md5_hash = hashlib.md5()
md5_hash.update(data)
print("MD5:", md5_hash.hexdigest())

# 使用 SHA-512 算法
sha512_hash = hashlib.sha512()
sha512_hash.update(data)
print("SHA-512:", sha512_hash.hexdigest())

注意事项

1. 不可逆性：哈希函数是不可逆的，意味着无法从哈希值恢复原始数据。
2. 碰撞：不同的输入可能生成相同的哈希值（称为碰撞），但现代的哈希算法力求使碰撞的概率尽量低。
3. 安全性：对于密码存储，建议使用更安全的哈希算法（如 SHA-256 或更高版本）和适当的盐值（salt）来增强安全性。

使用场景

• 数据完整性：用于验证文件或数据在传输过程中未被篡改。
• 密码存储：将用户密码的哈希值存储在数据库中，而不是明文密码。
• 数字签名：用于创建数字签名，确保数据来源的可靠性。

任何允许用户登录的网站都会存储用户登录的用户名和口令。如何存储用户名和口令呢？方法是存到数据库表中

name    | password
--------+----------
michael | 123456
bob     | abc999
alice   | alice2008

如果使用md5来将保护密码那么就是这样

username | password
---------+---------------------------------
michael  | e10adc3949ba59abbe56e057f20f883e
bob      | 878ef96e86145580c38c87f0410ad153
alice    | 99b1c2188db85afee403b1536010c2c9

有很多md5撞库工具，可以轻松的将简单密码给碰撞出来

所以，要确保存储的用户口令不是那些已经被计算出来的常用口令的MD5，这一方法通过对原始口令加一个复杂字符串来实现，俗称“加盐”

collections模块

在内置数据类型（dict、list、set、tuple）的基础上，collections模块还提供了几个额外的数据类型：Counter、deque、defaultdict、namedtuple和OrderedDict等。

1. namedtuple: 生成可以使用名字来访问元素内容的tuple

2. deque: 双端队列，可以快速的从另外一侧追加和推出对象

3. Counter: 计数器，主要用来计数

4. OrderedDict: 有序字典

5. defaultdict: 带有默认值的字典

namedtuple

from collections import namedtuple
point = namedtuple('point',['x','y'])
p = point(1,2)
print(p.x)

一个点的二维坐标就可以表示成,但是，看到(1, 2)，很难看出这个tuple是用来表示一个坐标的。

这时，namedtuple就派上了用场

deque

使用list存储数据时，按索引访问元素很快，但是插入和删除元素就很慢了，因为list是线性存储，数据量大的时候，插入和删除效率很低。

deque是为了高效实现插入和删除操作的双向列表，适合用于队列和栈

from collections import deque

q = deque(['a','b','c'])
q.append('x')
q.appendleft('y')

print(q)

deque除了实现list的append()和pop()外，还支持appendleft()和popleft()，这样就可以非常高效地往头部添加或删除元素。

OrderedDict

from collections import OrderedDict

d = dict([('a',1),('b',2),('c',3)])
print(d)

od = OrderedDict([('a',1),('b',2),('c',3)])
print(od)

注意，OrderedDict的Key会按照插入的顺序排列，不是Key本身排序

defaultdict

有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。

即： {'k1': 大于66 , 'k2': 小于66}

# 以前的做法
li = [11,22,33,44,55,77,88,99,90]

result = {}
for row in li:
    if row < 66:
        if 'key1' not in result:
            result['key1']=[]
        result['key1'].append(row)
    else:
        if 'key2' not in result:
            result['key2']=[]
        result['key2'].append(row)
print(result)

#defaultdict
from collections import defaultdict

li = [11,22,33,44,55,77,88,99,90]
result=defaultdict(list)

for row in li:
    if row > 66:
        result['key1'].append(row)
    else:
        result['key2'].append(row)

print(result)

counter

Counter类的目的是用来跟踪值出现的次数。它是一个无序的容器类型，以字典的键值对形式存储，其中元素作为key，其计数作为value。

from collections import Counter

c = Counter('qazxswqazxswqazxswsxaqwsxaqws') 
print(c)

输出：

Counter({'s': 6, 'q': 5, 'a': 5, 'x': 5, 'w': 5, 'z': 3})

时间相关的模块

time模块

常用方法

• time.sleep(secs)
  • (线程)推迟指定的时间运行。单位为秒。
• time.time()
  • 获取当前时间戳

表示时间的三种方式

在Python中，通常有这三种方式来表示时间：时间戳、结构化的时间(struct_time)、格式化的时间字符串(Format String)：

1. 时间戳(timestamp) ：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型。

2. 格式化的时间字符串(Format String)： ‘1999-12-06’

1. 结构化时间(struct_time) ：struct_time结构化时间共有9个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天等）

import time

# 第一种时间格式，时间戳的形式
print(time.time())

# 第二种时间格式，格式化的时间
print(time.strftime('%Y-%m-%d %X'))
print(time.strftime('%Y-%m-%d %H-%M-%S'))

# 第三种时间格式，结构化的时间，是一个元组
print(time.localtime())

小结：时间戳是计算机能够识别的时间；时间字符串是人能够看懂的时间；元组则是用来操作时间的

几种格式之间的转换

import time

# 格式化时间 ---->  结构化时间
ft = time.strftime('%Y/%m/%d %H:%M:%S')
st = time.strptime(ft,'%Y/%m/%d %H:%M:%S')
print(st)
# 结构化时间 ---> 时间戳
t = time.mktime(st)
print(t)

# 时间戳 ----> 结构化时间
t = time.time()
st = time.localtime(t)
print(st)
# 结构化时间 ---> 格式化时间
ft = time.strftime('%Y/%m/%d %H:%M:%S',st)
print(ft)

import time

#结构化时间 --> %a %b %d %H:%M:%S %Y串
#time.asctime(结构化时间) 如果不传参数，直接返回当前时间的格式化串
print(time.asctime(time.localtime(1550312090.4021888)))

#时间戳 --> %a %d %d %H:%M:%S %Y串
#time.ctime(时间戳)  如果不传参数，直接返回当前时间的格式化串
print(time.ctime(1550312090.4021888))

计算时间差

import time

start_time=time.mktime(time.strptime('2017-09-11 08:30:00','%Y-%m-%d %H:%M:%S'))
end_time=time.mktime(time.strptime('2024-10-12 11:00:50','%Y-%m-%d %H:%M:%S'))
dif_time=end_time-start_time
struct_time=time.gmtime(dif_time)
print('过去了%d年%d月%d天%d小时%d分钟%d秒'%(struct_time.tm_year-1970,struct_time.tm_mon-1,
                                       struct_time.tm_mday-1,struct_time.tm_hour,
                                       struct_time.tm_min,struct_time.tm_sec))

datatime模块

某些情况下，我们需要写一个定时的任务，比如几分钟后，几分钟前，这种情况下，用time模块就不太好操作。这个时候我们需要datatime模块来完成这个操作

# datatime模块
import datetime
now_time = datetime.datetime.now()  # 现在的时间
# 只能调整的字段：weeks days hours minutes seconds
print(datetime.datetime.now() + datetime.timedelta(weeks=3)) # 三周后
print(datetime.datetime.now() + datetime.timedelta(weeks=-3)) # 三周前
print(datetime.datetime.now() + datetime.timedelta(days=-3)) # 三天前
print(datetime.datetime.now() + datetime.timedelta(days=3)) # 三天后
print(datetime.datetime.now() + datetime.timedelta(hours=5)) # 5小时后
print(datetime.datetime.now() + datetime.timedelta(hours=-5)) # 5小时前
print(datetime.datetime.now() + datetime.timedelta(minutes=-15)) # 15分钟前
print(datetime.datetime.now() + datetime.timedelta(minutes=15)) # 15分钟后
print(datetime.datetime.now() + datetime.timedelta(seconds=-70)) # 70秒前
print(datetime.datetime.now() + datetime.timedelta(seconds=70)) # 70秒后

current_time = datetime.datetime.now()
# 可直接调整到指定的 年 月 日 时 分 秒 等

print(current_time.replace(year=1977))  # 直接调整到1977年
print(current_time.replace(month=1))  # 直接调整到1月份
print(current_time.replace(year=1989,month=4,day=25))  # 1989-04-25 18:49:05.898601

# 将时间戳转化成时间
print(datetime.date.fromtimestamp(1232132131))  # 2009-01-17

random模块

用来生成随机数模块

import random

print(random.random())          # 大于0且小于1之间的小数
print(random.uniform(1,3))      # 大于1小于3的小数

print(random.randint(1,5))      # 大于等于1且小于等于5之间的整数
print(random.randrange(1,10,2))   # 大于等于1且小于10之间的奇数

ret = random.choice([1,'23',[4,5]])     # 1或者23或者[4,5]
print(ret)

a,b = random.sample([1,'23',[4,5]],2)   # 列表元素任意2个组合
print(a,b)

item = [1,3,5,7,9]
random.shuffle(item)    # 打乱次序
print(item)

生成随机验证码

import random

def v_code():
    code = ''
    for i in range(5):
        num=random.randint(0,9)
        alf=chr(random.randint(65,90))
        add=random.choice([num,alf])
        code="".join([code,str(add)])

    return code

print(v_code())

OS模块

os模块是与操作系统交互的一个接口

当前执行这个python文件的工作目录相关的工作路径

文件夹相关

文件相关

操作系统差异相关

执行系统命令相关

path系列，和路径相关

import os

print(os.stat('.\diary.txt'))  # 当前目录下的diary文件的信息

# Output:
os.stat_result(st_mode=33206, st_ino=36310271995704245, st_dev=2088613962, st_nlink=1, st_uid=0, st_gid=0, st_size=11, st_atime=1725502765, st_mtime=1725502764, st_ctime=1725502759)

sys模块

sys模块是与python解释器交互的一个接口

re模块

正则表达式

正则就是用一些具有特殊含义的符号组合到一起（称为正则表达式）来描述字符或者字符串的方法。或者说：正则就是用来描述一类事物的规则。（在Python中）它内嵌在Python中，并通过 re 模块实现。正则表达式模式被编译成一系列的字节码，然后由用 C 编写的匹配引擎执行。

单字符匹配

import re

print(re.findall('\w','上大人123asdfg%^&*(_ \t \n)'))
print(re.findall('\W','上大人123asdfg%^&*(_ \t \n)'))

print(re.findall('\s','上大人123asdfg%^&*(_ \t \n)'))
print(re.findall('\S','上大人123asdfg%^&*(_ \t \n)'))

print(re.findall('\d','上大人123asdfg%^&*(_ \t \n)'))
print(re.findall('\D','上大人123asdfg%^&*(_ \t \n)'))

print(re.findall('\A上大','上大人123asdfg%^&*(_ \t \n)'))
print(re.findall('^上大','上大人123asdfg%^&*(_ \t \n)'))

print(re.findall('666\z','上大人123asdfg%^&*(_ \t \n)666'))
print(re.findall('666\Z','上大人123asdfg%^&*(_ \t \n)666'))
print(re.findall('666$','上大人123asdfg%^&*(_ \t \n)666'))

print(re.findall('\n','上大人123asdfg%^&*(_ \t \n)'))
print(re.findall('\t','上大人123asdfg%^&*(_ \t \n)'))

重复匹配

import re

print(re.findall('a.b', 'ab aab a*b a2b a牛b a\nb'))
print(re.findall('a.b', 'ab aab a*b a2b a牛b a\nb',re.DOTALL))

print(re.findall('a?b', 'ab aab abb aaaab a牛b aba**b'))

print(re.findall('a*b', 'ab aab aaab abbb'))
print(re.findall('ab*', 'ab aab aaab abbbbb'))

print(re.findall('a+b', 'ab aab aaab abbb'))

print(re.findall('a{2,4}b', 'ab aab aaab aaaaabb'))

print(re.findall('a.*b', 'ab aab a*()b'))

print(re.findall('a.*?b', 'ab a1b a*()b, aaaaaab'))
# .*? 此时的?不是对左边的字符进行0次或者1次的匹配,
# 而只是针对.*这种贪婪匹配的模式进行一种限定:告知他要遵从非贪婪匹配 推荐使用!

# []: 括号中可以放任意一个字符,一个中括号代表一个字符
# - 在[]中表示范围,如果想要匹配上- 那么这个-符号不能放在中间.
# ^ 在[]中表示取反的意思.
print(re.findall('a.b', 'a1b a3b aeb a*b arb a_b'))
print(re.findall('a[abc]b', 'aab abb acb adb afb a_b'))
print(re.findall('a[0-9]b', 'a1b a3b aeb a*b arb a_b'))
print(re.findall('a[a-z]b', 'a1b a3b aeb a*b arb a_b'))
print(re.findall('a[a-zA-Z]b', 'aAb aWb aeb a*b arb a_b'))
print(re.findall('a[0-9][0-9]b', 'a11b a12b a34b a*b arb a_b'))
print(re.findall('a[*-+]b','a-b a*b a+b a/b a6b'))
print(re.findall('a[-*+]b','a-b a*b a+b a/b a6b'))
print(re.findall('a[^a-z]b', 'acb adb a3b a*b'))

# 分组：() 制定一个规则,将满足规则的结果匹配出来
print(re.findall('(.*?)_66', 'cs_66 zhao_66 日天_66'))
print(re.findall('href="(.*?)"','<a href="http://www.baidu.com">点击</a>'))

print(re.findall('compan(y|ies)','Too many companies have gone bankrupt, and the next one is my company'))
print(re.findall('compan(?:y|ies)','Too many companies have gone bankrupt, and the next one is my company'))
# 分组() 中加入?: 表示将整体匹配出来而不只是()里面的内容

常用方法举例

import re

# findall 全部找到返回一个列表
print(re.findall('a','aghjmnbghagjmnbafgv'))

# search 只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以通过调用group()方法得到匹配的字符串,如果字符串没有匹配，则返回None
print(re.search('Eagle', 'welcome to Eagleslab'))
print(re.search('Eagle', 'welcome to Eagleslab').group())

# match：None,同search,不过在字符串开始处进行匹配,完全可以用search+^代替match
print(re.match('sb|chensong', 'chenong 66 66 demon 日天'))
print(re.match('chensong', 'chensong 66 66 barry 日天').group())

# split 分割 可按照任意分割符进行分割
print(re.split('[:：,;；，]','1;3,c,a：3'))

# sub 替换
print(re.sub('镇江','英格科技','欢迎来到镇江'))

# complie 根据包含的正则表达式的字符串创建模式对象。可以实现更有效率的匹配。
obj = re.compile('\d{2}')
print(obj.search('abc123eeee').group())
print(obj.findall('1231232aasd'))

ret = re.finditer('\d','asd123affess32432')      # finditer返回一个存放匹配结果的迭代器
print(ret)
print(next(ret).group())
print(next(ret).group())
print([i.group() for i in ret])

命名分组举例

import re

ret = re.search("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>")
print(ret.group('tag_name'))
print(ret.group())

ret = re.search(r"<(\w+)>\w+</\1>","<h1>hello</h1>")
# 如果不给组起名字，也可以用\序号来找到对应的组，表示要找的内容和前面的组内容一致
# 获取的匹配结果可以直接用group(序号)拿到对应的值
print(ret.group(1))
print(ret.group())

shutil模块

shutil 是 Python 的标准库之一，提供了许多高级文件操作，例如复制和移动文件，以及创建和提取压缩文件

可以理解为高级的文件、文件夹、压缩包处理模块

常用方法

拷贝内容

import shutil

shutil.copyfileobj(open('a.txt','r'),open('a.txt.new','w'))

拷贝文件

import shutil

shutil.copyfile('file.txt','file1.txt') # 目标文件无需存在

拷贝状态信息

import shutil

shutil.copystat('file.txt','file1.txt') # 目标文件必须存在

移动文件

import shutil
# 移动文件或目录
shutil.move(src_path, dst_path)

删除文件和目录

import shutil
# 删除单个文件
shutil.rmtree(directory_path)  # 删除整个目录树
shutil.remove(file_path)       # 删除单个文件

创建目录

import shutil
# 创建单个目录
shutil.mkdir(directory_path)
# 创建嵌套目录
shutil.makedirs(directory_path)

压缩和解压缩文件

shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的

import zipfile

# 压缩
z = zipfile.ZipFile('ab.zip', 'w')
z.write('a.txt')
z.write('b.txt')
z.close()

# 解压
z = zipfile.ZipFile('ab.zip', 'r')
z.extractall(path=r'C:\Users\Atopos\Desktop')
z.close()

import tarfile

# 压缩文件
t = tarfile.open('/tmp/egon.tar','w')
t.add('/test1/a.py',arcname='a.bak')
t.add('/test1/b.py',arcname='b.bak')
t.close()

# 解压缩文件
t = tarfile.open('/tmp/egon.tar','r')
t.extractall('/egon')
t.close()