Correct way to write line to file?


How do I write a line to a file in modern Python? I heard that this is deprecated:

print >>f, "hi there"

Also, does "n" work on all platforms, or should I use "rn" on Windows?

Asked By: Yaroslav Bulatov



I do not think there is a "correct" way.

I would use:

with open('myfile', 'a') as f:
    f.write('hi theren')

In memoriam Tim Toady.

Answered By: Hyperboreus

You should use the print() function which is available since Python 2.6+

from __future__ import print_function  # Only needed for Python 2
print("hi there", file=f)

For Python 3 you don’t need the import, since the print() function is the default.

The alternative in Python 3 would be to use:

with open('myfile', 'w') as f:
    f.write('hi theren')  # python will convert n to os.linesep

Quoting from Python documentation regarding newlines:

When writing output to the stream, if newline is None, any 'n' characters written are translated to the system default line separator, os.linesep. If newline is '' or 'n', no translation takes place. If newline is any of the other legal values, any 'n' characters written are translated to the given string.

See also: Reading and Writing Files – The Python Tutorial

Answered By: sorin

In Python 3 it is a function, but in Python 2 you can add this to the top of the source file:

from __future__ import print_function

Then you do

print("hi there", file=f)
Answered By: Keith

This should be as simple as:

with open('somefile.txt', 'a') as the_file:

From The Documentation:

Do not use os.linesep as a line terminator when writing files opened in text mode (the default); use a single 'n' instead, on all platforms.

Some useful reading:

Answered By: johnsyweb

Regarding os.linesep:

Here is an exact unedited Python 2.7.1 interpreter session on Windows:

Python 2.7.1 (r271:86832, Nov 27 2010, 18:30:46) [MSC v.1500 32 bit (Intel)] on
Type "help", "copyright", "credits" or "license" for more information.
>>> import os
>>> os.linesep
>>> f = open('myfile','w')
>>> f.write('hi theren')
>>> f.write('hi there' + os.linesep) # same result as previous line ?????????
>>> f.close()
>>> open('myfile', 'rb').read()
'hi therernhi thererrn'

On Windows:

As expected, os.linesep does NOT produce the same outcome as 'n'. There is no way that it could produce the same outcome. 'hi there' + os.linesep is equivalent to 'hi therern', which is NOT equivalent to 'hi theren'.

It’s this simple: use n which will be translated automatically to os.linesep. And it’s been that simple ever since the first port of Python to Windows.

There is no point in using os.linesep on non-Windows systems, and it produces wrong results on Windows.

DO NOT USE os.linesep!

Answered By: John Machin

The python docs recommend this way:

with open('file_to_write', 'w') as f:
    f.write('file contentsn')

So this is the way I usually do it 🙂

Statement from

It is good practice to use the ‘with’ keyword when dealing with file
objects. This has the advantage that the file is properly closed after
its suite finishes, even if an exception is raised on the way. It is
also much shorter than writing equivalent try-finally blocks.

Answered By: j7nn7k

When you said Line it means some serialized characters which are ended to ‘n’ characters. Line should be last at some point so we should consider ‘n’ at the end of each line. Here is solution:

with open('YOURFILE.txt', 'a') as the_file:

in append mode after each write the cursor move to new line, if you want to use w mode you should add n characters at the end of the write() function:

Answered By: Reza Tanzifi

If you are writing a lot of data and speed is a concern you should probably go with f.write(...). I did a quick speed comparison and it was considerably faster than print(..., file=f) when performing a large number of writes.

import time    

start = start = time.time()
with open("test.txt", 'w') as f:
    for i in range(10000000):
        # print('This is a speed test', file=f)
        # f.write('This is a speed testn')
end = time.time()
print(end - start)

On average write finished in 2.45s on my machine, whereas print took about 4 times as long (9.76s). That being said, in most real-world scenarios this will not be an issue.

If you choose to go with print(..., file=f) you will probably find that you’ll want to suppress the newline from time to time, or replace it with something else. This can be done by setting the optional end parameter, e.g.;

with open("test", 'w') as f:
    print('Foo1,', file=f, end='')
    print('Foo2,', file=f, end='')
    print('Foo3', file=f)

Whichever way you choose I’d suggest using with since it makes the code much easier to read.

Update: This difference in performance is explained by the fact that write is highly buffered and returns before any writes to disk actually take place (see this answer), whereas print (probably) uses line buffering. A simple test for this would be to check performance for long writes as well, where the disadvantages (in terms of speed) for line buffering would be less pronounced.

