Как создать zip-архив каталога на Python?
https://stackoverflow.com/questions/1855095
-
13-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianВопрос
Как я могу создать zip-архив структуры каталогов на Python?
Решение
Как указывали другие, вы должны использовать почтовый файл.Документация сообщает вам, какие функции доступны, но на самом деле не объясняет, как вы можете использовать их для архивирования всего каталога.Я думаю, это проще всего объяснить с помощью какого-нибудь примера кода:
#!/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()
Адаптированный из: http://www.devshed.com/c/a/Python/Python-UnZipped/
Другие советы
Самый простой способ - это использовать shutil.make_archive.Он поддерживает как форматы zip, так и tar.
import shutil
shutil.make_archive(output_filename, 'zip', dir_name)
Если вам нужно сделать что-то более сложное, чем архивирование всего каталога (например, пропустить определенные файлы), то вам нужно покопаться в zipfile модуль, как предлагали другие.
Чтобы добавить содержимое mydirectory в новый zip-файл, включая все файлы и подкаталоги:
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()
Как я могу создать zip-архив структуры каталогов на Python?
В скрипте на Python
В Python 2.7+, shutil имеет 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
Здесь заархивированный архив будет назван zipfile_name.zip.Если base_dir находится дальше вниз от root_dir это исключит файлы, которых нет в base_dir, но все равно архивируйте файлы в родительских каталогах до root_dir.
У меня действительно была проблема с тестированием этого на Cygwin с 2.7 - ему нужен аргумент root_dir для cwd:
make_archive('zipfile_name', 'zip', root_dir='.')
Использование Python из оболочки
Вы можете сделать это с помощью Python из оболочки, также используя zipfile модуль:
$ python -m zipfile -c zipname sourcedir
Где zipname это имя целевого файла, который вы хотите (добавить .zip если вы этого хотите, это не будет сделано автоматически), а sourcedir - это путь к каталогу.
Архивирование Python (или просто не хотите родительский каталог):
Если вы пытаетесь заархивировать пакет python с помощью __init__.py и __main__.py, и вам не нужен родительский каталог, это
$ python -m zipfile -c zipname sourcedir/*
И
$ python zipname
запустил бы пакет.(Обратите внимание, что вы не можете запускать подпакеты в качестве точки входа из заархивированного архива.)
Архивирование приложения на Python:
Если у вас есть python3.5+, и вы специально хотите заархивировать пакет Python, используйте zipapp - приложение zipapp:
$ python -m zipapp myapp
$ python myapp.pyz
Эта функция рекурсивно заархивирует дерево каталогов, сжимающий файлы и запись правильных относительных имен файлов в архив.Записи архива совпадают с теми, которые сгенерированы 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)
Используйте shutil, который является частью набора стандартных библиотек python.Использовать shutil очень просто (смотрите код ниже).:
- 1 - й аргумент:Имя файла результирующего zip / tar-файла,
- 2 - й аргумент:застежка-молния/ деготь,
- 3 - й аргумент:имя_дира
Код:
import shutil
shutil.make_archive('/home/user/Desktop/Filename','zip','/home/username/Desktop/Directory')
Для добавления сжатия к результирующему zip-файлу ознакомьтесь эта ссылка.
Тебе нужно измениться:
zip = zipfile.ZipFile('Python.zip', 'w')
Для
zip = zipfile.ZipFile('Python.zip', 'w', zipfile.ZIP_DEFLATED)
Я внес некоторые изменения в код , предоставленный Марком Байерсом.Приведенная ниже функция также добавит пустые каталоги, если они у вас есть.Примеры должны сделать более понятным, какой путь добавляется к 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)
Выше приведена простая функция, которая должна работать для простых случаев.Вы можете найти более элегантный класс в моей Сути:https://gist.github.com/Eccenux/17526123107ca0ac28e6
Вы, вероятно, хотите взглянуть на zipfile модуль;документация есть по адресу http://docs.python.org/library/zipfile.html.
Вы также можете захотеть os.walk() чтобы проиндексировать структуру каталогов.
У меня есть еще один пример кода, который может помочь, используя python3, pathlib и zipfile.Это должно работать в любой ОС.
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!')
Вот вариант ответа, данного Nux, который работает для меня:
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 )
Попробуйте следующий вариант. у меня это сработало.
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()
Если вам нужна функциональность, подобная папке сжатия любого распространенного графического файлового менеджера, вы можете использовать следующий код, он использует почтовый файл модуль.Используя этот код, вы получите zip-файл с указанным путем в качестве корневой папки.
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()
Современный Python (3.6+), использующий pathlib модуль для краткой обработки путей, подобной ООП, и pathlib.Path.rglob() для рекурсивного глобулирования.Насколько я могу судить, это эквивалентно Георгу V.Ответ Рейли:архивируется при сжатии, самым верхним элементом является каталог, хранятся пустые каталоги, используются относительные пути.
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))
Примечание:как указывают необязательные подсказки типа, zip_name не может быть объектом Path (было бы исправлено в 3.6.2+).
Чтобы обеспечить большую гибкость, напримервыберите каталог / файл по используемому имени:
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
Для дерева файлов:
.
├── dir
│ ├── dir2
│ │ └── file2.txt
│ ├── dir3
│ │ └── file3.txt
│ └── file.txt
├── dir4
│ ├── dir5
│ └── file4.txt
├── listdir.zip
├── main.py
├── root.txt
└── selective.zip
Вы можете, например,выбрать только dir4 и 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)
Или просто listdir в каталоге вызова скрипта и добавьте все оттуда:
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)
Допустим, вы хотите заархивировать все папки (подкаталоги) в текущем каталоге.
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))
Вот современный подход, использующий pathlib и контекстный менеджер.Помещает файлы непосредственно в zip-файл, а не во вложенную папку.
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))
Я подготовил функцию, объединив решение Марка Байерса с комментариями Реймунда и Мортена Цилмера (относительный путь и включение пустых каталогов).В качестве наилучшей практики, with используется при создании файла ZipFile.
Функция также подготавливает имя zip-файла по умолчанию с именем заархивированного каталога и расширением '.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))
Что ж, после прочтения предложений я придумал очень похожий способ, который работает с 2.7.x без создания "смешных" имен каталогов (абсолютноподобных имен) и создаст только указанную папку внутри zip.
Или на всякий случай, если вам нужно, чтобы ваш zip-файл содержал внутри папку с содержимым выбранного каталога.
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" )
Функция для создания 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()
Для краткого описания способа сохранения иерархии папок в родительском каталоге, подлежащем архивированию:
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, ""))
Если вы хотите, вы могли бы изменить это, чтобы использовать pathlib для масштабирования файлов.
Здесь так много ответов, и я надеюсь, что смогу внести свой вклад с моей собственной версией, которая основана на оригинальном ответе (кстати), но с более графической перспективой, также используя контекст для каждого zipfile настройка и сортировка os.walk(), для того, чтобы иметь упорядоченный вывод.
Имея эти папки и их файлы (среди других папок), я хотел создать .zip для каждого 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
Вот что я применил, с комментариями для лучшего понимания процесса.
$ 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)
В принципе, для каждой итерации по os.walk(path), Я открываю контекст для zipfile настройка и впоследствии, повторяя итерацию по files, который является list файлов из root каталог, формирующий относительный путь для каждого файла на основе текущего root каталог, добавляющийся к zipfile контекст, который выполняется.
И результат представлен следующим образом:
$ python3 zip_cap_dirs.py
Compressing: ./cap_01
Compressing: ./cap_02
Compressing: ./cap_03
Чтобы увидеть содержимое каждого .zip каталог, вы можете использовать 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
