Comment copier un fichier en Python?

Comment copier un fichier en Python?

Je n'ai rien trouvé sous os.

shutilpropose de nombreuses méthodes. L'un d'eux est:

from shutil import copyfile
copyfile(src, dst)

• Copiez le contenu du fichier nommé src dans un fichier nommé dst .
• L'emplacement de destination doit être accessible en écriture; sinon, une exception IOError sera déclenchée .
• Si dst existe déjà, il sera remplacé.
• Les fichiers spéciaux tels que les périphériques et les canaux de caractères ou de blocs ne peuvent pas être copiés avec cette fonction.
• Avec copy , src et dst sont des noms de chemin donnés sous forme de chaînes .

Si vous utilisez des os.pathopérations, utilisez copyplutôt que copyfile. copyfilen'acceptera que des chaînes .

┌──────────────────┬────────┬───────────┬───────┬────────────────┐
│     Function     │ Copies │   Copies  │Can use│   Destination  │
│                  │metadata│permissions│buffer │may be directory│
├──────────────────┼────────┼───────────┼───────┼────────────────┤
│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 dstd'être un répertoire (au lieu du nom de fichier cible complet), auquel cas le nom de base de srcest utilisé pour créer le nouveau fichier;
• il conserve les informations de modification et d'accès d'origine (mtime et atime) dans les métadonnées du fichier (cependant, cela s'accompagne d'une légère surcharge).

Voici un petit 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

Vous pouvez utiliser l'une des fonctions de copie du shutilpackage:

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ━━━━━━━━━━━━━━━━━━━━━━━━━━━━
La fonction préserve les supports accepte les copies autres
                      répertoire des autorisations dest. fichier métadonnées obj  
―――――――――――――――――――――――――――――――――――――――――――――――――― ――――――――――――――――――――――――――――
shutil.copy               ✔ ✔ ☐ ☐
 shutil.copy2              ✔ ✔ ☐ ✔
 shutil.copyfile           ☐ ☐ ☐ ☐
 shutil.copyfileobj        ☐ ☐ ✔ ☐
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Exemple:

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

En Python, vous pouvez copier les fichiers en utilisant

• shutil module
• os module
• subprocess module

import os
import shutil
import subprocess

1) Copie de fichiers à l'aide du shutilmodule

shutil.copyfile Signature

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

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

shutil.copy 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 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) Copie de fichiers à l'aide du osmodule

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) Copie de fichiers à l'aide du subprocessmodule

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)

La copie d'un fichier est une opération relativement simple, comme le montrent les exemples ci-dessous, mais vous devez plutôt utiliser le module shutil stdlib 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 souhaitez 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)

Utilisez le module shutil .

copyfile(src, dst)

Copiez le contenu du fichier nommé src dans un fichier nommé dst. L'emplacement de destination doit être accessible en écriture; sinon, une exception IOError sera déclenchée. Si dst existe déjà, il sera remplacé. Les fichiers spéciaux tels que les périphériques et les canaux de caractères ou de blocs ne peuvent pas être copiés avec cette fonction. src et dst sont des noms de chemin donnés sous forme de chaînes.

Jetez un œil à filesys pour toutes les fonctions de gestion de fichiers et de répertoires disponibles dans les modules Python standard.

Exemple de copie de répertoire et de fichier - De Tim Golden's 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"

Tout d'abord, j'ai fait une feuille de calcul exhaustive des méthodes de 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, expliquez les méthodes de copie dans des exemples:

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() Copiez sans prédéfinir 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() Copier en conservant 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()

Copiez récursivement une arborescence de répertoires entière enracinée dans src, en retournant le répertoire de destination

Pour les petits fichiers et en utilisant uniquement des modules intégrés python, vous pouvez utiliser la ligne unique suivante:

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

Comme @maxschlepzig l'a mentionné dans les commentaires ci-dessous, ce n'est pas le moyen optimal pour les applications où le fichier est trop volumineux ou lorsque la mémoire est critique, donc la réponse de Swati devrait être préférée.

Vous pourriez utiliser os.system('cp nameoffilegeneratedbyprogram /otherdirectory/')

ou comme je l'ai fait,

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

où rawfileest le nom que j'avais généré à l'intérieur du programme.

Ceci est une solution Linux uniquement

Pour les gros fichiers, j'ai lu le fichier ligne par ligne et lu chaque ligne dans un tableau. Ensuite, une fois que le tableau a atteint une certaine taille, ajoutez-le à 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)

Depuis Python 3.5, vous pouvez effectuer les opérations suivantes pour les petits fichiers (c'est-à-dire: les fichiers texte, les petits fichiers JPEG):

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 écrasera tout ce qui était à l'emplacement de la destination

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

Ouvrez le fichier source en mode lecture et écrivez dans le fichier de destination en mode écriture.

Python fournit des fonctions intégrées pour copier facilement des fichiers à l'aide des utilitaires du système d'exploitation.

La commande suivante est utilisée pour copier le fichier

shutil.copy(src,dst)

La commande suivante est utilisée pour copier un fichier avec des informations de métadonnées

shutil.copystat(src,dst)