Bagaimana saya bisa membuat arsip zip dari struktur direktori dengan Python?

Seperti yang orang lain tunjukkan, Anda harus menggunakan zipfile . Dokumentasi memberi tahu Anda apa fungsi yang tersedia, tetapi tidak benar-benar menjelaskan bagaimana Anda dapat menggunakannya untuk zip seluruh direktori. Saya pikir ini paling mudah untuk dijelaskan dengan beberapa contoh kode:

#!/usr/bin/env python
import os
import zipfile

def zipdir(path, ziph):
    # ziph is zipfile handle
    for root, dirs, files in os.walk(path):
        for file in files:
            ziph.write(os.path.join(root, file))

if __name__ == '__main__':
    zipf = zipfile.ZipFile('Python.zip', 'w', zipfile.ZIP_DEFLATED)
    zipdir('tmp/', zipf)
    zipf.close()

Diadaptasi dari: http://www.devshed.com/c/a/Python/Python-UnZipped/

Cara termudah adalah menggunakan shutil.make_archive. Ini mendukung format zip dan tar.

import shutil
shutil.make_archive(output_filename, 'zip', dir_name)

Jika Anda perlu melakukan sesuatu yang lebih rumit daripada zip seluruh direktori (seperti melewatkan file tertentu), maka Anda perlu menggali ke dalam zipfilemodul seperti yang disarankan orang lain.

Untuk menambahkan konten mydirectoryke file zip baru, termasuk semua file dan subdirektori:

import os
import zipfile

zf = zipfile.ZipFile("myzipfile.zip", "w")
for dirname, subdirs, files in os.walk("mydirectory"):
    zf.write(dirname)
    for filename in files:
        zf.write(os.path.join(dirname, filename))
zf.close()

Bagaimana saya bisa membuat arsip zip dari struktur direktori dengan Python?

Dalam skrip Python

Dalam Python 2.7+, shutilmemiliki make_archivefungsi.

from shutil import make_archive
make_archive(
  'zipfile_name', 
  'zip',           # the archive format - or tar, bztar, gztar 
  root_dir=None,   # root for archive - current working dir if None
  base_dir=None)   # start archiving from here - cwd if None too

Di sini arsip zip akan dinamai zipfile_name.zip. Jika base_dirlebih jauh dari root_diritu akan mengecualikan file tidak di base_dir, tetapi masih mengarsipkan file dalam dir induk ke atas root_dir.

Saya memang memiliki masalah pengujian ini pada Cygwin dengan 2,7 - ia menginginkan argumen root_dir, untuk cwd:

make_archive('zipfile_name', 'zip', root_dir='.')

Menggunakan Python dari shell

Anda dapat melakukan ini dengan Python dari shell juga menggunakan zipfilemodul:

$ python -m zipfile -c zipname sourcedir

Di mana zipnamenama file tujuan yang Anda inginkan (tambahkan .zipjika Anda menginginkannya, itu tidak akan melakukannya secara otomatis) dan sourcedir adalah path ke direktori.

Zip up Python (atau hanya tidak ingin dir induk):

Jika Anda mencoba untuk meng-zip paket python dengan __init__.pydan __main__.py, dan Anda tidak ingin dir induknya, itu

