Come creare un archivio zip di una directory in Python?


492

Come posso creare un archivio zip di una struttura di directory in Python?


21
Non utilizzare la soluzione suggerita nella risposta accettata ma quella più in basso usando make_archiveda shutil(se si desidera comprimere ricorsivamente una singola directory).
Malana,

Risposte:


527

Come altri hanno sottolineato, è necessario utilizzare zipfile . La documentazione indica quali funzioni sono disponibili, ma non spiega in che modo è possibile utilizzarle per comprimere un'intera directory. Penso che sia più facile da spiegare con un codice di esempio:

#!/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()

Adattato da: http://www.devshed.com/c/a/Python/Python-UnZipped/


129
Vorrei aggiungere un secondo argomento alla chiamata di scrittura, passando os.path.relpath(os.path.join(root, file), os.path.join(path, '..')). Ciò ti consentirebbe di comprimere una directory da qualsiasi directory di lavoro, senza ottenere i percorsi assoluti completi nell'archivio.
Reimund,

8
C'è una divertente ricorsione in corso quando provo a comprimere una cartella e a generare lo zip risultante nella stessa cartella. :-)
Sibbs Gioco d'azzardo

13
shutillo rende davvero facile in una sola riga. Si prega di controllare la risposta di seguito ..
droidlabour,

7
potresti essere più interessato facendo ziph.write (os.path.join (percorso, file), arcname = file) in modo che i nomi dei file all'interno dell'archivio non siano relativi al disco rigido
Christophe Blin,

1
Ah, mi mancava la .close()chiamata!
information_interchange il

1066

Il modo più semplice è usare shutil.make_archive. Supporta entrambi i formati zip e tar.

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

Se devi fare qualcosa di più complicato che comprimere l'intera directory (come saltare determinati file), dovrai scavare nel zipfilemodulo come altri hanno suggerito.


113
shutilfa parte della libreria standard di Python. Questa dovrebbe essere la risposta migliore
AlexG

4
Questa è la risposta più concisa qui e ha anche il vantaggio di aggiungere direttamente tutte le sottodirectory e i file all'archivio, piuttosto che avere tutto incluso in una cartella di livello superiore (che si traduce in un livello ridondante nella struttura delle cartelle quando decompresso).
aitch-hat,

3
@cmcginty potresti per favore essere un po 'più specifico su quale aspetto di esso non è thread-safe? L'esecuzione di più thread mentre uno chiama questo provoca l'interruzione dell'interprete?
std''OrgnlDave,

13
Tieni presente che prima di Python 3.4, shutil.make_archive non supporta ZIP64 e non riuscirà a creare file ZIP di dimensioni superiori a 2 GB.
Azdev,

2
@Teekin No. Se guardi il rapporto sui bug (bugs.python.org/issue30511), vedrai che shutil.make_archiveusa os.chdir(). Da quello che sto leggendo os.chdir(), opera a livello globale.
Sam Malayek,

65

Per aggiungere il contenuto di mydirectoryun nuovo file zip, inclusi tutti i file e le sottodirectory:

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()

Per me questo codice lancia sotto l'errore TypeError: file non valido: <zipfile.ZipFile [chiuso]>
Nishad Up

10
Non puoi usare un withinvece di doverti chiamare close()alla fine?
ArtOfWarfare il

50

Come posso creare un archivio zip di una struttura di directory in Python?

In uno script Python

In Python 2.7+, shutilha una make_archivefunzione.

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

Qui verrà chiamato l'archivio zippato zipfile_name.zip. Se base_dirè più in basso root_dir, verranno esclusi i file non presenti in base_dir, ma verranno comunque archiviati i file nelle directory principali fino a root_dir.

Ho avuto un problema test questo su Cygwin con 2.7 - vuole un argomento root_dir, per cwd:

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

Usando Python dalla shell

Puoi farlo con Python dalla shell anche usando il zipfilemodulo:

$ python -m zipfile -c zipname sourcedir

Dov'è zipnameil nome del file di destinazione desiderato (aggiungere .zipse lo si desidera, non lo farà automaticamente) e sourcedir è il percorso della directory.

Zipping up Python (o semplicemente non vuoi dir genitore):

Se stai cercando di comprimere un pacchetto Python con un __init__.pye __main__.py, e non vuoi la directory principale, lo è

