Python para imprimir barra de status e porcentagem

Para implementar uma barra de status como abaixo:

[==========                ]  45%
[================          ]  60%
[==========================] 100%

Quero que isso seja impresso no stdout e continue atualizando-o, não imprima para outra linha. Como fazer isso?

Há um módulo Python que você pode obter do PyPI chamado progressbarque implementa essa funcionalidade. Se você não se importa em adicionar uma dependência, é uma boa solução. Caso contrário, vá com uma das outras respostas.

Um exemplo simples de como usá-lo:

import progressbar
from time import sleep
bar = progressbar.ProgressBar(maxval=20, \
    widgets=[progressbar.Bar('=', '[', ']'), ' ', progressbar.Percentage()])
bar.start()
for i in xrange(20):
    bar.update(i+1)
    sleep(0.1)
bar.finish()

Para instalá-lo, você pode usar easy_install progressbar, ou pip install progressbarse preferir pip.

O '\r'caractere (retorno de carro) redefine o cursor para o início da linha e permite que você escreva sobre o que estava anteriormente na linha.

from time import sleep
import sys

for i in range(21):
    sys.stdout.write('\r')
    # the exact output you're looking for:
    sys.stdout.write("[%-20s] %d%%" % ('='*i, 5*i))
    sys.stdout.flush()
    sleep(0.25)

Não tenho 100% de certeza se isso é completamente portátil em todos os sistemas, mas funciona no Linux e OSX, pelo menos.

