Como criar um arquivo zip de um diretório em Python?

491

Como posso criar um arquivo zip de uma estrutura de diretórios em Python?

Martha Yi
fonte
21
Não use a solução sugerida na resposta aceita, mas a mais abaixo usando make_archivefrom shutil(se você deseja compactar um único diretório recursivamente).
malana

Respostas:

526

Como outros já apontaram, você deve usar o zipfile . A documentação informa quais funções estão disponíveis, mas realmente não explica como você pode usá-las para compactar um diretório inteiro. Eu acho que é mais fácil explicar com algum código de exemplo:

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

Adaptado de: http://www.devshed.com/c/a/Python/Python-UnZipped/

Mark Byers
fonte
129
Eu adicionaria um segundo argumento à chamada de gravação, passando os.path.relpath(os.path.join(root, file), os.path.join(path, '..')). Isso permitiria que você zipasse um diretório de qualquer diretório ativo, sem obter os caminhos absolutos completos no arquivo morto.
Reimund
8
Há uma recursão engraçada quando tento compactar uma pasta e enviar o zip resultante para a mesma pasta. :-)
Sibbs Gambling
13
shutiltorna muito fácil em apenas uma linha. Por favor, verifique a resposta abaixo ..
droidlabour 30/17/17
7
você pode estar mais interessado fazendo ziph.write (os.path.join (caminho, arquivo), arcname = arquivo) para que os nomes de arquivos dentro do pacote não são em relação ao disco rígido
Christophe Blin
1
Ah, estava faltando a .close()ligação!
information_interchange
1063

A maneira mais fácil é usar shutil.make_archive. Ele suporta os formatos zip e tar.

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

Se você precisar fazer algo mais complicado do que compactar o diretório inteiro (como pular certos arquivos), precisará cavar no zipfilemódulo, conforme sugerido por outros.

crdavis
fonte
113
shutilfaz parte da biblioteca python padrão. Esta deve ser a resposta superior
AlexG
4
Essa é a resposta mais concisa aqui e também tem a vantagem de adicionar todos os subdiretórios e arquivos ao arquivo diretamente, em vez de incluir tudo em uma pasta de nível superior (o que resulta em um nível redundante na estrutura da pasta ao descompactar).
aitch-hat
3
@cmcginty, você poderia ser um pouco mais específico sobre qual aspecto não é seguro para threads? A execução de vários threads enquanto alguém chama isso causa uma falha no intérprete?
precisa saber é o seguinte
13
Esteja avisado de que, antes do Python 3.4, o shutil.make_archive não suporta ZIP64 e falhará ao criar arquivos ZIP com mais de 2 GB.
precisa saber é
2
@Teekin No. Se você olhar para o relatório de bugs (bugs.python.org/issue30511), verá que os shutil.make_archiveusos os.chdir(). Pelo que estou lendo os.chdir(), ele opera globalmente.
Sam Malayek
65

Para adicionar o conteúdo de mydirectoryum novo arquivo zip, incluindo todos os arquivos e subdiretórios:

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()
Ben James
fonte
Para mim, este código lançando abaixo o erro TypeError: arquivo inválido: <zipfile.ZipFile [closed]>
Nishad Up
10
Você não pode usar um em withvez de ter que close()se chamar no final?
ArtOfWarfare
50

Como posso criar um arquivo zip de uma estrutura de diretórios em Python?

Em um script Python

No Python 2.7+, shutiltem uma make_archivefunção.

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

Aqui o arquivo compactado será nomeado zipfile_name.zip. Se base_direstiver mais abaixo root_dir, excluirá os arquivos que não estão no diretório base_dir, mas ainda arquivará os arquivos nos diretórios pai até o diretório root_dir.

Eu tive um problema ao testar isso no Cygwin com 2.7 - ele quer um argumento root_dir, para cwd:

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

Usando Python a partir do shell

Você pode fazer isso com o Python a partir do shell também usando o zipfilemódulo:

$ python -m zipfile -c zipname sourcedir

Onde zipnameestá o nome do arquivo de destino que você deseja (adicione, .zipse quiser, ele não o fará automaticamente) e sourcedir é o caminho para o diretório.

Fechando o Python (ou simplesmente não quer o diretório pai):

Se você está tentando compactar um pacote python com um __init__.pye __main__.py, e você não deseja o diretório pai, é

