Writing string to a file on a new line every time

Thank you for visiting the Q&A section on Magenaut. Please note that all the answers may not help you solve the issue immediately. So please treat them as advisements. If you found the post helpful (or not), leave a comment & I’ll get back to you as soon as possible.

Method 1

Use “n”:

file.write("My Stringn")

See the Python manual for reference.

Method 2

You can do this in two ways:

f.write("text to writen")

or, depending on your Python version (2 or 3):

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

Method 3

You can use:

file.write(your_string + 'n')

Method 4

If you use it extensively (a lot of written lines), you can subclass ‘file’:

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

Now it offers an additional function wl that does what you want:

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

Maybe I am missing something like different newline characters (n, r, …) or that the last line is also terminated with a newline, but it works for me.

Method 5

you could do:

file.write(your_string + 'n')

as suggested by another answer, but why using string concatenation (slow, error-prone) when you can call file.write twice:

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

note that writes are buffered so it amounts to the same thing.

Method 6

Another solution that writes from a list using fstring

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

And as a function

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

Method 7

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

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

Method 8

Unless write to binary files, use print. Below example good for formatting csv files:

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

Usage:

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

Notes:

print documentation
'{}, {}'.format(1, 'the_second') – https://pyformat.info/, PEP-3101
‘t’ – tab character
*columns in function definition – dispatches any number of arguments to list – see question on *args & **kwargs

Method 9

Just a note, file isn’t supported in Python 3 and was removed. You can do the same with the open built-in function.

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

Method 10

I really didn’t want to type n every single time and @matthause’s answer didn’t seem to work for me, so I created my own class

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)

And here it is implemented

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

This should show in the log file as

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

Method 11

Using append (a) with open() on a print() statement looks easier for me:

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+"))

Method 12

This is the solution that I came up with trying to solve this problem for myself in order to systematically produce n’s as separators. It writes using a list of strings where each string is one line of the file, however it seems that it may work for you as well. (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 ""

Method 13

Ok, here is a safe way of doing it.

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

This writes 1 to 10 each number on a new line.

Method 14

You can decorate method write in specific place where you need this behavior:

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

Method 15

Usually you would use n but for whatever reason in Visual Studio Code 2019 Individual it won’t work. But you can use this:

# Workaround to n not working
print("lorem ipsum", file=f) **Python 3.0 onwards only!**
print >>f, "Text" **Python 2.0 and under**

Method 16

If write is a callback, you may need a custom writeln.

  def writeln(self, string):
        self.f.write(string + 'n')

Itself inside a custom opener. See answers and feedback for this question : subclassing file objects (to extend open and close operations) in python 3

(Context Manager)

I faced this when using ftplib to “retrieve lines” from a file that was “record based” (FB80):

with open('somefile.rpt', 'w') as fp:
     ftp.retrlines('RETR USER.REPORT', fp.write)

and ended up with one long record with no newlines, this is likely a problem with ftplib, but obscure.

So this became:

with OpenX('somefile.rpt') as fp:
     ftp.retrlines('RETR USER.REPORT', fp.writeln)

It does the job. This is a use case a few people will be looking for.

Complete declaration (only the last two lines are mine):

class OpenX:
    def __init__(self, filename):
        self.f = open(filename, 'w')

    def __enter__(self):
        return self.f

    def __exit__(self, exc_type, exc_value, traceback):
        self.f.close()

    def writeln(self, string):
        self.f.write(string + 'n')

Method 17

in order to suspport multiple operating systems use:
file.write(f'some strings and/or {variable}. {os.linesep}')

Method 18

You could use C-style string formatting:

file.write("%sn" % "myString")

More about String Formatting.

All methods was sourced from stackoverflow.com or stackexchange.com, is licensed under cc by-sa 2.5, cc by-sa 3.0 and cc by-sa 4.0

0 0 votes

Article Rating