Encontrei a biblioteca útil tqdm ( https://github.com/tqdm/tqdm/ , anteriormente: https://github.com/noamraph/tqdm ). Ele estima automaticamente o tempo de conclusão e pode ser usado como iterador.

Uso:

import tqdm
import time

for i in tqdm.tqdm(range(1000)):
    time.sleep(0.01)
    # or other long operations

Resulta em:

|####------| 450/1000  45% [elapsed: 00:04 left: 00:05, 99.15 iters/sec]

tqdm pode envolver qualquer iterável.

Você pode usar \r( retorno de carro ). Demo:

import sys
total = 10000000
point = total / 100
increment = total / 20
for i in xrange(total):
    if(i % (5 * point) == 0):
        sys.stdout.write("\r[" + "=" * (i / increment) +  " " * ((total - i)/ increment) + "]" +  str(i / point) + "%")
        sys.stdout.flush()

Aqui você pode usar o seguinte código como uma função:

def drawProgressBar(percent, barLen = 20):
    sys.stdout.write("\r")
    progress = ""
    for i in range(barLen):
        if i < int(barLen * percent):
            progress += "="
        else:
            progress += " "
    sys.stdout.write("[ %s ] %.2f%%" % (progress, percent * 100))
    sys.stdout.flush()

Com o uso de .format:

def drawProgressBar(percent, barLen = 20):
    # percent float from 0 to 1. 
    sys.stdout.write("\r")
    sys.stdout.write("[{:<{}}] {:.0f}%".format("=" * int(barLen * percent), barLen, percent * 100))
    sys.stdout.flush()

com base nas respostas acima e em outras perguntas semelhantes sobre a barra de progresso da CLI, acho que recebi uma resposta geral geral para todas elas. Verifique em https://stackoverflow.com/a/15860757/2254146

Aqui está uma cópia da função, mas modificada para se adequar ao seu estilo:

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 = 20 # 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 float\r\n"
    if progress < 0:
        progress = 0
        status = "Halt...\r\n"
    if progress >= 1:
        progress = 1
        status = "Done...\r\n"
    block = int(round(barLength*progress))
    text = "\rPercent: [{0}] {1}% {2}".format( "="*block + " "*(barLength-block), progress*100, status)
    sys.stdout.write(text)
    sys.stdout.flush()

Parece

Porcentagem: [====================] 99,0%

Se você estiver desenvolvendo uma interface de linha de comando, sugiro que você dê uma olhada no clickque é muito bom:

import click
import time

for filename in range(3):
    with click.progressbar(range(100), fill_char='=', empty_char=' ') as bar:
        for user in bar:
            time.sleep(0.01)

Aqui a saída que você obtém:

$ python test.py
  [====================================]  100%
  [====================================]  100%
  [=========                           ]   27%

Melhorando ainda mais, usando uma função como:

import sys

def printProgressBar(i,max,postText):
    n_bar =10 #size of progress bar
    j= i/max
    sys.stdout.write('\r')
    sys.stdout.write(f"[{'=' * int(n_bar * j):{n_bar}s}] {int(100 * j)}%  {postText}")
    sys.stdout.flush()

exemplo de chamada:

total=33
for i in range(total):
    printProgressBar(i,total,"blah")
    sleep(0.05)  

resultado:

[================================================  ] 96%  blah  

Encontrei este tópico hoje e depois de experimentar essa solução da Mark Rushakoff

from time import sleep
import sys

for i in range(21):
sys.stdout.write('\r')
# the exact output you're looking for:
sys.stdout.write("[%-20s] %d%%" % ('='*i, 5*i))
sys.stdout.flush()
sleep(0.25)

Posso dizer que isso funciona bem no W7-64 com o python 3.4.3 de 64 bits, mas apenas no console nativo. No entanto, ao usar o console interno do spyder 3.0.0dev, as quebras de linha ainda estão presentes novamente. Como isso levou algum tempo para descobrir, gostaria de relatar esta observação aqui.

Com base em algumas das respostas aqui e em outros lugares, escrevi essa função simples que exibe uma barra de progresso e o tempo restante decorrido / estimado. Deve funcionar na maioria das máquinas baseadas em unix.

import time
import sys

percent = 50.0
start = time.time()
draw_progress_bar(percent, start)


def draw_progress_bar(percent, start, barLen=20):
sys.stdout.write("\r")
progress = ""
for i in range(barLen):
    if i < int(barLen * percent):
        progress += "="
    else:
        progress += " "

elapsedTime = time.time() - start;
estimatedRemaining = int(elapsedTime * (1.0/percent) - elapsedTime)

if (percent == 1.0):
    sys.stdout.write("[ %s ] %.1f%% Elapsed: %im %02is ETA: Done!\n" % 
        (progress, percent * 100, int(elapsedTime)/60, int(elapsedTime)%60))
    sys.stdout.flush()
    return
else:
    sys.stdout.write("[ %s ] %.1f%% Elapsed: %im %02is ETA: %im%02is " % 
        (progress, percent * 100, int(elapsedTime)/60, int(elapsedTime)%60,
         estimatedRemaining/60, estimatedRemaining%60))
    sys.stdout.flush()
    return

Essa é uma abordagem bastante simples que pode ser usada com qualquer loop.

#!/usr/bin/python
for i in range(100001):
    s =  ((i/5000)*'#')+str(i)+(' %')
    print ('\r'+s),

Mais fácil ainda

import sys
total_records = 1000
for i in range (total_records):
    sys.stdout.write('\rUpdated record: ' + str(i) + ' of ' + str(total_records))
    sys.stdout.flush()

A chave é converter o tipo inteiro em string.

Conforme descrito na solução de Mark Rushakoff , você pode gerar o caractere de retorno de carro sys.stdout.write('\r'), para redefinir o cursor para o início da linha. Para generalizar essa solução, além de implementar as f-Strings do Python 3 , você pode usar

from time import sleep
import sys

n_bar = 50
iterable = range(33)  # for demo purposes
n_iter = len(iterable)
for i, item in enumerate(iterable):
    j = (i + 1) / n_iter

    sys.stdout.write('\r')
    sys.stdout.write(f"[{'=' * int(n_bar * j):{n_bar}s}] {int(100 * j)}%")
    sys.stdout.flush()

    sleep(0.05)  
    # do something with <item> here

Experimente o PyProg. PyProg é uma biblioteca de código aberto para Python para criar barras e indicadores de progresso super personalizáveis.

Atualmente, está na versão 1.0.2; está hospedado no Github e disponível no PyPI (links abaixo). É compatível com Python 3 e 2 e também pode ser usado com o Qt Console.

É realmente fácil de usar. O código a seguir:

import pyprog
from time import sleep

# Create Object
prog = pyprog.ProgressBar(" ", " ", total=34, bar_length=26, complete_symbol="=", not_complete_symbol=" ", wrap_bar_prefix=" [", wrap_bar_suffix="] ", progress_explain="", progress_loc=pyprog.ProgressBar.PROGRESS_LOC_END)
# Update Progress Bar
prog.update()

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

# Make the Progress Bar final
prog.end()

produzirá exatamente o que você deseja (até o comprimento da barra!):

[===========               ] 45%
[===============           ] 60%
[==========================] 100%

Para mais opções para personalizar a barra de progresso, vá para a página Github deste site.

Na verdade, eu criei o PyProg porque precisava de uma biblioteca de barras de progresso simples, mas super personalizável. Você pode facilmente instalá-lo com: pip install pyprog.

PyProg Github: https://github.com/Bill13579/pyprog
PyPI: https://pypi.python.org/pypi/pyprog/

Usando a resposta do @ Mark-Rushakoff, desenvolvi uma abordagem mais simples, sem necessidade de chamar a biblioteca sys. Funciona com o Python 3. Testado no Windows:

from time import sleep
for i in range(21):
    # the exact output you're looking for:
    print ("\r[%-20s] %d%%" % ('='*i, 5*i), end='')
    sleep(0.25)

Aqui está algo que eu fiz usando a solução de @ Mark-Rushakoff. Ajustar adaptativamente à largura do terminal.

from time import sleep
import os
import sys
from math import ceil

l = list(map(int,os.popen('stty size','r').read().split()))
col = l[1]
col = col - 6

for i in range(col):
    sys.stdout.write('\r')
    getStr = "[%s " % ('='*i)
    sys.stdout.write(getStr.ljust(col)+"]"+"%d%%" % (ceil((100/col)*i)))
    sys.stdout.flush()
    sleep(0.25)
print("")