Wie kopiere ich eine Datei in Python?

┌──────────────────┬───────────────┬──────────────────┬──────────────┬───────────┐
│     Function     │Copies metadata│Copies permissions│Can use buffer│Dest dir OK│
├──────────────────┼───────────────┼──────────────────┼──────────────┼───────────┤
│shutil.copy       │      No       │        Yes       │    No        │    Yes    │
│shutil.copyfile   │      No       │        No        │    No        │    No     │
│shutil.copy2      │      Yes      │        Yes       │    No        │    Yes    │
│shutil.copyfileobj│      No       │        No        │    Yes       │    No     │
└──────────────────┴───────────────┴──────────────────┴──────────────┴───────────┘

copy2(src,dst) ist oft nützlicher als copyfile(src,dst) weil:

• es erlaubt dst, ein Verzeichnis zu sein (anstelle des vollständigen Zieldateinamens), in welchem ​​Fall Basisname of src wird zum Erstellen der neuen Datei verwendet.
• die ursprünglichen Änderungs- und Zugriffsinformationen (mtime und atime) in den Dateimetadaten bleiben erhalten (dies ist jedoch mit einem geringfügigen Mehraufwand verbunden).

Hier ist ein kurzes Beispiel:

import shutil
shutil.copy2('/src/dir/file.ext', '/dst/dir/newname.ext') # complete target filename given
shutil.copy2('/src/file.ext', '/dst/dir') # target filename is /dst/dir/file.ext

Sie können eine der Kopierfunktionen aus dem Paket shutil verwenden:

 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 
 Funktionserhalt unterstützt akzeptiert Kopien anderer 
 Berechtigungen Verzeichnis Ziel file obj metadata 
 ―――――――――――――――――――――――――――――――――――――――――― ―――――――――――――――――――――――――――――――――――― 
  shutil.copy  = ✔ ✔ ☐ ☐ 
  shutil.copy2  ✔ ✔ ✔ ☐ 
  shutil.copyfile  ☐ ☐ ☐ ☐ 
 -  shutil.copyfileobj  ☐ ☐ ☐ ✔ 
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 

Beispiel:

import shutil
shutil.copy('/etc/hostname', '/var/tmp/testhostname')

Das Kopieren einer Datei ist relativ unkompliziert, wie in den folgenden Beispielen gezeigt, aber Sie sollten stattdessen das shutil stdlib-Modul verwenden.

def copyfileobj_example(source, dest, buffer_size=1024*1024):
    """      
    Copy a file from source to dest. source and dest
    must be file-like objects, i.e. any object with a read or
    write method, like for example StringIO.
    """
    while True:
        copy_buffer = source.read(buffer_size)
        if not copy_buffer:
            break
        dest.write(copy_buffer)

Wenn Sie nach Dateiname kopieren möchten, können Sie Folgendes tun:

def copyfile_example(source, dest):
    # Beware, this example does not handle any Edge cases!
    with open(source, 'rb') as src, open(dest, 'wb') as dst:
        copyfileobj_example(src, dst)

In Python können Sie die Dateien mit kopieren

• shutil Modul
• os Modul
• subprocess Modul

_import os
import shutil
import subprocess
_

1) Kopieren von Dateien mit dem Modul shutil

shutil.copyfile Signatur

_shutil.copyfile(src_file, dest_file, *, follow_symlinks=True)

# example    
shutil.copyfile('source.txt', 'destination.txt')
_

shutil.copy Signatur

_shutil.copy(src_file, dest_file, *, follow_symlinks=True)

# example
shutil.copy('source.txt', 'destination.txt')
_

shutil.copy2 Signatur

_shutil.copy2(src_file, dest_file, *, follow_symlinks=True)

# example
shutil.copy2('source.txt', 'destination.txt')  
_

shutil.copyfileobj Signatur

_shutil.copyfileobj(src_file_object, dest_file_object[, length])

# example
file_src = 'source.txt'  
f_src = open(file_src, 'rb')

file_dest = 'destination.txt'  
f_dest = open(file_dest, 'wb')

shutil.copyfileobj(f_src, f_dest)  
_

2) Kopieren von Dateien mit dem Modul os

os.popen Signatur

_os.popen(cmd[, mode[, bufsize]])

