Hoe kan een bestand worden gekopieerd?

Antwoord 3, autoriteit 23%

copy2(src,dst)is vaak nuttiger dan copyfile(src,dst)omdat:

• het staat toe dat dsteen directoryis (in plaats van de volledige doelbestandsnaam), in welk geval de basenamevan srcwordt gebruikt voor het maken van het nieuwe bestand;
• het behoudt de oorspronkelijke wijzigings- en toegangsinformatie (mtime en atime) in de metadata van het bestand (dit brengt echter een lichte overhead met zich mee).

Hier is een kort voorbeeld:

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

Antwoord 4, autoriteit 4%

U kunt een van de kopieerfuncties gebruiken van de shutilpakket:

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Function-conservensteunen accepteert kopieën andere
           Machtigingen Directory Dest. Bestand obj metadata
--------------------------------------------------- --------------------------------
shutil.copy ✔ ✔ ☐ ☐
Shutil.copy2 ✔ ✔ ☐ ✔
shutil.copyfile ☐ ☐ ☐ ☐
shutil.copyfileobj ☐ ☐ ✔ ☐
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Voorbeeld:

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

5, Autoriteit 3%

Een bestand kopiëren is een relatief eenvoudige bediening zoals weergegeven door de onderstaande voorbeelden, maar u moet in plaats daarvan de Shutil Stdlib-module voor dat.

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)

Als u wilt kopiëren door bestandsnaam, zou u zoiets kunnen doen:

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)

6, Autoriteit 2%

Gebruik de Shutil Module .

copyfile(src, dst)

Kopieer de inhoud van het bestand met de naam SRC naar een bestand met de naam DST. De bestemmingslocatie moet beschrijfbaar zijn; Anders wordt een uitzondering van IoError verhoogd. Als DST al bestaat, wordt deze vervangen. Speciale bestanden zoals teken- of blokapparatuur en leidingen kunnen niet met deze functie worden gekopieerd. SRC en DST zijn padnamen die als snaren worden gegeven.

Bekijk filesys voor alle functies voor bestandsinstellingen en directory handelingen in standaard Python-modules.

7

Directory en bestandskopie Voorbeeld – van Tim Golden’s Python-dingen:

http://timgolden.me.uk/python/win32_how_do_i/ kopiëren-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"

8

Ten eerste heb ik een uitputtend cheatsheet van Shutil-methoden voor uw referentie gemaakt.

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',]
}

Ten tweede, leg de kopieermethoden uit in voorbeelden:

1. shutil.copyfileobj(fsrc, fdst[, length])geopende objecten manipuleren

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)Kopiëren en hernoemen

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()Kopiëren zonder de metadata te bewaren

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()Kopiëren met behoud van de metadata

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

Kopieer recursief een hele mappenboom geroot op src, waarbij de doelmap wordt geretourneerd

Antwoord 9

Voor kleine bestanden en het gebruik van alleen ingebouwde python-ins, kunt u de volgende one-liner gebruiken:

with open(source, 'rb') as src, open(dest, 'wb') as dst: dst.write(src.read())

Zoals @MAXSCHLEPZIG vermeld in de onderstaande opmerkingen, is dit niet optimale manier voor toepassingen waarbij het bestand te groot is of wanneer het geheugen van cruciaal belang is, dus Swati’s antwoord moet de voorkeur hebben.

10

U kunt os.system('cp nameoffilegeneratedbyprogram /otherdirectory/')

of zoals ik het deed,

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

Waar rawfileis de naam die ik in het programma had gegenereerd.

Dit is een oplossing van Linux

11

vanaf python 3.5 kunt u de volgen voor kleine bestanden (dwz: tekstbestanden, kleine JPEG’s):

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_bytesoverschrijft alles wat op de locatie van de bestemming

was

12

Voor grote bestanden, wat ik deed, lees de bestandslijn per regel en lees elke regel in een array. Nadat de array een bepaalde maat heeft bereikt, voegt u deze toe aan een nieuw bestand.

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

13

Gebruik subprocess.callom het bestand

te kopiëren

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

14

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

Open het bronbestand in de leesmodus en schrijf naar het bestemmingsbestand in de schrijfmodus.

15

Hier is een eenvoudige manier om het te doen, zonder elke module. Het is vergelijkbaar met dit antwoord , maar heeft Het voordeel om ook te werken als het een groot bestand is dat niet in RAM past:

with open('sourcefile', 'rb') as f, open('destfile', 'wb') as g:
    while True:
        block = f.read(16*1024*1024)  # work by blocks of 16 MB
        if not block:  # end of file
            break
        g.write(block)

Omdat we een nieuw bestand schrijven, behoudt het de modificatietijd, enz.
We kunnen dan os.utimehiervoor indien nodig.

16

In het geval dat u deze verlaag bent gekomen. Het antwoord is dat u het volledige pad en de bestandsnaam nodig hebt

import os
shutil.copy(os.path.join(old_dir, file), os.path.join(new_dir, file))

17

Vergelijkbaar met het geaccepteerde antwoord, kan het volgende codeblok handig zijn als u er ook voor wilt zorgen dat u (niet-bestaande) mappen op het pad naar de bestemming kunt maken.

from os import path, makedirs
from shutil import copyfile
makedirs(path.dirname(path.abspath(destination_path)), exist_ok=True)
copyfile(source_path, destination_path)

Zoals de geaccepteerde antwoorden opmerken, zullen deze regels elk bestand overschrijven dat zich op het doelpad bevindt, dus soms kan het handig zijn om ook toe te voegen: if not path.exists(destination_path):hiervoor codeblok.

Antwoord 18

Python biedt ingebouwde functies voor het eenvoudig kopiëren van bestanden met behulp van de hulpprogramma’s van het besturingssysteem Shell.

Het volgende commando wordt gebruikt om het bestand te kopiëren

shutil.copy(src,dst)

Het volgende commando wordt gebruikt om een bestand met metadata-informatie te kopiëren

shutil.copystat(src,dst)