start = start = time.time()
long_line = 'This is a speed test' * 100
with open("test.txt", 'w') as f:
    for i in range(1000000):
        # print(long_line, file=f)
        # f.write(long_line + 'n')
end = time.time()

print(end - start, "s")

The performance difference now becomes much less pronounced, with an average time of 2.20s for write and 3.10s for print. If you need to concatenate a bunch of strings to get this loooong line performance will suffer, so use-cases where print would be more efficient are a bit rare.

Answered By: Robin Keskisarkka

One can also use the io module as in:

import io
my_string = "hi there"

with"output_file.txt", mode='w', encoding='utf-8') as f:
Answered By: kmario23

Since 3.5 you can also use the pathlib for that purpose:

Path.write_text(data, encoding=None, errors=None)

Open the file pointed to in text mode, write data to it, and close the file:

import pathlib

Answered By: johnson

You can also try filewriter

pip install filewriter

from filewriter import Writer

Writer(filename='my_file', ext='txt') << ["row 1 hi there", "row 2"]

Writes into my_file.txt

Takes an iterable or an object with __str__ support.

Answered By: Emin Bugra Saral

When I need to write new lines a lot, I define a lambda that uses a print function:

out = open(file_name, 'w')
fwl = lambda *x, **y: print(*x, **y, file=out) # FileWriteLine

This approach has the benefit that it can utilize all the features that are available with the print function.

Update: As is mentioned by Georgy in the comment section, it is possible to improve this idea further with the partial function:

from functools import partial
fwl = partial(print, file=out)

IMHO, this is a more functional and less cryptic approach.

Answered By: MxNx

To write text in a file in the flask can be used:

filehandle = open("text.txt", "w")
filebuffer = ["hi","welcome","yes yes welcome"]

If you want to avoid using write() or writelines() and joining the strings with a newline yourself, you can pass all of your lines to print(), and the newline delimiter and your file handle as keyword arguments. This snippet assumes your strings do not have trailing newlines.

print(line1, line2, sep="n", file=f)

You don’t need to put a special newline character is needed at the end, because print() does that for you.

If you have an arbitrary number of lines in a list, you can use list expansion to pass them all to print().

lines = ["The Quick Brown Fox", "Lorem Ipsum"]
print(*lines, sep="n", file=f)

It is OK to use "n" as the separator on Windows, because print() will also automatically convert it to a Windows CRLF newline ("rn").

Answered By: Zenul_Abidin

since others have answered how to do it, I’ll answer how it happens line by line.

with FileOpenerCM('file.txt') as fp: # is equal to "with open('file.txt') as fp:"
      fp.write('dummy text')

this is a so-called context manager, anything that comes with a with block is a context manager. so let’s see how this happens under the hood.

class FileOpenerCM:
     def __init__(self, file, mode='w'):
         self.file = open(file, mode)
     def __enter__(self):
          return self.file
     def __exit__(self, exc_type, exc_value, exc_traceback):

the first method __init__ is (as you all know) the initialization method of an object. whenever an object is created obj.__init__ is definitely called. and that’s the place where you put your all the init kinda code.

the second method __enter__ is a bit interesting. some of you might not have seen it because it is a specific method for context managers. what it returns is the value to be assigned to the variable after the as keyword. in our case, fp.

the last method is the method to run after an error is captured or if the code exits the with block. exc_type, exc_value, exc_traceback variables are the variables that hold the values of the errors that occurred inside with block. for example,

exc_type: TypeError
exc_value: unsupported operand type(s) for +: 'int' and 'str
exc_traceback: <traceback object at 0x6af8ee10bc4d>

from the first two variables, you can get info enough info about the error. honestly, I don’t know the use of the third variable, but for me, the first two are enough. if you want to do more research on context managers surely you can do it and note that writing classes are not the only way to write context managers. with contextlib you can write context managers through functions(actually generators) as well. it’s totally up to you to have a look at it. you can surely try
generator functions with contextlib but as I see classes are much cleaner.

Answered By: Hyperx837

If you want to insert items in a list with a format per line, a way to start could be:

with open('somefile.txt', 'a') as the_file:
    for item in items:
Answered By: Alfredo EP
with open('sample.txt', 'a') as f:

Insert f.write(‘n’) at the end

Answered By: Mounesh
Categories: questions Tags: ,
Answers are sorted by their score. The answer accepted by the question owner as the best is marked with
at the top-right corner.