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

1574

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

Petter
fuente

Respuestas:

2448
with open("test.txt", "a") as myfile:
    myfile.write("appended text")
Petter
fuente
10
Esto del tutorial también puede ser útil.
Dan
28
Noté que muchas personas están usando el with open(file, "a")método. Soy quizá anticuado, pero ¿cuál es la ventaja sobreopen(file, "a") ... file.close()
75
bluewoodtree: Los beneficios son similares a los de RAII en C ++. Si olvida close (), puede pasar un tiempo antes de que el archivo se cierre realmente. Es más fácil pensar en olvidarlo cuando el código tiene múltiples puntos de salida, excepciones, etc.
Petter
54
print("appended text", file=myfile)También es posible, para una API más familiar.
Thomas Ahle
206

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'
sinelaw
fuente
49

Siempre hago esto

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

Es simple, pero muy útil.

Seth Connell
fuente
12
es un poco más agradable y un poco más seguro escribir: con abierto ('nombre de archivo', 'a') como f: f.write ('cosas')
Sam Redway
35

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.

istruble
fuente
20
fileSombra una función incorporada. No lo use para variables.
Mark Tolonen
11
@MarkTolonen: fileya no está incluido en Python 3. Incluso en Python 2, se usa muy raramente . Abrir un archivo es una operación común. Está bien usar el filenombre aquí en Python 2 y 3. Sepa cuándo ser inconsistente.
jfs
34

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
Cleve Green
fuente
14

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")
K.Suthagar
fuente
9

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á ...

Alaa M.
fuente
6

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.

Primusa
fuente
4

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)
nima moradi
fuente
4

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

Alec Alameddine
fuente
2

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.

mattc-7
fuente
1
"file.close" se llama automáticamente al final del bloque "with", que es la ventaja de la palabra clave. Además, el OP preguntó acerca de cómo abrir un archivo para agregarlo. El modo "+" no es necesario a menos que desee leer también.
Erik Knowles
-6

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()
huesos de viaje
fuente