Python Progress Bar


How do I use a progress bar when my script is doing some task that is likely to take time?

For example, a function which takes some time to complete and returns True when done. How can I display a progress bar during the time the function is being executed?

Note that I need this to be in real time, so I can’t figure out what to do about it. Do I need a thread for this? I have no idea.

Right now I am not printing anything while the function is being executed, however a progress bar would be nice. Also I am more interested in how this can be done from a code point of view.

Asked By: user225312



There are specific libraries (like this one here) but maybe something very simple would do:

import time
import sys

toolbar_width = 40

# setup toolbar
sys.stdout.write("[%s]" % (" " * toolbar_width))
sys.stdout.write("b" * (toolbar_width+1)) # return to start of line, after '['

for i in range(toolbar_width):
    time.sleep(0.1) # do real work here
    # update the bar

sys.stdout.write("]n") # this ends the progress bar

Note: progressbar2 is a fork of progressbar which hasn’t been maintained in years.

Answered By: ChristopheD

If your work can’t be broken down into measurable chunks, you could call your function in a new thread and time how long it takes:

import thread
import time
import sys

def work():
    time.sleep( 5 )

def locked_call( func, lock ):

lock = thread.allocate_lock()
thread.start_new_thread( locked_call, ( work, lock, ) )

# This part is icky...
while( not lock.locked() ):
    time.sleep( 0.1 )

while( lock.locked() ):
    sys.stdout.write( "*" )
    time.sleep( 1 )
print "nWork Done"

You can obviously increase the timing precision as required.

Answered By: bvanvugt

You should link the progress bar to the task at hand (so that it measures the progress :D). For example, if you are FTPing a file, you can tell ftplib to grab a certain size buffer, let’s say 128K, and then you add to your progress bar whatever percentage of the filesize 128k represents. If you are using the CLI, and your progress meter is 20 characters long, you would add one character when 1/20th of the file had transferred.

Answered By: johncip

Use this library: fish (GitHub).


>>> import fish
>>> while churning:
...     churn_churn()
...     fish.animate()

Have fun!

Answered By: Etienne

for a similar application (keeping track of the progress in a loop) I simply used the python-progressbar:

Their example goes something like this,

from progressbar import *               # just a simple progress bar

widgets = ['Test: ', Percentage(), ' ', Bar(marker='0',left='[',right=']'),
           ' ', ETA(), ' ', FileTransferSpeed()] #see docs for other options

pbar = ProgressBar(widgets=widgets, maxval=500)

for i in range(100,500+1,50):
    # here do something long at each iteration
    pbar.update(i) #this adds a little symbol at each iteration
Answered By: Massagran

The above suggestions are pretty good, but I think most people just want a ready made solution, with no dependencies on external packages, but is also reusable.

I got the best points of all the above, and made it into a function, along with a test cases.

To use it, just copy the lines under “def update_progress(progress)” but not the test script. Don’t forget to import sys. Call this whenever you need to display or update the progress bar.

This works by directly sending the “r” symbol to console to move cursor back to the start. “print” in python does not recongise the above symbol for this purpose, hence we need ‘sys’

import time, sys

# update_progress() : Displays or updates a console progress bar
## Accepts a float between 0 and 1. Any int will be converted to a float.
## A value under 0 represents a 'halt'.
## A value at 1 or bigger represents 100%
def update_progress(progress):
    barLength = 10 # Modify this to change the length of the progress bar
    status = ""
    if isinstance(progress, int):
        progress = float(progress)
    if not isinstance(progress, float):
        progress = 0
        status = "error: progress var must be floatrn"
    if progress < 0:
        progress = 0
        status = "Halt...rn"
    if progress >= 1:
        progress = 1
        status = "Done...rn"
    block = int(round(barLength*progress))
    text = "rPercent: [{0}] {1}% {2}".format( "#"*block + "-"*(barLength-block), progress*100, status)

# update_progress test script
print "progress : 'hello'"

print "progress : 3"

print "progress : [23]"

print ""
print "progress : -10"

print ""
print "progress : 10"

print ""
print "progress : 0->1"
for i in range(101):

print ""
print "Test completed"

This is what the result of the test script shows (The last progress bar animates):

