¿Cómo copio un archivo en Python?

¿Cómo copio un archivo en Python?

No pude encontrar nada debajo os.

preguntado el 23 de septiembre de 08 a las 17:09

19 Respuestas

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 llamado src a un archivo llamado dst.
  • La ubicación de destino debe poder escribirse; de lo contrario, un IOError se planteará una excepción.
  • If dst ya existe, será reemplazado.
  • Con esta función no se pueden copiar archivos especiales, como dispositivos de caracteres o bloques y tuberías.
  • Con copy, src y dst son nombres de ruta dados como strs.

Otra shutil método para mirar es shutil.copy2(). Es similar pero conserva más metadatos (por ejemplo, marcas de tiempo).

Si utiliza os.path operaciones, uso copy más bien que copyfile. copyfile solo aceptará cadenas.

Respondido 07 Feb 21, 12:02

¿Cuál es la diferencia entre copiar y copiar archivos? - Matt

en copia (src, dst) el dst puede ser un directorio. - Owen

Tenga en cuenta que no se copiarán todos los metadatos, dependiendo de su plataforma. - kevin cuerno

Tenga en cuenta que no es una operación atómica. Tenga cuidado al usarlo en una aplicación roscada. - byte de agua

Tenga en cuenta que no puede manejar abreviaturas como ~, pero puede tratar con rutas relativas - zwep

Función Copias
metadatos		 Copias
permisos		 Utiliza el objeto de archivo Destino
puede ser directorio
Shutil.copia No Sí No Sí
shutil.copyfile No No No No
Shutil.copy2 Sí Sí No Sí
Shutil.copyfileobj No No Sí No

Respondido 02 Feb 21, 09:02

¿Shutil proporciona copia con modo de anexión en el destino en lugar de sobrescribir? - Syed Mohamed Mehdi

¿Qué significa "Puede usar búfer"? - Lucidbrot

@lucidbrot - Si marca este - The integer length, if given, is the buffer size. In particular, a negative length value means to copy the data without looping over the source data in chunks; by default the data is read in chunks to avoid uncontrolled memory consumption. - Jezrael

Eso es bastante inexacto, lo siento. shutil utilizará la copia de datos basada en fragmentos en cualquier caso. P.ej copy2 invoca copyfile() que a su vez invoca copyfileobj() - que realizará la copia fragmentada. La unica diferencia: copyfileobj() permite especificar el tamaño del búfer explícitamente (si se desea), las otras funciones solo utilizan el tamaño del búfer predeterminado de shutil y no ofrecen ninguna posibilidad de configurarlo. Por lo tanto, una columna de "puede usar búfer" no tiene ningún sentido. Se usa un búfer todo el tiempo. Si -1 se especifica para copyfileobj sería tan grande como el archivo en sí. - Regis mayo

@jezrael: Haz lo que quieras, pero creo que eliminar es mejor. NUNCA HAY NECESIDAD de modificar el tamaño del búfer para los usuarios habituales de Python si quieren copiar archivos. Muy probablemente los autores de shutils Sentí lo mismo: Probablemente esa sea exactamente la razón por la que a) no se puede especificar un tamaño de búfer durante la copia b) ni hay ninguna forma de modificarlo en general. Así que esta información es más engañosa que útil. Por lo general, NO querrá leer los datos completos de un archivo en la memoria de todos modos si va a copiar archivos. - Regis mayo

copy2(src,dst) a menudo es más útil que copyfile(src,dst) porque:

  • Permite dst a ser un directorio (en lugar del nombre de archivo de destino completo), en cuyo caso el nombre base of src se utiliza para crear el nuevo archivo;
  • conserva la información original de modificación y acceso (mtime y atime) en los metadatos del archivo (sin embargo, esto viene con una ligera sobrecarga).

A continuación, se muestra 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

respondido 13 mar '17, 17:03

Estoy tratando de copiar aleatoriamente 100k archivos de 1 millón de archivos. copyfile es considerablemente más rápido que copy2 - Vijay

¿Estoy en lo correcto al asumir que 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? - Zak

@Vijay Creo que esta sobrecarga se debe a copiar los metadatos. - jonathan h

@Zak No hay ambigüedad si /new/dir es un directorio existente, consulte el comentario de @ MatthewAlpert. - jonathan h

@Zak Tienes razón, agregar una barra al final elimina la ambigüedad. Si /new/dir/ no existe, Python lanzará un IsADirectoryError, de lo contrario, copia el archivo a /new/dir/ bajo el nombre original. - martonbognar

