Как создать zip-архив каталога
Как я могу создать zip-архив структуры каталогов в Python?
31 ответ
Как уже отмечали другие, вы должны использовать zipfile. Документация говорит вам, какие функции доступны, но не объясняет, как вы можете использовать их для архивирования всего каталога. Я думаю, что это проще всего объяснить с помощью некоторого примера кода:
#!/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:
$ 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)
С Python 3.9,
pathlib &
zipfile модуль вы можете создавать zip-файлы из любой точки системы.
def zip_dir(dir: Union[Path, str], filename: Union[Path, str]):
"""Zip the provided directory without navigating to that directory using `pathlib` module"""
# Convert to Path object
dir = Path(dir)
with zipfile.ZipFile(filename, "w", zipfile.ZIP_DEFLATED) as zip_file:
for entry in dir.rglob("*"):
zip_file.write(entry, entry.relative_to(dir))
Он аккуратный, типизированный и содержит меньше кода.
Современный Python (3.6+) с использованием pathlib модуль для краткой ООП-подобной обработки путей, и pathlib.Path.rglob() для рекурсивного сглаживания. Насколько я могу судить, это эквивалентно ответу Джорджа В. Рейли: сжатие сжато, самый верхний элемент - это каталог, содержит пустые каталоги, использует относительные пути.
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+).
Используйте shutil, который является частью набора стандартных библиотек python. Использовать shutil очень просто (см. Код ниже):
- 1-й аргумент: имя результирующего файла zip/tar,
- 2-й аргумент: zip/tar,
- 3-й аргумент: dir_name
Код:
import shutil
shutil.make_archive('/home/user/Desktop/Filename','zip','/home/username/Desktop/Directory')
Чтобы добавить сжатие к полученному файлу почтового индекса, проверьте эту ссылку.
Вам нужно изменить:
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)
Выше простая функция, которая должна работать для простых случаев. Вы можете найти более элегантный класс в моем Gist: https://gist.github.com/Eccenux/17526123107ca0ac28e6
Для краткого способа сохранить иерархию папок в родительском каталоге для архивации:
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 для подстановки файлов.
У меня есть другой пример кода, который может помочь, используя 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!')
Если вам нужна такая функциональность, как папка сжатия любого обычного графического файлового менеджера, вы можете использовать следующий код, он использует модуль zipfile. Используя этот код, вы получите 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()
Решение с использованием
pathlib.Path, который не зависит от используемой ОС:
import zipfile
from pathlib import Path
def zip_dir(path: Path, zip_file_path: Path):
"""Zip all contents of path to zip_file"""
files_to_zip = [
file for file in path.glob('*') if file.is_file()]
with zipfile.ZipFile(
zip_file_path, 'w', zipfile.ZIP_DEFLATED) as zip_f:
for file in files_to_zip:
print(file.name)
zip_f.write(file, file.name)
current_dir = Path.cwd()
zip_dir = current_dir / "test"
tools.zip_dir(
zip_dir, current_dir / 'Zipped_dir.zip')
Здесь так много ответов, и я надеюсь, что смогу внести свой вклад в свою собственную версию, которая основана на исходном ответе (кстати), но с более графической перспективой, также используя контекст для каждого 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 setup, а затем, итерация, повторение 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
При использованииshutilобратите внимание, что вы должны включить путь к выходному каталогу вbase_nameаргумент:
import shutil
shutil.make_archive(
base_name=output_dir_path + output_filename_without_extension,
format="zip",
root_dir=input_root_dir)
Для большей гибкости, например, выберите каталог / файл по имени, используйте:
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)
Вы, вероятно, хотите посмотреть на zipfile модуль; есть документация по адресу http://docs.python.org/library/zipfile.html.
Вы также можете хотеть os.walk() индексировать структуру каталогов.
Попробуйте приведенный ниже. Он работал для меня.
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()
Заархивируйте файл или дерево (каталог и его подкаталоги).
from pathlib import Path
from zipfile import ZipFile, ZIP_DEFLATED
def make_zip(tree_path, zip_path, mode='w', skip_empty_dir=False):
with ZipFile(zip_path, mode=mode, compression=ZIP_DEFLATED) as zf:
paths = [Path(tree_path)]
while paths:
p = paths.pop()
if p.is_dir():
paths.extend(p.iterdir())
if skip_empty_dir:
continue
zf.write(p)
Чтобы добавить в существующий архив, передайте
mode='a', чтобы создать свежий архив
mode='w'(значение по умолчанию, указанное выше). Допустим, вы хотите объединить 3 разных дерева каталогов в один архив.
make_zip(path_to_tree1, path_to_arch, mode='w')
make_zip(path_to_tree2, path_to_arch, mode='a')
make_zip(path_to_file3, path_to_arch, mode='a')
Скажем, вы хотите сжать все папки (подкаталоги) в текущем каталоге.
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))
Одна вещь, полностью упущенная предыдущими ответами, заключается в том, что использованиеos.path.join()может легко возвращать пути, несовместимые с POSIX, при запуске кода в Windows. Результирующий архив будет содержать файлы с буквальными обратными косыми чертами в именах при обработке его любым распространенным программным обеспечением для архивирования в Linux, а это не то, что вам нужно. Использоватьpath.as_posix()дляarcnameвместо параметра!
import zipfile
from pathlib import Path
with zipfile.ZipFile("archive.zip", "w", zipfile.ZIP_DEFLATED) as zf:
for path in Path("include_all_of_this_folder").rglob("*"):
zf.write(path, path.as_posix())
Очевидным способом было бы пойти с shutil, как сказано во втором верхнем ответе, но если вы по какой-то причине все еще хотите использовать ZipFile, и если у вас возникают проблемы с этим (например, ERR 13 в Windows и т. Д.), Вы можете использовать это исправление:
import os
import zipfile
def retrieve_file_paths(dirName):
filePaths = []
for root, directories, files in os.walk(dirName):
for filename in files:
filePath = os.path.join(root, filename)
filePaths.append(filePath)
return filePaths
def main(dir_name, output_filename):
filePaths = retrieve_file_paths(dir_name)
zip_file = zipfile.ZipFile(output_filename+'.zip', 'w')
with zip_file:
for file in filePaths:
zip_file.write(file)
main("my_dir", "my_dir_archived")
Этот рекурсивно выполняет итерацию по каждой подпапке / файлу в данной папке и записывает их в zip-файл вместо попытки напрямую заархивировать папку.
Вот вариант ответа от 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 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))
Для всех, кто углубляется в этот вопрос и пытается заархивировать тот же каталог, в котором находится их программа, и получает как очень глубокие древовидные структуры, так и заканчивает рекурсией из-за самого zip-файла, попробуйте это.
Это комбинация ответа Марка и некоторых дополнительных проверок, чтобы убедиться, что нет рекурсивного архивирования самого zip-файла и нет излишне глубоких структур папок.
import os
import zipfile
def zipdir(path, ziph, ignored_directories, ignored_files):
# ziph is zipfile handle
for root, dirs, files in os.walk(path):
for file in files:
if not any(ignored_dir in root for ignored_dir in ignored_directories):
if not any(ignored_fname in file for ignored_fname in ignored_files):
ziph.write(os.path.join(root, file))
# current working directory
this_dir = os.path.dirname(os.path.abspath(__file__))
# the directory within the working directory the zip will be created in (build/archives).
zip_dest_dir = os.path.join('build', 'archives')
# verify zip_dest_dir exists: if not, create it
if not os.path.isdir(zip_dest_dir):
os.makedirs(zip_dest_dir, exist_ok=True)
# leave zip_dest_dir blank (or set dist_dir = this_dir) if you want the zip file in the working directory (same directory as the script)
dest_dir = os.path.join(this_dir, zip_dest_dir)
# name the zip file: remember the file extension
zip_filename = 'zipped_directory.zip'
# zip file's path
zip_path = os.path.join(dest_dir, zip_filename)
# create the zipfile handle: you can change ZIP_STORED to any other compression algorithm of your choice, like ZIP_DEFLATED, if you need actual compression
zipf = zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_STORED)
# ignored files and directories: I personally wanted to ignore the "build" directory, alongside with "node_modules", so those would be listed here.
ignored_dirs = []
# ignore any specific files: in my case, I was ignoring the script itself, so I'd include 'deploy.py' here
ignored_files = [zip_filename]
# zip directory contents
zipdir('.', zipf, ignored_dirs, ignored_files)
zipf.close()
Результирующий zip-файл должен включать только каталоги, начинающиеся с рабочего каталога: поэтому нет Users/user/Desktop/code/.../working_directory/.../ и т. Д. вид файловой структуры.
Функция для создания 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()
Что ж, после прочтения предложений я придумал очень похожий способ, который работает с 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" )
Вот современный подход, использующий 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))
суммируйте другие, создайте функцию:
import zipfile
def zipFolder(toZipFolder, outputZipFile):
"""
zip/compress a whole folder/directory to zip file
"""
print("Zip for foler %s" % toZipFolder)
with zipfile.ZipFile(outputZipFile, 'w', zipfile.ZIP_DEFLATED) as zipFp:
for dirpath, dirnames, filenames in os.walk(toZipFolder):
# print("%s" % ("-"*80))
# print("dirpath=%s, dirnames=%s, filenames=%s" % (dirpath, dirnames, filenames))
# print("Folder: %s, Files: %s" % (dirpath, filenames))
for curFileName in filenames:
# print("curFileName=%s" % curFileName)
curFilePath = os.path.join(dirpath, curFileName)
# print("curFilePath=%s" % curFilePath)
fileRelativePath = os.path.relpath(curFilePath, toZipFolder)
# print("fileRelativePath=%s" % fileRelativePath)
# print(" %s" % fileRelativePath)
zipFp.write(curFilePath, arcname=fileRelativePath)
print("Completed zip file %s" % outputZipFile)
вызов:
toZipFullPath = "/Users/crifan/dev/dev_root/iosReverse/WhatsApp/ipa/forRepackIpa_20231128"
outputZipFile = "/Users/crifan/dev/dev_root/iosReverse/WhatsApp/ipa/WhatsApp_v23.24.0_20231128.ipa"
zipFolder(toZipFullPath, outputZipFile)
выход:
Zip for foler /Users/crifan/dev/dev_root/iosReverse/WhatsApp/ipa/forRepackIpa_20231128
Completed zip file /Users/crifan/dev/dev_root/iosReverse/WhatsApp/ipa/WhatsApp_v23.20.79_idaAllSymbols_20231128.ipa
последний код: crifanLib/crifanFile.py