vegibit

Compress and Decompress Files with Python zipfile and gzip Modules

Click to share! ⬇️

File compression and decompression are essential techniques in modern computing, as they allow users to efficiently store, transfer, and manage large amounts of data. In the world of Python, there are two built-in modules that can assist you in handling file compression and decompression tasks: the zipfile and gzip modules. These modules are powerful, easy to use, and provide excellent performance, making them ideal for a wide range of applications.

In this tutorial, we will explore the capabilities of the zipfile and gzip modules in Python. We will learn how to install these modules, compress and decompress files using both modules, handle multiple files, set compression levels, work with password-protected archives, and more. We will also discuss error handling and performance optimization techniques to ensure that your Python compression and decompression tasks run smoothly and efficiently.

Whether you are a beginner or an experienced Python developer, this tutorial will provide you with valuable insights and practical examples that will help you effectively utilize the zipfile and gzip modules in your projects. So let’s dive in and start compressing and decompressing files with Python!

How To Install zipfile and gzip Modules in Python

The zipfile and gzip modules are part of the Python Standard Library, which means that you don’t need to install them separately. As long as you have a compatible version of Python installed on your system, you should be able to use these modules right away.

To check if you have Python installed, open a terminal or command prompt and type the following command:

python --version

If Python is installed, you’ll see the version number displayed. For instance, you might see something like this:

Python 3.9.7

Once you have Python installed, you can start using the zipfile and gzip modules in your Python scripts. To import them, simply add the following lines at the beginning of your script:

import zipfile
import gzip

Now you’re ready to use the zipfile and gzip modules to compress and decompress files in your Python projects! In the following sections, we’ll explore various functionalities and techniques for working with these modules.

How To Compress Files Using the zipfile Module

The zipfile module in Python allows you to compress files and directories into a ZIP archive. In this section, we’ll demonstrate how to create a new ZIP archive and add files to it using the zipfile module.

  1. Import the zipfile module:
import zipfile
  1. Create a new ZIP archive:

To create a new ZIP archive, use the ZipFile class from the zipfile module. You’ll need to specify the archive name and the mode in which to open the file. For creating a new archive, use the 'w' (write) mode.

archive_name = 'my_archive.zip'
with zipfile.ZipFile(archive_name, 'w') as zipf:
    # Add files to the archive here
  1. Add files to the ZIP archive:

Inside the with block, you can use the write() method to add files to the archive. The write() method takes two arguments: the file’s original path and the name it should have inside the archive (also called the arcname). If you want to maintain the original file name in the archive, you can just provide the file path as the first argument.

file_name = 'example.txt'
with zipfile.ZipFile(archive_name, 'w') as zipf:
    zipf.write(file_name)
  1. (Optional) Compress files with a specific compression method:

By default, the zipfile module uses the DEFLATED compression method. However, you can specify a different method by setting the compression parameter when creating the ZipFile object. Available compression methods are zipfile.ZIP_STORED (no compression) and zipfile.ZIP_DEFLATED (standard compression).

compression_method = zipfile.ZIP_DEFLATED
with zipfile.ZipFile(archive_name, 'w', compression=compression_method) as zipf:
    zipf.write(file_name)

That’s it! You have successfully compressed a file using the zipfile module in Python. You can add more files to the archive by calling the write() method multiple times before closing the ZipFile object.

How To Decompress Files Using the zipfile Module

In this section, we will demonstrate how to decompress files from a ZIP archive using the zipfile module in Python.

  1. Import the zipfile module:
import zipfile
  1. Open the ZIP archive:

To open an existing ZIP archive, use the ZipFile class from the zipfile module and specify the archive name and mode in which to open the file. For decompressing files, use the 'r' (read) mode.

archive_name = 'my_archive.zip'
with zipfile.ZipFile(archive_name, 'r') as zipf:
    # Extract files from the archive here
  1. Extract files from the ZIP archive:

Inside the with block, you can use the extract() or extractall() methods to decompress files from the archive.

  • extract(): This method extracts a single file from the archive. You’ll need to provide the name of the file inside the archive (arcname) and the destination path where the file should be saved.python
arcname = 'example.txt'
destination_path = 'extracted_files'
with zipfile.ZipFile(archive_name, 'r') as zipf:
    zipf.extract(arcname, path=destination_path)