Puede utilizar una de las funciones de copia del shutil paquete:

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ━━━━━━━━━━━━━━━━━━━━━━━━━━━━ La función preserva soporta acepta copias de otros permisos del directorio dest. metadatos de archivo obj ――――――――――――――――――――――――――――――――――――――――――― ―――――――――――――――――――――――――――――
Shutil.copia              ✔ ✔ ☐ ☐
Shutil.copy2             ✔ ✔ ☐ ✔
shutil.copyfile          ☐ ☐ ☐ ☐
Shutil.copyfileobj       ☐ ☐ ✔ ☐ ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Ejemplo:

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

Respondido 15 ago 18, 18:08

Solo por curiosidad, ¿cómo generaste esa tabla? - químico ligero

@lightalchemist Acabo de usar vim como bloc de notas, copié los símbolos unicode usados ​​de una tabla de wikipedia y copié el resultado en el editor de stackoverflow para el pulido final. - maxschlepzig

¿En qué se diferencia de otra respuesta 2 años antes? stackoverflow.com/a/30359308/674039 - wim

@wim, tienes que comparar mi respuesta con la Versión 2017 de la respuesta que ha vinculado que estaba actualizado cuando publiqué mi respuesta. Principales diferencias: mi respuesta usa encabezados de columna mejores / más descriptivos, el diseño de la tabla no distrae, incluye enlaces directos a la documentación y agregué una columna (es decir, 'acepta obj de archivo'). - maxschlepzig

está bien. YMMV, pero creo que los cambios cosméticos y las mejoras menores como esa se realizan mejor como ediciones en las respuestas existentes, en lugar de duplicar las respuestas. - wim

En Python, puede copiar los archivos usando

import os
import shutil
import subprocess

1) Copiar archivos usando 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) Copiar archivos usando 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) Copiar archivos usando 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)

Respondido el 20 de junio de 20 a las 10:06

Usar comandos de una sola cadena es un estilo de codificación incorrecto (flexibilidad, confiabilidad y seguridad), en su lugar use ['copy', sourcefile, destfile] sintaxis siempre que sea posible, especialmente si los parámetros son de entrada del usuario. - Marcel Waldvogel

¿Por qué enumera tantas malas alternativas a las funciones de copia de shutil? - maxschlepzig

shutil está integrado, no es necesario proporcionar alternativas no portátiles. La respuesta podría mejorarse eliminando las soluciones dependientes del sistema, y ​​después de esa eliminación, esta respuesta es solo una copia de las respuestas existentes / una copia de la documentación. - Jean-François Fabre ♦

os.popen está en desuso por un tiempo. y check_output no devuelve el estado pero la salida (que está vacía en el caso de copy/cp) - Jean-François Fabre ♦

shutil en realidad no copia archivos. Hay una gran advertencia en la parte superior de los documentos. "esto significa que el propietario y el grupo del archivo se pierden, así como las ACL. En Mac OS, la bifurcación de recursos y otros metadatos no se utilizan. Esto significa que los recursos se perderán y el tipo de archivo y los códigos de creador no serán correctos. En Windows, los propietarios de archivos, las ACL y los flujos de datos alternativos no se copian ". - gman

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 la 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)

Respondido 10 Abr '18, 16:04

Hace un tiempo noté que el módulo se llama shutil (singular) y no shutils (plural), y de hecho is en Python 2.3. No obstante dejo aquí esta función como ejemplo. - Pi.

Copiar un archivo contenido es una operación sencilla. Copiar el archivo con sus metadatos no es nada sencillo, más aún si desea ser multiplataforma. - Laca

Cierto. Mirando los documentos de shutil, la función copyfile tampoco copiará metadatos. - Pi.

Sí, no estoy seguro de por qué no copiaría la fuente de shutil.copyfileobj. Además, no tienes ninguna try, finally para 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 en absoluto. Eso debería ir en una función de envoltura, como cómo shutil.copyfile envuelve shutil.copyfileobj. - erlvolton

El código anterior debe especificar dest ser escribible: open(dest, 'wb') - user1016274

Use 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. Con esta función no se pueden copiar archivos especiales, como dispositivos de caracteres o bloques y tuberías. 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.

Respondido el 07 de Septiembre de 14 a las 14:09

shutil en realidad no copia archivos. Hay una gran advertencia en la parte superior de los documentos. "esto significa que el propietario y el grupo del archivo se pierden, así como las ACL. En Mac OS, la bifurcación de recursos y otros metadatos no se utilizan. Esto significa que los recursos se perderán y el tipo de archivo y los códigos de creador no serán correctos. En Windows, los propietarios de archivos, las ACL y los flujos de datos alternativos no se copian ". - gman

