Làm cách nào để sao chép toàn bộ thư mục tệp vào thư mục hiện có bằng Python?

Chạy đoạn mã sau từ thư mục chứa thư mục có tên bar(chứa một hoặc nhiều tệp) và thư mục có tên baz(cũng chứa một hoặc nhiều tệp). Hãy chắc chắn rằng không có một thư mục có tên foo.

import shutil
shutil.copytree('bar', 'foo')
shutil.copytree('baz', 'foo')

Nó sẽ thất bại với:

$ python copytree_test.py 
Traceback (most recent call last):
  File "copytree_test.py", line 5, in <module>
    shutil.copytree('baz', 'foo')
  File "/System/Library/Frameworks/Python.framework/Versions/2.5/lib/python2.5/shutil.py", line 110, in copytree
  File "/System/Library/Frameworks/Python.framework/Versions/2.5/lib/python2.5/os.py", line 172, in makedirs
OSError: [Errno 17] File exists: 'foo'

Tôi muốn nó hoạt động theo cách tương tự như tôi đã gõ:

$ mkdir foo
$ cp bar/* foo/
$ cp baz/* foo/

Tôi có cần sử dụng shutil.copy()để sao chép từng tập tin bazvào fookhông? (Sau khi tôi đã sao chép nội dung của 'thanh' vào 'foo' với shutil.copytree()?) Hoặc có cách nào dễ dàng / tốt hơn không?

Hạn chế này của tiêu chuẩn shutil.copytreecó vẻ tùy tiện và gây phiền nhiễu. Cách giải quyết:

import os, shutil
def copytree(src, dst, symlinks=False, ignore=None):
    for item in os.listdir(src):
        s = os.path.join(src, item)
        d = os.path.join(dst, item)
        if os.path.isdir(s):
            shutil.copytree(s, d, symlinks, ignore)
        else:
            shutil.copy2(s, d)

Lưu ý rằng nó không hoàn toàn phù hợp với tiêu chuẩn copytree:

• nó không tôn vinh symlinksvà ignoretham số cho thư mục gốc của srccây;
• nó không gây ra shutil.Errorlỗi ở cấp độ gốc src;
• trong trường hợp có lỗi trong quá trình sao chép một cây con, nó sẽ tăng shutil.Errorcho cây con đó thay vì cố gắng sao chép các cây con khác và tăng đơn lẻ kết hợp shutil.Error.

Đây là một giải pháp là một phần của thư viện chuẩn:

from distutils.dir_util import copy_tree
copy_tree("/a/b/c", "/x/y/z")

Xem câu hỏi tương tự này.

Sao chép nội dung thư mục vào một thư mục với python

• Tham khảo - https://docs.python.org/3/distutils/apiref.html#distutils.dir_util.copy_tree

Để cải thiện một chút về câu trả lời của atzz cho chức năng trong đó chức năng trên luôn cố gắng sao chép các tệp từ nguồn sang đích.

def copytree(src, dst, symlinks=False, ignore=None):
    if not os.path.exists(dst):
        os.makedirs(dst)
    for item in os.listdir(src):
        s = os.path.join(src, item)
        d = os.path.join(dst, item)
        if os.path.isdir(s):
            copytree(s, d, symlinks, ignore)
        else:
            if not os.path.exists(d) or os.stat(s).st_mtime - os.stat(d).st_mtime > 1:
                shutil.copy2(s, d)

Trong triển khai trên của tôi

• Tạo thư mục đầu ra nếu chưa tồn tại
• Làm thư mục sao chép bằng cách gọi đệ quy phương thức của riêng tôi.
• Khi chúng ta thực sự sao chép tập tin, tôi kiểm tra xem tập tin có bị sửa đổi không thì chúng ta chỉ nên sao chép.

Tôi đang sử dụng chức năng trên cùng với xây dựng scons. Nó giúp tôi rất nhiều vì mỗi lần tôi biên dịch, tôi có thể không cần sao chép toàn bộ tập tin .. mà chỉ cần sửa đổi các tập tin.

Một sự hợp nhất lấy cảm hứng từ atzz và Mital Vora:

#!/usr/bin/python
import os
import shutil
import stat
def copytree(src, dst, symlinks = False, ignore = None):
  if not os.path.exists(dst):
    os.makedirs(dst)
    shutil.copystat(src, dst)
  lst = os.listdir(src)
  if ignore:
    excl = ignore(src, lst)
    lst = [x for x in lst if x not in excl]
  for item in lst:
    s = os.path.join(src, item)
    d = os.path.join(dst, item)
    if symlinks and os.path.islink(s):
      if os.path.lexists(d):
        os.remove(d)
      os.symlink(os.readlink(s), d)
      try:
        st = os.lstat(s)
        mode = stat.S_IMODE(st.st_mode)
        os.lchmod(d, mode)
      except:
        pass # lchmod not available
    elif os.path.isdir(s):
      copytree(s, d, symlinks, ignore)
    else:
      shutil.copy2(s, d)

• Hành vi tương tự như shutil.copytree , với các liên kết tượng trưng và bỏ qua các tham số
• Tạo cấu trúc đích thư mục nếu không tồn tại
• Sẽ không thất bại nếu dst đã tồn tại

Python 3.8 đã giới thiệu dirs_exist_okđối số cho shutil.copytree:

Đệ quy sao chép toàn bộ cây thư mục bắt nguồn từ src vào thư mục có tên dst và trả về thư mục đích. dirs_exist_ok ra lệnh xem có nên đưa ra một ngoại lệ trong trường hợp dst hoặc bất kỳ thư mục cha bị thiếu nào đã tồn tại.

Do đó, với Python 3.8+, điều này sẽ hoạt động:

import shutil

shutil.copytree('bar', 'foo')
shutil.copytree('baz', 'foo', dirs_exist_ok=True)

tài liệu tuyên bố rõ ràng rằng thư mục đích không nên tồn tại :

Thư mục đích, được đặt tên theo dst, không được tồn tại; nó sẽ được tạo ra cũng như thiếu các thư mục cha.

Tôi nghĩ rằng đặt cược tốt nhất của bạn là os.walkthứ hai và tất cả các thư mục, copy2thư mục và tập tin hệ quả và làm thêm copystatcho các thư mục. Sau tất cả, đó chính xác là những gì được copytreegiải thích trong các tài liệu. Hoặc bạn có thể copyvà copystattừng thư mục / tập tin và os.listdirthay vì os.walk.

Điều này được lấy cảm hứng từ câu trả lời tốt nhất ban đầu được cung cấp bởi atzz, tôi chỉ cần thêm logic tệp / thư mục thay thế. Vì vậy, nó không thực sự hợp nhất, nhưng xóa tệp / thư mục hiện có và sao chép tệp mới:

import shutil
import os
def copytree(src, dst, symlinks=False, ignore=None):
    for item in os.listdir(src):
        s = os.path.join(src, item)
        d = os.path.join(dst, item)
        if os.path.exists(d):
            try:
                shutil.rmtree(d)
            except Exception as e:
                print e
                os.unlink(d)
        if os.path.isdir(s):
            shutil.copytree(s, d, symlinks, ignore)
        else:
            shutil.copy2(s, d)
    #shutil.rmtree(src)

Uncomment rmtree để làm cho nó một chức năng di chuyển.

Đây là phiên bản của tôi của cùng một nhiệm vụ ::

import os, glob, shutil

def make_dir(path):
    if not os.path.isdir(path):
        os.mkdir(path)


def copy_dir(source_item, destination_item):
    if os.path.isdir(source_item):
        make_dir(destination_item)
        sub_items = glob.glob(source_item + '/*')
        for sub_item in sub_items:
            copy_dir(sub_item, destination_item + '/' + sub_item.split('/')[-1])
    else:
        shutil.copy(source_item, destination_item)

Đây là một phiên bản lấy cảm hứng từ chủ đề này bắt chước chặt chẽ hơn distutils.file_util.copy_file.

updateonlylà một bool nếu True, sẽ chỉ sao chép các tệp có ngày sửa đổi mới hơn các tệp hiện có dsttrừ khi được liệt kê trong forceupdateđó sẽ sao chép bất kể.

ignorevà forceupdatemong đợi danh sách tên tệp hoặc thư mục / tên tệp liên quan đến src và chấp nhận ký tự đại diện kiểu Unix tương tự globhoặc fnmatch.

Hàm trả về danh sách các tệp được sao chép (hoặc sẽ được sao chép dryrunnếu đúng).

import os
import shutil
import fnmatch
import stat
import itertools

def copyToDir(src, dst, updateonly=True, symlinks=True, ignore=None, forceupdate=None, dryrun=False):

    def copySymLink(srclink, destlink):
        if os.path.lexists(destlink):
            os.remove(destlink)
        os.symlink(os.readlink(srclink), destlink)
        try:
            st = os.lstat(srclink)
            mode = stat.S_IMODE(st.st_mode)
            os.lchmod(destlink, mode)
        except OSError:
            pass  # lchmod not available
    fc = []
    if not os.path.exists(dst) and not dryrun:
        os.makedirs(dst)
        shutil.copystat(src, dst)
    if ignore is not None:
        ignorepatterns = [os.path.join(src, *x.split('/')) for x in ignore]
    else:
        ignorepatterns = []
    if forceupdate is not None:
        forceupdatepatterns = [os.path.join(src, *x.split('/')) for x in forceupdate]
    else:
        forceupdatepatterns = []
    srclen = len(src)
    for root, dirs, files in os.walk(src):
        fullsrcfiles = [os.path.join(root, x) for x in files]
        t = root[srclen+1:]
        dstroot = os.path.join(dst, t)
        fulldstfiles = [os.path.join(dstroot, x) for x in files]
        excludefiles = list(itertools.chain.from_iterable([fnmatch.filter(fullsrcfiles, pattern) for pattern in ignorepatterns]))
        forceupdatefiles = list(itertools.chain.from_iterable([fnmatch.filter(fullsrcfiles, pattern) for pattern in forceupdatepatterns]))
        for directory in dirs:
            fullsrcdir = os.path.join(src, directory)
            fulldstdir = os.path.join(dstroot, directory)
            if os.path.islink(fullsrcdir):
                if symlinks and dryrun is False:
                    copySymLink(fullsrcdir, fulldstdir)
            else:
                if not os.path.exists(directory) and dryrun is False:
                    os.makedirs(os.path.join(dst, dir))
                    shutil.copystat(src, dst)
        for s,d in zip(fullsrcfiles, fulldstfiles):
            if s not in excludefiles:
                if updateonly:
                    go = False
                    if os.path.isfile(d):
                        srcdate = os.stat(s).st_mtime
                        dstdate = os.stat(d).st_mtime
                        if srcdate > dstdate:
                            go = True
                    else:
                        go = True
                    if s in forceupdatefiles:
                        go = True
                    if go is True:
                        fc.append(d)
                        if not dryrun:
                            if os.path.islink(s) and symlinks is True:
                                copySymLink(s, d)
                            else:
                                shutil.copy2(s, d)
                else:
                    fc.append(d)
                    if not dryrun:
                        if os.path.islink(s) and symlinks is True:
                            copySymLink(s, d)
                        else:
                            shutil.copy2(s, d)
    return fc

Giải pháp trước đây có một số vấn đề srccó thể ghi đè dstmà không có bất kỳ thông báo hoặc ngoại lệ nào.

Tôi thêm một predict_errorphương pháp để dự đoán lỗi trước khi sao chép. copytreechủ yếu dựa trên phiên bản của Cyrille Pontvieux.

Sử dụng predict_errorđể dự đoán tất cả các lỗi lúc đầu là tốt nhất, trừ khi bạn muốn thấy ngoại lệ được đưa ra lần khác khi thực hiện copytreecho đến khi sửa tất cả lỗi.

def predict_error(src, dst):  
    if os.path.exists(dst):
        src_isdir = os.path.isdir(src)
        dst_isdir = os.path.isdir(dst)
        if src_isdir and dst_isdir:
            pass
        elif src_isdir and not dst_isdir:
            yield {dst:'src is dir but dst is file.'}
        elif not src_isdir and dst_isdir:
            yield {dst:'src is file but dst is dir.'}
        else:
            yield {dst:'already exists a file with same name in dst'}

    if os.path.isdir(src):
        for item in os.listdir(src):
            s = os.path.join(src, item)
            d = os.path.join(dst, item)
            for e in predict_error(s, d):
                yield e


def copytree(src, dst, symlinks=False, ignore=None, overwrite=False):
    '''
    would overwrite if src and dst are both file
    but would not use folder overwrite file, or viceverse
    '''
    if not overwrite:
        errors = list(predict_error(src, dst))
        if errors:
            raise Exception('copy would overwrite some file, error detail:%s' % errors)

    if not os.path.exists(dst):
        os.makedirs(dst)
        shutil.copystat(src, dst)
    lst = os.listdir(src)
    if ignore:
        excl = ignore(src, lst)
        lst = [x for x in lst if x not in excl]
    for item in lst:
        s = os.path.join(src, item)
        d = os.path.join(dst, item)
        if symlinks and os.path.islink(s):
            if os.path.lexists(d):
                os.remove(d)
            os.symlink(os.readlink(s), d)
            try:
                st = os.lstat(s)
                mode = stat.S_IMODE(st.st_mode)
                os.lchmod(d, mode)
            except:
                pass  # lchmod not available
        elif os.path.isdir(s):
            copytree(s, d, symlinks, ignore)
        else:
            if not overwrite:
                if os.path.exists(d):
                    continue
            shutil.copy2(s, d)

Đây là vượt qua của tôi tại vấn đề. Tôi đã sửa đổi mã nguồn cho copytree để giữ chức năng ban đầu, nhưng bây giờ không có lỗi xảy ra khi thư mục đã tồn tại. Tôi cũng đã thay đổi nó để nó không ghi đè lên các tệp hiện có mà chỉ giữ cả hai bản sao, một bản có tên đã được sửa đổi, vì điều này rất quan trọng đối với ứng dụng của tôi.

import shutil
import os


def _copytree(src, dst, symlinks=False, ignore=None):
    """
    This is an improved version of shutil.copytree which allows writing to
    existing folders and does not overwrite existing files but instead appends
    a ~1 to the file name and adds it to the destination path.
    """

    names = os.listdir(src)
    if ignore is not None:
        ignored_names = ignore(src, names)
    else:
        ignored_names = set()

    if not os.path.exists(dst):
        os.makedirs(dst)
        shutil.copystat(src, dst)
    errors = []
    for name in names:
        if name in ignored_names:
            continue
        srcname = os.path.join(src, name)
        dstname = os.path.join(dst, name)
        i = 1
        while os.path.exists(dstname) and not os.path.isdir(dstname):
            parts = name.split('.')
            file_name = ''
            file_extension = parts[-1]
            # make a new file name inserting ~1 between name and extension
            for j in range(len(parts)-1):
                file_name += parts[j]
                if j < len(parts)-2:
                    file_name += '.'
            suffix = file_name + '~' + str(i) + '.' + file_extension
            dstname = os.path.join(dst, suffix)
            i+=1
        try:
            if symlinks and os.path.islink(srcname):
                linkto = os.readlink(srcname)
                os.symlink(linkto, dstname)
            elif os.path.isdir(srcname):
                _copytree(srcname, dstname, symlinks, ignore)
            else:
                shutil.copy2(srcname, dstname)
        except (IOError, os.error) as why:
            errors.append((srcname, dstname, str(why)))
        # catch the Error from the recursive copytree so that we can
        # continue with other files
        except BaseException as err:
            errors.extend(err.args[0])
    try:
        shutil.copystat(src, dst)
    except WindowsError:
        # can't copy file access times on Windows
        pass
    except OSError as why:
        errors.extend((src, dst, str(why)))
    if errors:
        raise BaseException(errors)

Thử cái này:

import os,shutil

def copydir(src, dst):
  h = os.getcwd()
  src = r"{}".format(src)
  if not os.path.isdir(dst):
     print("\n[!] No Such directory: ["+dst+"] !!!")
     exit(1)

  if not os.path.isdir(src):
     print("\n[!] No Such directory: ["+src+"] !!!")
     exit(1)
  if "\\" in src:
     c = "\\"
     tsrc = src.split("\\")[-1:][0]
  else:
    c = "/"
    tsrc = src.split("/")[-1:][0]

  os.chdir(dst)
  if os.path.isdir(tsrc):
    print("\n[!] The Directory Is already exists !!!")
    exit(1)
  try:
    os.mkdir(tsrc)
  except WindowsError:
    print("\n[!] Error: In[ {} ]\nPlease Check Your Dirctory Path !!!".format(src))
    exit(1)
  os.chdir(h)
  files = []
  for i in os.listdir(src):
    files.append(src+c+i)
  if len(files) > 0:
    for i in files:
        if not os.path.isdir(i):
            shutil.copy2(i, dst+c+tsrc)

  print("\n[*] Done ! :)")

copydir("c:\folder1", "c:\folder2")

Đây là một phiên bản mong đợi pathlib.Pathnhư là một đầu vào.

# Recusively copies the content of the directory src to the directory dst.
# If dst doesn't exist, it is created, together with all missing parent directories.
# If a file from src already exists in dst, the file in dst is overwritten.
# Files already existing in dst which don't exist in src are preserved.
# Symlinks inside src are copied as symlinks, they are not resolved before copying.
#
def copy_dir(src, dst):
    dst.mkdir(parents=True, exist_ok=True)
    for item in os.listdir(src):
        s = src / item
        d = dst / item
        if s.is_dir():
            copy_dir(s, d)
        else:
            shutil.copy2(str(s), str(d))

Lưu ý rằng hàm này yêu cầu Python 3.6, đây là phiên bản đầu tiên của Python có os.listdir()hỗ trợ các đối tượng giống như đường dẫn làm đầu vào. Nếu bạn cần hỗ trợ các phiên bản trước của Python, bạn có thể thay thế listdir(src)bằng listdir(str(src)).

Tôi nghĩ rằng cách nhanh nhất và đơn giản nhất sẽ là python gọi các lệnh hệ thống ...

thí dụ..

import os
cmd = '<command line call>'
os.system(cmd)

Tar và gzip lên thư mục .... giải nén và giải nén thư mục ở vị trí mong muốn.

vâng