Wie kopiere ich mit Python ein ganzes Verzeichnis von Dateien in ein vorhandenes Verzeichnis?

Führen Sie den folgenden Code aus einem Verzeichnis aus, das ein Verzeichnis mit dem Namen bar(das eine oder mehrere Dateien enthält) und ein Verzeichnis mit dem Namen baz(das auch eine oder mehrere Dateien enthält) enthält. Stellen Sie sicher, dass kein Verzeichnis mit dem Namen vorhanden ist foo.

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

Es wird scheitern mit:

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

Ich möchte, dass dies so funktioniert, als hätte ich Folgendes eingegeben:

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

Muss ich verwenden , shutil.copy()jede Datei in kopieren bazin foo? (Nachdem ich den Inhalt von 'bar' bereits in 'foo' mit kopiert habe shutil.copytree()?) Oder gibt es einen einfacheren / besseren Weg?

Diese Einschränkung des Standards shutil.copytreeerscheint willkürlich und ärgerlich. Problemumgehung:

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)

Beachten Sie, dass dies nicht vollständig mit dem Standard übereinstimmt copytree:

• es nicht ehren symlinksund ignoreParameter für das Stammverzeichnis des srcBaumes;
• Es werden keine shutil.ErrorFehler auf der Stammebene von srcausgelöst.
• Im Falle von Fehlern beim Kopieren eines Teilbaums wird shutil.Errordieser Teilbaum ausgelöst, anstatt zu versuchen, andere Teilbäume zu kopieren und einzelne zusammen zu erhöhen shutil.Error.

Hier ist eine Lösung, die Teil der Standardbibliothek ist:

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

Siehe diese ähnliche Frage.

Kopieren Sie den Verzeichnisinhalt in ein Verzeichnis mit Python

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

Eine leichte Verbesserung gegenüber der Antwort von atzz auf die Funktion, bei der die obige Funktion immer versucht, die Dateien von der Quelle zum Ziel zu kopieren.

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)

In meiner obigen Implementierung

• Erstellen des Ausgabeverzeichnisses, falls noch nicht vorhanden
• Durchführen des Kopierverzeichnisses durch rekursives Aufrufen meiner eigenen Methode.
• Wenn wir die Datei tatsächlich kopieren, überprüfe ich, ob die Datei geändert wurde, und nur wir sollten sie kopieren.

Ich benutze die obige Funktion zusammen mit Scons Build. Es hat mir sehr geholfen, da ich beim Kompilieren möglicherweise nicht den gesamten Satz von Dateien kopieren muss, sondern nur die Dateien, die geändert werden.

Eine Fusion, die von atzz und Mital Vora inspiriert wurde:

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

• Gleiches Verhalten wie shutil.copytree , mit Symlinks und ignorierten Parametern
• Erstellen Sie eine Verzeichniszielstruktur, falls diese nicht vorhanden ist
• Wird nicht scheitern, wenn dst bereits existiert

Python 3.8 führte das dirs_exist_okArgument ein in shutil.copytree:

Kopieren Sie rekursiv einen gesamten Verzeichnisbaum, der bei src verwurzelt ist, in ein Verzeichnis mit dem Namen dst und geben Sie das Zielverzeichnis zurück. dirs_exist_ok legt fest, ob eine Ausnahme ausgelöst werden soll, falls dst oder ein fehlendes übergeordnetes Verzeichnis bereits vorhanden ist.

Daher sollte dies mit Python 3.8+ funktionieren:

import shutil

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

Dokumente geben ausdrücklich an, dass das Zielverzeichnis nicht existieren sollte :

Das von benannte Zielverzeichnis dstdarf noch nicht vorhanden sein. Es werden ebenso wie fehlende übergeordnete Verzeichnisse erstellt.

Ich denke, Ihre beste Wahl ist os.walkdas zweite und alle nachfolgenden Verzeichnisse, copy2Verzeichnisse und Dateien und zusätzliche copystatVerzeichnisse. Immerhin ist es genau das, was copytreein den Dokumenten erklärt wird. Oder Sie könnten copyund copystatjedes Verzeichnis / Datei und os.listdirstatt os.walk.

Dies ist inspiriert von der ursprünglich besten Antwort von atzz. Ich habe gerade die Logik zum Ersetzen von Dateien / Ordnern hinzugefügt. Es wird also nicht zusammengeführt, sondern die vorhandene Datei / der vorhandene Ordner gelöscht und die neue kopiert:

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)

Kommentieren Sie den rmtree aus, um ihn zu einer Verschiebungsfunktion zu machen.

Hier ist meine Version derselben Aufgabe:

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)

Hier ist eine von diesem Thread inspirierte Version, die genauer nachahmt distutils.file_util.copy_file.

updateonlyist ein Bool, wenn True, kopiert nur Dateien mit Änderungsdaten, die neuer als vorhandene Dateien sind, dstsofern nicht aufgeführt, in forceupdatedenen unabhängig kopiert wird.

ignoreund forceupdateerwarten Sie Listen mit Dateinamen oder Ordner- / Dateinamen in Bezug auf src und akzeptieren Platzhalter im Unix-Stil ähnlich globoder fnmatch.

Die Funktion gibt eine Liste der kopierten Dateien zurück (oder würde kopiert, dryrunwenn True).

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

Die vorherige Lösung weist ein Problem auf, das srcmöglicherweise dstohne Benachrichtigung oder Ausnahme überschrieben wird .

Ich füge eine predict_errorMethode hinzu, um Fehler vor dem Kopieren vorherzusagen. copytreehauptsächlich basierend auf Cyrille Pontvieux 'Version.

Es predict_errorist am besten, zunächst alle Fehler vorherzusagen, es sei denn, Sie möchten, dass bei der Ausführung eine Ausnahme von einer anderen ausgelöst wird, copytreebis alle Fehler behoben sind.

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)

Hier ist mein Pass zum Problem. Ich habe den Quellcode für Copytree geändert, um die ursprüngliche Funktionalität beizubehalten, aber jetzt tritt kein Fehler auf, wenn das Verzeichnis bereits vorhanden ist. Ich habe es auch geändert, damit vorhandene Dateien nicht überschrieben werden, sondern beide Kopien beibehalten werden, eine mit einem geänderten Namen, da dies für meine Anwendung wichtig war.

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)

Versuche dies:

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

Hier ist eine Version, die eine pathlib.PathEingabe als erwartet .

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

Beachten Sie, dass für diese Funktion Python 3.6 erforderlich ist. Dies ist die erste Version von Python, in os.listdir()der pfadähnliche Objekte als Eingabe unterstützt werden. Wenn Sie frühere Versionen von Python unterstützen müssen, können Sie ersetzen listdir(src)durch listdir(str(src)).

Ich würde annehmen, der schnellste und einfachste Weg wäre, Python die Systembefehle aufrufen zu lassen ...

Beispiel..

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

Tar und gzip das Verzeichnis .... entpacken und entpacken Sie das Verzeichnis an der gewünschten Stelle.

Yah?