Elke keer een string naar een bestand op een nieuwe regel schrijven

Ik wil elke keer dat ik file.write()aanroep, een nieuwe regel aan mijn string toevoegen. Wat is de gemakkelijkste manier om dit in Python te doen?

Antwoord 1, autoriteit 100%

Gebruik “\n”:

file.write("My String\n")

Zie de Python-handleidingter referentie.

Antwoord 2, autoriteit 36%

Je kunt dit op twee manieren doen:

f.write("text to write\n")

of, afhankelijk van uw Python-versie (2 of 3):

print >>f, "text to write"         # Python 2.x
print("text to write", file=f)     # Python 3.x

Antwoord 3, autoriteit 22%

U kunt gebruiken:

file.write(your_string + '\n')

Antwoord 4, autoriteit 8%

Als je het veel gebruikt (veel geschreven regels), kun je ‘bestand’ subclasseren:

class cfile(file):
    #subclass file to have a more convienient use of writeline
    def __init__(self, name, mode = 'r'):
        self = file.__init__(self, name, mode)
    def wl(self, string):
        self.writelines(string + '\n')

Nu biedt het een extra functie die doet wat je wilt:

with cfile('filename.txt', 'w') as fid:
    fid.wl('appends newline charachter')
    fid.wl('is written on a new line')

Misschien mis ik iets als verschillende nieuwe regeltekens (\n, \r, …) of dat de laatste regel ook wordt afgesloten met een nieuwe regel, maar het werkt voor mij.

Antwoord 5, autoriteit 4%

je zou kunnen doen:

file.write(your_string + '\n')

zoals gesuggereerd door een ander antwoord, maar waarom zou je tekenreeksaaneenschakeling gebruiken (langzaam, foutgevoelig) als je file.writetwee keer kunt aanroepen:

file.write(your_string)
file.write("\n")

merk op dat schrijfacties worden gebufferd, zodat het op hetzelfde neerkomt.

Antwoord 6, autoriteit 2%

Een andere oplossing die schrijft vanuit een lijst met fstring

lines = ['hello','world']
with open('filename.txt', "w") as fhandle:
  for line in lines:
    fhandle.write(f'{line}\n')

En als functie

def write_list(fname, lines):
    with open(fname, "w") as fhandle:
      for line in lines:
        fhandle.write(f'{line}\n')
write_list('filename.txt', ['hello','world'])

Antwoord 7, autoriteit 2%

file_path = "/path/to/yourfile.txt"
with open(file_path, 'a') as file:
    file.write("This will be added to the next line\n")

of

log_file = open('log.txt', 'a')
log_file.write("This will be added to the next line\n")

Antwoord 8, autoriteit 2%

Gebruik print, tenzij u naar binaire bestanden schrijft. Onderstaand voorbeeld is goed voor het opmaken van csv-bestanden:

def write_row(file_, *columns):
    print(*columns, sep='\t', end='\n', file=file_)

Gebruik:

PHI = 45
with open('file.csv', 'a+') as f:
    write_row(f, 'header', 'phi:', PHI, 'serie no. 2')
    write_row(f)  # additional empty line
    write_row(f, data[0], data[1])

Opmerkingen:

• printdocumentatie
• '{}, {}'.format(1, 'the_second')– https: //pyformat.info/ , pep-3101
• ‘\ t’ – tab teken
• *columnsIN FUNCTION DEFINITION – Verzonden elk aantal argumenten naar lijst – zie Vraag over * AGS & AMP; ** KWARGS

Antwoord 9

slechts een opmerking, filewordt niet ondersteund in Python 3en is verwijderd. U kunt hetzelfde doen met de openingebouwde functie.

f = open('test.txt', 'w')
f.write('test\n')

Antwoord 10

Gebruik append (a)met open()op een print()verklaring ziet er gemakkelijker voor mij:

save_url  = ".\test.txt"
your_text = "This will be on line 1"
print(your_text, file=open(save_url, "a+"))
another_text = "This will be on line 2"
print(another_text, file=open(save_url, "a+"))
another_text = "This will be on line 3"
print(another_text, file=open(save_url, "a+"))

Antwoord 11

Dit is de oplossing die ik bedacht om dit probleem voor mezelf op te lossen om systematisch \n’s als scheidingstekens te produceren. Het schrijft met behulp van een lijst met tekenreeksen waarbij elke tekenreeks één regel van het bestand is, maar het lijkt erop dat het ook voor u kan werken. (Python 3.+)

#Takes a list of strings and prints it to a file.
def writeFile(file, strList):
    line = 0
    lines = []
    while line < len(strList):
        lines.append(cheekyNew(line) + strList[line])
        line += 1
    file = open(file, "w")
    file.writelines(lines)
    file.close()
#Returns "\n" if the int entered isn't zero, otherwise "".
def cheekyNew(line):
    if line != 0:
        return "\n"
    return ""

Antwoord 12

Ik wilde echt niet elke keer \ntypen en @matthause’s antwoordleek niet te werken voor mij, dus ik heb mijn eigen klas gemaakt

class File():
    def __init__(self, name, mode='w'):
        self.f = open(name, mode, buffering=1)
    def write(self, string, newline=True):
        if newline:
            self.f.write(string + '\n')
        else:
            self.f.write(string)

En hier is het geïmplementeerd

f = File('console.log')
f.write('This is on the first line')
f.write('This is on the second line', newline=False)
f.write('This is still on the second line')
f.write('This is on the third line')

Dit zou in het logbestand moeten worden weergegeven als

This is on the first line
This is on the second lineThis is still on the second line
This is on the third line

Antwoord 13

Ok, hier is een veilige manier om het te doen.

with open('example.txt', 'w') as f:
 for i in range(10):
  f.write(str(i+1))
  f.write('\n')

Dit schrijft 1 tot 10 elk nummer op een nieuwe regel.

Antwoord 14

Je kunt de methode schrijven op een specifieke plaats waar je dit gedrag nodig hebt:

#Changed behavior is localized to single place.
with open('test1.txt', 'w') as file:    
    def decorate_with_new_line(method):
        def decorated(text):
            method(f'{text}\n')
        return decorated
    file.write = decorate_with_new_line(file.write)
    file.write('This will be on line 1')
    file.write('This will be on line 2')
    file.write('This will be on line 3')
#Standard behavior is not affected. No class was modified.
with open('test2.txt', 'w') as file:
    file.write('This will be on line 1')
    file.write('This will be on line 1')
    file.write('This will be on line 1')