Bagaimana cara menyalin seluruh direktori file ke direktori yang ada menggunakan Python?

Jalankan kode berikut dari direktori yang berisi direktori bernama bar(mengandung satu atau lebih file) dan direktori bernama baz(juga mengandung satu atau lebih file). Pastikan tidak ada direktori yang bernama foo.

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

Itu akan gagal dengan:

$ 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'

Saya ingin ini bekerja dengan cara yang sama seperti jika saya telah mengetik:

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

Apakah saya perlu menggunakan shutil.copy()untuk menyalin setiap file bazke dalam foo? (Setelah saya sudah menyalin isi 'bar' ke 'foo' dengan shutil.copytree()?) Atau apakah ada cara yang lebih mudah / lebih baik?

Batasan standar ini shutil.copytreetampaknya sewenang-wenang dan menjengkelkan. Penanganan masalah:

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)

Perhatikan bahwa itu tidak sepenuhnya konsisten dengan standar copytree:

• itu tidak menghormati symlinksdan ignoreparameter untuk direktori root dari srcpohon;
• itu tidak meningkatkan shutil.Errorkesalahan di tingkat root src;
• jika terjadi kesalahan saat menyalin subtree, subtree itu akan meningkat shutil.Erroralih-alih mencoba menyalin subtree lain dan menaikkan satu kombinasi shutil.Error.

Inilah solusi yang merupakan bagian dari pustaka standar:

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

Lihat pertanyaan serupa ini.

Salin konten direktori ke direktori dengan python

• Referensi - https://docs.python.org/3/distutils/apiref.html#distutils.dir_util.copy_tree

Dalam sedikit perbaikan pada jawaban atzz untuk fungsi di mana fungsi di atas selalu mencoba untuk menyalin file dari sumber ke tujuan.

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)

Dalam implementasi saya di atas

• Membuat direktori keluaran jika belum ada
• Melakukan direktori salin dengan secara berulang memanggil metode saya sendiri.
• Ketika kita benar-benar menyalin file, saya memeriksa apakah file diubah maka hanya kita yang harus menyalin.

Saya menggunakan fungsi di atas bersama dengan membangun scon. Ini banyak membantu saya karena setiap kali saya mengkompilasi saya mungkin tidak perlu menyalin seluruh set file .. tetapi hanya file yang dimodifikasi.

Penggabungan yang terinspirasi oleh atzz dan 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)

• Perilaku yang sama seperti shutil.copytree , dengan symlink dan abaikan parameter
• Buat struktur tujuan direktori jika tidak ada
• Tidak akan gagal jika dst sudah ada

Python 3.8 memperkenalkan dirs_exist_okargumen untuk shutil.copytree:

Secara rekursif menyalin seluruh pohon direktori yang di-root di src ke direktori bernama dst dan mengembalikan direktori tujuan. dirs_exist_ok menentukan apakah akan menaikkan pengecualian jika dst atau direktori induk yang hilang sudah ada.

Oleh karena itu, dengan Python 3.8+ ini harus berfungsi:

import shutil

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

dokumen secara eksplisit menyatakan bahwa direktori tujuan tidak boleh ada :

Direktori tujuan, dinamai oleh dst, harus belum ada; itu akan dibuat serta direktori induk yang hilang.

Saya pikir taruhan terbaik Anda adalah os.walkdirektori kedua, semua direktori, copy2dan file dan melakukan tambahan copystatuntuk direktori. Lagi pula itulah yang copytreedilakukan seperti yang dijelaskan dalam dokumen. Atau Anda bisa copydan copystatsetiap direktori / file dan os.listdirbukannya os.walk.

Ini terinspirasi dari jawaban terbaik asli yang disediakan oleh atzz, saya baru saja menambahkan ganti logika file / folder. Jadi itu tidak benar-benar bergabung, tetapi menghapus file / folder yang ada dan menyalin yang baru:

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)

Batalkan komentar rmtree untuk menjadikannya fungsi pemindahan.

Ini adalah versi saya dari tugas yang sama ::

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)

Berikut adalah versi yang terinspirasi oleh utas ini yang lebih mirip meniru distutils.file_util.copy_file.

updateonlyadalah bool jika True, hanya akan menyalin file dengan tanggal modifikasi yang lebih baru dari file yang ada dstkecuali terdaftar di forceupdatemana akan menyalin.

ignoredan forceupdatemengharapkan daftar nama file atau folder / nama file relatif terhadap src dan menerima wildcard gaya Unix mirip dengan globatau fnmatch.

Fungsi mengembalikan daftar file yang disalin (atau akan disalin jika dryrunjika Benar).

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

Solusi sebelumnya memiliki beberapa masalah yang srcdapat ditimpadst tanpa pemberitahuan atau pengecualian.

Saya menambahkan predict_errormetode untuk memprediksi kesalahan sebelum menyalin. copytreeterutama didasarkan pada versi Cyrille Pontvieux.

Menggunakan predict_erroruntuk memprediksi semua kesalahan pada awalnya adalah yang terbaik, kecuali jika Anda ingin melihat pengecualian dimunculkan satu demi satu saat dijalankan copytreehingga memperbaiki semua kesalahan.

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)

Ini kartu saya di masalahnya. Saya memodifikasi kode sumber untuk copytree untuk menjaga fungsi asli, tetapi sekarang tidak ada kesalahan terjadi ketika direktori sudah ada. Saya juga mengubahnya sehingga tidak menimpa file yang sudah ada tetapi menyimpan kedua salinan, satu dengan nama yang dimodifikasi, karena ini penting untuk aplikasi saya.

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)

Coba ini:

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

Ini adalah versi yang mengharapkan pathlib.Pathinput sebagai.

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

Perhatikan bahwa fungsi ini memerlukan Python 3.6, yang merupakan versi Python pertama di mana os.listdir()mendukung objek path-like sebagai input. Jika Anda perlu mendukung versi Python sebelumnya, Anda bisa menggantinya listdir(src)dengan listdir(str(src)).

saya akan menganggap cara tercepat dan termudah adalah memanggil python perintah sistem ...

contoh..

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

Tar dan gzip direktori .... unzip dan untar direktori di tempat yang diinginkan.

yah