Como faço para copiar um arquivo em Python?

https://stackoverflow.com/questions/123198

02-07-2019
|

Pergunta

Eu não poderia encontrar qualquer coisa sob os .

Solução

shutil tem muitos métodos que você pode usar. Uma delas é:

from shutil import copyfile

copyfile(src, dst)

Copiar o conteúdo do src arquivo chamado a um dst arquivo chamado. O local de destino deve ser gravável; de outro modo, uma excepção IOError será levantado. Se dst já existir, ele será substituído. arquivos especiais, como aparelhos e tubulações de caracteres ou blocos não podem ser copiados com esta função. src e dst são nomes caminho dado como strings.

Outras dicas

┌──────────────────┬───────────────┬──────────────────┬──────────────┬───────────┐
│     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) é muitas vezes mais útil do que copyfile(src,dst) porque:

permite dst ser um diretório (em vez do nome do arquivo alvo completa), caso em que o basename de src é usado para criar o novo arquivo;
preserva a modificação original e informações de acesso (mtime e atime) nos metadados do arquivo (no entanto, este vem com uma ligeira sobrecarga).

Aqui está um pequeno exemplo:

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

Você pode usar uma das funções de cópia do href="https://docs.python.org/3/library/shutil.html" rel="noreferrer"> shutil pacote :

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

Exemplo:

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

Copiar um arquivo é uma operação relativamente simples, como mostrado pelos exemplos abaixo, mas em vez disso você deve usar o shutil stdlib módulo para isso.

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 você deseja copiar por nome de arquivo que você poderia fazer algo como isto:

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)

Em Python, você pode copiar os arquivos usando

shutil módulo
os módulo
subprocess módulo

import os
import shutil
import subprocess

1) Cópia de arquivos usando `shutil` módulo

shutil.copyfile assinatura

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

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

shutil.copy assinatura

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

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

shutil.copy2 assinatura

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

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

shutil.copyfileobj assinatura

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 arquivos usando `os` módulo

os.popen assinatura

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 assinatura

os.system(command)


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

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

3) Copiar arquivos usando `subprocess` módulo

subprocess.call assinatura

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 assinatura

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)

Use a shutil módulo .

copyfile(src, dst)

Copiar o conteúdo do src arquivo chamado a um dst arquivo chamado. O local de destino deve ser gravável; de outro modo, uma exceção IOError será levantado. Se dst já existir, ele será substituído. arquivos especiais, como aparelhos e tubulações de caracteres ou blocos não podem ser copiados com esta função. src e dst nomes de caminho são dados como strings.

Dê uma olhada filesys para todos os arquivos e diretórios manipulação funções disponíveis em módulos Python padrão.

Directory e exemplo de cópia de arquivo - De Python material de Tim Golden:

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

Você pode usar os.system('cp nameoffilegeneratedbyprogram /otherdirectory/')

ou como eu fiz isso,

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

onde rawfile é o nome que eu tinha gerado dentro do programa.

Esta é uma única solução Linux

Para pequenos arquivos e usando apenas python built-ins, você pode usar a seguinte linha:

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

Como @maxschlepzig mencionado nos comentários abaixo, este não é o caminho ideal para aplicações onde o arquivo é muito grande ou quando a memória é fundamental, portanto, resposta de Swati deve ser preferida.

Em primeiro lugar, eu fiz uma cheatsheet exaustiva de métodos shutil para sua referência.

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

Em segundo lugar, explicar os métodos de cópia em exmaples:

shutil.copyfileobj(fsrc, fdst[, length]) manipular objetos abriu

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 e renomear

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() Copiar sem preseving os metadados

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() Copy com preseving os metadados

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 ()` `

Recursively copiar uma árvore de diretórios inteira com raiz em src, retornando o diretório de destino

Para arquivos grandes, o que fiz foi ler o arquivo linha por linha e ler cada linha em uma matriz. Então, uma vez que o conjunto atingiu um determinado tamanho, anexá-lo para um novo arquivo.

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 partir de Python 3.5 você pode fazer o seguinte para arquivos pequenos (ou seja: arquivos de texto, pequenas jpegs):

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 irá substituir o que estava no local do destino

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

Abra o arquivo de origem em modo de leitura e gravação ao arquivo de destino no modo de escrita.

Python fornece funções embutido para copiar facilmente arquivos usando os utilitários de shell do sistema operacional.

Na sequência de comando é usado para copiar o arquivo

shutil.copy(src,dst)

Na sequência de comando é usado para cópia de ficheiros com informações de metadados

shutil.copystat(src,dst)

Licenciado em: CC-BY-SA com atribuição

Não afiliado a StackOverflow

Como faço para copiar um arquivo em Python?

1) Cópia de arquivos usando shutil módulo

2) Copiar arquivos usando os módulo

3) Copiar arquivos usando subprocess módulo

1) Cópia de arquivos usando `shutil` módulo

2) Copiar arquivos usando `os` módulo

3) Copiar arquivos usando `subprocess` módulo