Come copio un file in Python?

https://stackoverflow.com/questions/123198

02-07-2019
|

Domanda

Non sono riuscito a trovare nulla in os .

Soluzione

shutil ha molti metodi che puoi usare . Uno dei quali è:

from shutil import copyfile

copyfile(src, dst)

Copia il contenuto del file chiamato src in un file chiamato dst . La posizione di destinazione deve essere scrivibile; in caso contrario, verrà sollevata un'eccezione IOError . Se dst esiste già, verrà sostituito. File speciali come dispositivi a caratteri o blocchi e pipe non possono essere copiati con questa funzione. src e dst sono nomi di percorso indicati come stringhe.

Altri suggerimenti

┌──────────────────┬───────────────┬──────────────────┬──────────────┬───────────┐
│     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) è spesso più utile di copyfile (src, dst) perché:

consente a dst di essere una directory (anziché il nome file di destinazione completo), nel qual caso basename di src viene usato per creare il nuovo file;
conserva la modifica originale e le informazioni di accesso (mtime e atime) nei metadati del file (tuttavia, ciò comporta un leggero sovraccarico).

Ecco un breve esempio:

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

Puoi utilizzare una delle funzioni di copia da shutil pacchetto:

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

Esempio:

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

La copia di un file è un'operazione relativamente semplice, come mostrato negli esempi seguenti, ma dovresti invece usare modulo shutd stdlib per questo.

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)

Se vuoi copiare per nome file puoi fare qualcosa del genere:

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, puoi copiare i file usando

shutil modulo
os modulo
sottoprocesso modulo

import os
import shutil
import subprocess

1) Copia dei file utilizzando il modulo `shutil`

shutil.copyfile firma

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

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

shutil.copy firma

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

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

shutil.copy2 firma

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

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

shutil.copyfileobj firma

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) Copia dei file utilizzando il modulo `os`

os.popen firma

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 firma

os.system(command)


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

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

3) Copia dei file utilizzando il modulo `subprocess`

subprocess.call firma

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 firma

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)

Utilizza il modulo shutil .

copyfile(src, dst)

Copia il contenuto del file chiamato src in un file chiamato dst. La posizione di destinazione deve essere scrivibile; in caso contrario, verrà sollevata un'eccezione IOError. Se dst esiste già, verrà sostituito. File speciali come dispositivi a caratteri o blocchi e pipe non possono essere copiati con questa funzione. src e dst sono nomi di percorso indicati come stringhe.

Dai un'occhiata a filesys per tutte le funzioni di gestione di file e directory disponibili nei moduli Python standard.

Esempio di copia di directory e file - Da Tim Golden's Python Stuff:

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

Puoi usare os.system ('cp nameoffilegeneratedbyprogram / otherdirectory /')

o come l'ho fatto,

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

dove rawfile è il nome che avevo generato all'interno del programma.

Questa è una soluzione solo Linux

Per file di piccole dimensioni e utilizzando solo i built-in python, è possibile utilizzare il seguente one-liner:

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

Come menzionato @maxschlepzig nei commenti seguenti, questo non è un modo ottimale per le applicazioni in cui il file è troppo grande o quando la memoria è critica, quindi La risposta di Swati dovrebbe essere preferita.

In primo luogo, ho creato un completo cheatsheet di metodi shutil per il tuo riferimento.

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

In secondo luogo, spiega i metodi di copia negli esempi:

shutil.copyfileobj (fsrc, fdst [, length]) manipola oggetti aperti

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)

shutil.copyfile (src, dst, *, follow_symlinks = True) Copia e rinomina

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

shutil.copy () Copia senza salvare i metadati

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

shutil.copy2 () Copia con la conservazione dei metadati

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

`shutil.copytree ()` `

Copia ricorsivamente un intero albero di directory radicato su src, restituendo la directory di destinazione

Per file di grandi dimensioni, quello che ho fatto è stato leggere il file riga per riga e leggere ogni riga in un array. Quindi, una volta che l'array ha raggiunto una determinata dimensione, aggiungerlo a un nuovo file.

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)

A partire da Python 3.5 puoi farlo quanto segue per file di piccole dimensioni (ad esempio: file di testo, jpeg di piccole dimensioni):

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 sovrascriverà qualunque cosa si trovasse nella posizione di destinazione

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

Apri il file sorgente in modalità lettura e scrivi sul file di destinazione in modalità scrittura.

Python fornisce funzioni integrate per copiare facilmente i file utilizzando le utility Shell del sistema operativo.

Il seguente comando viene utilizzato per copiare il file

shutil.copy(src,dst)

Il seguente comando viene utilizzato per copiare file con informazioni MetaData

shutil.copystat(src,dst)

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow

Come copio un file in Python?

1) Copia dei file utilizzando il modulo shutil

2) Copia dei file utilizzando il modulo os

3) Copia dei file utilizzando il modulo subprocess

1) Copia dei file utilizzando il modulo `shutil`

2) Copia dei file utilizzando il modulo `os`

3) Copia dei file utilizzando il modulo `subprocess`