python3怎么解壓縮.gz文件

這篇文章主要講解了“python3怎么解壓縮.gz文件”，文中的講解內容簡單清晰，易于學習與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學習“python3怎么解壓縮.gz文件”吧！

python3 解壓縮.gz文件

python3 解壓一個.gz后綴的壓縮文件，如下：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
import gzip
 
def un_gz(file_name):
    
    # 獲取文件的名稱，去掉后綴名
    f_name = file_name.replace(".gz", "")
    # 開始解壓
    g_file = gzip.GzipFile(file_name)
    #讀取解壓后的文件，并寫入去掉后綴名的同名文件（即得到解壓后的文件）
    open(f_name, "wb+").write(g_file.read())
    g_file.close()
    
un_gz('D:\\python36\\config.gz')

可以看到在此路徑下生成一個解壓后的文件

注：一開始網上看到很多類似的寫法但是上面第13行的寫法是以下的樣子

open(f_name, "w+").write(g_file.read())

實際執行會報 TypeError: write() argument must be str, not bytes

說是打開方式的問題，按照 “wb+” 的格式解決此問題

Python3 壓縮與解壓縮(zlib/gzip/bz2/lzma/zipfile/tarfile)

以下代碼以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()

<link rel="stylesheet" href="https://csdnimg.cn/release/phoenix/template/css/markdown_views-ea0013b516.css" rel="external nofollow" >
</div>

感謝各位的閱讀，以上就是“python3怎么解壓縮.gz文件”的內容了，經過本文的學習后，相信大家對python3怎么解壓縮.gz文件這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是億速云，小編將為大家推送更多相關知識點的文章，歡迎關注！