Python3 压缩与解压缩(zlib / gzip / bz2 / lzma / zipfile / tarfile)
本文由 Luzhuo 编写,转发请保留该信息.
原文: http://blog.csdn.net/Rozol/article/details/72672703
以下代码以Python3.6.1为例
Less is more!
文件的归档 (各种格式的压缩 / 解压缩)
实际使用中仅需要使用shutil模块的压缩和解压函数就可以了, 如果想尝试其他功能, zipfile(暴力破解), tarfile(命令行)也是值得推荐的
#!/usr/bin/env python
# coding=utf-8
__author__ = 'Luzhuo'
__date__ = '2017/5/21'
# filscondense.py 文件的归档 (各种格式的压缩 / 解压缩)
# 实际使用中仅需要使用shutil模块的压缩和解压函数就可以了, 如果想尝试其他功能, zipfile(暴力破解), tarfile(命令行)也是值得推荐的
import zlib
def zlib_demo():
# 对直接进行压缩
data = b'luzhuo.me'
com_bytes = zlib.compress(data)
print("压缩后的数据: ", com_bytes)
decom_bytes = zlib.decompress(com_bytes)
print("解压后的数据: ", decom_bytes)
# 对数据流进行压缩
with open("file.txt", "rb") as read, open("com.txt", "wb") as write:
com = zlib.compressobj(level=9, memLevel=9)
for data in read:
# 压缩数据并写入文件
write.write(com.compress(data))
write.write(com.flush())
# 对数据流进行解压
with open("com.txt", "rb") as read, open("temp.txt", "wb") as write:
decom = zlib.decompressobj()
for data in read:
write.write(decom.decompress(data))
write.write(decom.flush())
def zlib_func():
'''
zlib
'''
# zlib.adler32(data[, value]) // 计算数据的Adler-32校验和(比CRC32快), value:校验和的起始值(默认1)
num = zlib.adler32(b"luzhuo.me")
# zlib.crc32(data[, value]) // 计算数据的CRC(循环冗余校验)校验和, value:校验和的起始值,默认0
num = zlib.crc32(b"luzhuo.me")
# zlib.compress(data[, level]) // 压缩字节数据,返回压缩后的字节, level:[0,9],0:无压缩,1最小压缩,9最高压缩, 默认:6
bytes = zlib.compress(b"luzhuo.me")
# zlib.decompress(data[, wbits[, bufsize]]) // 解压缩, wbits:历史缓冲区(默认:15), bufsize:保存解压数据的缓冲区(默认:16384)
bytes = zlib.decompress(bytes)
# 压缩对象 level:压缩级别[0,9], method:压缩算法(DEFLATED), wbits:历史缓冲区大小,值越大,压缩效果更好(注:使用默认值), memLevel:内存量[1,9],值越大,效果更好更快
# strategy:策略 Z_DEFAULT_STRATEGY / Z_FILTERED / Z_HUFFMAN_ONLY, zdict:压缩字典(预期频繁出现的字节序列)
# zlib.compressobj(level=-1, method=DEFLATED, wbits=15, memLevel=8, strategy=Z_DEFAULT_STRATEGY[, zdict])
com = zlib.compressobj(level=9, memLevel=9)
# zlib.decompressobj(wbits=15[, zdict]) // 解压缩对象
decom = zlib.decompressobj()
strs = zlib.ZLIB_VERSION # zlib版本
strs = zlib.ZLIB_RUNTIME_VERSION # 解释器运行的zlib版本
# 压缩对象
com_data = com.compress(b"luzhuo.me") # 压缩数据
# Compress.flush([mode]) // 完成剩余压缩数据的字节对象, mode:Z_SYNC_FLUSH(可进步压缩) / Z_FULL_FLUSH(可进步压缩) / Z_FINISH(完成压缩)
data = com.flush()
com.copy() # 拷贝压缩对象副本
# 解压缩对象
# Decompress.decompress(data[, max_length]) // 解压
data = decom.decompress(data)
decom.unused_data # 将要解压的数据
decom.unconsumed_tail # 未解压的数据
decom.eof # 数据流是否已结束
decom.flush() # 完成压缩, 无法再次解压, length:缓冲区大小
decom.copy()
# 异常
try: pass
except zlib.error: pass # 压缩和解压缩错误而引发的异常
if __name__ == "__main__":
zlib_demo()
# zlib_func()
# ==================================
import gzip
import shutil
content = b"luzhuo.me"
def gzip_demo():
# 类字节对象的压缩与解压
# 压缩
bytes_com = gzip.compress(content)
print("字节压缩: ", bytes_com)
bytes_decom = gzip.decompress(bytes_com)
print("字节解压: ", bytes_decom)
# 对gzip文件的读写操作
# 写入
with gzip.open('box.gz', 'wb') as write:
write.write(content)
# 读取
with gzip.open('box.gz', 'rb') as read:
data = read.read()
print(data)
# 文件对象的压缩与解压
# 压缩
with open('file.txt', 'rb') as read, gzip.open('file.txt.gz', 'wb') as write:
shutil.copyfileobj(read, write)
# 解压
with gzip.open('file.txt.gz', 'rb') as read, open('temp.txt', 'wb') as write:
shutil.copyfileobj(read, write)
def gzip_func():
'''
该模块提供简单压缩和解压缩文件, 数据压缩有zlib提供
f = gzip.open(), 压缩就直接往里写, 解压就直接读取
'''
# 打开gzip压缩文件: filename:文件名或file对象, mode:读写模式,二进制: 'r', 'rb'(默认), 'a', 'ab', 'w', 'wb', 'x', 'xb',文本:'rt', 'at', 'wt', 'xt', compresslevel:压缩级别[0,9], 文本模式可提供(二进制模式不需要):encoding / errors / newline
# gzip.open(filename, mode='rb', compresslevel=9, encoding=None, errors=None, newline=None)
file = gzip.open("box.gz")
# gzip.compress(data, compresslevel=9) // 压缩
bytes = gzip.compress(b"luzhuo.me")
bytes = gzip.decompress(bytes) # 解压
if __name__ == "__main__":
gzip_demo()
# gzip_func()
# ================================
import bz2
def bz2_demo():
# 单次压缩
bytes_com = bz2.compress(content)
print("单次压缩: ", bytes_com)
bytes_decom = bz2.decompress(bytes_com)
print("单次解压: ", bytes_decom)
# 增量压缩
bzcom = bz2.BZ2Compressor()
bzdecom = bz2.BZ2Decompressor()
bytes_com = bzcom.compress(content)
bytes_com += bzcom.flush()
print("增量压缩: ", bytes_com)
bytes_decom = bzdecom.decompress(bytes_com)
print("增量解压: ", bytes_decom)
# 读写压缩
with open('file.txt', 'rb') as read, bz2.open('file.txt.gz', 'wb') as write:
shutil.copyfileobj(read, write)
with bz2.open('file.txt.gz', 'rb') as read, open('temp.txt', 'wb') as write:
shutil.copyfileobj(read, write)
def bz2_func():
'''
使用bzip2压缩算法压缩和解压
该模块的所有类都是线程安全的
读取和写入压缩文件: open() BZ2File
增量压缩: BZ2Compressor BZ2Decopressor
单次压缩: compress() decompress()
'''
# 读写压缩文件
# 二进制或文本模式打开bzip2压缩文件
# bz2.open(filename, mode='r', compresslevel=9, encoding=None, errors=None, newline=None)
file = bz2.open("box.bz2")
# 单次压缩
# bz2.compress(data, compresslevel=9)
bytes_com = bz2.compress(b'luzhuo.me')
# bz2.decompress(data)
bytes_decom = bz2.decompress(bytes_com)
# 增量压缩
# class bz2.BZ2Compressor(compresslevel=9)
bzcom = bz2.BZ2Compressor()
bytes_com = bzcom.compress(b'luzhuo.me') # 压缩
bytes_com = bzcom.flush() # 完成压缩, 返回剩余的压缩数据
# 增量压缩的解压缩
# class bz2.BZ2Decompressor
bzdecom = bz2.BZ2Decompressor()
# decompress(data, max_length=-1) // 解压
bytes_decom = bzdecom.decompress(bytes_com)
boolean = bzdecom.eof # 是否到达流结束标记
if __name__ == "__main__":
bz2_demo()
# bz2_func()
# =====================================
import lzma
def lzma_demo():
# 增量压缩
lzmacom = lzma.LZMACompressor()
data = lzmacom.compress(b'luzhuo')
data += lzmacom.compress(b'.')
data += lzmacom.compress(b'me')
print("增量压缩: ", data)
# 读写
with open('file.txt', 'rb') as read, lzma.open('file.txt.xz', 'wb') as write:
shutil.copyfileobj(read, write)
def lzma_func():
'''
LZMA压缩算法压缩和解压缩
LZMAFile线程不是安全的
'''
# 文件
# 读取:format, filters, 写入:format, check, preset, filters
# lzma.open(filename, mode="rb", *, format=None, check=-1, preset=None, filters=None, encoding=None, errors=None, newline=None)
f = lzma.open("box.xz")
# lzma.compress(data, format=FORMAT_XZ, check=-1, preset=None, filters=None) // 压缩
bytes_com = lzma.compress(b'luzhuo.me')
# lzma.decompress(data, format=FORMAT_AUTO, memlimit=None, filters=None) // 解压
bytes_decom = lzma.decompress(bytes_com)
# lzma.is_check_supported(check) // 是否支持完整性检查
boolean = lzma.is_check_supported(lzma.CHECK_SHA256)
# 压缩对象 check:完整性检查:CHECK_NONE,CHECK_CRC32(32位循环冗余校验),CHECK_CRC64(64位循环冗余校验),CHECK_SHA256(sha256)
# preset: 压缩级别[0,9]
# class lzma.LZMACompressor(format=FORMAT_XZ, check=-1, preset=None, filters=None)
lzmacom = lzma.LZMACompressor()
bytes_com = lzmacom.compress(b"luzhuo.me") # 压缩
bytes_com = lzmacom.flush() # 完成压缩
# 解压缩对象
# class lzma.LZMADecompressor(format=FORMAT_AUTO, memlimit=None, filters=None)
lzmadecom = lzma.LZMADecompressor()
# decompress(data, max_length=-1)
bytes_decom = lzmadecom.decompress(bytes_com) # 解压
# 异常
try: pass
except lzma.LZMAError: pass # 在压缩或解压或初始化时发生错误
if __name__ == "__main__":
lzma_demo()
# lzma_func()
# ================================================
import zipfile
def zip_demo():
# 创建压缩包
with zipfile.ZipFile(r"file.zip", "a") as write:
# 往压缩包里添加文件
write.write("file.txt")
# 测试压缩包
error = write.testzip()
if error:
print("压缩文件错误: ", error)
return
# 打印压缩包信息
write.printdir()
write.close()
# 解压压缩包
with zipfile.ZipFile(r"file.zip", "r") as read:
read.extractall("temp")
read.close()
def zip_func():
'''
ZIP格式的压缩和解压
不支持多磁盘ZIP文件处理
可以使用ZIP64扩展(>4G的ZIP文件)
可以解密经过加密的ZIP文件,但是不能创建加密的ZIP文件
解密速度缓慢,因为是通过Python实现的
'''
# class zipfile.ZipFile // 读写的zip类
# class zipfile.ZipInfo(filename='NoName', date_time=(1980, 1, 1, 0, 0, 0)) // Zip信息
zipfile.ZIP_STORED # 存储 方法常量0
zipfile.ZIP_DEFLATED # ZIP压缩 方法常量8
zipfile.ZIP_BZIP2 # BZIP2压缩 方法常量12
zipfile.ZIP_LZMA # LZMA压缩 方法常量14
boolean = zipfile.is_zipfile(r"file.zip") # 是否是zip文件, 参数可为文件名 / 类文件对象 (测试:.rar也是zip文件)
# --- class zipfile.ZipFile // 读写的zip类 ---
# file:文件名 / 类文件对象, mode:r, w, a, x(创建并写入), compression:ZIP_STORED, ZIP_DEFLATED, ZIP_BZIP2, ZIP_LZMA, allowZip64:zip文件大于2G时需要使用, 支持with
# class zipfile.ZipFile(file, mode='r', compression=ZIP_STORED, allowZip64=True)
zipf = zipfile.ZipFile(r"file.zip")
zipf.close() # 关闭压缩文件,并写入基本信息
lists = zipf.infolist() # 压缩包里每个成员文件的zipinfo对象
lists = zipf.namelist() # 压缩包里的成员文件列表
info = zipf.getinfo(lists[0]) # 获取指定成员文件的zipinfo对象
# ZipFile.open(name, mode='r', pwd=None) //打开成员文件, name:文件名 / zipinfo, pwd:密码,用于加密了的文件
f = zipf.open(lists[0])
# ZipFile.extract(member, path=None, pwd=None) // 提取成员文件, member:文件名 / zipinfo, path:提取到指定目录, 返回提取后的文件绝对路径
path = zipf.extract(lists[0])
# ZipFile.extractall(path=None, members=None, pwd=None) // 提取全部成员文件, members:提取的成员,由namelist()返回的列表子集
zipf.extractall()
zipf.printdir() # 打印(sys.stdout)成员文件
zipf.setpassword("123") # 设置密码, 用于提取加密文件
# ZipFile.read(name, pwd=None) // 读取指定成员文件字节内容, 压缩文件必须以 r / a 打开
zipf.read(lists[0])
# ZipFile.write(filename, arcname=None, compress_type=None) // 追加成员文件, filename:文件名, arcname:写入压缩包的名字(默认同filename)
zipf.write("temp.txt")
# ZipFile.writestr(zinfo_or_arcname, data[, compress_type]) // 成员文件写入字符串, zinfo_or_arcname: 成员文件名 / zipinfo
zipf.writestr(lists[0], b"luzhuo.me") # 压缩文件必须以 w, a, x 打开, 覆盖写入成员文件, 并且最后要close()
zipf.testzip() # 测试压缩包, 检查CRC和文件头, 返回第一个坏文件的名称, 没有坏文件返回None
zipf.debug # 测试输出, [0,3], 0(默认):无输出, 3:最大输出
zipf.comment # 注释文本, 压缩文件以 w, x ,a 打开, 不超过65535字节的字符
# ZipInfo类的实例由ZipFile对象的getinfo()和infolist()方法返回
# --- class zipfile.ZipInfo(filename='NoName', date_time=(1980, 1, 1, 0, 0, 0)) // Zip信息 ---
info.filename # 成员文件文件名
info.date_time # 修改日期时间 (年, 月, 日, 时, 分, 秒)
info.compress_type # 压缩类型
info.comment # 注释
info.compress_size # 文件压缩后的大小
info.file_size # 文件未压缩时的大小
info.extra # 扩展字段数据
info.create_system # 创建ZIP存档的系统
info.create_version # PKZIP版本创建ZIP存档
info.extract_version # PKZIP版本需要提取归档
info.reserved # 0
info.flag_bits # ZIP标志
info.volume # 文件头的卷编号
info.internal_attr # 内部属性
info.external_attr # 外部文件属性
info.header_offset # 字节偏移到文件头
info.CRC # CRC - 32的未压缩文件
# 异常
try: pass
except zipfile.BadZipFile: pass # zip文件引发的错误
except zipfile.LargeZipFile: pass # 需要ZIP64功能, 但未启用
if __name__ == "__main__":
zip_demo()
# zip_func()
# ==============================================
import tarfile
def tarfile_demo():
# 创建压缩包
with tarfile.open(r"file.tar", "w:gz") as write:
# 往压缩包里添加文件
write.add("file.txt")
# 测试压缩包
# 没有提供测试函数
# 打印压缩包信息
write.list()
# 解压压缩包
with tarfile.open(r"file.tar", "r:gz") as read:
read.extractall("temp")
def tarfile_func():
'''
tar文件的压缩和解压
同时支持gzip / bz2 / lzma的相关操作
'''
# mode:
# 'r''r:*': 打开(默认)
# 'r:': 无压缩打开
# 'r:gz': gzip压缩打开
# 'r:bz2': bzip2压缩打开
# 'r:xz': lzma压缩打开
# 'x''x:': 创建无压缩tarfile
# 'x:gz': 创建gzip压缩tarfile
# 'x:bz2': 创建bzip2压缩tarfile
# 'x:xz': 创建lzma压缩tarfile
# 'a''a:': 打开
# 'w''w:': 未压缩的写入(注:存在则覆盖)
# 'w:gz': gzip压缩写入
# 'w:bz2':bzip2压缩写入
# 'w:xz': lzma压缩写
# 'r|*': 读取流
# 'r|': 读取未压缩流
# 'r|gz': 读取gzip压缩流
# 'r|bz2': 读取bzip2压缩流
# 'r|xz': 读取lzma压缩流
# 'w|': 写入未压缩流
# 'w|gz': 写入gzip压缩流
# 'w|bz2': 写入bzip2压缩流
# 'w|xz': 写入lzma压缩流
tarfile.ENCODING # 编码
tarfile.USTAR_FORMAT # POSIX.1 - 1988格式
tarfile.GNU_FORMAT # GNU tar格式
tarfile.PAX_FORMAT # POSIX.1 - 2001格式
tarfile.DEFAULT_FORMAT # GNU_FORMAT(默认格式)
# tarfile.open(name=None, mode='r', fileobj=None, bufsize=10240, **kwargs) // fileobj: 二进制file-object 支持with
tarf = tarfile.open(r"file.tar")
tarfile.is_tarfile(r"file.tar") # 是否是tar文件
# class tarfile.TarFile // tarfile.open()返回的对象
# mode: r, a, w, x, fileobj:file-obj, format:USTAR_FORMAT,GNU_FORMAT,PAX_FORMAT, tarinfo:可替换默认的TarInfo, dereference:True添加文件,False添加软硬链接, ignore_zeros: 是否忽略空块(损坏的文件设为False), debug:[0,3]
# class tarfile.TarFile(name=None, mode='r', fileobj=None, format=DEFAULT_FORMAT, tarinfo=TarInfo, dereference=False, ignore_zeros=False, encoding=ENCODING, errors='surrogateescape', pax_headers=None, debug=0, errorlevel=0)
# 类方法
tarfile.TarFile.open(...) # 同 tarfile.open()
tarinfo = tarf.getmember("file.txt") # 获取指定成员文件的TarInfo对象, 未找到KeyError
lists = tarf.getmembers() # 成员文件TarInfo列表
lists = tarf.getnames() # 成员文件名字列表
# TarFile.list(verbose=True, *, members=None) // 打印目录, verbose:是否详细, members:可选成员,getmembers()的子集
tarf.list()
tarf.next() # 下个文件的TarInfo
# TarFile.extractall(path=".", members=None, *, numeric_owner=False) // 解压全部
tarf.extractall()
# TarFile.extract(member, path="", set_attrs=True, *, numeric_owner=False) // 解压指定成员文件
tarf.extract(lists[0])
bf_read = tarf.extractfile(lists[0]) # 提取成员文件,返回io.BufferedReader对象
# name: 文件名, arcname:存储的成员文件名, exclude: def exclude(filename){已弃用}:return True排除,False添加, filter:def filter(tarinfo):return Tarinfo添加,None排除
# TarFile.add(name, arcname=None, recursive=True, exclude=None, *, filter=None)
tarf.add("temp.txt")
# TarFile.addfile(tarinfo, fileobj=None) // 添加tarinfo
tarf.addfile(tarf.gettarinfo())
# TarFile.gettarinfo(name=None, arcname=None, fileobj=None) // 获取TarInfo,可通过addfile()修改, 非r模式
tarinfo = tarf.gettarinfo(arcname="file.txt")
tarf.close() # 关闭, 并写入两个零块
tarf.pax_headers # pax全局头的键值对的字典
# --- TarInfo ---
# 创建
# class tarfile.TarInfo(name="")
tarinfo = tarfile.TarInfo(name="temp.txt")
# 类方法
# TarInfo.frombuf(buf, encoding, errors) // 从字符缓冲区创建TarInfo
tarinfo = tarfile.TarInfo.fromtarfile(tarf) # tarfile读取下个成员,返回TarInfo
# TarInfo.tobuf(format=DEFAULT_FORMAT, encoding=ENCODING, errors='surrogateescape') // 从TarInfo创建字符缓冲区
tarinfo.name # 文件名
tarinfo.size # 大小(bite)
tarinfo.mtime # 修改时间戳
tarinfo.mode # 权限
tarinfo.type # 类型:REGTYPE,AREGTYPE,LNKTYPE,SYMTYPE,DIRTYPE,FIFOTYPE,CONTTYPE,CHRTYPE,BLKTYPE,GNUTYPE_SPARSE
tarinfo.linkname # 目标文件名
tarinfo.uid # 用户id
tarinfo.gid # 用户组
tarinfo.uname # 用户名
tarinfo.gname # 用户组名
tarinfo.pax_headers # pax扩展头的键值对的字典
tarinfo.isfile() # 是否是文件
tarinfo.isreg() # 同isfile
tarinfo.isdir() # 是否是目录
tarinfo.issym() # 是否是符号链接
tarinfo.islnk() # 是否是硬链接
tarinfo.ischr() # 是否是字符设备
tarinfo.isblk() # 是否是块设备
tarinfo.isfifo() # 是否是FIFO
tarinfo.isdev() # 是否是字符设备,块设备或FIFO之一
# 异常
try: pass
except tarfile.TarError: pass # tarfile异常的基类
except tarfile.ReadError: pass # tar文件打开时引发的异常
except tarfile.CompressionError: pass # 无法解码
except tarfile.StreamError: pass # 数据流异常
except tarfile.ExtractError: pass # TarFile.extract()(解压)引发的异常
except tarfile.HeaderError: pass # TarInfo.frombuf()(缓冲区无效)引发的异常
# 命令行模式(python -m tarfile -l file.tar)
# -l <tarfile>
# --list <tarfile>
# 列出成员文件
#
# -c <tarfile> <source1> <sourceN>
# --create <tarfile> <source1> <sourceN>
# 创建, tarfile:压缩包名, source1:资源名...
#
# -e <tarfile> [<output_dir>]
# --extract <tarfile> [<output_dir>]
# 解压, output_dir:解压目录
#
# -t <tarfile>
# --test <tarfile>
# 测试
#
# -v
# --verbose
# 打印命令详情
if __name__ == "__main__":
tarfile_demo()
# tarfile_func()
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
- 140
- 141
- 142
- 143
- 144
- 145
- 146
- 147
- 148
- 149
- 150
- 151
- 152
- 153
- 154
- 155
- 156
- 157
- 158
- 159
- 160
- 161
- 162
- 163
- 164
- 165
- 166
- 167
- 168
- 169
- 170
- 171
- 172
- 173
- 174
- 175
- 176
- 177
- 178
- 179
- 180
- 181
- 182
- 183
- 184
- 185
- 186
- 187
- 188
- 189
- 190
- 191
- 192
- 193
- 194
- 195
- 196
- 197
- 198
- 199
- 200
- 201
- 202
- 203
- 204
- 205
- 206
- 207
- 208
- 209
- 210
- 211
- 212
- 213
- 214
- 215
- 216
- 217
- 218
- 219
- 220
- 221
- 222
- 223
- 224
- 225
- 226
- 227
- 228
- 229
- 230
- 231
- 232
- 233
- 234
- 235
- 236
- 237
- 238
- 239
- 240
- 241
- 242
- 243
- 244
- 245
- 246
- 247
- 248
- 249
- 250
- 251
- 252
- 253
- 254
- 255
- 256
- 257
- 258
- 259
- 260
- 261
- 262
- 263
- 264
- 265
- 266
- 267
- 268
- 269
- 270
- 271
- 272
- 273
- 274
- 275
- 276
- 277
- 278
- 279
- 280
- 281
- 282
- 283
- 284
- 285
- 286
- 287
- 288
- 289
- 290
- 291
- 292
- 293
- 294
- 295
- 296
- 297
- 298
- 299
- 300
- 301
- 302
- 303
- 304
- 305
- 306
- 307
- 308
- 309
- 310
- 311
- 312
- 313
- 314
- 315
- 316
- 317
- 318
- 319
- 320
- 321
- 322
- 323
- 324
- 325
- 326
- 327
- 328
- 329
- 330
- 331
- 332
- 333
- 334
- 335
- 336
- 337
- 338
- 339
- 340
- 341
- 342
- 343
- 344
- 345
- 346
- 347
- 348
- 349
- 350
- 351
- 352
- 353
- 354
- 355
- 356
- 357
- 358
- 359
- 360
- 361
- 362
- 363
- 364
- 365
- 366
- 367
- 368
- 369
- 370
- 371
- 372
- 373
- 374
- 375
- 376
- 377
- 378
- 379
- 380
- 381
- 382
- 383
- 384
- 385
- 386
- 387
- 388
- 389
- 390
- 391
- 392
- 393
- 394
- 395
- 396
- 397
- 398
- 399
- 400
- 401
- 402
- 403
- 404
- 405
- 406
- 407
- 408
- 409
- 410
- 411
- 412
- 413
- 414
- 415
- 416
- 417
- 418
- 419
- 420
- 421
- 422
- 423
- 424
- 425
- 426
- 427
- 428
- 429
- 430
- 431
- 432
- 433
- 434
- 435
- 436
- 437
- 438
- 439
- 440
- 441
- 442
- 443
- 444
- 445
- 446
- 447
- 448
- 449
- 450
- 451
- 452
- 453
- 454
- 455
- 456
- 457
- 458
- 459
- 460
- 461
- 462
- 463
- 464
- 465
- 466
- 467
- 468
- 469
- 470
- 471
- 472
- 473
- 474
- 475
- 476
- 477
- 478
- 479
- 480
- 481
- 482
- 483
- 484
- 485
- 486
- 487
- 488
- 489
- 490
- 491
- 492
- 493
- 494
- 495
- 496
- 497
- 498
- 499
- 500
- 501
- 502
- 503
- 504
- 505
- 506
- 507
- 508
- 509
- 510
- 511
- 512
- 513
- 514
- 515
- 516
- 517
- 518
- 519
- 520
- 521
- 522
- 523
- 524
- 525
- 526
- 527
- 528
- 529
- 530
- 531
- 532
- 533
- 534
- 535
- 536
- 537
- 538
- 539
- 540
- 541
- 542
- 543
- 544
- 545
- 546
- 547
- 548
- 549
- 550
- 551
- 552
- 553
- 554
- 555
- 556
- 557
- 558
- 559
- 560
- 561
- 562
- 563
- 564
- 565
- 566
- 567
- 568
- 569
- 570
<link rel="stylesheet" href="https://csdnimg.cn/release/phoenix/template/css/markdown_views-ea0013b516.css">
</div>