# example
# In Unix/Linux
os.popen('cp source.txt destination.txt') 

# In Windows
os.popen('copy source.txt destination.txt')
_

os.system Signatur

_os.system(command)


# In Linux/Unix
os.system('cp source.txt destination.txt')  

# In Windows
os.system('copy source.txt destination.txt')
_

3) Kopieren von Dateien mit dem Modul subprocess

subprocess.call Signatur

_subprocess.call(args, *, stdin=None, stdout=None, stderr=None, Shell=False)

# example (WARNING: setting `Shell=True` might be a security-risk)
# In Linux/Unix
status = subprocess.call('cp source.txt destination.txt', Shell=True) 

# In Windows
status = subprocess.call('copy source.txt destination.txt', Shell=True)
_

subprocess.check_output Signatur

_subprocess.check_output(args, *, stdin=None, stderr=None, Shell=False, universal_newlines=False)

# example (WARNING: setting `Shell=True` might be a security-risk)
# In Linux/Unix
status = subprocess.check_output('cp source.txt destination.txt', Shell=True)

# In Windows
status = subprocess.check_output('copy source.txt destination.txt', Shell=True)
_

Verwenden Sie das Shutil-Modul .

copyfile(src, dst)

Kopieren Sie den Inhalt der Datei mit dem Namen src in eine Datei mit dem Namen dst. Der Zielort muss beschreibbar sein. Andernfalls wird eine IOError-Ausnahme ausgelöst. Wenn dst bereits existiert, wird es ersetzt. Spezielle Dateien wie Zeichen- oder Blockgeräte und Pipes können mit dieser Funktion nicht kopiert werden. src und dst sind Pfadnamen, die als Zeichenfolgen angegeben werden.

Schauen Sie sich filesys für alle Datei- und Verzeichnisverwaltungsfunktionen an, die in Standardmodulen Python verfügbar sind.

Beispiel für das Kopieren von Verzeichnissen und Dateien - Aus Tim Goldens Python Stuff:

http://timgolden.me.uk/python/win32_how_do_i/copy-a-file.html

import os
import shutil
import tempfile

filename1 = tempfile.mktemp (".txt")
open (filename1, "w").close ()
filename2 = filename1 + ".copy"
print filename1, "=>", filename2

shutil.copy (filename1, filename2)

if os.path.isfile (filename2): print "Success"

dirname1 = tempfile.mktemp (".dir")
os.mkdir (dirname1)
dirname2 = dirname1 + ".copy"
print dirname1, "=>", dirname2

shutil.copytree (dirname1, dirname2)

if os.path.isdir (dirname2): print "Success"

Sie könnten os.system('cp nameoffilegeneratedbyprogram /otherdirectory/') verwenden

oder wie ich es tat,

os.system('cp '+ rawfile + ' rawdata.dat')

dabei ist rawfile der Name, den ich im Programm generiert habe.

Dies ist eine reine Linux-Lösung

Erstens habe ich ein ausführliches Spickzettel mit Methoden zum Schließen für Ihre Referenz erstellt.

shutil_methods =
{'copy':['shutil.copyfileobj',
          'shutil.copyfile',
          'shutil.copymode',
          'shutil.copystat',
          'shutil.copy',
          'shutil.copy2',
          'shutil.copytree',],
 'move':['shutil.rmtree',
         'shutil.move',],
 'exception': ['exception shutil.SameFileError',
                 'exception shutil.Error'],
 'others':['shutil.disk_usage',
             'shutil.chown',
             'shutil.which',
             'shutil.ignore_patterns',]
}

Zweitens erklären Sie Kopiermethoden in Beispielen:

1. shutil.copyfileobj(fsrc, fdst[, length]) manipulieren geöffnete Objekte

In [3]: src = '~/Documents/Head+First+SQL.pdf'
In [4]: dst = '~/desktop'
In [5]: shutil.copyfileobj(src, dst)
AttributeError: 'str' object has no attribute 'read'
#copy the file object
In [7]: with open(src, 'rb') as f1,open(os.path.join(dst,'test.pdf'), 'wb') as f2:
    ...:      shutil.copyfileobj(f1, f2)