extractall(): This method extracts all files from the archive to a specified directory. If the destination path is not provided, the files will be extracted to the current working directory.

destination_path = 'extracted_files'
with zipfile.ZipFile(archive_name, 'r') as zipf:
    zipf.extractall(path=destination_path)

You have successfully decompressed files from a ZIP archive using the zipfile module in Python.

How To Compress Files Using the gzip Module

The gzip module in Python allows you to compress and decompress files using the Gzip file format. In this section, we’ll demonstrate how to compress a file using the gzip module.

  1. Import the gzip module:
import gzip
  1. Open the source file and the destination Gzip file:

To compress a file using the gzip module, you’ll need to open both the source file (in read-binary mode, ‘rb’) and the destination Gzip file (in write-binary mode, ‘wb’).

source_file = 'example.txt'
gzip_file = 'example.txt.gz'

with open(source_file, 'rb') as src_file, gzip.open(gzip_file, 'wb') as gz_file:
    # Compress the file here
  1. Compress the file:

Inside the with block, read the contents of the source file and write them to the destination Gzip file. You can read and write the file in chunks to handle larger files efficiently.

buffer_size = 1024 * 1024  # 1 MB

with open(source_file, 'rb') as src_file, gzip.open(gzip_file, 'wb') as gz_file:
    buffer = src_file.read(buffer_size)
    while buffer:
        gz_file.write(buffer)
        buffer = src_file.read(buffer_size)

Great Work! You have successfully compressed a file using the gzip module in Python. The compressed file will be saved with a ‘.gz’ extension.

How To Decompress Files Using the gzip Module

In this section, we will demonstrate how to decompress files from a Gzip file using the gzip module in Python.

  1. Import the gzip module:
import gzip
  1. Open the Gzip file and the destination file:

To decompress a Gzip file, you’ll need to open both the Gzip file (in read-binary mode, ‘rb’) and the destination file (in write-binary mode, ‘wb’).

gzip_file = 'example.txt.gz'
destination_file = 'example_decompressed.txt'

with gzip.open(gzip_file, 'rb') as gz_file, open(destination_file, 'wb') as dest_file:
    # Decompress the file here
  1. Decompress the file:

Inside the with block, read the contents of the Gzip file and write them to the destination file. You can read and write the file in chunks to handle larger files efficiently.

buffer_size = 1024 * 1024  # 1 MB

with gzip.open(gzip_file, 'rb') as gz_file, open(destination_file, 'wb') as dest_file:
    buffer = gz_file.read(buffer_size)
    while buffer:
        dest_file.write(buffer)
        buffer = gz_file.read(buffer_size)

How To Handle Multiple Files with zipfile and gzip Modules

In this section, we’ll demonstrate how to handle multiple files with zipfile and gzip modules in Python.

  1. Handling multiple files with zipfile module:

The zipfile module is designed to work with archives that can contain multiple files. To compress multiple files into a single ZIP archive, you can call the write() method multiple times before closing the ZipFile object.

import zipfile

file_list = ['file1.txt', 'file2.txt', 'file3.txt']
archive_name = 'multiple_files.zip'

with zipfile.ZipFile(archive_name, 'w') as zipf:
    for file_name in file_list:
        zipf.write(file_name)

To decompress specific files from a ZIP archive, you can use the extract() method for each file you want to extract. If you want to extract all files, use the extractall() method.

import zipfile

archive_name = 'multiple_files.zip'
destination_path = 'extracted_files'

with zipfile.ZipFile(archive_name, 'r') as zipf:
    # Extract all files
    zipf.extractall(path=destination_path)

    # Or, extract specific files
    for file_name in file_list:
        zipf.extract(file_name, path=destination_path)
  1. Handling multiple files with gzip module:

The gzip module is designed to work with individual files rather than archives containing multiple files. To compress or decompress multiple files with the gzip module, you can use a loop and process each file separately.

For example, to compress multiple files:

import gzip

file_list = ['file1.txt', 'file2.txt', 'file3.txt']

for file_name in file_list:
    gzip_file = file_name + '.gz'

    with open(file_name, 'rb') as src_file, gzip.open(gzip_file, 'wb') as gz_file:
        gz_file.writelines(src_file)

To decompress multiple gzip files:

import gzip

gzip_file_list = ['file1.txt.gz', 'file2.txt.gz', 'file3.txt.gz']

