Comment puis-je copier un fichier en 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) est souvent plus utile que copyfile(src,dst) parce que:

• il permet à dst d'être un répertoire (au lieu du nom de fichier cible complet), auquel cas le basename de src est utilisé pour créer le nouveau fichier;
• il préserve la modification d'origine et les informations d'accès (mtime et atime) dans le métadonnées des fichiers (toutefois, cela s'accompagne d'une légère surimpression).

voici un bref exemple:

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

copier un fichier est une opération relativement simple comme le montrent les exemples ci-dessous, mais vous devriez plutôt utiliser le shutil stdlib module pour cela.

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)

si vous voulez copier par nom de fichier, vous pouvez faire quelque chose comme ceci:

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)

utiliser le module shutil .

copyfile(src, dst)

Copiez le contenu du fichier nommé src dans un fichier nommé dst. Le lieu de destination doit être accessible en écriture, sinon une exception IOError sera soulevée. Si la dst existe déjà, elle sera remplacée. Cette fonction ne permet pas de copier des fichiers spéciaux tels que les périphériques de type caractère ou bloc et les pipes. src et dst sont des noms de chemins donnés sous forme de chaînes.

regardez filesys pour toutes les fonctions de gestion de fichiers et de répertoires disponibles dans les modules Python standard.

vous pouvez utiliser l'une des fonctions de copie du paquet shutil :

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Function              preserves     supports          accepts     copies other
                      permissions   directory dest.   file obj    metadata  
――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――
shutil.copy              ✔             ✔                 ☐           ☐
shutil.copy2             ✔             ✔                 ☐           ✔
shutil.copyfile          ☐             ☐                 ☐           ☐
shutil.copyfileobj       ☐             ☐                 ✔           ☐
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

exemple:

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

exemple de copie de répertoire et de fichier-à partir de Python Stuff de Tim Golden:

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"

en Python, vous pouvez copier les fichiers en utilisant

• shutil module
• os module
• subprocess module

import os
import shutil
import subprocess

1) copier des fichiers en utilisant shutil module

shutil.copyfile signature

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

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

shutil.copy la signature

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

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

shutil.copy2 signature

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

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

shutil.copyfileobj la signature

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) Copier des fichiers en utilisant os module

os.popen signature

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 signature

os.system(command)


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

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

3) Copier des fichiers en utilisant subprocess module

subprocess.call signature

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 signature

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)

regardez le module shutil . Il contient la fonction copyfile ( src , heure d'été )

vous pouvez utiliser os.system('cp nameoffilegeneratedbyprogram /otherdirectory/')

ou comme je l'ai fait il,

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

où rawfile est le nom que j'ai généré dans le programme.

C'est un Linux seule solution

pour les gros fichiers, ce que j'ai fait c'est lire le fichier ligne par ligne et lire chaque ligne dans un tableau. Ensuite, une fois que le tableau a atteint une certaine taille, l'ajouter dans un nouveau fichier.

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)

je suggère d'utiliser Swati's réponse, mais en supposant que vous avez un fichier texte et ne veulent pas utiliser des bibliothèques supplémentaires dans votre code juste pour le copier, Vous pouvez utiliser le suivant-liner:

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

tout d'abord, j'ai fait un cheatsheet exhaustif des méthodes shutil pour votre référence.

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

deuxièmement, expliquer les méthodes de copie dans exmaples:

1. shutil.copyfileobj(fsrc, fdst[, length]) manipuler des objets ouverts

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) copier et renommer

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() copier sans présupposer les métadonnées

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() Copie avec preseving les métadonnées

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

copie Récursivement un répertoire entier arbre enraciné à la src, le retour de la répertoire des destinations