파이썬에서 디렉토리 구조의 zip 아카이브를 어떻게 만들 수 있습니까?

다른 사람들이 지적했듯이 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 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,하지만 여전히 최대의 부모 DIRS의 파일을 보관root_dir .

Cygwin에서 2.7로 테스트하는 데 문제가있었습니다 .cwd에 대해 root_dir 인수를 원합니다.

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

쉘에서 파이썬 사용하기

zipfile모듈을 사용하여 쉘에서 Python 으로이 작업을 수행 할 수 있습니다 .

$ python -m zipfile -c zipname sourcedir

zipname원하는 대상 파일의 이름은 어디에 있습니까?.zip 경우 하면 자동으로 수행되지 않음) sourcedir은 디렉토리의 경로입니다.

파이썬을 압축 (또는 부모 디렉토리를 원하지 않음) :

__init__.pyand 로 파이썬 패키지를 압축하려고 시도 __main__.py하고 부모 디렉토리를 원하지 않는 경우

$ python -m zipfile -c zipname sourcedir/*

과

$ python zipname

패키지를 실행합니다. 압축 된 아카이브에서 진입 점으로 하위 패키지를 실행할 수 없습니다.

파이썬 앱 압축하기 :

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)

파이썬 표준 라이브러리 세트의 일부인 shutil을 사용하십시오. shutil 사용은 매우 간단합니다 (아래 코드 참조).

• 첫 번째 인수 : 결과 zip / tar 파일의 파일 이름
• 두 번째 인수 : zip / tar,
• 3 번째 인수 : dir_name

암호:

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)

Mark Byers가 제공 한 코드를 약간 변경했습니다 . 아래 함수는 빈 디렉토리가 있으면 추가합니다. 예제는 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

pathlib간결한 OOP와 같은 경로 처리 및 pathlib.Path.rglob()재귀 globbing에 모듈을 사용하는 최신 Python (3.6+) . 내가 알 수있는 한, 이것은 George V. Reilly의 대답과 같습니다. 압축이있는 zip, 최상위 요소는 디렉토리이며 빈 디렉토리를 유지하고 상대 경로를 사용합니다.

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_namePath 객체 는 될 수 없습니다 ( 3.6.2 +에서 수정 됨 ).

python3, pathlib 및 zipfile을 사용하면 도움이되는 다른 코드 예제가 있습니다. 모든 OS에서 작동해야합니다.

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모듈 을보고 싶을 것입니다 . http://docs.python.org/library/zipfile.html에 설명서가 있습니다.

os.walk()디렉토리 구조를 색인화 할 수도 있습니다 .

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

일반적인 그래픽 파일 관리자의 압축 폴더와 같은 기능을 원하는 경우 다음 코드를 사용할 수 있으며 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()

유연성을 높이려면 예를 들어 이름으로 디렉토리 / 파일을 선택하십시오.

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

보관할 상위 디렉토리 아래에 폴더 계층 구조를 간결하게 유지하려면 다음을 수행하십시오.

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 파일 globbing 에 사용하도록 이것을 변경할 수 있습니다 .

여기에 많은 답변이 있으며 원래 답변을 기반으로하는 자체 버전으로 기여할 수 있기를 바랍니다.하지만 더 그래픽적인 관점에서 각 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

다음은 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))

Mark Byers의 솔루션을 Reimund 및 Morten Zilmer의 의견 (상대 경로 및 빈 디렉토리 포함)과 통합하여 기능을 준비했습니다. 모범 사례로서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()

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)