I have text file which I want to erase in Python. How do I do that?
12 Answers
In python:
open('file.txt', 'w').close()
Or alternatively, if you have already an opened file:
f = open('file.txt', 'r+')
f.truncate(0) # need '0' when using r+

- 179,855
- 19
- 132
- 245

- 9,122
- 1
- 25
- 34
-
`#include
` and then `std::ofstream("file.txt");` about as short as in Python. :) – wilhelmtell May 04 '10 at 21:44 -
14the reason this works (in both C++ and python) is because by default when you open a file for writing, it truncates the existing contents. So really it's sorta a side effect, and thus I would prefer the explicit call to truncate() for clarity reasons, even though it is unnecessary. – rmeador May 04 '10 at 22:05
-
11if you have opened the file using "r+", use truncate(0) if you have parsed file, which you likely has. Add this to the answer above to have it complete! – Johan Engblom Apr 20 '17 at 07:57
-
7
-
28I was reading as well as writing to file. The answer perfectly truncates the file, but beware if you want to write something to it again don't forget to add `f.seek(0)` after `f.truncate(0)`, else you will have weird \x00 appended at the start of the file. – krishna chaitanya May 10 '20 at 08:47
Opening a file in "write" mode clears it, you don't specifically have to write to it:
open("filename", "w").close()
(you should close it as the timing of when the file gets closed automatically may be implementation specific)

- 3,447
- 3
- 24
- 26

- 52,368
- 9
- 94
- 137
Not a complete answer more of an extension to ondra's answer
When using truncate()
( my preferred method ) make sure your cursor is at the required position.
When a new file is opened for reading - open('FILE_NAME','r')
it's cursor is at 0 by default.
But if you have parsed the file within your code, make sure to point at the beginning of the file again i.e truncate(0)
By default truncate()
truncates the contents of a file starting from the current cusror position.

- 867
- 8
- 16
-
this helped me alot to understand how `truncate()` is working in regard to the cursor position. – Frankstar Jan 16 '22 at 13:53
As @jamylak suggested, a good alternative that includes the benefits of context managers is:
with open('filename.txt', 'w'):
pass

- 631
- 7
- 16
When using with open("myfile.txt", "r+") as my_file:
, I get strange zeros in myfile.txt
, especially since I am reading the file first. For it to work, I had to first change the pointer of my_file
to the beginning of the file with my_file.seek(0)
. Then I could do my_file.truncate()
to clear the file.

- 3,826
- 2
- 31
- 25
-
2This should come as no surprised, it was mentioned in [this answer](https://stackoverflow.com/a/20879930/11301900) 3 years earlier. – AMC Apr 14 '20 at 23:19
If security is important to you then opening the file for writing and closing it again will not be enough. At least some of the information will still be on the storage device and could be found, for example, by using a disc recovery utility.
Suppose, for example, the file you're erasing contains production passwords and needs to be deleted immediately after the present operation is complete.
Zero-filling the file once you've finished using it helps ensure the sensitive information is destroyed.
On a recent project we used the following code, which works well for small text files. It overwrites the existing contents with lines of zeros.
import os
def destroy_password_file(password_filename):
with open(password_filename) as password_file:
text = password_file.read()
lentext = len(text)
zero_fill_line_length = 40
zero_fill = ['0' * zero_fill_line_length
for _
in range(lentext // zero_fill_line_length + 1)]
zero_fill = os.linesep.join(zero_fill)
with open(password_filename, 'w') as password_file:
password_file.write(zero_fill)
Note that zero-filling will not guarantee your security. If you're really concerned, you'd be best to zero-fill and use a specialist utility like File Shredder or CCleaner to wipe clean the 'empty' space on your drive.

- 1,518
- 12
- 26
Writing and Reading file content
def writeTempFile(text = None):
filePath = "/temp/file1.txt"
if not text: # If not provided return file content
f = open(filePath, "r")
slug = f.read()
return slug
else:
f = open(filePath, "a") # Create a blank file
f.seek(0) # sets point at the beginning of the file
f.truncate() # Clear previous content
f.write(text) # Write file
f.close() # Close file
return text
It Worked for me

- 179,855
- 19
- 132
- 245

- 301
- 4
- 5
You have to overwrite the file. In C++:
#include <fstream>
std::ofstream("test.txt", std::ios::out).close();

- 14,916
- 5
- 44
- 55
-
1There's no need for the `close()` call. The destructor will close the file. So you just need to create a temporary: `ofstream("test.txt");` – wilhelmtell May 04 '10 at 21:40
-
This question has changed since this answer. Maybe delete the question given the new direction of the question? – Seanny123 May 01 '19 at 18:39
-
You can also use this (based on a few of the above answers):
file = open('filename.txt', 'w')
file.close()
of course this is a really bad way to clear a file because it requires so many lines of code, but I just wrote this to show you that it can be done in this method too.
happy coding!

- 99
- 2
- 7
Since text files are sequential, you can't directly erase data on them. Your options are:
- The most common way is to create a new file. Read from the original file and write everything on the new file, except the part you want to erase. When all the file has been written, delete the old file and rename the new file so it has the original name.
- You can also truncate and rewrite the entire file from the point you want to change onwards. Seek to point you want to change, and read the rest of file to memory. Seek back to the same point, truncate the file, and write back the contents without the part you want to erase.
- Another simple option is to overwrite the data with another data of same length. For that, seek to the exact position and write the new data. The limitation is that it must have exact same length.
Look at the seek
/truncate
function/method to implement any of the ideas above. Both Python and C have those functions.

- 217,122
- 57
- 293
- 297
-
-
2Then just remove the file. Use `os.remove` or `os.unlink` in python, or `unlink` in C. Another option is to just reopen the file for writing or use `truncate`. – nosklo May 04 '10 at 21:30
You cannot "erase" from a file in-place unless you need to erase the end. Either be content with an overwrite of an "empty" value, or read the parts of the file you care about and write it to another file.

- 776,304
- 153
- 1,341
- 1,358
-
ok how to overwrite it without giving garbage value? i mean suppose a string length of 9 is there and i am overwriting it with string length of 6 . that would mean 3 garbage values rt? – Hick May 04 '10 at 21:24
-
Correct. Plus you would have to have some way of identifying to any reader the fact that those 3 characters are garbage. – Ignacio Vazquez-Abrams May 04 '10 at 21:28
-
the fact is my code is spanned between python and c++ . so if a file read is done in C++ and file write in python .. both the time the file has to be erased.. – Hick May 04 '10 at 21:32
Assigning the file pointer to null inside your program will just get rid of that reference to the file. The file's still there. I think the remove()
function in the c stdio.h
is what you're looking for there. Not sure about Python.

- 954
- 1
- 10
- 24
-
2BTW, both remove() and unlink() will decrease the reference count on a regular file, not actually erase it. The file will be erased once the reference count drops to zero. For example, if your process has the file open and you call unlink() or remove() on it, it won't be deleted until the file is close()d (i.e. ref count drops to zero - also assumes no other processes have the file open). This behavior is useful, for example, to ensure temporary files are not left around after abnormal process termination (e.g. open(), unlink(), perform file IO, **CRASH**, close() NOT called). – Void - Othman May 04 '10 at 21:54