In [8]: os.stat(os.path.join(dst,'test.pdf'))
Out[8]: os.stat_result(st_mode=33188, st_ino=8598319475, st_dev=16777220, st_nlink=1, st_uid=501, st_gid=20, st_size=13507926, st_atime=1516067347, st_mtime=1516067335, st_ctime=1516067345)

2. shutil.copyfile(src, dst, *, follow_symlinks=True) Kopieren und umbenennen

In [9]: shutil.copyfile(src, dst)
IsADirectoryError: [Errno 21] Is a directory: ~/desktop'
#so dst should be a filename instead of a directory name

3. shutil.copy() Kopieren, ohne die Metadaten beizubehalten

In [10]: shutil.copy(src, dst)
Out[10]: ~/desktop/Head+First+SQL.pdf'
#check their metadata
In [25]: os.stat(src)
Out[25]: os.stat_result(st_mode=33188, st_ino=597749, st_dev=16777220, st_nlink=1, st_uid=501, st_gid=20, st_size=13507926, st_atime=1516066425, st_mtime=1493698739, st_ctime=1514871215)
In [26]: os.stat(os.path.join(dst, 'Head+First+SQL.pdf'))
Out[26]: os.stat_result(st_mode=33188, st_ino=8598313736, st_dev=16777220, st_nlink=1, st_uid=501, st_gid=20, st_size=13507926, st_atime=1516066427, st_mtime=1516066425, st_ctime=1516066425)
# st_atime,st_mtime,st_ctime changed

4. shutil.copy2() Kopieren Sie unter Beibehaltung der Metadaten

In [30]: shutil.copy2(src, dst)
Out[30]: ~/desktop/Head+First+SQL.pdf'
In [31]: os.stat(src)
Out[31]: os.stat_result(st_mode=33188, st_ino=597749, st_dev=16777220, st_nlink=1, st_uid=501, st_gid=20, st_size=13507926, st_atime=1516067055, st_mtime=1493698739, st_ctime=1514871215)
In [32]: os.stat(os.path.join(dst, 'Head+First+SQL.pdf'))
Out[32]: os.stat_result(st_mode=33188, st_ino=8598313736, st_dev=16777220, st_nlink=1, st_uid=501, st_gid=20, st_size=13507926, st_atime=1516067063, st_mtime=1493698739, st_ctime=1516067055)
# Preseved st_mtime

5. shutil.copytree()

Kopieren Sie rekursiv einen gesamten Verzeichnisbaum, der unter src verwurzelt ist, und geben Sie das Zielverzeichnis zurück

Für kleine Dateien und nur mit python integrierten Funktionen können Sie den folgenden Einzeiler verwenden:

with open(source, 'r') as src, open(dest, 'w') as dst: dst.write(src.read())

Wie in den Kommentaren unten unter @maxschlepzig erwähnt, ist dies nicht optimal für Anwendungen, bei denen die Datei zu groß ist oder wenn der Speicher kritisch ist. Daher sollte Swatis die Antwort bevorzugt werden.

Bei großen Dateien habe ich die Datei Zeile für Zeile gelesen und jede Zeile in ein Array eingelesen. Sobald das Array eine bestimmte Größe erreicht hat, hängen Sie es an eine neue Datei an.

for line in open("file.txt", "r"):
    list.append(line)
    if len(list) == 1000000: 
        output.writelines(list)
        del list[:]

from subprocess import call
call("cp -p <file> <file>", Shell=True)

Ab Python 3.5 können Sie für kleine Dateien (z. B. Textdateien, kleine JPEGs) Folgendes tun:

from pathlib import Path

source = Path('../path/to/my/file.txt')
destination = Path('../path/where/i/want/to/store/it.txt')
destination.write_bytes(source.read_bytes())

write_bytes überschreibt alles, was sich am Zielort befand

open(destination, 'wb').write(open(source, 'rb').read())

Öffnen Sie die Quelldatei im Lesemodus und schreiben Sie im Schreibmodus in die Zieldatei.

Python bietet integrierte Funktionen zum einfachen Kopieren von Dateien mit den Dienstprogrammen der Betriebssystem-Shell.

Der folgende Befehl wird zum Kopieren der Datei verwendet

shutil.copy(src,dst)

Der folgende Befehl wird zum Kopieren von Dateien mit Metadateninformationen verwendet

shutil.copystat(src,dst)