for gzip_file in gzip_file_list:
    destination_file = gzip_file[:-3]

    with gzip.open(gzip_file, 'rb') as gz_file, open(destination_file, 'wb') as dest_file:
        dest_file.writelines(gz_file)

When handling multiple files, the zipfile module is suitable for creating and extracting archives containing multiple files, while the gzip module works with individual files and requires processing each file separately in a loop.

How To Set Compression Levels in zipfile and gzip Modules

Setting compression levels allows you to balance the trade-off between file size and compression/decompression speed. In this section, we’ll show you how to set compression levels in zipfile and gzip modules in Python.

  1. Set Compression Levels in zipfile Module:

To set the compression level in the zipfile module, you need to use the ZipFile class with the compresslevel parameter. The compresslevel parameter accepts an integer value from 0 to 9, where 0 represents no compression (fastest) and 9 represents maximum compression (slowest).

import zipfile

file_name = 'example.txt'
archive_name = 'compressed.zip'
compression_level = 5

with zipfile.ZipFile(archive_name, 'w', compresslevel=compression_level) as zipf:
    zipf.write(file_name)

Note that the compresslevel parameter is only effective when using the zipfile.ZIP_DEFLATED compression method (default). If you set the compression method to zipfile.ZIP_STORED, there will be no compression regardless of the compresslevel value.

  1. Set Compression Levels in gzip Module:

To set the compression level in the gzip module, you need to use the gzip.open() function with the compresslevel parameter. Similar to the zipfile module, the compresslevel parameter accepts an integer value from 0 to 9.

import gzip

source_file = 'example.txt'
gzip_file = 'example.txt.gz'
compression_level = 5

with open(source_file, 'rb') as src_file, gzip.open(gzip_file, 'wb', compresslevel=compression_level) as gz_file:
    gz_file.writelines(src_file)

By setting appropriate compression levels, you can optimize your compression and decompression tasks according to your specific requirements, whether you need faster speeds or smaller file sizes.

How To Work with Password-Protected Archives in zipfile Module

In this section, we’ll demonstrate how to create and extract password-protected ZIP archives using the zipfile module in Python. The gzip module does not support password protection, so we’ll only cover the zipfile module here.

  1. Create a password-protected ZIP archive:

To create a password-protected ZIP archive, you can use the setpassword() method after creating a ZipFile object. The setpassword() method accepts a password in bytes format.

import zipfile

file_name = 'example.txt'
archive_name = 'protected.zip'
password = b'my_password'

with zipfile.ZipFile(archive_name, 'w') as zipf:
    zipf.write(file_name)
    zipf.setpassword(password)
  1. Extract files from a password-protected ZIP archive:

To extract files from a password-protected ZIP archive, you can use the extract() or extractall() methods with the pwd parameter, which accepts a password in bytes format.

  • Extract a single file:
import zipfile

archive_name = 'protected.zip'
destination_path = 'extracted_files'
arcname = 'example.txt'
password = b'my_password'

with zipfile.ZipFile(archive_name, 'r') as zipf:
    zipf.extract(arcname, path=destination_path, pwd=password)
  • Extract all files:
import zipfile

archive_name = 'protected.zip'
destination_path = 'extracted_files'
password = b'my_password'

with zipfile.ZipFile(archive_name, 'r') as zipf:
    zipf.extractall(path=destination_path, pwd=password)

Please note that the password protection provided by the zipfile module is based on the Zip 2.0 encryption standard, which is considered weak and can be cracked using brute-force attacks. If you need to protect sensitive data, consider using more secure encryption methods or tools like 7-Zip, which support AES-256 encryption.

How To Handle Errors and Exceptions in zipfile and gzip Modules

When working with the zipfile and gzip modules, it’s essential to handle errors and exceptions that may occur during file compression or decompression. In this section, we’ll cover common exceptions and how to handle them when using zipfile and gzip modules.

  1. Handling exceptions in zipfile module:

Some common exceptions when using the zipfile module are:

  • BadZipFile: Raised when the file is not a valid ZIP file or is corrupted.
  • LargeZipFile: Raised when the size of the ZIP file exceeds the allowed limit (by default, 4 GB).
  • RuntimeError: Raised when you try to write to a closed ZipFile object or when an unsupported compression method is specified.

To handle exceptions in the zipfile module, use a try-except block:

import zipfile

