¿Cómo se adjunta a un archivo?

1797

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

0
2763
with open("test.txt", "a") as myfile:
    myfile.write("appended text")
5
  • 13
    Esto del tutorial también puede ser útil. Dan 29/07/11 a las 22:44
  • 88
    bluewoodtree: Los beneficios son similares a los de RAII en C ++. Si olvida close (), es posible que el archivo tarde un poco en cerrarse. Es más fácil pensar en olvidarlo cuando el código tiene múltiples puntos de salida, excepciones, etc. Petter 13/06/2013 a las 17:37
  • 11
    Hay una diferencia funcional además de recordar cerrar. withabre un administrador de contexto que cerrará el archivo incluso si hay un error entre abrir y close(). Brian 23 jul.20 a las 18:49
  • Se podría hacer fácilmente with open("test.txt") as myfile: myfile.write("appended text",'a'), pero se necesita una en abierto. Timo 25 de ene a las 17:54
  • @Timo TypeError: TextIOWrapper.write () toma exactamente un argumento (2 dado)pupsozeyde 6 de julio a las 9:48
233

Necesita abrir el archivo en modo adjuntar, configurando "a" o "ab" como modo. Ver open () .

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 estará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 suceder 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 las siguientes escrituras se agregarán atómicamente al final del archivo (incluso cuando el archivo crece con 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:

Opening a file in append mode (a as the first character of mode) causes all subsequent write operations to this stream to occur at end-of-file, as if preceded the call:

fseek(stream, 0, SEEK_END);

Antigua respuesta simplificada (sin usar with):

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

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

Yo siempre hago esto

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

Es simple, pero muy útil.

1
  • 17
    es un poco más agradable y un poco más seguro de escribir: con open ('nombre de archivo', 'a') como f: f.write ('cosas')Sam Redway 2 feb 2015 a las 22:00
45

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

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

Entonces, para 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
38

Probablemente desee pasar "a"como argumento de modo. Consulte los documentos de open () .

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

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

2
17

También puedes hacerlo con en printlugar de write:

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

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

0
14

cuando usamos esta línea open(filename, "a"), eso aindica que se agrega el archivo, eso significa permitir insertar datos adicionales al 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")
7

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, mientras ay a+forzará la escritura hasta el final.

6

El 'a'parámetro significa modo de adición. 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 por esta función es para @Primusa

0
5

si desea agregar a un archivo

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

Declaramos la variable myfilepara abrir un archivo llamado test.txt. Abrir toma 2 argumentos, el archivo que queremos abrir y una cadena que representa los tipos de permisos u operaciones que queremos hacer en el archivo.

aquí están las opciones del modo de archivo

Mode    Description

'r' This is the default mode. It Opens file for reading.
'w' This Mode Opens file for writing. 
If file does not exist, it creates a new file.
If file exists it truncates the file.
'x' Creates a new file. If file already exists, the operation fails.
'a' Open file in append mode. 
If file does not exist, it creates a new file.
't' This is the default mode. It opens in text mode.
'b' This opens in binary mode.
'+' This will open a file for reading and writing (updating)
1

Si varios procesos están escribiendo en el archivo , debe usar el modo de agregar o los datos se codificarán. El modo Append hará que el sistema operativo coloque cada escritura, al final del archivo, independientemente de dónde crea el escritor su posición en el archivo. Este es un problema común para los servicios multiproceso como nginx o apache donde varias instancias del mismo proceso escriben en el mismo archivo de registro. Considere lo que sucede si intenta buscar, luego escriba:

Example does not work well with multiple processes: 

f = open("logfile", "w"); f.seek(0, os.SEEK_END); f.write("data to write");

writer1: seek to end of file.           position 1000 (for example)
writer2: seek to end of file.           position 1000
writer2: write data at position 1000    end of file is now 1000 + length of data.
writer1: write data at position 1000    writer1's data overwrites writer2's data.

Al usar el modo de adición, el sistema operativo colocará cualquier escritura al final del archivo.

f = open("logfile", "a"); f.seek(0, os.SEEK_END); f.write("data to write");

Agregar la mayoría no significa "abrir archivo, ir al final del archivo una vez después de abrirlo". Significa, "archivo abierto, cada escritura que haga estará al final del archivo".

ADVERTENCIA: Para que esto funcione, debe escribir todo su registro de una sola vez, en una llamada de escritura. Si divide los datos entre varias escrituras, otros escritores pueden y obtendrán sus escrituras entre las suyas y alterarán sus datos.

-1

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(...)declaración indica que se abra el archivo en modo adjunto y permite el acceso de lectura y escritura.

También es una buena práctica utilizar file.close()para cerrar los archivos que haya abierto una vez que haya terminado de usarlos.

1
  • 6
    "file.close" se llama automáticamente al final del bloque "with", que es la ventaja de la palabra clave. Además, el OP preguntó sobre la apertura de un archivo para agregar. El modo "+" no es necesario a menos que también desee leer. Erik Knowles 23 mar.20 a las 19:56
-9

Aquí está mi guión, 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()