$ python -m zipfile -c zipname sourcedir/*

Dan

$ python zipname

akan menjalankan paket. (Perhatikan bahwa Anda tidak dapat menjalankan subpackages sebagai titik masuk dari arsip zip.)

Zip aplikasi Python:

Jika Anda memiliki python3.5 +, dan secara khusus ingin men- zip paket Python, gunakan zipapp :

$ python -m zipapp myapp
$ python myapp.pyz

Fungsi ini akan secara zip-up zip pohon direktori, mengompresi file, dan merekam nama file relatif yang benar dalam arsip. Entri arsip sama dengan yang dihasilkan oleh zip -r output.zip source_dir.

import os
import zipfile
def make_zipfile(output_filename, source_dir):
    relroot = os.path.abspath(os.path.join(source_dir, os.pardir))
    with zipfile.ZipFile(output_filename, "w", zipfile.ZIP_DEFLATED) as zip:
        for root, dirs, files in os.walk(source_dir):
            # add directory (needed for empty dirs)
            zip.write(root, os.path.relpath(root, relroot))
            for file in files:
                filename = os.path.join(root, file)
                if os.path.isfile(filename): # regular files only
                    arcname = os.path.join(os.path.relpath(root, relroot), file)
                    zip.write(filename, arcname)

Gunakan shutil, yang merupakan bagian dari set pustaka standar python. Menggunakan shutil sangat sederhana (lihat kode di bawah):

• Argumen 1: Nama file file zip / tar yang dihasilkan,
• Arg ke-2: zip / tar,
• Argumen ke-3: dir_name

Kode:

import shutil
shutil.make_archive('/home/user/Desktop/Filename','zip','/home/username/Desktop/Directory')

Untuk menambahkan kompresi ke file zip yang dihasilkan, lihat tautan ini .

Anda perlu mengubah:

zip = zipfile.ZipFile('Python.zip', 'w')

untuk

zip = zipfile.ZipFile('Python.zip', 'w', zipfile.ZIP_DEFLATED)

Saya telah membuat beberapa perubahan pada kode yang diberikan oleh Mark Byers . Fungsi di bawah ini juga akan menambahkan direktori kosong jika Anda memilikinya. Contoh harus membuatnya lebih jelas apa jalur yang ditambahkan ke zip.

#!/usr/bin/env python
import os
import zipfile

def addDirToZip(zipHandle, path, basePath=""):
    """
    Adding directory given by \a path to opened zip file \a zipHandle

    @param basePath path that will be removed from \a path when adding to archive

    Examples:
        # add whole "dir" to "test.zip" (when you open "test.zip" you will see only "dir")
        zipHandle = zipfile.ZipFile('test.zip', 'w')
        addDirToZip(zipHandle, 'dir')
        zipHandle.close()

        # add contents of "dir" to "test.zip" (when you open "test.zip" you will see only it's contents)
        zipHandle = zipfile.ZipFile('test.zip', 'w')
        addDirToZip(zipHandle, 'dir', 'dir')
        zipHandle.close()

        # add contents of "dir/subdir" to "test.zip" (when you open "test.zip" you will see only contents of "subdir")
        zipHandle = zipfile.ZipFile('test.zip', 'w')
        addDirToZip(zipHandle, 'dir/subdir', 'dir/subdir')
        zipHandle.close()

        # add whole "dir/subdir" to "test.zip" (when you open "test.zip" you will see only "subdir")
        zipHandle = zipfile.ZipFile('test.zip', 'w')
        addDirToZip(zipHandle, 'dir/subdir', 'dir')
        zipHandle.close()

        # add whole "dir/subdir" with full path to "test.zip" (when you open "test.zip" you will see only "dir" and inside it only "subdir")
        zipHandle = zipfile.ZipFile('test.zip', 'w')
        addDirToZip(zipHandle, 'dir/subdir')
        zipHandle.close()

        # add whole "dir" and "otherDir" (with full path) to "test.zip" (when you open "test.zip" you will see only "dir" and "otherDir")
        zipHandle = zipfile.ZipFile('test.zip', 'w')
        addDirToZip(zipHandle, 'dir')
        addDirToZip(zipHandle, 'otherDir')
        zipHandle.close()
    """
    basePath = basePath.rstrip("\\/") + ""
    basePath = basePath.rstrip("\\/")
    for root, dirs, files in os.walk(path):
        # add dir itself (needed for empty dirs
        zipHandle.write(os.path.join(root, "."))
        # add files
        for file in files:
            filePath = os.path.join(root, file)
            inZipPath = filePath.replace(basePath, "", 1).lstrip("\\/")
            #print filePath + " , " + inZipPath
            zipHandle.write(filePath, inZipPath)

Di atas adalah fungsi sederhana yang harus berfungsi untuk kasus-kasus sederhana. Anda dapat menemukan kelas yang lebih elegan di Gist saya: https://gist.github.com/Eccenux/17526123107ca0ac28e6

Python modern (3,6+) menggunakan pathlibmodul untuk penanganan jalur singkat mirip OOP, dan pathlib.Path.rglob()untuk penggumpalan rekursif. Sejauh yang saya tahu, ini setara dengan jawaban George V. Reilly: ritsleting dengan kompresi, elemen paling atas adalah direktori, menyimpan direktori kosong, menggunakan jalur relatif.

from pathlib import Path
from zipfile import ZIP_DEFLATED, ZipFile

from os import PathLike
from typing import Union


def zip_dir(zip_name: str, source_dir: Union[str, PathLike]):
    src_path = Path(source_dir).expanduser().resolve(strict=True)
    with ZipFile(zip_name, 'w', ZIP_DEFLATED) as zf:
        for file in src_path.rglob('*'):
            zf.write(file, file.relative_to(src_path.parent))

Catatan: seperti yang ditunjukkan oleh petunjuk tipe opsional, zip_nametidak bisa menjadi objek Path ( akan diperbaiki di 3.6.2+ ).

Saya punya contoh kode lain yang dapat membantu, menggunakan python3, pathlib dan zipfile. Ini harus bekerja di OS apa pun.

from pathlib import Path
import zipfile
from datetime import datetime

DATE_FORMAT = '%y%m%d'


def date_str():
    """returns the today string year, month, day"""
    return '{}'.format(datetime.now().strftime(DATE_FORMAT))


def zip_name(path):
    """returns the zip filename as string"""
    cur_dir = Path(path).resolve()
    parent_dir = cur_dir.parents[0]
    zip_filename = '{}/{}_{}.zip'.format(parent_dir, cur_dir.name, date_str())
    p_zip = Path(zip_filename)
    n = 1
    while p_zip.exists():
        zip_filename = ('{}/{}_{}_{}.zip'.format(parent_dir, cur_dir.name,
                                             date_str(), n))
        p_zip = Path(zip_filename)
        n += 1
    return zip_filename


def all_files(path):
    """iterator returns all files and folders from path as absolute path string
    """
    for child in Path(path).iterdir():
        yield str(child)
        if child.is_dir():
            for grand_child in all_files(str(child)):
                yield str(Path(grand_child))


def zip_dir(path):
    """generate a zip"""
    zip_filename = zip_name(path)
    zip_file = zipfile.ZipFile(zip_filename, 'w')
    print('create:', zip_filename)
    for file in all_files(path):
        print('adding... ', file)
        zip_file.write(file)
    zip_file.close()


if __name__ == '__main__':
    zip_dir('.')
    print('end!')

Anda mungkin ingin melihat zipfilemodul; ada dokumentasi di http://docs.python.org/library/zipfile.html .

Anda mungkin juga ingin os.walk()mengindeks struktur direktori.

Berikut adalah variasi jawaban yang diberikan oleh Nux yang cocok untuk saya:

def WriteDirectoryToZipFile( zipHandle, srcPath, zipLocalPath = "", zipOperation = zipfile.ZIP_DEFLATED ):
    basePath = os.path.split( srcPath )[ 0 ]
    for root, dirs, files in os.walk( srcPath ):
        p = os.path.join( zipLocalPath, root [ ( len( basePath ) + 1 ) : ] )
        # add dir
        zipHandle.write( root, p, zipOperation )
        # add files
        for f in files:
            filePath = os.path.join( root, f )
            fileInZipPath = os.path.join( p, f )
            zipHandle.write( filePath, fileInZipPath, zipOperation )

Coba yang di bawah ini. Itu berhasil untuk saya .

import zipfile, os
zipf = "compress.zip"  
def main():
    directory = r"Filepath"
    toZip(directory)
def toZip(directory):
    zippedHelp = zipfile.ZipFile(zipf, "w", compression=zipfile.ZIP_DEFLATED )

    list = os.listdir(directory)
    for file_list in list:
        file_name = os.path.join(directory,file_list)

        if os.path.isfile(file_name):
            print file_name
            zippedHelp.write(file_name)
        else:
            addFolderToZip(zippedHelp,file_list,directory)
            print "---------------Directory Found-----------------------"
    zippedHelp.close()

def addFolderToZip(zippedHelp,folder,directory):
    path=os.path.join(directory,folder)
    print path
    file_list=os.listdir(path)
    for file_name in file_list:
        file_path=os.path.join(path,file_name)
        if os.path.isfile(file_path):
            zippedHelp.write(file_path)
        elif os.path.isdir(file_name):
            print "------------------sub directory found--------------------"
            addFolderToZip(zippedHelp,file_name,path)


if __name__=="__main__":
    main()

Jika Anda ingin fungsi seperti folder kompres dari semua manajer file grafis umum Anda dapat menggunakan kode berikut, ia menggunakan modul zipfile . Dengan menggunakan kode ini, Anda akan memiliki file zip dengan path sebagai folder root.

import os
import zipfile

def zipdir(path, ziph):
    # Iterate all the directories and files
    for root, dirs, files in os.walk(path):
        # Create a prefix variable with the folder structure inside the path folder. 
        # So if a file is at the path directory will be at the root directory of the zip file
        # so the prefix will be empty. If the file belongs to a containing folder of path folder 
        # then the prefix will be that folder.
        if root.replace(path,'') == '':
                prefix = ''
        else:
                # Keep the folder structure after the path folder, append a '/' at the end 
                # and remome the first character, if it is a '/' in order to have a path like 
                # folder1/folder2/file.txt
                prefix = root.replace(path, '') + '/'
                if (prefix[0] == '/'):
                        prefix = prefix[1:]
        for filename in files:
                actual_file_path = root + '/' + filename
                zipped_file_path = prefix + filename
                zipf.write( actual_file_path, zipped_file_path)


zipf = zipfile.ZipFile('Python.zip', 'w', zipfile.ZIP_DEFLATED)
zipdir('/tmp/justtest/', zipf)
zipf.close()

Untuk memberikan lebih banyak fleksibilitas, mis. Pilih direktori / file dengan menggunakan nama:

import os
import zipfile

def zipall(ob, path, rel=""):
    basename = os.path.basename(path)
    if os.path.isdir(path):
        if rel == "":
            rel = basename
        ob.write(path, os.path.join(rel))
        for root, dirs, files in os.walk(path):
            for d in dirs:
                zipall(ob, os.path.join(root, d), os.path.join(rel, d))
            for f in files:
                ob.write(os.path.join(root, f), os.path.join(rel, f))
            break
    elif os.path.isfile(path):
        ob.write(path, os.path.join(rel, basename))
    else:
        pass

Untuk pohon file:

.
├── dir
│   ├── dir2
│   │   └── file2.txt
│   ├── dir3
│   │   └── file3.txt
│   └── file.txt
├── dir4
│   ├── dir5
│   └── file4.txt
├── listdir.zip
├── main.py
├── root.txt
└── selective.zip

Anda dapat mis pilih saja dir4dan root.txt:

cwd = os.getcwd()
files = [os.path.join(cwd, f) for f in ['dir4', 'root.txt']]

with zipfile.ZipFile("selective.zip", "w" ) as myzip:
    for f in files:
        zipall(myzip, f)

Atau cukup listdirdalam direktori permintaan skrip dan tambahkan semuanya dari sana:

with zipfile.ZipFile("listdir.zip", "w" ) as myzip:
    for f in os.listdir():
        if f == "listdir.zip":
            # Creating a listdir.zip in the same directory
            # will include listdir.zip inside itself, beware of this
            continue
        zipall(myzip, f)

Katakanlah Anda ingin Zip semua folder (sub direktori) di direktori saat ini.

for root, dirs, files in os.walk("."):
    for sub_dir in dirs:
        zip_you_want = sub_dir+".zip"
        zip_process = zipfile.ZipFile(zip_you_want, "w", zipfile.ZIP_DEFLATED)
        zip_process.write(file_you_want_to_include)
        zip_process.close()

        print("Successfully zipped directory: {sub_dir}".format(sub_dir=sub_dir))

Untuk cara ringkas untuk mempertahankan hierarki folder di bawah direktori induk yang akan diarsipkan:

import glob
import zipfile

with zipfile.ZipFile(fp_zip, "w", zipfile.ZIP_DEFLATED) as zipf:
    for fp in glob(os.path.join(parent, "**/*")):
        base = os.path.commonpath([parent, fp])
        zipf.write(fp, arcname=fp.replace(base, ""))

