Como criar um arquivo zip de um diretório em Python?
https://stackoverflow.com/questions/1855095
-
13-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
Como posso criar um arquivo zip de uma estrutura de diretório em Python?
Solução
Como outros apontaram, você deve usar zipfile . A documentação diz-lhe que estão disponíveis funções, mas realmente não explica como você pode usá-los para fechar um diretório inteiro. Eu acho que é mais fácil de 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 /
Outras dicas
A maneira mais fácil é usar shutil.make_archive . Ele suporta ambos os formatos ZIP e alcatrão.
import shutil
shutil.make_archive(output_filename, 'zip', dir_name)
Se você precisa fazer algo mais complicado do que fechando o diretório inteiro (como ignorar determinados arquivos), então você precisa cavar o zipfile módulo como já foi sugerido.
Para adicionar o conteúdo de mydirectory para um 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()
Como posso criar um arquivo zip de uma estrutura de diretório em Python?
Em um script Python
Em Python 2.7+, shutil tem uma função make_archive.
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 zipado será nomeado zipfile_name.zip. Se base_dir é mais para baixo a partir root_dir ele irá excluir arquivos não no base_dir, mas ainda arquivar os arquivos nos diretórios pais até ao root_dir.
Eu tinha um problema de testar isso em Cygwin com 2,7 - ele quer um argumento ROOT_DIR, por cwd:
make_archive('zipfile_name', 'zip', root_dir='.')
Usando Python a partir da casca
Você pode fazer isso com Python a partir da casca também usando o módulo zipfile:
$ python -m zipfile -c zipname sourcedir
Onde zipname é o nome do arquivo de destino que você quer (add .zip se quiser, ele não vai fazer isso automaticamente) e sourcedir é o caminho para o diretório.
fechando Python (ou simplesmente não querem dir pai):
Se você está tentando fechar acima de um pacote de python com um __init__.py e __main__.py, e você não quer que o dir pai, é
$ python -m zipfile -c zipname sourcedir/*
E
$ python zipname
iria executar o pacote. (Note que você não pode executar subpackages como o ponto de entrada a partir de um arquivo zipado.)
Zipping um Python app:
Se você tem python3.5 + e, especificamente, quer fechar acima de um pacote Python, use zipapp :
$ python -m zipapp myapp
$ python myapp.pyz
Esta função irá recursivamente fechar acima de uma árvore de diretórios, compressão os arquivos e gravar os nomes de arquivos relativos corretos no arquivo. As entradas de arquivo são os mesmos que aqueles gerados 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)
Use shutil, que faz parte do python set biblioteca padrão. Usando shutil é tão simples (ver código abaixo):
- 1 arg: Nome de arquivo zip / tar resultante,
- 2 arg: zip / tar,
- 3ª arg: dir_name
Código:
import shutil
shutil.make_archive('/home/user/Desktop/Filename','zip','/home/username/Desktop/Directory')
Para adicionar compressão para o arquivo zip resultando, veja este link .
Você precisa mudar:
zip = zipfile.ZipFile('Python.zip', 'w')
para
zip = zipfile.ZipFile('Python.zip', 'w', zipfile.ZIP_DEFLATED)
Eu fiz algumas mudanças para dada por Mark Byers . Abaixo função também acrescenta diretórios vazios, se os tiver. Exemplos deve torná-lo mais claro o que é o caminho adicionado à 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 é uma função simples que deve funcionar para casos simples. Você pode encontrar mais classe elegante na minha Síntese: https://gist.github.com/Eccenux/17526123107ca0ac28e6
Você provavelmente vai querer olhar para o módulo zipfile; há documentação em http://docs.python.org/library/zipfile.html .
Você também pode querer os.walk() para indexar a estrutura do diretório.
Eu tenho um outro exemplo de código que pode ajudar, usando python3, pathlib e zipfile. Ele 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!')
Aqui é uma variação sobre a resposta dada por 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 )
Experimente o abaixo de um .it trabalhou 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()
Se você quer uma funcionalidade como a pasta compressa de qualquer gerenciador de arquivos gráfico comum você pode usar o código a seguir, ele usa o zipfile módulo. Com esse código você terá o arquivo zip com o caminho como a 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()
Modern Python (3.6+), utilizando o pathlib módulo para OOP concisa -como manuseamento de caminhos, e pathlib.Path.rglob() para recursiva englobamento. Tanto quanto eu posso dizer, isso é equivalente a resposta de George V. Reilly: fecha com a compressão, o elemento superior é um diretório, mantém diretórios 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 sugestões tipo opcionais indicam, zip_name pode não ser um objeto Path ( seria fixado em 3,6. 2+ ).
Para dar maior flexibilidade, por exemplo selecionar o diretório / arquivo pelo uso name:
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 dir4 e 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 listdir no diretório de script invocação e add tudo de 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)
Digamos que você queira Zip todas as pastas (sub diretó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))
Aqui está uma abordagem moderna, usando pathlib, e um gerente 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))
Eu preparei uma função, consolidando solução Mark Byers' com Reimund e comentários de Morten ZILMER (caminho relativo e incluindo pastas vazias). Como uma prática recomendada, with é usado na construção de arquivos do ZipFile.
A função também prepara um nome de arquivo padrão zip com o nome do diretório compactado e extensão '.zip'. Portanto, ele trabalha com apenas um argumento:. O diretório de origem para 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)))
# 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))
Bem, depois de ler as sugestões que eu vim com uma forma muito semelhante que funciona com 2.7.x sem criar nomes de diretório "engraçadas" (absolute-como nomes), e só vai criar a pasta especificada dentro do zip.
Ou apenas em caso necessário o seu zip para conter um dentro da pasta 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" )
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()
Para uma maneira concisa para manter a hierarquia de pastas sob o diretório pai para 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 você quiser, você pode mudar isso para usar pathlib para arquivo globbing .
Então, muitas respostas aqui, e espero que eu possa contribuir com a minha própria versão, que é baseada na resposta original (por sinal), mas com uma perspectiva mais gráfica, utilizando também o contexto para cada configuração zipfile e classificação os.walk(), a fim de ter uma saída ordenada.
Tendo essas pastas e arquivos deles (entre outras pastas), eu queria criar um .zip para cada pasta 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
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 sobre os.walk(path), estou abrindo um contexto para a instalação zipfile e depois, iteração iteração sobre files, que é um list de arquivos do diretório root, formando o caminho relativo para cada arquivo com base na root atual diretório, anexando ao contexto zipfile que está 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 diretório .zip, você pode usar o comando less:
$ 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