$ python -m zipfile -c zipname sourcedir/*

E

$ python zipname

eseguirà il pacchetto. (Si noti che non è possibile eseguire i pacchetti secondari come punto di ingresso da un archivio zippato.)

Compressione di un'app Python:

Se hai python3.5 + e in particolare vuoi comprimere un pacchetto Python, usa zipapp :

$ python -m zipapp myapp
$ python myapp.pyz

32

Questa funzione comprimerà in modo ricorsivo un albero di directory, comprimendo i file e registrando i nomi dei file relativi corretti nell'archivio. Le voci di archivio sono le stesse di quelle generate da 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)

17

Usa shutil, che fa parte del set di librerie standard di Python. L'uso di shutil è così semplice (vedi codice sotto):

  • 1 ° argomento: nome file del file zip / tar risultante,
  • 2o argomento: zip / tar,
  • 3 ° argomento: nome_dir

Codice:

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

12

Per aggiungere la compressione al file zip risultante, controlla questo link .

Devi cambiare:

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

per

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

5

Ho apportato alcune modifiche al codice fornito da Mark Byers . La funzione di seguito aggiunge anche directory vuote se le hai. Gli esempi dovrebbero chiarire qual è il percorso aggiunto alla 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)

Sopra è una semplice funzione che dovrebbe funzionare per casi semplici. Puoi trovare classe più elegante nel mio Gist: https://gist.github.com/Eccenux/17526123107ca0ac28e6


1
La gestione del percorso potrebbe essere notevolmente semplificata utilizzando os.path . Vedi la mia risposta
George V. Reilly,

Bug: zipHandle.write (os.path.join (root, ".")) Non prende in considerazione basePath.
Petter,

Sì, probabilmente hai ragione. In seguito l'ho migliorato un po ';-) gist.github.com/Eccenux/17526123107ca0ac28e6
Nux,

4

Python moderno (3.6+) che utilizza il pathlibmodulo per la gestione concisa di percorsi simili a OOP e pathlib.Path.rglob()per globbing ricorsivo. Per quanto ne so, questo equivale alla risposta di George V. Reilly: zip con compressione, l'elemento più in alto è una directory, mantiene le directory vuote, usa percorsi relativi.

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))

Nota: come indicano i suggerimenti di tipo opzionali, zip_namenon può essere un oggetto Path ( sarebbe corretto in 3.6.2+ ).


1
Fantastico! Conciso! Moderno!
ingyhere il

3

Ho un altro esempio di codice che può aiutare, usando python3, pathlib e zipfile. Dovrebbe funzionare in qualsiasi sistema operativo.

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!')


1

Ecco una variazione sulla risposta data da Nux che funziona per me:

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 )

1

Prova quello sotto. Ha funzionato per me .

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()

1

Se si desidera una funzionalità come la cartella compress di un comune gestore di file grafici, è possibile utilizzare il codice seguente, utilizza il modulo zipfile . Usando questo codice avrai il file zip con il percorso come cartella principale.

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()

1

Per dare maggiore flessibilità, ad esempio selezionare directory / file per nome utilizzare:

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

Per un albero di file:

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

Ad esempio è possibile selezionare solo dir4eroot.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)

O semplicemente listdirnella directory di invocazione degli script e aggiungi tutto da lì:

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)

Questo zip, ma non comprime.
Alex,

1

Supponi di voler comprimere tutte le cartelle (sottodirectory) nella directory corrente.

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))

1

Per un modo conciso di conservare la gerarchia di cartelle nella directory principale da archiviare:

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, ""))

Se vuoi, puoi cambiarlo per usarlo pathlib per il globbing dei file .


1

Così tante risposte qui, e spero di poter contribuire con la mia versione, che si basa sulla risposta originale (a proposito), ma con una prospettiva più grafica, usando anche il contesto per ogni zipfileinstallazione e ordinamentoos.walk() , al fine di avere un uscita ordinata.

Avendo queste cartelle e quei file (tra le altre cartelle), volevo creare un .zipper ogni cap_cartella:

$ 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

Ecco cosa ho applicato, con commenti per una migliore comprensione del processo.

$ 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) 

Fondamentalmente, per ogni iterazione sopra os.walk(path), sto aprendo un contesto per l' zipfileinstallazione e successivamente, iterando iterando sopra files, che è uno listdei file dalla rootdirectory, formando il percorso relativo per ogni file basato sulla rootdirectory corrente , aggiungendo allazipfile contesto in esecuzione .

E l'output è presentato in questo modo:

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

Per vedere il contenuto di ciascuna .zipdirectory, puoi usare il lesscomando:

$ 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

0

Ecco un approccio moderno, usando pathlib e un gestore di contesto. Mette i file direttamente nella zip, piuttosto che in una sottocartella.

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))

0

Ho preparato una funzione consolidando la soluzione di Mark Byers con i commenti di Reimund e Morten Zilmer (percorso relativo e includendo directory vuote). Come best practice,with viene utilizzato nella costruzione di file ZipFile.

La funzione prepara anche un nome file zip predefinito con il nome della directory zippata e l'estensione '.zip'. Pertanto, funziona con un solo argomento: la directory di origine da comprimere.

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)))

0
# 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))

0

Bene, dopo aver letto i suggerimenti ho trovato un modo molto simile che funziona con 2.7.x senza creare nomi di directory "divertenti" (nomi di tipo assoluto) e creerò solo la cartella specificata all'interno dello zip.

O nel caso in cui fosse necessario che zip contenga una cartella all'interno con i contenuti della directory selezionata.

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" )

0

Funzione per creare 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()

per favore spiega con un esempio in modo che io possa correggere la mia risposta
sushh

Tuttavia, zipfile "al momento non è possibile creare un file crittografato" (da docs.python.org/3.9/library/zipfile.html )
Georg

0

Usando 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)
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.