Jak dodać plik w Pythonie?

Musisz otworzyć plik w trybie dopisywania, ustawiając "a "lub " ab"jako tryb. Zobacz też open().

Po otwarciu w trybie " a " pozycja zapisu będzie zawsze znajdować się na końcu pliku (dopisek). Możesz otworzyć za pomocą " a+", aby umożliwić czytanie, szukać Wstecz i czytać (ale wszystkie zapisy nadal będą na końcu pliku!).

Przykład:

>>> 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'

Uwaga : użycie "a" nie jest tym samym, co otwarcie za pomocą " w " i dążenie do końca plik-zastanów się, co może się stać, jeśli inny program otworzy plik i rozpocznie pisanie między seek I write. W niektórych systemach operacyjnych, otwarcie pliku z " a " gwarantuje, że wszystkie następujące zapisy zostaną dołączone atomicznie do końca pliku (nawet gdy plik rośnie przez inne zapisy).

Kilka szczegółów o tym, jak działa tryb " a "(testowane tylko na Linuksie ). Nawet jeśli będziesz szukać, każdy zapis będzie dołączany do końca plik:

>>> 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'

W rzeczywistości,fopen manpage stwierdza:

Otwieranie pliku w trybie dopisywania (a jako pierwszy znak trybu) powoduje, że wszystkie kolejne operacje zapisu do tego strumienia mają miejsce w koniec pliku, jakby poprzedzał wywołanie:

fseek(stream, 0, SEEK_END);

Stara uproszczona odpowiedź (nie za pomocą with):

Przykład: ( w prawdziwym programie użyj with, aby zamknąć plik - patrz dokumentacja)

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

Zawsze to robię,

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

Python ma wiele odmian głównych trzech trybów, te trzy tryby to:

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

Aby dodać do pliku to jest tak proste jak:

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

Potem są tryby, które sprawiają, że Twój kod jest mniej linijek:

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

Wreszcie, istnieją tryby odczytu/zapisu w formacie binarnym:

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

Prawdopodobnie chcesz przekazać "a" jako argument mode. Zobacz dokumenty dla open () .

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

Istnieją inne permutacje argumentu mode dla Update ( + ), truncating (w) I binary (b) mode, ale zaczynając od tylko "a" jest najlepszym rozwiązaniem.

Kiedy używamy tej linii open(filename, "a"), to a wskazuje na dołączenie pliku, to znaczy pozwala na wstawienie dodatkowych danych do istniejącego pliku.

Możesz użyć następujących linii, aby dodać tekst do pliku

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

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

Możesz to zrobić również za pomocą print zamiast write:

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

If test.txt nie istnieje, zostanie utworzony...

Można również otworzyć plik w trybie r+, a następnie ustawić pozycję pliku na końcu pliku.

import os

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

Otwarcie pliku w trybie r+ pozwoli na zapis do innych pozycji pliku poza końcem, podczas gdy a i a+ wymusi zapis do końca.

Jeśli chcesz dołączyć do pliku

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

Zadeklarowaliśmy zmienną myfile, aby otworzyć plik o nazwie test.txt. Open pobiera 2 argumenty, plik, który chcemy otworzyć i łańcuch znaków, który reprezentuje rodzaje uprawnień lub operacji, które chcemy wykonać na pliku

Oto opcje trybu pliku

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)

Parametr 'a' oznacza tryb dodawania. Jeśli nie chcesz używać with open za każdym razem, możesz łatwo napisać funkcję, która zrobi to za Ciebie:

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

Jeśli chcesz pisać gdzie indziej niż koniec, możesz użyć 'r+'^†:

import os

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

Wreszcie, parametr 'w+' daje jeszcze większą swobodę. W szczególności umożliwia utworzenie pliku, jeśli nie istnieje, a także opróżnienie zawartości aktualnie istniejącego pliku.

^†kredyt na ta funkcja idzie do @Primusa

Najprostszym sposobem na dodanie większej ilości tekstu na końcu pliku jest użycie:

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

a+ w instrukcji open(...) instruuje, aby otworzyć plik w trybie dopisywania i umożliwia dostęp do odczytu i zapisu.

Jest również zawsze dobrą praktyką używanie file.close() do zamykania plików, które zostały otwarte po ich użyciu.

Jeśli do pliku zapisuje się wiele procesów, musisz użyć trybu dodawania lub dane zostaną zakodowane. Tryb dodawania sprawi, że system operacyjny umieści każdy zapis na końcu pliku, niezależnie od tego, gdzie pisarz myśli, że jego pozycja w pliku jest. Jest to częsty problem w przypadku usług wieloprocesowych, takich jak nginx lub apache, w których wiele instancji tego samego procesu zapisuje się do tego samego dziennika plik. Zastanów się, co się stanie, jeśli spróbujesz szukać, a następnie napisz:

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.

Używając trybu dodawania, system operacyjny umieści dowolny zapis na końcu pliku.

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

Append most robi nie oznacza "otwórz plik, przejdź do końca pliku raz po jego otwarciu". Oznacza to, "otwórz plik, każdy zapis będzie na końcu pliku".

Ostrzeżenie: aby to zadziałało, musisz zapisać cały swój rekord w jednym ujęciu, w jednym wywołaniu zapisu. Jeśli podzielisz dane między wiele zapisów, inni pisarze mogą i otrzymają swoje zapisy pomiędzy twoje i zmanipuluj swoje dane.

Oto mój skrypt, który w zasadzie liczy liczbę linii, następnie dołącza, a następnie zlicza je ponownie, więc masz dowód, że zadziałał.

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()