progress : 'hello'
Percent: [----------] 0% error: progress var must be float
progress : 3
Percent: [##########] 100% Done...
progress : [23]
Percent: [----------] 0% error: progress var must be float

progress : -10
Percent: [----------] 0% Halt...

progress : 10
Percent: [##########] 100% Done...

progress : 0->1
Percent: [##########] 100% Done...
Test completed
Answered By: Brian Khuu

@Massagran: It works well in my programs. Furthermore, we need to add a counter to indicate the loop times. This counter plays as the argument of the method update.
For example: read all lines of a test file and treat them on something. Suppose that the function dosth() do not concern in the variable i.

lines = open(sys.argv[1]).readlines()
i = 0
widgets=[Percentage(), Bar()]
pbar = ProgressBar(widgets=widgets,maxval=len(lines)).start()
for line in lines:<pre>
    i += 1

The variable i controls the status of pbar via the method update

Answered By: Tung

Try progress from

from import Bar

bar = Bar('Processing', max=20)
for i in range(20):
    # Do some work

The result will be a bar like the following:

Processing |#############                   | 42/100
Answered By: Vladislav

With tqdm (conda install tqdm or pip install tqdm) you can add a progress meter to your loops in a second:

from time import sleep
from tqdm import tqdm
for i in tqdm(range(10)):

 60%|██████    | 6/10 [00:18<00:12,  0.33 it/s]

Also, there is a notebook version:

from tqdm.notebook import tqdm
for i in tqdm(range(100)):

You can use instead of tqdm.notebook to work in both a terminal and notebooks.

tqdm.contrib contains some helper functions to do things like enumerate, map, and zip. There are concurrent maps in tqdm.contrib.concurrent.

You can even get progress sent to your phone after disconnecting from a jupyter notebook using tqdm.contrib.telegram or tqdm.contrib.discord.

GIF showing an example of the output of using tqdm.contrib.telegram to display progress bar in Telegram mobile app

Answered By: scls

I like this page.

Starts with simple example and moves onto a multi-threaded version. Works out of the box. No 3rd party packages required.

The code will look something like this:

import time
import sys

def do_task():

def example_1(n):
    for i in range(n):
        print 'b.',
    print ' Done!'

print 'Starting ',

Or here is example to use threads in order to run the spinning loading bar while the program is running:

import sys
import time
import threading

class progress_bar_loading(threading.Thread):

    def run(self):
            global stop
            global kill
            print 'Loading....  ',
            i = 0
            while stop != True:
                    if (i%4) == 0: 
                    elif (i%4) == 1: 
                    elif (i%4) == 2: 
                    elif (i%4) == 3: 


            if kill == True: 
                print 'bbbb ABORT!',
                print 'bb done!',

kill = False      
stop = False
p = progress_bar_loading()

    #anything you want to run. 
    stop = True
except KeyboardInterrupt or EOFError:
         kill = True
         stop = True
Answered By: user1862895

I really like the python-progressbar, as it is very simple to use.

For the most simple case, it is just:

import progressbar
import time

progress = progressbar.ProgressBar()
for i in progress(range(80)):

The appearance can be customized and it can display the estimated remaining time. For an example use the same code as above but with:

progress = progressbar.ProgressBar(widgets=[progressbar.Bar('=', '[', ']'), ' ',
                                            progressbar.Percentage(), ' ',
Answered By: luator

No external packages. A ready-made piece of code.

You can customize bar progress symbol "#", bar size, text prefix etc.

Python 3.3+

import sys
def progressbar(it, prefix="", size=60, out=sys.stdout): # Python3.3+
    count = len(it)
    def show(j):
        x = int(size*j/count)
        print("{}[{}{}] {}/{}".format(prefix, "#"*x, "."*(size-x), j, count), 
                end='r', file=out, flush=True)
    for i, item in enumerate(it):
        yield item
    print("n", flush=True, file=out)


import time    
for i in progressbar(range(15), "Computing: ", 40):
    time.sleep(0.1) # any code you need

To fill the whole character space use a unicode u"█" char replacing "#". With for i in progressbar(range(100)): ... you get :

enter image description here

  • Doesn’t require a second thread. Some solutions/packages above require.

  • Works with any iterable it means anything that len() can be used on. A list, a dict of anything for example ['a', 'b', 'c' ... 'g']

  • Works with generators only have to wrap it with a list(). For example for i in progressbar(list(your_generator), "Computing: ", 40): Unless the work is done in the generator. In that case you need another solution (like tqdm).

You can also change output by changing out to sys.stderr for example.

Python 3.6+ (f-string)

def progressbar(it, prefix="", size=60, out=sys.stdout): # Python3.6+
    count = len(it)
    def show(j):
        x = int(size*j/count)
        print(f"{prefix}[{u'█'*x}{('.'*(size-x))}] {j}/{count}", end='r', file=out, flush=True)
    for i, item in enumerate(it):
        yield item
    print("n", flush=True, file=out)

Python 2 (old-code)

import sys
def progressbar(it, prefix="", size=60, out=sys.stdout):
    count = len(it)
    def show(j):
        x = int(size*j/count)
        out.write("%s[%s%s] %i/%ir" % (prefix, u"#"*x, "."*(size-x), j, count))
    for i, item in enumerate(it):
        yield item
Answered By: imbr

Here’s a short solution that builds the loading bar programmatically (you must decide how long you want it).

import time

n = 33  # or however many loading slots you want to have
load = 0.01  # artificial loading time!
loading = '.' * n  # for strings, * is the repeat operator

for i in range(n+1):
    # this loop replaces each dot with a hash!
    print('r%s Loading at %3d percent!' % (loading, i*100/n), end='')
    loading = loading[:i] + '#' + loading[i+1:]
    if i==n: print()
Answered By: étale-cohomology

I’ve just made a simple progress class for my needs after searching here for a equivalent solution. I thought I might a well post it.

from __future__ import print_function
import sys
import re

class ProgressBar(object):
    DEFAULT = 'Progress: %(bar)s %(percent)3d%%'
    FULL = '%(bar)s %(current)d/%(total)d (%(percent)3d%%) %(remaining)d to go'

    def __init__(self, total, width=40, fmt=DEFAULT, symbol='=',
        assert len(symbol) == 1 = total
        self.width = width
        self.symbol = symbol
        self.output = output
        self.fmt = re.sub(r'(?P<name>%(.+?))d',
            r'g<name>%dd' % len(str(total)), fmt)

        self.current = 0

    def __call__(self):
        percent = self.current / float(
        size = int(self.width * percent)
        remaining = - self.current
        bar = '[' + self.symbol * size + ' ' * (self.width - size) + ']'

        args = {
            'bar': bar,
            'current': self.current,
            'percent': percent * 100,
            'remaining': remaining
        print('r' + self.fmt % args, file=self.output, end='')

    def done(self):
        self.current =
        print('', file=self.output)

Example :

from time import sleep

progress = ProgressBar(80, fmt=ProgressBar.FULL)

for x in xrange(
    progress.current += 1

Will print the following:

[======== ] 17/80 ( 21%) 63 to go

Answered By: Romuald Brunet

I like Brian Khuu’s answer for its simplicity and not needing external packages. I changed it a bit so I’m adding my version here:

import sys
import time

def updt(total, progress):
    Displays or updates a console progress bar.

    Original source:
    barLength, status = 20, ""
    progress = float(progress) / float(total)
    if progress >= 1.:
        progress, status = 1, "rn"
    block = int(round(barLength * progress))
    text = "r[{}] {:.0f}% {}".format(
        "#" * block + "-" * (barLength - block), round(progress * 100, 0),

runs = 300
for run_num in range(runs):
    updt(runs, run_num + 1)

It takes the total number of runs (total) and the number of runs processed so far (progress) assuming total >= progress. The result looks like this:

[#####---------------] 27%
Answered By: Gabriel

I like Gabriel answer, but i changed it to be flexible. You can send bar-length to the function and get your progress bar with any length that you want. And you can’t have a progress bar with zero or negative length. Also, you can use this function like Gabriel answer (Look at the Example #2).

import sys
import time

def ProgressBar(Total, Progress, BarLength=20, ProgressIcon="#", BarIcon="-"):
        # You can't have a progress bar with zero or negative length.
        if BarLength <1:
            BarLength = 20
        # Use status variable for going to the next line after progress completion.
        Status = ""
        # Calcuting progress between 0 and 1 for percentage.
        Progress = float(Progress) / float(Total)
        # Doing this conditions at final progressing.
        if Progress >= 1.:
            Progress = 1
            Status = "rn"    # Going to the next line
        # Calculating how many places should be filled
        Block = int(round(BarLength * Progress))
        # Show this
        Bar = "[{}] {:.0f}% {}".format(ProgressIcon * Block + BarIcon * (BarLength - Block), round(Progress * 100, 0), Status)
        return Bar
        return "ERROR"

def ShowBar(Bar):

if __name__ == '__main__':
    print("This is a simple progress bar.n")

    # Example #1:
    print('Example #1')
    Runs = 10
    for i in range(Runs + 1):
        progressBar = "rProgress: " + ProgressBar(10, i, Runs)

    # Example #2:
    print('nExample #2')
    Runs = 10
    for i in range(Runs + 1):
        progressBar = "rProgress: " + ProgressBar(10, i, 20, '|', '.')


# Example #2:
Runs = 10
for i in range(Runs + 1):
    ProgressBar(10, i)


This is a simple progress bar.

Example #1

Progress: [###——-] 30%

Example #2

Progress: [||||||||||||……..] 60%


If it is a big loop with a fixed amount of iterations that is taking a lot of time you can use this function I made. Each iteration of loop adds progress. Where count is the current iteration of the loop, total is the value you are looping to and size(int) is how big you want the bar in increments of 10 i.e. (size 1 =10 chars, size 2 =20 chars)

import sys
def loadingBar(count,total,size):
    percent = float(count)/float(total)*100
    sys.stdout.write("r" + str(int(count)).rjust(3,'0')+"/"+str(int(total)).rjust(3,'0') + ' [' + '='*int(percent/10)*size + ' '*(10-int(percent/10))*size + ']')


for i in range(0,100):
     #do some code 


i = 50
>> 050/100 [==========          ]
Answered By: jelde015

Try PyProg. PyProg is an open-source library for Python to create super customizable progress indicators & bars.

It is currently at version 1.0.2; it is hosted on Github and available on PyPI (Links down below). It is compatible with Python 3 & 2 and it can also be used with Qt Console.

It is really easy to use. The following code:

import pyprog
from time import sleep

# Create Object
prog = pyprog.ProgressBar(" ", "", 34)
# Update Progress Bar

for i in range(34):
    # Do something
    # Set current status
    prog.set_stat(i + 1)
    # Update Progress Bar again

# Make the Progress Bar final

will produce:

Initial State:
Progress: 0% --------------------------------------------------

When half done:
Progress: 50% #########################-------------------------

Final State:
Progress: 100% ##################################################

I actually made PyProg because I needed a simple but super customizable progress bar library. You can easily install it with: pip install pyprog.

PyProg Github:

Answered By: Bill Kudo

The code below is a quite general solution and also has a time elapsed and time remaining estimate. You can use any iterable with it. The progress bar has a fixed size of 25 characters but it can show updates in 1% steps using full, half, and quarter block characters. The output looks like this:

 18% |████▌                    |  [0:00:01, 0:00:06]

Code with example:

import sys, time
from numpy import linspace

def ProgressBar(iterObj):
  def SecToStr(sec):
    m, s = divmod(sec, 60)
    h, m = divmod(m, 60)
    return u'%d:%02d:%02d'%(h, m, s)
  L = len(iterObj)
  steps = {int(x):y for x,y in zip(linspace(0, L, min(100,L), endpoint=False),
                                   linspace(0, 100, min(100,L), endpoint=False))}
  qSteps = ['', u'u258E', u'u258C', u'u258A'] # quarter and half block chars
  startT = time.time()
  timeStr = '   [0:00:00, -:--:--]'
  activity = [' -',' \',' |',' /']
  for nn,item in enumerate(iterObj):
    if nn in steps:
      done = u'u2588'*int(steps[nn]/4.0)+qSteps[int(steps[nn]%4)]
      todo = ' '*(25-len(done))
      barStr = u'%4d%% |%s%s|'%(steps[nn], done, todo)
    if nn>0:
      endT = time.time()
      timeStr = ' [%s, %s]'%(SecToStr(endT-startT),
    sys.stdout.write('r'+barStr+activity[nn%4]+timeStr); sys.stdout.flush()
    yield item
  barStr = u'%4d%% |%s|'%(100, u'u2588'*25)
  timeStr = '   [%s, 0:00:00]n'%(SecToStr(time.time()-startT))
  sys.stdout.write('r'+barStr+timeStr); sys.stdout.flush()

# Example
s = ''
for c in ProgressBar(list('Disassemble and reassemble this string')):
  s += c

Suggestions for improvements or other comments are appreciated. Cheers!

Answered By: Niko

It is quite straightforward in Python3:

   import time
   import math

    def show_progress_bar(bar_length, completed, total):
        bar_length_unit_value = (total / bar_length)
        completed_bar_part = math.ceil(completed / bar_length_unit_value)
        progress = "*" * completed_bar_part
        remaining = " " * (bar_length - completed_bar_part)
        percent_done = "%.2f" % ((completed / total) * 100)
        print(f'[{progress}{remaining}] {percent_done}%', end='r')

    bar_length = 30
    total = 100
    for i in range(0, total + 1):
        show_progress_bar(bar_length, i, total)

Answered By: Anton Ivanov

You can also use enlighten. The main advantage is you can log at the same time without overwriting your progress bar.

import time
import enlighten

manager = enlighten.Manager()
pbar = manager.counter(total=100)

for num in range(1, 101):
    print('Step %d complete' % num)

It also handles multiple progress bars.

import time
import enlighten

manager = enlighten.Manager()
odds = manager.counter(total=50)
evens = manager.counter(total=50)

for num in range(1, 101):
    if num % 2:
Answered By: aviso

When running in jupyter notebooks use of normal tqdm doesn’t work, as it writes output on multiple lines. Use this instead:

import time
from tqdm import tqdm_notebook as tqdm

for i in tqdm(range(100))
Answered By: Jacques MALAPRADE

a little more generic answer of jelde015 (credit to him of course)

for updating the loading bar manually will be:

import sys
from math import *

def loadingBar(i, N, size):
    percent = float(i) / float(N)
                     + str(int(i)).rjust(3, '0')
                     +str(int(N)).rjust(3, '0')
                     + ' ['
                     + '='*ceil(percent*size)
                     + ' '*floor((1-percent)*size)
                     + ']')

and calling it by:

loadingBar(7, 220, 40)

will result:

007/220 [=                                       ]  

just call it whenever you want with the current i value.

set the size as the number of chars the bar should be

Answered By: Yarden Cohen

use the os_sys lib:

i use it for many types of bars, example:

from os_sys.progress import bar as Bar
bar = Bar('progresing: ', max=20)
for i in range(20):
    #do somthing

your output will be:

procesing:  |######                          | 2/10

read more in the discription of os_sys

Answered By: Matthijs990

Guess i’m a little late but this should work for people working with the current versions of python 3, since this uses “f-strings”, as introduced in Python 3.6 PEP 498:


from numpy import interp

class Progress:
    def __init__(self, value, end, title='Downloading',buffer=20):
        self.title = title
        #when calling in a for loop it doesn't include the last number
        self.end = end -1
        self.buffer = buffer
        self.value = value

    def progress(self):
        maped = int(interp(self.value, [0, self.end], [0, self.buffer]))
        print(f'{self.title}: [{"#"*maped}{"-"*(self.buffer - maped)}]{self.value}/{self.end} {((self.value/self.end)*100):.2f}%', end='r')


#some loop that does perfroms a task
for x in range(21)  #set to 21 to include until 20
    Progress(x, 21)


Downloading: [########------------] 8/20 40.00%
Answered By: Gustavo Barros

This is a simple way to create a progressbar

import time,sys
toolbar_width = 50
# setting up toolbar [-------------------------------------]
# each hash represents 2 % of the progress
for i in range(toolbar_width):
    sys.stdout.write("r") # return to start of line
    sys.stdout.write("[")#Overwrite over the existing text from the start 
    sys.stdout.write("#"*(i+1))# number of # denotes the progress completed 

You can use tqdm:

from tqdm import tqdm

with tqdm(total=100, desc="Adding Users", bar_format="{l_bar}{bar} [ time left: {remaining} ]") as pbar:
    for i in range(100):

In this example the progress bar is running for 5 minutes
and it is shown like that:

Adding Users:   3%|█████▊                                     [ time left: 04:51 ]                                                                                                        

You can change it and customize it as you like.

Answered By: Eyal.D

Use alive-progress, the coolest progress bar ever!

GIF showing an example of alive-progress

To use any progress bar framework in a useful manner, i.e. to get a percentage of completion and an estimated time of arrival (ETA), you need to be able to tell how many steps your processing will have.

Then you can just insert an yield to mark an item has been processed, and you’re good to go!

def compute():
    for i in range(1000):
        ... # process items as usual.
        yield  # insert this :)

Then just use it like:

from alive_progress import alive_bar

with alive_bar(1000) as bar:
    for i in compute():

To get an awesome and alive progress bar!

|█████████████▎                      | ▅▃▁ 321/1000 [32%] in 8s (40.1/s, eta: 16s)

Disclosure: I’m the author of alive-progress, but it should solve your problem nicely! Read the documentation at to know more. Now it works also on Jupyter Notebooks! Here are some more examples of what it can do:

GIF showing various styles of alive-progress

GIF showing alive-progress on Jupyter Notebooks

Answered By: rsalmei

This progress bar shows points of each 2 percent complete and numbers for each 10 percent complete.

import sys

def ProgressBar (num, total, nextPercent, nextPoint):
    num = float (num)
    total = float (total) - 1
    if not nextPoint:
        nextPoint = 0.0
    if not nextPercent:
        nextPoint += 2.0
        sys.stdout.write ("[0%")
        nextPercent = 10
    elif num == total:
        sys.stdout.write ("100%]n")
        nextPercent += 10
    elif not nextPoint:
        nextPoint = 0.0
    elif num / total * 100 >= nextPercent:
        sys.stdout.write (str(int (nextPercent)) + "%")
        nextPercent += 10
    elif num / total * 100 >= nextPoint:
        sys.stdout.write (":")
        nextPoint += 2
    return (nextPercent, nextPoint)

nextPercent, nextPoint = 0, 0
total = 1000

for num in range (total):
    nextPercent, nextPoint = ProgressBar (num, total, nextPercent, nextPoint)


Answered By: Emil Brundage

I used format() method to make a load bar. Here is my solution:

import time

loadbarwidth = 23

for i in range(1, loadbarwidth + 1):

    strbarwidth = '[{}{}] - {}r'.format(
        (i * '#'),
        ((loadbarwidth - i) * '-'),
        (('{:0.2f}'.format(((i) * (100/loadbarwidth))) + '%'))

    print(strbarwidth ,end = '')



[#######################] - 100.00%
Answered By: Matheus Tavares

Use the progress library!

pip install progress

Here is a custom subclass I wrote to format the ETA/Elapsed times into a better readable format:

import datetime
from import IncrementalBar

class ProgressBar(IncrementalBar):
    My custom progress bar that:
       - Show %, count, elapsed, eta
       - Time is shown in H:M:S format

    message = 'Progress'
    suffix  = '%(percent).1f%% (%(index)d/%(max)d) -- %(elapsed_min)s (eta: %(eta_min)s)'

    def formatTime(self, seconds):
        return str(datetime.timedelta(seconds=seconds))

    def elapsed_min(self):
        return self.formatTime(self.elapsed)

    def eta_min(self):
        return self.formatTime(self.eta)

if __name__=='__main__':
    counter = 120
    bar     = ProgressBar('Processing', max=counter)

    for i in range(counter):

Answered By: kakhkAtion

This is my simple solution:

import time

def progress(_cur, _max):
    p = round(100*_cur/_max)
    b = f"Progress: {p}% - ["+"."*int(p/5)+" "*(20-int(p/5))+"]"
    print(b, end="r")

for i in range(0,101):

print("..."*5, end="r")
Answered By: dododo

A simple solution here !

void = '-'
fill = '#'
count = 100/length
increaseCount = 0
for i in range(length):
    print('['+(fill*i)+(void*(length-i))+'] '+str(int(increaseCount))+'%',end='r')
    increaseCount += count
print('['+(fill*(i+1))+(void*(length-(i+1)))+'] '+str(int(increaseCount))+'%',end='n')

Note : You can modify the fill and the "void" character if you want.

The loading bar (picture)

Answered By: RandomProgrammer

A very simple approach:

def progbar(count: int) -> None:
    for i in range(count):
        print(f"[{i*'#'}{(count-1-i)*' '}] - {i+1}/{count}", end="r")
        yield i

And the usage:

from time import sleep

for i in progbar(10):
    sleep(0.2) #whatever task you need to do
Answered By: JHAR Productions

Here is a very simple version, in case you have a loop and just want to get an idea of progression of iterations, such as a dot for every, say, 5000 iterations.

my_list = range(0,100000)

counter = 0
for x in my_list:
    #your code here

    counter = counter + 1
    if counter % 5000 == 0:
        print(".", end="") # end="" avoids a newline, keeps dots together

print() #this makes sure whatever you print next is in a new line

my_list is not part of the scheme. Use your own iterable, whatever you are looping over.
This version doesn’t tell you ahead of time how many total iterations.

Answered By: Rabi

I use wget, you have to install the module tho in cmd prompt in windows or terminal if on mac or linux

pip install wget

It’s pretty straight forward, just use the download() function

import wget
url = input("Enter Url to download: ")

tqdm is also an option, u have to download the module, too.

pip install tqdm

now make sure to import the module, set the range and pass

from tqdm import tqdm
for i in tqdm(range(int(9e7))):
Answered By: 1409aram

Progressbar for iterrows. Adaptation of @eusoubrasileiro code for displaying progress when looping through rows of a dataframe. Additionally shows percentage, ith/count, elapsed seconds, iters/sec, remaining seconds. Allows specifying an nth updating count (per).

import time
import sys
def progressbar_iterrows(df, prefix="", size=60, file=sys.stdout, per=1000):
    count = len(df)
    t = 0
    def show(j,elapsed):
        avg = 0 if elapsed == 0 else j/elapsed
        remaining = 0 if avg == 0 else (count-j)/avg
        x = int(size*j/count)
        file.write("%s[%s%s] %i%% %i/%i elapsed:%i %i/sec remaining:%ir" % (prefix, "#"*x, "."*(size-x), j/count, j, count, elapsed, avg, remaining))
    file.write("Initializing ...r")
    for i, item in df.iterrows():
        yield i,item
        if t == 0:
            t = time.time()
        if i % per == 0:


    for n,r in progressbar_iterrows(br_b_sections_df, "Processed: "):
        # do something


Processed: [........................] 0% 5000/28751240 elapsed:12 413/sec remaining:55054
Answered By: BSalita
from IPython.display import clear_output
progress_bar=u"u001b[7m Loading: "
for i in range(100):
    progress_bar+=u"u001b[7m "
    time.sleep(0.03) #you can change the speed


Answered By: Gayrat Dadamirzaev

A simple oneliner:

K = 628318
for k in range(K):
    # your stuff
    print(end="r|%-80s|" % ("="*int(80*k/(K-1))))
|=====================================================================       |

80 is the length of the bar. Eventually you want a final print().

It can be also put into a convencience function. Along with yield, one can emulate the behaviour of tqdm:

def progbar(iterobj):
    K = len(iterobj)
    for k, obj in enumerate(iterobj):
        print(end="r|%-80s|" % ("="*int(80*k/(K-1))))
        yield obj
    raise StopIteration

for k in progbar(range(628318)):
    # your stuff

And not to forget the digital progress indicator:

K = 628318
for k in range(K):
    # your stuff
    print(end="r%6.2f %%" % (k/(K-1)*100))
 94.53 %

It is not to difficult to combine both, if needed.

The keys are the "Carriage Return" r and the suppression of the default end="n" in print.

2022 Answer for simple progress bar without external library

import time, sys

def progress(size):
    for item in range(size):


            #main work goes here


#doesnt affect actual execution
#based on events and consumption in background
#may be that actual process completes a bit earlier than progress shows 99%
#make an instance with number of elements in a loop
#in each iteration call the method current_progress

import time
from math import ceil
import os
import sys
from threading import Thread
class progress_bar(object):
 def __init__(self,total_elements,length_bar=25):
 def current_progress(self):
 def display_progress(self):
  while True:
    for i in range(0,self.length_bar+3-(len(bar))):
    if self.progress <= 100:
     print("Progress:",barp, sep=' ', end='n', file=sys.stdout, flush=True)
    if self.call_count == self.total_elements:
Answered By: Syed Waleed Shah

There are a lot of amazing answers already still I would like to share my solution to the progress bar.

from time import sleep

def progress_bar(progress: float, total: float, width: int = 25):
    percent = width * ((progress + 1) / total)
    bar = chr(9608) * int(percent) + "-" * (width - int(percent))
    print(f"r|{bar}| {(100/width)*percent:.2f}%", end="r")

numbers = range(0, 1000)
numbersLen = len(numbers)
for i in numbers:
    sleep(0.01) # Do something usefull here
    progress_bar(i, numbersLen)


If you are looking for a bar that adjusts it’s with based on the terminal’s width and a possibility for messages at the end then this works too. Note that the message will disappear if the Terminal gets too narrow as the bar will break if it’s too wide for 1 line.

def progressBar(progress: float, total: float, message: str = ""):
    terminalWidth = get_terminal_size().columns
    width = int(terminalWidth / 4)
    percent = width * ((progress + 1) / total)
    bar = chr(9608) * int(percent) + "-" * (width - int(percent))
    if terminalWidth <= 40:
        message = ""
        message = message + (" " * (int(terminalWidth / 2) - len(message)))
    print(f"r|{bar}| {(100/width)*percent:.2f}% " + message, end="r")
Answered By: HandyGold75

There’s a lot of good ansers already, but adding this specidfic based upon @HandyGold75 answer, I wanted it to be callabe under a specific context, with an initial msg, plus a timing feedback in seconds at the end.

from time import sleep, time

class ProgressBar:
    def __init__(self, total: float, width: int = 50, msg: str = ""): = total
    self.width = width
    self.start: float = time()
    if msg:

    def progress(self, progress: float):
        percent = self.width * ((progress) /
        bar = chr(9608) * int(percent) + "-" * (self.width - int(percent))
            f"r|{bar}| {(100/self.width)*percent:.2f}% "
            f"[{progress} of {}]",

    def __enter__(self):
        return self.progress

    def __exit__(self, type, value, traceback):
        end: float = time()
        print(f"nFinished after {end - self.start: .3f} seconds.")

total_loops = 150
with ProgressBar(total=total_loops) as progress:
    for i in range(total_loops):
        sleep(0.01)  # Do something usefull here
        progress(i + 1)
Answered By: Bravhek

Inspired by many of the answers with no package dependency, I am sharing my implementation here. The function to be used in any loop expects the current iteration number, the total number of iterations, and the initial time.

import time    
def simple_progress_bar(i: int, n: int, init_time: float):
    avg_time = (time.time()-init_time)/(i+1)
    percent = ((i+1)/(n))*100
        end=f"r|{'='*(int(percent))+'>'+'.'*int(100-int(percent))}|| " + 
        f"||Completion: {percent : 4.3f}% || t "+ 
        f"||Time elapsed: {avg_time*(i+1):4.3f} seconds || t " + 
        f"||Remaining time: {(avg_time*(n-(i+1))): 4.3f} seconds."

N = 325
t0 = time.time()
for k in range(N):
    # stuff goes here #
    # stuff goes here #
    simple_progress_bar(k, N, t0)
Answered By: Rajesh Nakka

pip install progressbar2


import os
import time
import progressbar 

os.environ['PYCHARM_HOSTED'] = '1' #

class COLOR: #
    YELLOW    = '33[93m'
    GREEN     = '33[92m'
    RED       = '33[91m'
    BOLD      = '33[1m'
    ENDC      = '33[0m'

    'FILE.JSON ',
    COLOR.YELLOW          , progressbar.Percentage()                        , COLOR.ENDC,
    COLOR.RED + COLOR.BOLD, progressbar.Bar(left=' ', marker='━', right=' '), COLOR.ENDC,
    COLOR.YELLOW          , progressbar.Timer()                             , COLOR.ENDC

for i in progressbar.progressbar(range(100), widgets=widgets):
    if i == 99:
        widgets[4] = COLOR.GREEN

Use enumerate(...progressbar(max_value=...) + this in case you want to use it as a download progressbar

Answered By: Giorgos Xou

You can use the rich library, wich has really good terminal styling, including progress bars.
First run the followng command:
pip install rich

Example from docs:

import time
from rich.progress import track

for i in track(range(20), description="Processing..."):
    time.sleep(1)  # Simulate work being done
Answered By: Taitep

With quo (pip install quo) you can add a progress meter to your loops in a second:enter image description here
Check the documentation here

Answered By: Gerrishon Sirere
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.