$ python -m zipfile -c zipname sourcedir/*

E

$ python zipname

executaria o pacote. (Observe que você não pode executar subpacotes como ponto de entrada de um arquivo compactado.)

Fechando um aplicativo Python:

Se você tem python3.5 + e deseja especificamente compactar um pacote Python, use zipapp :

$ python -m zipapp myapp
$ python myapp.pyz
Aaron Hall
fonte
32

Essa função compactará recursivamente uma árvore de diretórios, compactando os arquivos e gravando os nomes de arquivos relativos corretos no arquivo morto. As entradas de arquivamento são as mesmas que as geradas por 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)
George V. Reilly
fonte
17

Use shutil, que faz parte do conjunto de bibliotecas padrão do python. O uso do shutil é tão simples (veja o código abaixo):

  • 1º argumento: nome do arquivo zip / tar resultante,
  • 2º argumento: zip / tar,
  • Terceiro argumento: dir_name

Código:

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

Para adicionar compactação ao arquivo zip resultante, confira este link .

Você precisa mudar:

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

para

zip = zipfile.ZipFile('Python.zip', 'w', zipfile.ZIP_DEFLATED)
E Smith
fonte
5

Fiz algumas alterações no código fornecidas por Mark Byers . A função abaixo também adiciona diretórios vazios, se você os tiver. Os exemplos devem deixar mais claro qual é o caminho adicionado ao 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)

Acima está uma função simples que deve funcionar em casos simples. Você pode encontrar uma classe mais elegante em meu Gist: https://gist.github.com/Eccenux/17526123107ca0ac28e6

Nux
fonte
1
O tratamento do caminho pode ser bastante simplificado usando os.path . Veja minha resposta.
George V. Reilly
Bug: zipHandle.write (os.path.join (root, ".")) Não leva em consideração o basePath.
Petter
Sim, você provavelmente está certo. Mais tarde, aprimorei isso um pouco ;-) gist.github.com/Eccenux/17526123107ca0ac28e6
Nux
4

Python moderno (3.6+) usando o pathlibmódulo para manipulação concisa de caminhos no modo OOP e pathlib.Path.rglob()globbing recursivo. Até onde eu sei, isso é equivalente à resposta de George V. Reilly: fecha com compressão, o elemento superior é um diretório, mantém dirs vazios, usa caminhos relativos.

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: como as dicas de tipo opcionais indicam, zip_namenão pode ser um objeto Path ( seria corrigido em 3.6.2+ ).

tempo monge
fonte
1
Fantástico! Conciso! Moderno!
ingyhere 27/04
3

Eu tenho outro exemplo de código que pode ajudar, usando python3, pathlib e zipfile. Deve funcionar em qualquer sistema operacional.

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!')
duncanmonty
fonte
1

Aqui está uma variação da resposta dada pelo Nux que funciona para mim:

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 )
M Katz
fonte
1

Experimente o abaixo. Funcionou para mim .

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()
Chandra
fonte
1

Se você deseja uma funcionalidade como a pasta compactar de qualquer gerenciador de arquivos gráficos comum, pode usar o código a seguir, ele usa o módulo zipfile . Usando esse código, você terá o arquivo zip com o caminho como sua pasta raiz.

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()
VGe0rge
fonte
1

Para dar mais flexibilidade, por exemplo, selecione diretório / arquivo pelo nome, use:

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

Para uma árvore de arquivos:

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

Você pode, por exemplo, selecionar apenas dir4e 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)

Ou apenas listdirno diretório de chamada de script e adicione tudo a partir daí:

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)
pbn
fonte
Isso fecha, mas não é compactado.
12128 Alex
1

Digamos que você queira compactar todas as pastas (subdiretórios) no diretório atual.

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))
ShiningGo
fonte
1

Para uma maneira concisa de manter a hierarquia de pastas no diretório pai a ser arquivado:

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 desejar, você pode alterar isso para usar pathlib no globbing de arquivos .

ryanjdillon
fonte
1

Tantas respostas aqui, e espero poder contribuir com minha própria versão, que é baseada na resposta original (a propósito), mas com uma perspectiva mais gráfica, também usando o contexto para cada zipfileconfiguração e classificação os.walk(), a fim de ter um saída ordenada.

Tendo essas pastas e os arquivos (entre outras pastas), eu queria criar um .zippara cada cap_pasta:

$ 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

Aqui está o que eu apliquei, com comentários para uma melhor compreensão do 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) 

Basicamente, para cada iteração encerrada os.walk(path), estou abrindo um contexto para zipfileinstalação e, posteriormente, iterando sobre iteração files, que é um listdos arquivos do rootdiretório, formando o caminho relativo para cada arquivo com base no rootdiretório atual , anexando ao zipfilecontexto em execução .

E a saída é apresentada assim:

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

Para ver o conteúdo de cada .zipdiretório, você pode usar o 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
ivanleoncz
fonte
0

Aqui está uma abordagem moderna, usando pathlib, e um gerenciador de contexto. Coloca os arquivos diretamente no zip, em vez de em uma subpasta.

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))
As tartarugas são bonitos
fonte
0

Eu preparei uma função consolidando a solução de Mark Byers com os comentários de Reimund e Morten Zilmer (caminho relativo e incluindo diretórios vazios). Como prática recomendada, withé usado na construção de arquivos do ZipFile.

A função também prepara um nome de arquivo zip padrão com o nome do diretório compactado e a extensão '.zip'. Portanto, ele funciona com apenas um argumento: o diretório de origem a ser compactado.

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)))
Gürol Canbek
fonte
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))
Praveen
fonte
0

Bem, depois de ler as sugestões, criei uma maneira muito semelhante à que funciona com o 2.7.x sem criar nomes de diretório "engraçados" (nomes absolutos) e só criará a pasta especificada dentro do zip.

Ou apenas no caso de você precisar do seu zip para conter uma pasta dentro com o conteúdo do diretório selecionado.

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" )
Xedret
fonte
0

Função para criar arquivo 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()
sushh
fonte
por favor explicar com um exemplo para que eu possa corrigir a minha resposta
sushh
No entanto, o zipfile "atualmente não pode criar um arquivo criptografado" (de 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)
sandes
fonte