Jika mau, Anda bisa mengubahnya untuk digunakan pathlib untuk globbing file .

Begitu banyak jawaban di sini, dan saya harap saya dapat berkontribusi dengan versi saya sendiri, yang didasarkan pada jawaban asli (by the way), tetapi dengan perspektif yang lebih grafis, juga menggunakan konteks untuk setiap zipfilepengaturan dan penyortiran os.walk(), untuk memiliki memesan output.

Memiliki folder ini dan file-file mereka (di antara folder lain), saya ingin membuat folder .zipuntuk setiap cap_:

$ tree -d
.
├── cap_01
|    ├── 0101000001.json
|    ├── 0101000002.json
|    ├── 0101000003.json
|
├── cap_02
|    ├── 0201000001.json
|    ├── 0201000002.json
|    ├── 0201001003.json
|
├── cap_03
|    ├── 0301000001.json
|    ├── 0301000002.json
|    ├── 0301000003.json
| 
├── docs
|    ├── map.txt
|    ├── main_data.xml
|
├── core_files
     ├── core_master
     ├── core_slave

Inilah yang saya terapkan, dengan komentar untuk pemahaman proses yang lebih baik.

$ cat zip_cap_dirs.py 
""" Zip 'cap_*' directories. """           
import os                                                                       
import zipfile as zf                                                            


