Is there any way to clear an output after it's printed, for an example if we write a code for a countdown the printed value is immediately cleared and another value is printed in the same place which the previous output was printed.
import time
a = [5,4,3,2,1,0]
for i in a:
time.sleep(0.2)
print(i,end="",)
Here the output is printed on the same line but is there a way to clear an output to print the next value in the same position which the previous output was like in a loading screen or a countdown (like 'cls' in the command prompt but as a process while the program is still running).
I would really appreciate the help.
Flush the output and print a carriage return character to place the cursor at the beginning of the line:
import time
a = [5,4,3,2,1,0]
print() # start on a new line
for i in a:
time.sleep(0.2)
print(i, end="\r", flush=True)
print()
Note that this will not clear the line, so you might want to do this too:
for i in [500] + a:
time.sleep(0.2)
print('\033[K', i, sep='', end="\r", flush=True)
Where \033[K is the ANSI escape sequence to clear the line.
Something like this. Use \r for end argument of print() call.
import time
for x in range(5, -1, -1):
print(f'\033[KCounting down {x}', end='\r')
time.sleep(1)
print()
The last print() is to move your cursor to next line otherwise the shell will overwrite the last line and \033[K is the ANSI escape sequence to clear the line.
If I had the following code:
for x in range(10):
print(x)
I would get the output of
1
2
etc..
What I would like to do is instead of printing a newline, I want to replace the previous value and overwrite it with the new value on the same line.
Simple Version
One way is to use the carriage return ('\r') character to return to the start of the line without advancing to the next line.
Python 3
for x in range(10):
print(x, end='\r')
print()
Python 2.7 forward compatible
from __future__ import print_function
for x in range(10):
print(x, end='\r')
print()
Python 2.7
for x in range(10):
print '{}\r'.format(x),
print
Python 2.0-2.6
for x in range(10):
print '{0}\r'.format(x),
print
In the latter two (Python 2-only) cases, the comma at the end of the print statement tells it not to go to the next line. The last print statement advances to the next line so your prompt won't overwrite your final output.
Line Cleaning
If you can’t guarantee that the new line of text is not shorter than the existing line, then you just need to add a “clear to end of line” escape sequence, '\x1b[1K' ('\x1b' = ESC):
for x in range(75):
print('*' * (75 - x), x, end='\x1b[1K\r')
print()
Since I ended up here via Google but am using Python 3, here's how this would work in Python 3:
for x in range(10):
print("Progress {:2.1%}".format(x / 10), end="\r")
Related answer here: How can I suppress the newline after a print statement?
#Mike DeSimone answer will probably work most of the time. But...
for x in ['abc', 1]:
print '{}\r'.format(x),
-> 1bc
This is because the '\r' only goes back to the beginning of the line but doesn't clear the output.
If POSIX support is enough for you, the following would clear the current line and leave the cursor at its beginning:
print '\x1b[2K\r',
It uses ANSI escape code to clear the terminal line. More info can be found in wikipedia and in this great talk.
Other approach
This other, (arguably worse) solution I have found looks like this:
last_x = ''
for x in ['abc', 1]:
print ' ' * len(str(last_x)) + '\r',
print '{}\r'.format(x),
last_x = x
-> 1
One advantage is that it will work on windows too.
I had the same question before visiting this thread. For me the sys.stdout.write worked only if I properly flush the buffer i.e.
for x in range(10):
sys.stdout.write('\r'+str(x))
sys.stdout.flush()
Without flushing, the result is printed only at the end out the script
Suppress the newline and print \r.
print 1,
print '\r2'
or write to stdout:
sys.stdout.write('1')
sys.stdout.write('\r2')
for x in range(10):
time.sleep(0.5) # shows how its working
print("\r {}".format(x), end="")
time.sleep(0.5) is to show how previous output is erased and new output is printed
"\r" when its at the start of print message , it gonna erase previous output before new output.
Try this:
import time
while True:
print("Hi ", end="\r")
time.sleep(1)
print("Bob", end="\r")
time.sleep(1)
It worked for me. The end="\r" part is making it overwrite the previous line.
WARNING!
If you print out hi, then print out hello using \r, you’ll get hillo because the output wrote over the previous two letters. If you print out hi with spaces (which don’t show up here), then it will output hi. To fix this, print out spaces using \r.
This works on Windows and python 3.6
import time
for x in range(10):
time.sleep(0.5)
print(str(x)+'\r',end='')
Here's a cleaner, more "plug-and-play", version of #Nagasaki45's answer. Unlike many other answers here, it works properly with strings of different lengths. It achieves this by clearing the line with just as many spaces as the length of the last line printed print. Will also work on Windows.
def print_statusline(msg: str):
last_msg_length = len(getattr(print_statusline, 'last_msg', ''))
print(' ' * last_msg_length, end='\r')
print(msg, end='\r')
sys.stdout.flush() # Some say they needed this, I didn't.
setattr(print_statusline, 'last_msg', msg)
Usage
Simply use it like this:
for msg in ["Initializing...", "Initialization successful!"]:
print_statusline(msg)
time.sleep(1)
This small test shows that lines get cleared properly, even for different lengths:
for i in range(9, 0, -1):
print_statusline("{}".format(i) * i)
time.sleep(0.5)
I couldn't get any of the solutions on this page to work for IPython, but a slight variation on #Mike-Desimone's solution did the job: instead of terminating the line with the carriage return, start the line with the carriage return:
for x in range(10):
print '\r{0}'.format(x),
Additionally, this approach doesn't require the second print statement.
The accepted answer is not perfect. The line that was printed first will stay there and if your second print does not cover the entire new line, you will end up with garbage text.
To illustrate the problem save this code as a script and run it (or just take a look):
import time
n = 100
for i in range(100):
for j in range(100):
print("Progress {:2.1%}".format(j / 100), end="\r")
time.sleep(0.01)
print("Progress {:2.1%}".format(i / 100))
The output will look something like this:
Progress 0.0%%
Progress 1.0%%
Progress 2.0%%
Progress 3.0%%
What works for me is to clear the line before leaving a permanent print. Feel free to adjust to your specific problem:
import time
ERASE_LINE = '\x1b[2K' # erase line command
n = 100
for i in range(100):
for j in range(100):
print("Progress {:2.1%}".format(j / 100), end="\r")
time.sleep(0.01)
print(ERASE_LINE + "Progress {:2.1%}".format(i / 100)) # clear the line first
And now it prints as expected:
Progress 0.0%
Progress 1.0%
Progress 2.0%
Progress 3.0%
I'm a bit surprised nobody is using the backspace character. Here's one that uses it.
import sys
import time
secs = 1000
while True:
time.sleep(1) #wait for a full second to pass before assigning a second
secs += 1 #acknowledge a second has passed
sys.stdout.write(str(secs))
for i in range(len(str(secs))):
sys.stdout.write('\b')
Here's my solution! Windows 10, Python 3.7.1
I'm not sure why this code works, but it completely erases the original line. I compiled it from the previous answers. The other answers would just return the line to the beginning, but if you had a shorter line afterwards, it would look messed up like hello turns into byelo.
import sys
#include ctypes if you're on Windows
import ctypes
kernel32 = ctypes.windll.kernel32
kernel32.SetConsoleMode(kernel32.GetStdHandle(-11), 7)
#end ctypes
def clearline(msg):
CURSOR_UP_ONE = '\033[K'
ERASE_LINE = '\x1b[2K'
sys.stdout.write(CURSOR_UP_ONE)
sys.stdout.write(ERASE_LINE+'\r')
print(msg, end='\r')
#example
ig_usernames = ['beyonce','selenagomez']
for name in ig_usernames:
clearline("SCRAPING COMPLETE: "+ name)
Output - Each line will be rewritten without any old text showing:
SCRAPING COMPLETE: selenagomez
Next line (rewritten completely on same line):
SCRAPING COMPLETE: beyonce
(Python3) This is what worked for me. If you just use the \010 then it will leave characters, so I tweaked it a bit to make sure it's overwriting what was there. This also allows you to have something before the first print item and only removed the length of the item.
print("Here are some strings: ", end="")
items = ["abcd", "abcdef", "defqrs", "lmnop", "xyz"]
for item in items:
print(item, end="")
for i in range(len(item)): # only moving back the length of the item
print("\010 \010", end="") # the trick!
time.sleep(0.2) # so you can see what it's doing
One more answer based on the prevous answers.
Content of pbar.py:
import sys, shutil, datetime
last_line_is_progress_bar=False
def print2(print_string):
global last_line_is_progress_bar
if last_line_is_progress_bar:
_delete_last_line()
last_line_is_progress_bar=False
print(print_string)
def _delete_last_line():
sys.stdout.write('\b\b\r')
sys.stdout.write(' '*shutil.get_terminal_size((80, 20)).columns)
sys.stdout.write('\b\r')
sys.stdout.flush()
def update_progress_bar(current, total):
global last_line_is_progress_bar
last_line_is_progress_bar=True
completed_percentage = round(current / (total / 100))
current_time=datetime.datetime.now().strftime('%m/%d/%Y-%H:%M:%S')
overhead_length = len(current_time+str(current))+13
console_width = shutil.get_terminal_size((80, 20)).columns - overhead_length
completed_width = round(console_width * completed_percentage / 100)
not_completed_width = console_width - completed_width
sys.stdout.write('\b\b\r')
sys.stdout.write('{}> [{}{}] {} - {}% '.format(current_time, '#'*completed_width, '-'*not_completed_width, current,
completed_percentage),)
sys.stdout.flush()
Usage of script:
import time
from pbar import update_progress_bar, print2
update_progress_bar(45,200)
time.sleep(1)
update_progress_bar(70,200)
time.sleep(1)
update_progress_bar(100,200)
time.sleep(1)
update_progress_bar(130,200)
time.sleep(1)
print2('some text that will re-place current progress bar')
time.sleep(1)
update_progress_bar(111,200)
time.sleep(1)
print('\n') # without \n next line will be attached to the end of the progress bar
print('built in print function that will push progress bar one line up')
time.sleep(1)
update_progress_bar(111,200)
time.sleep(1)
Better to overwrite the whole line otherwise the new line will mix with the old ones if the new line is shorter.
import time, os
for s in ['overwrite!', 'the!', 'whole!', 'line!']:
print(s.ljust(os.get_terminal_size().columns - 1), end="\r")
time.sleep(1)
Had to use columns - 1 on Windows.
This worked for me, using Python 3.7.9 within Spyder, in Windows:
from IPython.display import clear_output
from time import sleep
def print_and_overwrite(text):
'''Remember to add print() after the last print that you want to overwrite.'''
clear_output(wait=True)
print(text, end='\r')
for i in range(15):
#I print the results backwards (from 15 to 1), to test shorter strings
message = "Iteration %d out of 15" %(15-i)
print_and_overwrite(message)
sleep(0.5)
print() #This stops the overwriting
print("This will be on a new line")
Anyway if somebody wants to overprint (clear) a many lines previously printed in stdout, than this answer should be helpful for him. (Thanks Thijmen Dam for the nice article Overwrite Previously Printed Lines)
In ANSI console you can use special sequences:
\033[1A and \033[K
First of them lift up a cursor, second - erase a line entirely.
Example of the clearing a console (Python 3):
LINE_UP = '\033[1A'
LINE_CLEAR = '\033[K'
CONSOLE_HEIGHT = 24 #lines
def clear_console():
for a in range(CONSOLE_HEIGHT):
print(LINE_UP, end=LINE_CLEAR, flush=True)
or eventually simply (will clear screen and move cursor to 0,0):
print('\033[2J', end='', flush=True)
If you want just positioning cursor, then use this:
print('\033[<L>;<C>f', end='', flush=True)
where <L> and <C> are Line and Column correspondingly.
Handful reference for you ANSI escape sequences
I want my program to have a looping display, which the code works, but the problem is that the character display is a long continuous line whereas I want it to go back to the start of the printing after a certain amount of characters have been displayed.
This is the entire code at this current moment:
import time
import sys
def Startup(s):
for c in s:
sys.stdout.write( '%s' % c )
sys.stdout.flush()
time.sleep(0.25)
def StartUpDot(s):
while True:
timeout = time.time() + 3*5
Time = 0
for c in s:
sys.stdout.write( '%s' % c)
sys.stdout.flush()
time.sleep(0.25)
if Time == 5 or time.time() > timeout:
break
Time = Time - 1
Startup("BOOTING UP"),
StartUpDot(".......") #This is what i want to repeat
The function that I want to do what I ask is the StartUpDot function. It instead displays a continuous line like "BOOTING UP................. etc"
To clarify I want the ...... to repeat from the start, the "BOOTING UP" is from a different function, i put the comma there to make it one line. I have it in a loop if that helps.
Sorry about the confusion
You have two options:
If you want the text to print out on the line below the current text, you need to print a newline character to stdout
sys.stdout.write('\n')
If you're using a maximum line width of 10 characters your output will look like this:
1 BOOTING UP
2 ........
If you want to clear the current text and print on the same line, you need to print a carriage return to stdout, which returns the cursor to the front of the line. Then print empty space characters for the entire width of your line (to clear the old text), then another carriage return to return the cursor to the beginning of the line.
line_width = 10
sys.stdout.write('\r{0}\r'.format(' ' * line_width))
Using this method, the output would look like this (the line number is the same each time, so this is more like a time sequence).
1 BOOTING UP
1 OOTING UP.
1 OTING UP..
Here is an example
line_width = 10
for i in range(20):
msg = 'BOOTING{0}'.format('.' * i)
# Get only the last portion of the message
# that is shorter than the line width
msg = msg[-line_width:]
# Pad with spaces if shorter than line width
# Ensures old content is overwritten
msg = msg.ljust(line_width)
sys.stdout.write('\r{0}'.format(msg))
I would like to show one progress bar the resets when its finished. Here is the code. When you run it you can see it makes a new line every time .
import time
import sys
toolbar_width = 40
numbers = [1,2,4,5,6,7,8,9,10]
for number in numbers:
for i in xrange(toolbar_width):
time.sleep(0.1) # do real work here
# update the bar
sys.stdout.write("-")
sys.stdout.flush()
sys.stdout.write("\n")
Print a carriage return when you are done:
import time
import sys
toolbar_width = 40
numbers = [1,2,4,5,6,7,8,9,10]
for number in numbers:
#print number
for i in xrange(toolbar_width):
time.sleep(0.1) # do real work here
# update the bar
sys.stdout.write("-")
sys.stdout.flush()
sys.stdout.write("\r")
# ^^^^^^^^^^^^^^^^^^^^ <--- here!
This way, the cursor will go back to the beginning of the line.
However, this will go to the beginning of the line and keep what was there before, as #Kevin comments below. To blank the line you can print a long line with spaces surrounded by \r: the first to start printing at the beginning of the given line and the second to put the cursor back in the beginning.
sys.stdout.write("\r \r")
sys.stdout.write("\r" + " " * toolbar_width + "\r")
instead of
sys.stdout.write("\n")
Explain:
\r -- return at the beginning of line
" " * toolbar_width -- fill the line with space of the size toolbar_width
\r -- return again at the beginning of line
On Unix, I can either use \r (carriage return) or \b (backspace) to overwrite the current line (print over text already visible) in the shell.
Can I achieve the same effect in a Windows command line from a Python script?
I tried the curses module but it doesn't seem to be available on Windows.
yes:
import sys
import time
def restart_line():
sys.stdout.write('\r')
sys.stdout.flush()
sys.stdout.write('some data')
sys.stdout.flush()
time.sleep(2) # wait 2 seconds...
restart_line()
sys.stdout.write('other different data')
sys.stdout.flush()
I know this is old, but i wanted to tell my version (it works on my PC in the cmd, but not in the idle) to override a line in Python 3:
>>> from time import sleep
>>> for i in range(400):
>>> print("\r" + str(i), end="")
>>> sleep(0.5)
EDIT:
It works on Windows and on Ubuntu
import sys
import time
for i in range(10):
print '\r', # print is Ok, and comma is needed.
time.sleep(0.3)
print i,
sys.stdout.flush() # flush is needed.
And if on the IPython-notebook, just like this:
import time
from IPython.display import clear_output
for i in range(10):
time.sleep(0.25)
print(i)
clear_output(wait=True)
http://nbviewer.ipython.org/github/ipython/ipython/blob/master/examples/notebooks/Animations%20Using%20clear_output.ipynb
I just had this problem. You can still use \r, even in Windows Command Prompt, however, it only takes you back to the previous linebreak (\n).
If you do something like this:
cnt = 0
print str(cnt)
while True:
cnt += 1
print "\r" + str(cnt)
You'll get:
0
1
2
3
4
5
...
That's because \r only goes back to the last line. Since you already wrote a newline character with the last print statement, your cursor goes from the beginning of a new empty line to the beginning of the same new empty line.
To illustrate, after you print the first 0, your cursor would be here:
0
| # <-- Cursor
When you \r, you go to the beginning of the line. But you're already on the beginning of the line.
The fix is to avoid printing a \n character, so your cursor is on the same line and \r overwrites the text properly. You can do that with print 'text',. The comma prevents the printing of a newline character.
cnt = 0
print str(cnt),
while True:
cnt += 1
print "\r" + str(cnt),
Now it will properly rewrite lines.
Note that this is Python 2.7, hence the print statements.
Easy method:
import sys
from time import sleep
import os
#print("\033[y coordinate;[x coordinateH Hello")
os.system('cls')
sleep(0.2)
print("\033[1;1H[]")
sleep(0.2)
print("\033[1;1H []")
sleep(0.2)
print("\033[1;1H []")
sleep(0.2)
print("\033[1;1H []")
sleep(0.2)
print("\033[1;1H []")
sleep(0.2)
print("\033[1;1H []")
sleep(0.2)
print("\033[1;1H []")
sleep(0.2)
print("\033[1;1H []")
sleep(0.2)
print("\033[1;1H[]")
sleep(0.2)
Simple way if you're just wanting to update the previous line:
import time
for i in range(20):
print str(i) + '\r',
time.sleep(1)
Easiest way is to use two \r - one at the beginning and one at the end
for i in range(10000):
print('\r'+str(round(i*100/10000))+'% Complete\r'),
It will go pretty quickly
On Windows (python 3), it seems to work (not using stdout directly):
import sys
for i in reversed(range(0,20)):
time.sleep(0.1)
if(i == 19):
print(str(i), end='', file=sys.stdout)
else:
print("\r{0:{width}".format(str(i), width = w, fill = ' ', align = 'right'), end='', file=sys.stdout)
sys.stdout.flush()
w = len(str(i))
The same line is updated everytime print function is called.
This algorithm can be improved, but it is posted to show what you can do. You can modify the method according to your needs.
Thanks for all the useful answers in here guys. I needed this :)
I found nosklo's answer particularly useful, but I wanted something fully contained within a function by passing the desired output as a parameter. Also, I didn't really need the timer, since I wanted the printing to take place after a specific event).
This is what did the trick for me, I hope someone else finds it useful:
import sys
def replace_cmd_line(output):
"""Replace the last command line output with the given output."""
sys.stdout.write(output)
sys.stdout.flush()
sys.stdout.write('\r')
sys.stdout.flush()
Yes, this question was asked 11 years ago but it's cool. I like to improvise.
Add-on to nosklo's answer:
import sys
import time
def restart_line():
sys.stdout.write("\r")
sys.stdout.flush()
string_one = "some data that is very long..."
sys.stdout.write(string_one)
sys.stdout.flush()
time.sleep(2)
restart_line()
string_two = "shorter data"
if len(string_two) < len(string_one):
string_two = string_two+(" "*int((len(string_one)-len(string_two))))
# This will overwrite the characters that would be left on the console
sys.stdout.write(string_two)
sys.stdout.flush()
Tested on PyCharm 2020.3 and Python version 3.9, to overwrite written printout I use the following:
from time import sleep
for x in range(10):
print(f'\r {x}', end='')
sleep(0.6)
That's the code I mainly use for my programs. Using end='\r' will overwrite the whole text for me, ignoring sleep.
In real scenario, I set it up as follows:
def progress_callback(progress):
print(f'\rDownloading File: {progress.dlable.file_name} Progress: ' + '{0:.2f}%'.format(progress.percent), end='')
# `return True` if the download should be canceled
return False
print('\nDownload complete!)
The print after the overwrite function has to be in new line, or the same line before will be overwritten.