Python concatena i file di testo

Ho un elenco di 20 nomi di file, come ['file1.txt', 'file2.txt', ...]. Voglio scrivere uno script Python per concatenare questi file in un nuovo file. Potrei aprire ogni file f = open(...), leggere riga per riga chiamando f.readline()e scrivere ogni riga in quel nuovo file. Non mi sembra molto "elegante", specialmente la parte in cui devo leggere // scrivere riga per riga.

Esiste un modo più "elegante" per farlo in Python?

Questo dovrebbe farlo

Per file di grandi dimensioni:

filenames = ['file1.txt', 'file2.txt', ...]
with open('path/to/output/file', 'w') as outfile:
    for fname in filenames:
        with open(fname) as infile:
            for line in infile:
                outfile.write(line)

Per file piccoli:

filenames = ['file1.txt', 'file2.txt', ...]
with open('path/to/output/file', 'w') as outfile:
    for fname in filenames:
        with open(fname) as infile:
            outfile.write(infile.read())

... e un altro interessante a cui ho pensato :

filenames = ['file1.txt', 'file2.txt', ...]
with open('path/to/output/file', 'w') as outfile:
    for line in itertools.chain.from_iterable(itertools.imap(open, filnames)):
        outfile.write(line)

Purtroppo, quest'ultimo metodo lascia alcuni descrittori di file aperti, di cui il GC dovrebbe occuparsi comunque. Ho solo pensato che fosse interessante

Usa shutil.copyfileobj.

Legge automaticamente i file di input pezzo per pezzo, che è più efficiente e legge i file di input e funzionerà anche se alcuni dei file di input sono troppo grandi per adattarsi alla memoria:

import shutil

with open('output_file.txt','wb') as wfd:
    for f in ['seg1.txt','seg2.txt','seg3.txt']:
        with open(f,'rb') as fd:
            shutil.copyfileobj(fd, wfd)

Questo è esattamente lo scopo di fileinput :

import fileinput
with open(outfilename, 'w') as fout, fileinput.input(filenames) as fin:
    for line in fin:
        fout.write(line)

Per questo caso d'uso, in realtà non è molto più semplice della semplice iterazione manuale dei file, ma in altri casi, avere un singolo iteratore che scorre su tutti i file come se fossero un singolo file è molto utile. (Inoltre, il fatto che fileinputchiuda ogni file non appena viene eseguito significa che non è necessario witho closeciascuno di essi, ma è solo un risparmio di una riga, non è un grosso problema.)

Ci sono alcune altre funzionalità intelligenti fileinput, come la possibilità di apportare modifiche sul posto dei file semplicemente filtrando ogni riga.

Come notato nei commenti e discusso in un altro post , fileinputper Python 2.7 non funzionerà come indicato. Qui una leggera modifica per rendere conforme il codice Python 2.7

with open('outfilename', 'w') as fout:
    fin = fileinput.input(filenames)
    for line in fin:
        fout.write(line)
    fin.close()

Non conosco l'eleganza, ma questo funziona:

    import glob
    import os
    for f in glob.glob("file*.txt"):
         os.system("cat "+f+" >> OutFile.txt")

Cosa c'è che non va nei comandi UNIX? (dato che non stai lavorando su Windows):

ls | xargs cat | tee output.txt fa il lavoro (puoi chiamarlo da Python con sottoprocesso se vuoi)

outfile.write(infile.read()) # time: 2.1085190773010254s
shutil.copyfileobj(fd, wfd, 1024*1024*10) # time: 0.60599684715271s

Un semplice benchmark mostra che lo shutil ha prestazioni migliori.

Un'alternativa alla risposta @ inspectorG4dget (migliore risposta alla data 29-03-2016). Ho provato con 3 file di 436 MB.

@ inspectorG4dget soluzione: 162 secondi

La seguente soluzione: 125 secondi

from subprocess import Popen
filenames = ['file1.txt', 'file2.txt', 'file3.txt']
fbatch = open('batch.bat','w')
str ="type "
for f in filenames:
    str+= f + " "
fbatch.write(str + " > file4results.txt")
fbatch.close()
p = Popen("batch.bat", cwd=r"Drive:\Path\to\folder")
stdout, stderr = p.communicate()

L'idea è quella di creare un file batch ed eseguirlo, sfruttando la "vecchia buona tecnologia". È semi-pitone ma funziona più velocemente. Funziona per Windows.

Se nella directory sono presenti molti file, glob2potrebbe essere un'opzione migliore per generare un elenco di nomi di file anziché scriverli manualmente.

import glob2

filenames = glob2.glob('*.txt')  # list of all .txt files in the directory

with open('outfile.txt', 'w') as f:
    for file in filenames:
        with open(file) as infile:
            f.write(infile.read()+'\n')

Scopri il metodo .read () dell'oggetto File:

http://docs.python.org/2/tutorial/inputoutput.html#methods-of-file-objects

Potresti fare qualcosa del tipo:

concat = ""
for file in files:
    concat += open(file).read()

o un modo più 'elegante' di pitone:

concat = ''.join([open(f).read() for f in files])

che, secondo questo articolo: http://www.skymind.com/~ocrow/python_string/ sarebbe anche il più veloce.

Se i file non sono giganteschi:

with open('newfile.txt','wb') as newf:
    for filename in list_of_files:
        with open(filename,'rb') as hf:
            newf.write(hf.read())
            # newf.write('\n\n\n')   if you want to introduce
            # some blank lines between the contents of the copied files

Se i file sono troppo grandi per essere interamente letti e conservati nella RAM, l'algoritmo deve essere leggermente diverso per leggere ogni file per essere copiato in un ciclo da blocchi di lunghezza fissa, usando read(10000)ad esempio.

def concatFiles():
    path = 'input/'
    files = os.listdir(path)
    for idx, infile in enumerate(files):
        print ("File #" + str(idx) + "  " + infile)
    concat = ''.join([open(path + f).read() for f in files])
    with open("output_concatFile.txt", "w") as fo:
        fo.write(path + concat)

if __name__ == "__main__":
    concatFiles()

  import os
  files=os.listdir()
  print(files)
  print('#',tuple(files))
  name=input('Enter the inclusive file name: ')
  exten=input('Enter the type(extension): ')
  filename=name+'.'+exten
  output_file=open(filename,'w+')
  for i in files:
    print(i)
    j=files.index(i)
    f_j=open(i,'r')
    print(f_j.read())
    for x in f_j:
      outfile.write(x)