for root, dirs, files in sorted(os.walk('.')):                                                                                               
    if 'cap_' in root:                                                          
        print(f"Compressing: {root}")                                           
        # Defining .zip name, according to Capítulo.                            
        cap_dir_zip = '{}.zip'.format(root)                                     
        # Opening zipfile context for current root dir.                         
        with zf.ZipFile(cap_dir_zip, 'w', zf.ZIP_DEFLATED) as new_zip:          
            # Iterating over os.walk list of files for the current root dir.    
            for f in files:                                                     
                # Defining relative path to files from current root dir.        
                f_path = os.path.join(root, f)                                  
                # Writing the file on the .zip file of the context              
                new_zip.write(f_path) 

Pada dasarnya, untuk setiap iterasi selesai os.walk(path), saya membuka konteks untuk zipfilepengaturan dan setelah itu, iterasi berulang files, yang merupakan listfile dari rootdirektori, membentuk jalur relatif untuk setiap file berdasarkan rootdirektori saat ini , menambahkan ke zipfilekonteks yang sedang berjalan .

Dan hasilnya disajikan seperti ini:

$ python3 zip_cap_dirs.py
Compressing: ./cap_01
Compressing: ./cap_02
Compressing: ./cap_03

Untuk melihat isi dari setiap .zipdirektori, Anda dapat menggunakan lessperintah:

