First you must extract all the zip files sequentially:

import zipfile

paths = ["path_to_1", "path_to_2" ]
extract_paths = ["path_to_extract1", "path_to_extrac2"]

for i in range(0, paths):
    zip_ref = zipfile.ZipFile(paths[i], 'r')
    zip_ref.extractall(extract_paths[i])
    zip_ref.close()

Next you can go to the extracted location and read() individual files with open into a string. Concatenate those strings and save to foo.txt.

It may not answer this specific question, but for those looking to extract a gzipped directory structure: that would be a job for shutil.unpack_archive.

For example:

import shutil

shutil.unpack_archive(
    filename='path/to/archive.tar.gz', extract_dir='where/to/extract/to'
)

A large segment of of the wall clock time spent decompressing a file with gunzip or gzip -d will be from the I/O operations (reading and writing to disk). It might even be more than the time spent actually decompressing data. You can take advantage of this by having multiple gzip jobs going in the background. As some jobs are blocked on I/O, another job can actually run without having to wait in a queue.

You can speed up the decompressing of the entire file set by having multiple gunzip processes running in the background. Each serving a specific set of files.

You can whip up something easy in BASH. Split the file list into separate commands and use the & to start it as a background job. Then wait for each each job to finish.

I would recommend that you have between 2 to 2*N jobs going at once. Where N is the number of cores or logical processors on your computer. Experiment as appropriate to get the right number.

You can whip something up easy in BASH.

#!/bin/bash

argarray=( "$@" )
len=${#argarray[@]}

#declare 4 empty array sets
set1=()
set2=()
set3=()
set4=()

# enumerate over each argument passed to the script
# and round robin add it to one of the above arrays

i=0
while [ len ]
do

    if [ len ]; then
        set1+=( "${argarray[$i]}" )
        ((i++))
    fi

    if [ len ]; then
        set2+=( "${argarray[$i]}" )
        ((i++))
    fi

    if [ len ]; then
        set3+=( "${argarray[$i]}" )
        ((i++))
    fi

    if [ len ]; then
        set4+=( "${argarray[$i]}" )
        ((i++))
    fi
done

# for each array, start a background job
gzip -d ${set1[@]} &
gzip -d ${set2[@]} &
gzip -d ${set3[@]} &
gzip -d ${set4[@]} &

# wait for all jobs to finish    
wait

In the above example, I picked 4 files per job and started two separate jobs. You can easily extend the script to have more jobs, more files per process, and to take the file names as command line parameters.

Can you install cygwin? If so, you may be able to just do something simple from the commandline using xargs and a commandline extractor.

Use "wba" mode instead. a opens in append mode. w alone will erase the file upon opening.

From the documentation:

import gzip
with gzip.open('file.txt.gz', 'rb') as f:
    file_content = f.read()

Use Python's tarfile to get the contained files, and then Python's gzip again inside the loop to extract the xml.

Option # 1 : unzip multiple files using single quote (short version)

gunzip '*.gz'

Note that *.gz word is put in between two single quote, so that shell will not recognize it as a wild card character.

Option # 2 : unzip multiple files using shell for loop (long version)

for g in *.gz; do gunzip $g; done

The Source

EDIT :

I have just tried :

gunzip -dk *.gz

and it worked.

-d to decompress and k to keep original files.