archive_name = 'example.zip'
destination_path = 'extracted_files'

try:
    with zipfile.ZipFile(archive_name, 'r') as zipf:
        zipf.extractall(path=destination_path)
except zipfile.BadZipFile:
    print("Error: The file is not a valid ZIP file or is corrupted.")
except zipfile.LargeZipFile:
    print("Error: The size of the ZIP file exceeds the allowed limit.")
except RuntimeError as e:
    print(f"Error: {e}")
  1. Handling exceptions in gzip module:

Some common exceptions when using the gzip module are:

  • OSError: Raised when there’s an issue with opening, reading, or writing files.
  • EOFError: Raised when the end of the file is reached before the expected end.

To handle exceptions in the gzip module, use a try-except block:

import gzip

gzip_file = 'example.txt.gz'
destination_file = 'example_decompressed.txt'

try:
    with gzip.open(gzip_file, 'rb') as gz_file, open(destination_file, 'wb') as dest_file:
        dest_file.writelines(gz_file)
except OSError:
    print("Error: There was an issue with opening, reading, or writing files.")
except EOFError:
    print("Error: The end of the file was reached before the expected end.")

By handling errors and exceptions, you can ensure that your program provides helpful feedback to the user and doesn’t crash unexpectedly when encountering issues during file compression or decompression.

How To Optimize Compression and Decompression Performance with zipfile and gzip Modules

In this section, we will discuss various techniques to optimize compression and decompression performance when working with zipfile and gzip modules in Python.

  1. Adjust compression level:

Both zipfile and gzip modules allow you to set the compression level. By adjusting the compression level, you can balance the trade-off between file size and compression/decompression speed. Lower compression levels are faster, but produce larger files, while higher compression levels produce smaller files but are slower.

  • zipfile:
import zipfile

file_name = 'example.txt'
archive_name = 'compressed.zip'
compression_level = 5

with zipfile.ZipFile(archive_name, 'w', compresslevel=compression_level) as zipf:
    zipf.write(file_name)
  • gzip:
import gzip

source_file = 'example.txt'
gzip_file = 'example.txt.gz'
compression_level = 5

with open(source_file, 'rb') as src_file, gzip.open(gzip_file, 'wb', compresslevel=compression_level) as gz_file:
    gz_file.writelines(src_file)
  1. Work with file chunks:

Instead of reading or writing the entire file at once, you can read and write the file in chunks. This can help optimize performance, especially when working with large files.

  • zipfile:
import zipfile

source_file = 'example.txt'
archive_name = 'compressed.zip'
buffer_size = 1024 * 1024  # 1 MB

with zipfile.ZipFile(archive_name, 'w') as zipf:
    with open(source_file, 'rb') as src_file:
        buffer = src_file.read(buffer_size)
        while buffer:
            zipf.writestr(zipfile.ZipInfo(source_file), buffer)
            buffer = src_file.read(buffer_size)
  • gzip:
import gzip

source_file = 'example.txt'
gzip_file = 'example.txt.gz'
buffer_size = 1024 * 1024  # 1 MB

with open(source_file, 'rb') as src_file, gzip.open(gzip_file, 'wb') as gz_file:
    buffer = src_file.read(buffer_size)
    while buffer:
        gz_file.write(buffer)
        buffer = src_file.read(buffer_size)
  1. Use multithreading:

For compressing or decompressing multiple files, you can use multithreading to process several files concurrently, which can significantly improve performance. The concurrent.futures module provides a simple way to use threads for parallel processing.

  • Example with gzip:
import gzip
import concurrent.futures

file_list = ['file1.txt', 'file2.txt', 'file3.txt']

def compress_file(file_name):
    gzip_file = file_name + '.gz'
    with open(file_name, 'rb') as src_file, gzip.open(gzip_file, 'wb') as gz_file:
        gz_file.writelines(src_file)

with concurrent.futures.ThreadPoolExecutor() as executor:
    executor.map(compress_file, file_list)

By applying these techniques, you can optimize compression and decompression performance with zipfile and gzip modules in Python. Keep in mind that the degree of optimization will vary depending on the specific use case and the hardware resources available.

Click to share! ⬇️

Python Import Modules Tutorial Python Time Module Tutorial Python Functions, Parameters, and Arguments Read and Write Files with the Python os and io Modules Work with JSON Data using the Python json Module Work with Collections using the Python collections Module