$ less cap_01.zip

Archive:  cap_01.zip
 Length   Method    Size  Cmpr    Date    Time   CRC-32   Name
--------  ------  ------- ---- ---------- ----- --------  ----
  22017  Defl:N     2471  89% 2019-09-05 08:05 7a3b5ec6  cap_01/0101000001.json
  21998  Defl:N     2471  89% 2019-09-05 08:05 155bece7  cap_01/0101000002.json
  23236  Defl:N     2573  89% 2019-09-05 08:05 55fced20  cap_01/0101000003.json
--------          ------- ---                           -------
  67251             7515  89%                            3 files

Inilah pendekatan modern, menggunakan pathlib, dan manajer konteks. Letakkan file langsung di zip, bukan di subfolder.

def zip_dir(filename: str, dir_to_zip: pathlib.Path):
    with zipfile.ZipFile(filename, 'w', zipfile.ZIP_DEFLATED) as zipf:
        # Use glob instead of iterdir(), to cover all subdirectories.
        for directory in dir_to_zip.glob('**'):
            for file in directory.iterdir():
                if not file.is_file():
                    continue
                # Strip the first component, so we don't create an uneeded subdirectory
                # containing everything.
                zip_path = pathlib.Path(*file.parts[1:])
                # Use a string, since zipfile doesn't support pathlib  directly.
                zipf.write(str(file), str(zip_path))

