Come modificare un file di testo?

Sto usando Python e vorrei inserire una stringa in un file di testo senza eliminare o copiare il file. Come lo posso fare?

Sfortunatamente non c'è modo di inserirlo nel mezzo di un file senza riscriverlo. Come hanno indicato i poster precedenti, puoi aggiungere a un file o sovrascriverne una parte usando seek ma se vuoi aggiungere materiale all'inizio o al centro, dovrai riscriverlo.

Questa è una cosa del sistema operativo, non una cosa di Python. È lo stesso in tutte le lingue.

Quello che faccio di solito è leggere dal file, apportare le modifiche e scriverlo in un nuovo file chiamato myfile.txt.tmp o qualcosa del genere. È meglio che leggere l'intero file in memoria perché il file potrebbe essere troppo grande per quello. Una volta completato il file temporaneo, lo rinomino come il file originale.

Questo è un buon modo sicuro per farlo perché se la scrittura del file si arresta in modo anomalo o si interrompe per qualsiasi motivo, hai ancora il tuo file originale intatto.

Dipende da cosa vuoi fare. Per aggiungere puoi aprirlo con "a":

 with open("foo.txt", "a") as f:
     f.write("new line\n")

Se vuoi preprendere qualcosa, devi prima leggere dal file:

with open("foo.txt", "r+") as f:
     old = f.read() # read everything in the file
     f.seek(0) # rewind
     f.write("new line\n" + old) # write the new line before

Il fileinputmodulo della libreria standard Python riscriverà un file sul posto se usi il parametro inplace = 1:

import sys
import fileinput

# replace all occurrences of 'sit' with 'SIT' and insert a line after the 5th
for i, line in enumerate(fileinput.input('lorem_ipsum.txt', inplace=1)):
    sys.stdout.write(line.replace('sit', 'SIT'))  # replace 'sit' and write
    if i == 4: sys.stdout.write('\n')  # write a blank line after the 5th line

La riscrittura di un file in atto viene spesso eseguita salvando la vecchia copia con un nome modificato. La gente di Unix aggiunge a ~per contrassegnare quella vecchia. La gente di Windows fa ogni genere di cose - aggiungi .bak o .old - o rinomina completamente il file o mette il ~ in primo piano.

import shutil
shutil.move( afile, afile+"~" )

destination= open( aFile, "w" )
source= open( aFile+"~", "r" )
for line in source:
    destination.write( line )
    if <some condition>:
        destination.write( >some additional line> + "\n" )
source.close()
destination.close()

Invece di shutil, è possibile utilizzare quanto segue.

import os
os.rename( aFile, aFile+"~" )

Il modulo mmap di Python ti permetterà di inserire in un file. Il seguente esempio mostra come può essere fatto in Unix (Windows mmap potrebbe essere diverso). Si noti che questo non gestisce tutte le condizioni di errore e si potrebbe corrompere o perdere il file originale. Inoltre, questo non gestirà le stringhe unicode.

import os
from mmap import mmap

def insert(filename, str, pos):
    if len(str) < 1:
        # nothing to insert
        return

    f = open(filename, 'r+')
    m = mmap(f.fileno(), os.path.getsize(filename))
    origSize = m.size()

    # or this could be an error
    if pos > origSize:
        pos = origSize
    elif pos < 0:
        pos = 0

    m.resize(origSize + len(str))
    m[pos+len(str):] = m[pos:origSize]
    m[pos:pos+len(str)] = str
    m.close()
    f.close()

È anche possibile farlo senza mmap con i file aperti in modalità 'r +', ma è meno conveniente e meno efficiente in quanto dovresti leggere e archiviare temporaneamente il contenuto del file dalla posizione di inserimento in EOF - che potrebbe essere enorme.

Come accennato da Adam, devi prendere in considerazione le limitazioni del tuo sistema prima di poter decidere se hai abbastanza memoria per leggere tutto in memoria, sostituirne parti e riscriverlo.

Se hai a che fare con un file di piccole dimensioni o non hai problemi di memoria, questo potrebbe aiutare:

Opzione 1) Leggi l'intero file in memoria, fai una sostituzione regex sull'intera o parte della linea e sostituiscilo con quella linea più la linea aggiuntiva. Dovrai assicurarti che la 'linea di mezzo' sia univoca nel file o se hai timestamp su ogni linea, questo dovrebbe essere abbastanza affidabile.

# open file with r+b (allow write and binary mode)
f = open("file.log", 'r+b')   
# read entire content of file into memory
f_content = f.read()
# basically match middle line and replace it with itself and the extra line
f_content = re.sub(r'(middle line)', r'\1\nnew line', f_content)
# return pointer to top of file so we can re-write the content with replaced string
f.seek(0)
# clear file content 
f.truncate()
# re-write the content with the updated content
f.write(f_content)
# close file
f.close()

Opzione 2) Capire la linea di mezzo e sostituirla con quella linea più la linea aggiuntiva.

# open file with r+b (allow write and binary mode)
f = open("file.log" , 'r+b')   
# get array of lines
f_content = f.readlines()
# get middle line
middle_line = len(f_content)/2
# overwrite middle line
f_content[middle_line] += "\nnew line"
# return pointer to top of file so we can re-write the content with replaced string
f.seek(0)
# clear file content 
f.truncate()
# re-write the content with the updated content
f.write(''.join(f_content))
# close file
f.close()

Ha scritto una piccola classe per farlo in modo pulito.

import tempfile

class FileModifierError(Exception):
    pass

class FileModifier(object):

    def __init__(self, fname):
        self.__write_dict = {}
        self.__filename = fname
        self.__tempfile = tempfile.TemporaryFile()
        with open(fname, 'rb') as fp:
            for line in fp:
                self.__tempfile.write(line)
        self.__tempfile.seek(0)

    def write(self, s, line_number = 'END'):
        if line_number != 'END' and not isinstance(line_number, (int, float)):
            raise FileModifierError("Line number %s is not a valid number" % line_number)
        try:
            self.__write_dict[line_number].append(s)
        except KeyError:
            self.__write_dict[line_number] = [s]

    def writeline(self, s, line_number = 'END'):
        self.write('%s\n' % s, line_number)

    def writelines(self, s, line_number = 'END'):
        for ln in s:
            self.writeline(s, line_number)

    def __popline(self, index, fp):
        try:
            ilines = self.__write_dict.pop(index)
            for line in ilines:
                fp.write(line)
        except KeyError:
            pass

    def close(self):
        self.__exit__(None, None, None)

    def __enter__(self):
        return self

    def __exit__(self, type, value, traceback):
        with open(self.__filename,'w') as fp:
            for index, line in enumerate(self.__tempfile.readlines()):
                self.__popline(index, fp)
                fp.write(line)
            for index in sorted(self.__write_dict):
                for line in self.__write_dict[index]:
                    fp.write(line)
        self.__tempfile.close()

Quindi puoi usarlo in questo modo:

with FileModifier(filename) as fp:
    fp.writeline("String 1", 0)
    fp.writeline("String 2", 20)
    fp.writeline("String 3")  # To write at the end of the file

Se conosci qualche unix potresti provare quanto segue:

Note: $ indica il prompt dei comandi

Supponi di avere un file my_data.txt con il contenuto in quanto tale:

$ cat my_data.txt
This is a data file
with all of my data in it.

Quindi utilizzando il osmodulo è possibile utilizzare i soliti sedcomandi

import os

# Identifiers used are:
my_data_file = "my_data.txt"
command = "sed -i 's/all/none/' my_data.txt"

# Execute the command
os.system(command)

Se non sei a conoscenza di sed, dai un'occhiata, è estremamente utile.