Hoe voeg je toe aan het bestand in plaats van het te overschrijven? Is er een speciale functie die aan het bestand wordt toegevoegd?
Antwoord 1, autoriteit 100%
with open("test.txt", "a") as myfile:
myfile.write("appended text")
Antwoord 2, autoriteit 8%
U moet het bestand openen in de toevoegmodus, door “a” of “ab” als modus in te stellen. Zie open().
Als je opent met “a” modus, zal de schrijfpositie altijdaan het einde van het bestand zijn (een append). U kunt openen met “a+” om lezen toe te staan, achteruit zoeken en lezen (maar alle schrijfacties staan nog steeds aan het einde van het bestand!).
Voorbeeld:
>>> 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'
Opmerking: ‘a’ gebruiken is niet hetzelfde als openen met ‘w’ en naar het einde van het bestand zoeken – bedenk wat er kan gebeuren als een ander programma het bestand opent en begint te schrijven tussen de zoeken en schrijven. Op sommige besturingssystemen garandeert het openen van het bestand met ‘a’ dat al uw volgende schrijfbewerkingen atomair aan het einde van het bestand worden toegevoegd (zelfs als het bestand groeit door andere schrijfbewerkingen).
Een paar details over hoe de “a”-modus werkt (alleen getest op Linux). Zelfs als je terug zoekt, zal elke schrijfactie aan het einde van het bestand worden toegevoegd:
>>> 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'
In feite, de fopenMANTAGE Staten:
Een bestand openen in de APPEND-modus (A als het eerste teken van modus)
veroorzaakt alle volgende schrijfbewerkingen aan deze stream op
Eind-of-bestand, zoals de oproep voorafgegaan:fseek(stream, 0, SEEK_END);
Oud vereenvoudigd antwoord (niet met with):
Voorbeeld: (in een echt programma Gebruik withom het bestand te sluiten – zie de documentatie )
>>> open("test","wb").write("test")
>>> open("test","a+b").write("koko")
>>> open("test","rb").read()
'testkoko'
Antwoord 3, Autoriteit 2%
Ik doe dit altijd,
f = open('filename.txt', 'a')
f.write("stuff")
f.close()
Het is eenvoudig, maar erg handig.
Antwoord 4, Autoriteit 2%
Python heeft veel variaties van de hoofd drie-modi, deze drie modi zijn:
'w' write text
'r' read text
'a' append text
Dus om toe te voegen aan een bestand is het net zo eenvoudig als:
f = open('filename.txt', 'a')
f.write('whatever you want to write here (in append mode) here.')
Dan zijn er de modi die uw code slechts minder regels maken:
'r+' read + write text
'w+' read + write text
'a+' append + read text
Ten slotte zijn er de modi van lezen / schrijven in binair formaat:
'rb' read binary
'wb' write binary
'ab' append binary
'rb+' read + write binary
'wb+' read + write binary
'ab+' append + read binary
Antwoord 5
U wilt waarschijnlijk "a"doorgeven als het MODE-argument. Zie de documenten voor open () .
with open("foo", "a") as f:
f.write("cool beans...")
Er zijn andere permutaties van het modusargument voor het bijwerken (+), afkappen (W) en binaire (B) -modus, maar beginnen met alleen "a"is uw beste gok.
Antwoord 6
U kunt het ook doen met printin plaats van write:
with open('test.txt', 'a') as f:
print('appended text', file=f)
Als Test.txt bestaat niet, het zal worden gemaakt …
Antwoord 7
Wanneer we deze regel gebruiken open(filename, "a"), die aaangeeft, geeft het bestand toe, dat betekent toestaan dat u extra gegevens in het bestaande bestand kunt invoegen .
U kunt deze volgende regels gewoon gebruiken om de tekst in uw bestand
toe te voegen
def FileSave(filename,content):
with open(filename, "a") as myfile:
myfile.write(content)
FileSave("test.txt","test1 \n")
FileSave("test.txt","test2 \n")
Antwoord 8
U kunt ook het bestand openen in r+-modus en vervolgens de bestandsstand naar het einde van het bestand instellen.
import os
with open('text.txt', 'r+') as f:
f.seek(0, os.SEEK_END)
f.write("text to add")
Het openen van het bestand in r+-modus kunt u naast het einde naar andere bestandsposities schrijven, terwijl aen a+Force schrijven naar de einde.
Antwoord 9
De 'a'-parameter betekent Append-modus. Als u niet wilt gebruiken with opentelkens, kunt u eenvoudig een functie schrijven om het voor u te doen:
def append(txt='\nFunction Successfully Executed', file):
with open(file, 'a') as f:
f.write(txt)
Als u ergens anders anders dan het einde wilt schrijven, kunt u 'r+'† :
gebruiken
import os
with open(file, 'r+') as f:
f.seek(0, os.SEEK_END)
f.write("text to add")
Ten slotte verleent de 'w+'parameter nog meer vrijheid. Specifiek kunt u het bestand maken als deze niet bestaat, evenals de inhoud van een bestand dat momenteel bestaat.
† Krediet voor deze functie gaat naar @primusa
Antwoord 10
Als u wilt toevoegen aan een bestand
with open("test.txt", "a") as myfile:
myfile.write("append me")
We hebben de variabele myfilegedeclareerd om een bestand met de naam test.txtte openen. Open heeft 2 argumenten nodig, het bestand dat we willen openen en een tekenreeks die het soort toestemming of bewerking vertegenwoordigt dat we op het bestand willen uitvoeren
hier zijn opties voor bestandsmodus
Modus Beschrijving 'r' Dit is de standaardmodus. Het opent een bestand om te lezen. 'w' Deze modus Opent bestand om te schrijven. Als het bestand niet bestaat, wordt een nieuw bestand gemaakt. Als het bestand bestaat, wordt het bestand afgekapt. 'x' Maakt een nieuw bestand aan. Als het bestand al bestaat, mislukt de bewerking. 'a' Open bestand in toevoegmodus. Als het bestand niet bestaat, wordt een nieuw bestand gemaakt. 't' Dit is de standaardmodus. Het wordt geopend in de tekstmodus. 'b' Dit opent in binaire modus. '+' Hiermee wordt een bestand geopend voor lezen en schrijven (bijwerken)
Antwoord 11
Als meerdere processen naar het bestand schrijven, moet u de toevoegmodus gebruiken, anders worden de gegevens vervormd. De append-modus zorgt ervoor dat het besturingssysteem elke schrijfactie aan het einde van het bestand plaatst, ongeacht waar de schrijver denkt dat zijn positie in het bestand is. Dit is een veelvoorkomend probleem voor services met meerdere processen, zoals nginx of apache, waarbij meerdere instanties van hetzelfde proces naar hetzelfde logboek schrijven
het dossier. Bedenk wat er gebeurt als je probeert te zoeken, en schrijf dan:
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.
Door de APPEND-modus te gebruiken, plaatst het besturingssysteem een schrijf aan het einde van het bestand.
f = open("logfile", "a"); f.seek(0, os.SEEK_END); f.write("data to write");
Bevoegde het meest niet gemiddeld, “Open bestand, ga eens na het openen”. Het betekent, “Open bestand, elke write die ik doe, is aan het einde van het bestand”.
WAARSCHUWING: hiervoor moet u al uw record in één opname schrijven, in één schrijfoproep. Als u de gegevens tussen meerdere schrijft splitst, kunnen andere schrijvers hun schrijft tussen de uwe krijgen en uw gegevens maten.
Antwoord 12
De eenvoudigste manier om meer tekst aan het einde van een bestand toe te voegen, zou moeten gebruiken:
with open('/path/to/file', 'a+') as file:
file.write("Additions to file")
file.close()
De a+in de open(...)Verklaring Instrueert om het bestand in de APPEND-modus te openen en de toegang toe te kennen en te schrijven.
Het is ook altijd goede praktijk om file.close()om bestanden te sluiten die u hebt geopend zodra u klaar bent met deze.
Antwoord 13
Hier is mijn script, wat in feite het aantal lijnen telt, dan voegt toe, telt ze vervolgens weer, dus je hebt bewijs dat het werkte.
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()