Saya menyiapkan fungsi dengan menggabungkan solusi Mark Byers dengan komentar Reimund dan Morten Zilmer (jalur relatif dan termasuk direktori kosong). Sebagai praktik terbaik, withdigunakan dalam konstruksi file ZipFile.

Fungsi ini juga menyiapkan nama file zip standar dengan nama direktori zip dan ekstensi '.zip'. Oleh karena itu, ia hanya bekerja dengan satu argumen: direktori sumber yang akan di-zip.

import os
import zipfile

def zip_dir(path_dir, path_file_zip=''):
if not path_file_zip:
    path_file_zip = os.path.join(
        os.path.dirname(path_dir), os.path.basename(path_dir)+'.zip')
with zipfile.ZipFile(path_file_zip, 'wb', zipfile.ZIP_DEFLATED) as zip_file:
    for root, dirs, files in os.walk(path_dir):
        for file_or_dir in files + dirs:
            zip_file.write(
                os.path.join(root, file_or_dir),
                os.path.relpath(os.path.join(root, file_or_dir),
                                os.path.join(path_dir, os.path.pardir)))

# import required python modules
# You have to install zipfile package using pip install

import os,zipfile

# Change the directory where you want your new zip file to be

os.chdir('Type your destination')

# Create a new zipfile ( I called it myfile )

zf = zipfile.ZipFile('myfile.zip','w')

# os.walk gives a directory tree. Access the files using a for loop

for dirnames,folders,files in os.walk('Type your directory'):
    zf.write('Type your Directory')
    for file in files:
        zf.write(os.path.join('Type your directory',file))

Nah, setelah membaca saran saya datang dengan cara yang sangat mirip yang bekerja dengan 2.7.x tanpa membuat nama direktori "lucu" (nama seperti mutlak), dan hanya akan membuat folder yang ditentukan di dalam zip.

Atau untuk berjaga-jaga jika Anda memerlukan zip untuk memuat folder di dalamnya dengan isi direktori yang dipilih.

def zipDir( path, ziph ) :
 """
 Inserts directory (path) into zipfile instance (ziph)
 """
 for root, dirs, files in os.walk( path ) :
  for file in files :
   ziph.write( os.path.join( root, file ) , os.path.basename( os.path.normpath( path ) ) + "\\" + file )

def makeZip( pathToFolder ) :
 """
 Creates a zip file with the specified folder
 """
 zipf = zipfile.ZipFile( pathToFolder + 'file.zip', 'w', zipfile.ZIP_DEFLATED )
 zipDir( pathToFolder, zipf )
 zipf.close()
 print( "Zip file saved to: " + pathToFolder)

makeZip( "c:\\path\\to\\folder\\to\\insert\\into\\zipfile" )

Berfungsi untuk membuat file zip.

def CREATEZIPFILE(zipname, path):
    #function to create a zip file
    #Parameters: zipname - name of the zip file; path - name of folder/file to be put in zip file

    zipf = zipfile.ZipFile(zipname, 'w', zipfile.ZIP_DEFLATED)
    zipf.setpassword(b"password") #if you want to set password to zipfile

    #checks if the path is file or directory
    if os.path.isdir(path):
        for files in os.listdir(path):
            zipf.write(os.path.join(path, files), files)

    elif os.path.isfile(path):
        zipf.write(os.path.join(path), path)
    zipf.close()

Menggunakan zipfly

import zipfly

paths = [
    {
        'fs': '/path/to/large/file'
    },
]

zfly = zipfly.ZipFly( paths = paths )

with open("large.zip", "wb") as f:
    for i in zfly.generator():
        f.write(i)