Ejemplo de copia de directorio y archivo: de las cosas de Python 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"

respondido 15 mar '11, 10:03

En primer lugar, hice una hoja de trucos exhaustiva 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:

  1. 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)
  1. 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
  1. shutil.copy() Copiar sin guardar 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
  1. shutil.copy2() Copiar conservando 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
  1. shutil.copytree()

Copie de forma recursiva un árbol de directorios completo enraizado en src, devolviendo el directorio de destino

Respondido 08 Jul 19, 06:07

shutil en realidad no copia archivos. Hay una gran advertencia en la parte superior de los documentos. "esto significa que el propietario y el grupo del archivo se pierden, así como las ACL. En Mac OS, la bifurcación de recursos y otros metadatos no se utilizan. Esto significa que los recursos se perderán y el tipo de archivo y los códigos de creador no serán correctos. En Windows, los propietarios de archivos, las ACL y los flujos de datos alternativos no se copian ". - gman

Para archivos pequeños y usando solo elementos integrados de Python, puede usar el siguiente resumen:

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 Swati la respuesta debe ser preferida.

contestado el 15 de mayo de 20 a las 01:05

Esto lee el archivo fuente completo en la memoria antes de volver a escribirlo. Por lo tanto, esto desperdicia memoria innecesariamente para todas las operaciones de copia de archivos, excepto para las más pequeñas. - maxschlepzig

¿Es eso cierto? creo .read() y .write() se almacenan en búfer de forma predeterminada (al menos para CPython). - banda sonora

@soundstripe, por supuesto que esto es cierto. El hecho de que el objeto de archivo devuelto por open() hace IO en búfer, por defecto no le ayuda aquí, porque read() se especifica como: 'Si n es negativo o se omite, leer hasta EOF'. Eso significa que el read() devuelve el contenido completo del archivo como una cadena. - maxschlepzig

@maxschlepzig Entiendo tu punto y admito que no estaba al tanto. La razón por la que proporcioné esta respuesta fue en caso de que alguien quisiera hacer una copia de archivo simple usando solo elementos integrados, sin necesidad de importar un módulo para ello. Por supuesto, la optimización de la memoria no debería ser una preocupación si desea esta opción. De todos modos, gracias por aclarar eso. Actualicé la respuesta en consecuencia. - fabda01

Podrías usar os.system('cp nameoffilegeneratedbyprogram /otherdirectory/')

o como lo hice yo, 

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

donde rawfile es el nombre que había generado dentro del programa.

Esta es una solución única para Linux

Respondido el 19 de diciembre de 14 a las 23:12

esto no es portátil e innecesario, ya que solo puede usar shutil. - corey goldberg

Incluso cuando shutil no está disponible - subprocess.run() (sin shell=True!) es la mejor alternativa a os.system(). - maxschlepzig

shutil es más portátil - Hiadore

subprocess.run() como sugiere @maxschlepzig es un gran paso adelante, cuando se llaman programas externos. Sin embargo, para mayor flexibilidad y seguridad, utilice el ['cp', rawfile, 'rawdata.dat'] forma de pasar la línea de comando. (Sin embargo, para copiar, shutil y amigos en lugar de llamar a un programa externo). Marcel Waldvogel

inténtelo con nombres de archivo con espacios. - Jean-François Fabre ♦

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 alcanzó 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[:]

contestado el 25 de mayo de 15 a las 06:05

esto parece un poco redundante ya que el escritor debería manejar el almacenamiento en búfer. for l in open('file.txt','r'): output.write(l) debe encontrar trabajo; simplemente configure el búfer de flujo de salida según sus necesidades. o puede ir por los bytes haciendo un bucle sobre un intento con output.write(read(n)); output.flush() donde n es la cantidad de bytes que le gustaría escribir a la vez. ambos tampoco tienen una condición para verificar cuál es una bonificación. - Posee

Sí, pero pensé que tal vez esto podría ser más fácil de entender porque copia líneas completas en lugar de partes de ellas (en caso de que no sepamos cuántos bytes tiene cada línea). - ytpillai

Muy cierto. La codificación para la enseñanza y la codificación para la eficiencia son muy diferentes. - Posee

mirando la fuente: las llamadas a las líneas de escritura escriben, hg.python.org/cpython/file/c6880edaf6f3/Modules/_io/bytesio.c. Además, la secuencia de archivos ya está abierta, por lo que la escritura no necesitaría volver a abrirla cada vez. - Posee

