¿Cómo se agrega a un archivo en Python?

¿Cómo se agrega al archivo en lugar de sobrescribirlo? ¿Hay una función especial que se agrega al archivo?

with open("test.txt", "a") as myfile:
    myfile.write("appended text")

Debe abrir el archivo en modo de adición, configurando "a" o "ab" como modo. Ver abierto () .

Cuando abre con el modo "a", la posición de escritura siempre estará al final del archivo (un anexo). Puede abrir con "a +" para permitir la lectura, buscar hacia atrás y leer (¡pero todas las escrituras seguirán al final del archivo!).

Ejemplo:

>>> with open('test1','wb') as f:
        f.write('test')
>>> with open('test1','ab') as f:
        f.write('koko')
>>> with open('test1','rb') as f:
        f.read()
'testkoko'

Nota : Usar 'a' no es lo mismo que abrir con 'w' y buscar hasta el final del archivo: considere lo que podría pasar si otro programa abriera el archivo y comenzara a escribir entre la búsqueda y la escritura. En algunos sistemas operativos, abrir el archivo con 'a' garantiza que todas sus escrituras siguientes se agregarán atómicamente al final del archivo (incluso cuando el archivo crece por otras escrituras).

Algunos detalles más sobre cómo funciona el modo "a" ( probado solo en Linux ). Incluso si busca hacia atrás, cada escritura se agregará al final del archivo:

>>> f = open('test','a+') # Not using 'with' just to simplify the example REPL session
>>> f.write('hi')
>>> f.seek(0)
>>> f.read()
'hi'
>>> f.seek(0)
>>> f.write('bye') # Will still append despite the seek(0)!
>>> f.seek(0)
>>> f.read()
'hibye'

De hecho, la página de fopen manual dice:

Al abrir un archivo en modo anexar (a como primer carácter del modo), todas las operaciones de escritura posteriores en esta secuencia se producen al final del archivo, como si precediera a la llamada:

fseek(stream, 0, SEEK_END);

Antigua respuesta simplificada (sin usar with):

Ejemplo: ( en un programa real, use withpara cerrar el archivo ; consulte la documentación )

>>> open("test","wb").write("test")
>>> open("test","a+b").write("koko")
>>> open("test","rb").read()
'testkoko'

Siempre hago esto

f = open('filename.txt', 'a')
f.write("stuff")
f.close()

Es simple, pero muy útil.

Probablemente quiera pasar "a"como argumento de modo. Ver los documentos para open () .

with open("foo", "a") as f:
    f.write("cool beans...")

Hay otras permutaciones del argumento de modo para actualizar (+), truncar (w) y binario (b), pero comenzar con solo "a"es su mejor opción.

Python tiene muchas variaciones de los tres modos principales, estos tres modos son:

'w'   write text
'r'   read text
'a'   append text

Entonces, agregar a un archivo es tan fácil como:

f = open('filename.txt', 'a') 
f.write('whatever you want to write here (in append mode) here.')

Luego están los modos que solo hacen que su código tenga menos líneas:

'r+'  read + write text
'w+'  read + write text
'a+'  append + read text

Finalmente, están los modos de lectura / escritura en formato binario:

'rb'  read binary
'wb'  write binary
'ab'  append binary
'rb+' read + write binary
'wb+' read + write binary
'ab+' append + read binary

cuando usamos esta línea open(filename, "a"), eso aindica la adición del archivo, eso significa permitir insertar datos adicionales en el archivo existente.

Puede usar las siguientes líneas para agregar el texto en su archivo

def FileSave(filename,content):
    with open(filename, "a") as myfile:
        myfile.write(content)

FileSave("test.txt","test1 \n")
FileSave("test.txt","test2 \n")

También puedes hacerlo en printlugar de write:

with open('test.txt', 'a') as f:
    print('appended text', file=f)

Si test.txt no existe, se creará ...

También puede abrir el archivo en r+modo y luego establecer la posición del archivo al final del archivo.

import os

with open('text.txt', 'r+') as f:
    f.seek(0, os.SEEK_END)
    f.write("text to add")

Abrir el archivo en r+modo le permitirá escribir en otras posiciones de archivo además del final, mientrasa y a+la escritura vigor hasta el final.

si quieres adjuntar a un archivo

with open("test.txt", "a") as myfile:
    myfile.write("append me")

Declaramos la variable myfilepara abrir un archivo llamadotest.txt . Abrir toma 2 argumentos, el archivo que queremos abrir y una cadena que representa los tipos de permiso u operación que queremos hacer en el archivo

aquí están las opciones de modo de archivo

Descripción del modo

'r' Este es el modo predeterminado. Abre archivo para leer.
'w' Este modo Abre el archivo para escribir. 
Si el archivo no existe, crea un nuevo archivo.
Si el archivo existe, trunca el archivo.
'x' Crea un nuevo archivo. Si el archivo ya existe, la operación falla.
'a' Abre el archivo en modo agregar. 
Si el archivo no existe, crea un nuevo archivo.
't' Este es el modo predeterminado. Se abre en modo texto.
'b' Esto se abre en modo binario.
'+' Esto abrirá un archivo para leer y escribir (actualizar)

El 'a'parámetro significa modo anexar. Si no desea usarlo with opencada vez, puede escribir fácilmente una función para que lo haga por usted:

def append(txt='\nFunction Successfully Executed', file):
    with open(file, 'a') as f:
        f.write(txt)

Si desea escribir en otro lugar que no sea el final, puede usar 'r+'^† :

import os

with open(file, 'r+') as f:
    f.seek(0, os.SEEK_END)
    f.write("text to add")

Finalmente, el 'w+'parámetro otorga aún más libertad. Específicamente, le permite crear el archivo si no existe, así como vaciar el contenido de un archivo que existe actualmente.

^{† El} crédito para esta función va a @Primusa

La forma más sencilla de agregar más texto al final de un archivo sería usar:

with open('/path/to/file', 'a+') as file:
    file.write("Additions to file")
file.close()

El a+en la open(...)instrucción le indica que abra el archivo en modo agregar y permite el acceso de lectura y escritura.

También es una buena práctica usar file.close()para cerrar cualquier archivo que haya abierto una vez que haya terminado de usarlos.

Aquí está mi script, que básicamente cuenta el número de líneas, luego las agrega y luego las cuenta nuevamente para que tenga evidencia de que funcionó.

shortPath  = "../file_to_be_appended"
short = open(shortPath, 'r')

## this counts how many line are originally in the file:
long_path = "../file_to_be_appended_to" 
long = open(long_path, 'r')
for i,l in enumerate(long): 
    pass
print "%s has %i lines initially" %(long_path,i)
long.close()

long = open(long_path, 'a') ## now open long file to append
l = True ## will be a line
c = 0 ## count the number of lines you write
while l: 
    try: 
        l = short.next() ## when you run out of lines, this breaks and the except statement is run
        c += 1
        long.write(l)

    except: 
        l = None
        long.close()
        print "Done!, wrote %s lines" %c 

## finally, count how many lines are left. 
long = open(long_path, 'r')
for i,l in enumerate(long): 
    pass
print "%s has %i lines after appending new lines" %(long_path, i)
long.close()