¿Cómo puedo copiar un archivo en Python?
-
02-07-2019 - |
Pregunta
¿Cómo puedo copiar un archivo en Python?
No pude encontrar nada bajo os
.
Solución
shutil
tiene muchos métodos que puede utilizar.Uno de los cuales es:
from shutil import copyfile
copyfile(src, dst)
Copie el contenido del archivo de nombre src
en un archivo llamado dst
.La ubicación de destino debe tener permisos de escritura;de lo contrario, una IOError
excepción.Si dst
ya existe, será reemplazado.Archivos especiales, como el carácter o bloque de dispositivos y tuberías no pueden ser copiados con esta función. src
y dst
son nombres de ruta de acceso dado como cadenas.
Otros consejos
┌──────────────────┬───────────────┬──────────────────┬──────────────┬───────────┐
│ 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)
a menudo es más útil que copyfile(src,dst)
porque:
- permite
dst
para ser un directorio (en lugar de todo el nombre de archivo de destino), en cuyo caso el basename desrc
se utiliza para crear el nuevo archivo; - se conserva el original de la modificación y acceso a la información (mtime y atime) en el archivo de metadatos (sin embargo, este viene con una leve sobrecarga).
Aquí está un breve ejemplo:
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
Puede utilizar una de las funciones de copia de la shutil
paquete:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ Function preserves supports accepts copies other permissions directory dest. file obj metadata ―――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――― shutil.copia ✔ ✔ ☐ ☐ shutil.copy2 ✔ ✔ ☐ ✔ shutil.copyfile ☐ ☐ ☐ ☐ shutil.copyfileobj ☐ ☐ ✔ ☐ ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Ejemplo:
import shutil
shutil.copy('/etc/hostname', '/var/tmp/testhostname')
Copia de un archivo es una operación relativamente directa, como muestran los siguientes ejemplos, pero usted debería utilizar en su lugar el shutil stdlib módulo por eso.
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 usted desea copiar nombre de archivo que usted podría hacer algo como esto:
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)
En Python, puede copiar los archivos mediante
shutil
móduloos
módulosubprocess
módulo
import os
import shutil
import subprocess
1) Copia de archivos mediante shutil
módulo
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 de archivos mediante os
módulo
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 de archivos mediante subprocess
módulo
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)
El uso de la shutil módulo.
copyfile(src, dst)
Copie el contenido del archivo llamado src a un archivo llamado horario de verano.La ubicación de destino debe tener permisos de escritura;de otro modo, una excepción IOError excepción.Si el horario de verano ya existe, será reemplazado.Archivos especiales, como el carácter o bloque de dispositivos y tuberías no pueden ser copiados con esta función.src y dst son nombres de ruta de acceso dado como cadenas.
Echa un vistazo a filesys para todos los directorios y de archivos de gestión de las funciones disponibles en el estándar de los módulos de Python.
Directorio y el Archivo de ejemplo de copia - De Tim Golden Python Cosas:
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"
Usted podría utilizar os.system('cp nameoffilegeneratedbyprogram /otherdirectory/')
o como yo lo hice,
os.system('cp '+ rawfile + ' rawdata.dat')
donde rawfile
es el nombre que me había generado en el interior del programa.
Este es un Linux única solución
Para archivos pequeños y sólo usando python construido-ins, usted puede utilizar la siguiente línea:
with open(source, 'r') as src, open(dest, 'w') as dst: dst.write(src.read())
Como @maxschlepzig menciona en los comentarios de abajo, esta no es la manera óptima para aplicaciones donde el archivo es demasiado grande o cuando la memoria es fundamental, por lo tanto Swati del la respuesta debe ser preferido.
En primer lugar, me hizo una exhaustiva cheatsheet de shutil métodos para su referencia.
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',]
}
En segundo lugar, explicar los métodos de copia de ejemplos:
shutil.copyfileobj(fsrc, fdst[, length])
manipular abrió los objetos
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)
Copiar y cambiar el nombre de
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 sin preseving los metadatos
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 preseving los metadatos
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()`
De forma recursiva copiar un directorio entero árbol enraizado en src, devolviendo el directorio de destino
Para archivos de gran tamaño, lo que hice fue leer el archivo línea por línea y leer cada línea en una matriz.Luego, una vez que la matriz alcanza un cierto tamaño, anexar a un archivo nuevo.
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)
Como de Python 3.5 usted puede hacer lo siguiente para archivos pequeños (es decir:archivos de texto pequeños que los archivos 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
sobrescribirá todo lo que estaba en el destino de la ubicación
open(destination, 'wb').write(open(source, 'rb').read())
Abra el archivo de código fuente en el modo de lectura y escritura para el archivo de destino en el modo de escritura.
Python ofrece incorporado funciones para la facilidad de copia de archivos mediante el Shell del Sistema Operativo utilidades.
Siguiente comando se utiliza para Copiar Archivos
shutil.copy(src,dst)
Siguiente comando se utiliza para Copiar el Archivo con la Información de Metadatos
shutil.copystat(src,dst)