Esto es espantoso. Hace un trabajo innecesario sin una buena razón. No funciona para archivos arbitrarios. La copia no es idéntica en bytes si la entrada tiene finales de línea inusuales en sistemas como Windows. ¿Por qué cree que esto podría ser más fácil de entender que una llamada a una función de copia en shutil? Incluso al ignorar shutil, un bucle simple de lectura / escritura en bloque (usando E / S 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. - maxschlepzig 

from subprocess import call
call("cp -p <file> <file>", shell=True)

Respondido 04 Abr '16, 08:04

Esto depende de la plataforma, por lo que no lo usaría. - kevin meier

Un tal call no es seguro. Consulte el documento de subprocesos al respecto. - Buhtz dice vacunarse

esto no es portátil e innecesario, ya que solo puede usar shutil. - corey goldberg

Hmm, ¿por qué Python, entonces? - baris demiray

Quizás detecte el sistema operativo antes de comenzar (ya sea DOS o Unix, porque esos son los dos más usados) - Vía Láctea90

A partir del 3.5 Python puede hacer lo siguiente para archivos pequeños (es decir, archivos de texto, jpegs pequeños):

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

Respondido 25 Abr '19, 15:04

Y luego alguien usa el código (accidental o intencionalmente) en un archivo grande ... Usando funciones de shutil maneja todos los casos especiales por usted y le brinda tranquilidad. - Marcel Waldvogel

al menos no repite las mismas soluciones una y otra vez. - Jean-François Fabre ♦ 

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.

Respondido 29 Abr '19, 19:04

La idea es agradable y el código es hermoso, pero una función copy () adecuada puede hacer más cosas, como copiar atributos (+ x bit) o, por ejemplo, eliminar los bytes ya copiados en caso de que se encuentre una condición de disco lleno . - Raúl Salinas Monteagudo

Todos las respuestas necesitan explicación, incluso si es una oración. Ninguna explicación sienta un mal precedente y no ayuda a comprender el programa. ¿Qué pasa si un novato completo de Python llega y ve esto, quiere usarlo, pero no puede porque no lo entiende? Quieres ser útil para todos en tus respuestas. - conecta tu cargador

¿No es eso que falta el .close() en todos esos open(...)¿s? - suertedonald

No es necesario .close (), ya que NO ESTAMOS ALMACENANDO el objeto del puntero del archivo en ningún lugar (ni para el archivo src ni para el archivo de destino). - Profundosol471

El mismo enfoque de pérdida de memoria subóptimo que respuesta de yellow01. - maxschlepzig

Aquí tienes una forma sencilla de hacerlo, sin ningún módulo. Es similar a esta respuesta, pero tiene la ventaja de funcionar también si es un archivo grande que no cabe en la RAM:

with open('sourcefile', 'rb') as f, open('destfile', 'wb') as g:
    while True:
        block = f.read(16*1024*1024)  # work by blocks of 16 MB
        if not block:  # end of file
            break
        g.write(block)

Dado que estamos escribiendo un archivo nuevo, no conserva el tiempo de modificación, etc.
Entonces podemos usar os.utime para esto si es necesario.

Respondido el 06 de diciembre de 20 a las 12:12

De manera similar a la respuesta aceptada, el siguiente bloque de código puede ser útil si también desea asegurarse de crear carpetas (inexistentes) en la ruta al destino.

from os import path, makedirs
from shutil import copyfile
makedirs(path.dirname(path.abspath(destination_path)), exist_ok=True)
copyfile(source_path, destination_path)

Como indican las respuestas aceptadas, estas líneas sobrescribirán cualquier archivo que exista en la ruta de destino, por lo que a veces puede ser útil agregar también: if not path.exists(destination_path): antes de este bloque de código.

Respondido el 02 de enero de 21 a las 00:01

En caso de que hayas llegado tan abajo. La respuesta es que necesita la ruta completa y el nombre del archivo.

import os

shutil.copy(os.path.join(old_dir, file), os.path.join(new_dir, file))

Respondido el 13 de enero de 21 a las 20:01

Python proporciona funciones integradas para copiar archivos fácilmente utilizando las utilidades Shell del sistema operativo.

El siguiente comando se usa para copiar archivo

shutil.copy(src,dst)

El siguiente comando se usa para copiar archivos con información de metadatos

shutil.copystat(src,dst)

Respondido el 10 de junio de 19 a las 11:06

Deberías correr copy luego copystat para preservar los metadatos del archivo. En Python 3.3+ copystat también copia atributos extendidos. - aquí

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.