Respuestas:
shutil
tiene muchos métodos que puedes usar. Uno de los cuales es:
from shutil import copyfile
copyfile(src, dst)
Si usa os.path
operaciones, use en copy
lugar de copyfile
. copyfile
se acepta solamente cadenas .
~
, pero puede tratar con rutas relativas
┌──────────────────┬────────┬───────────┬───────┬────────────────┐
│ 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)
A menudo es más útil que copyfile(src,dst)
porque:
dst
ser un directorio (en lugar del nombre completo del archivo de destino), en cuyo caso el nombre base de src
se usa para crear el nuevo archivo;Aquí hay 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
copyfile
es considerablemente más rápido quecopy2
shutil.copy2('/dir/file.ext', '/new/dir/')
(con una barra inclinada después de la ruta de destino) eliminará la ambigüedad sobre si copiar a un nuevo archivo llamado "dir" o colocar el archivo en un directorio con ese nombre?
/new/dir
hay un directorio existente, vea el comentario de @ MatthewAlpert.
/new/dir/
no existe, Python arrojará un IsADirectoryError
archivo; de lo contrario, copiará el archivo /new/dir/
con el nombre original.
Puede usar una de las funciones de copia del shutil
paquete:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ━━━━━━━━━━━━━━━━━━━━━━━━━━━━ La función conserva los apoyos acepta copias otras directorio de permisos dest. archivo de metadatos de obj "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" " shutil.copy ✔ ✔ ☐ ☐ shutil.copy2 ✔ ✔ ☐ ✔ shutil.copyfile ☐ ☐ ☐ ☐ shutil.copyfileobj ☐ ☐ ✔ ☐ ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Ejemplo:
import shutil
shutil.copy('/etc/hostname', '/var/tmp/testhostname')
En Python, puede copiar los archivos usando
shutil
móduloos
módulosubprocess
móduloimport os
import shutil
import subprocess
shutil
móduloshutil.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)
os
móduloos.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')
subprocess
módulosubprocess.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)
['copy', sourcefile, destfile]
sintaxis siempre que sea posible, especialmente si los parámetros provienen de la entrada del usuario.
os.popen
está en desuso por un tiempo ahora. y check_output
no devuelve el estado sino la salida (que está vacía en el caso de copy/cp
)
Copiar un archivo es una operación relativamente sencilla como se muestra en los ejemplos a continuación, pero en su lugar debería usar el módulo shutil stdlib para 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 desea copiar por nombre de archivo, puede 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)
shutil.copyfileobj
. Además, no tiene try, finally
que manejar el cierre de los archivos después de las excepciones. Sin embargo, diría que su función no debería ser responsable de abrir y cerrar los archivos. Eso debería ir en una función de envoltura, como cómo se shutil.copyfile
envuelve shutil.copyfileobj
.
dest
que se puede escribir:open(dest, 'wb')
Utiliza el módulo shutil .
copyfile(src, dst)
Copie el contenido del archivo llamado src a un archivo llamado dst. La ubicación de destino debe poder escribirse; de lo contrario, se generará una excepción IOError. Si dst ya existe, será reemplazado. Los archivos especiales como dispositivos de caracteres o de bloque y tuberías no se pueden copiar con esta función. src y dst son nombres de ruta dados como cadenas.
Eche un vistazo a filesys para todas las funciones de manejo de archivos y directorios disponibles en los módulos estándar de Python.
Ejemplo de copia de directorio y archivo - 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"
En primer lugar, hice una exhaustiva hoja de trucos de métodos shutil 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, explique los métodos de copia en ejemplos:
shutil.copyfileobj(fsrc, fdst[, length])
manipular objetos abiertos
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 renombrar
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()
Copie sin preseleccionar 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()
Copiar preseleccionando 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()
Copie recursivamente un árbol de directorios completo enraizado en src, devolviendo el directorio de destino
Para archivos pequeños y que usan solo elementos integrados de Python, puede usar el siguiente one-liner:
with open(source, 'rb') as src, open(dest, 'wb') as dst: dst.write(src.read())
Como @maxschlepzig mencionó en los comentarios a continuación, esta no es la forma óptima para aplicaciones donde el archivo es demasiado grande o cuando la memoria es crítica, por lo tanto, se debe preferir la respuesta de Swati .
.read()
y .write()
están almacenados de forma predeterminada (al menos para CPython).
open()
IO amortiguado, por defecto no le ayuda aquí, porque read()
se especifica como: 'Si n es negativo u omitido, lea hasta EOF'. Eso significa que read()
devuelve el contenido completo del archivo como una cadena.
Podrías usar os.system('cp nameoffilegeneratedbyprogram /otherdirectory/')
o como lo hice
os.system('cp '+ rawfile + ' rawdata.dat')
¿Dónde rawfile
está el nombre que había generado dentro del programa?
Esta es una solución única para Linux
shutil
no está disponible, subprocess.run()
( shell=True
¡ sin !) Es la mejor alternativa a os.system()
.
subprocess.run()
según lo sugerido por @maxschlepzig es un gran paso adelante al llamar a programas externos. Sin embargo, para mayor flexibilidad y seguridad, use la ['cp', rawfile, 'rawdata.dat']
forma de pasar la línea de comando. (Sin embargo, para copiar, shutil
y se recomiendan amigos antes de llamar a un programa externo).
Para archivos grandes, 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 alcance un cierto tamaño, agréguela a un nuevo archivo.
for line in open("file.txt", "r"):
list.append(line)
if len(list) == 1000000:
output.writelines(list)
del list[:]
for l in open('file.txt','r'): output.write(l)
debería funcionar encontrar; simplemente configure el búfer de flujo de salida según sus necesidades. o puede ir por los bytes haciendo un bucle de prueba con output.write(read(n)); output.flush()
dónde n
está la cantidad de bytes que desea escribir a la vez. ambos tampoco tienen una condición para verificar cuál es un bono.
shutil
? Incluso cuando se ignora shutil
, un simple ciclo de lectura / escritura en bloque (usando IO sin búfer) es sencillo, sería eficiente y tendría mucho más sentido que esto, y por lo tanto seguramente es más fácil de enseñar y comprender.
from subprocess import call
call("cp -p <file> <file>", shell=True)
call
es inseguro. Consulte el documento de subprocesos al respecto.
A partir de Python 3.5 , puede hacer lo siguiente para archivos pequeños (es decir: archivos de texto, pequeños 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á lo que haya en la ubicación del destino
shutil
maneja todos los casos especiales para usted y le da tranquilidad.
open(destination, 'wb').write(open(source, 'rb').read())
Abra el archivo de origen en modo de lectura y escriba en el archivo de destino en modo de escritura.
.close()
en todos esos open(...)
s?
Python proporciona funciones integradas para copiar fácilmente archivos utilizando las utilidades Shell del sistema operativo.
El siguiente comando se utiliza para copiar el archivo
shutil.copy(src,dst)
El siguiente comando se utiliza para copiar archivos con información de metadatos
shutil.copystat(src,dst)
copy
entonces copystat
para preservar los metadatos del archivo. En Python 3.3+ copystat
también copia atributos extendidos.