Barra de progresso de texto no console [fechado]


435

Eu escrevi um aplicativo de console simples para carregar e baixar arquivos de um servidor FTP usando o ftplib.

Gostaria que o aplicativo mostrasse alguma visualização do progresso do download / upload para o usuário; sempre que um bloco de dados é baixado, eu gostaria de fornecer uma atualização de progresso, mesmo que seja apenas uma representação numérica como uma porcentagem.

Importante, quero evitar apagar todo o texto que foi impresso no console nas linhas anteriores (ou seja, não quero "limpar" todo o terminal enquanto estiver imprimindo o progresso atualizado).

Essa parece uma tarefa bastante comum - como posso fazer uma barra de progresso ou uma visualização semelhante que seja exibida no meu console, preservando a saída anterior do programa?


Hmm, olhar como um duplicado deste pergunta feita ontem: stackoverflow.com/questions/3160699/python-progress-bar/3162864 Então, você deve usar peixe pypi.python.org/pypi/fish
Etienne

29
"apenas use uma GUI" entende que as GUIs são ótimas em algumas situações (curva de aprendizado rápido, atividades ad-hoc exploratórias ou interativas ou pontuais), enquanto as ferramentas de linha de comando são ótimas para outros (usuários experientes, compondo aplicativos ad-hoc em a mosca para executar uma operação cuidadosamente definido muitas vezes).
Jonathan Hartley

14
Eu votei para reabrir. A questão não me parece muito ampla.
Franck Dernoncourt 26/06

Acho que o que você está procurando é tqdm ... embora eu também não saiba por que o SO está me levando a revisar reabrir votos em perguntas de um ano.
kungphu

Publiquei um novo tipo de barra de progresso, que você pode imprimir, ver taxa de transferência e eta, até pausá-la, além das animações muito legais! Por favor, dê uma olhada: github.com/rsalmei/alive-progress ! viva-progress
rsalmei

Respostas:


464

Uma barra de progresso simples e personalizável

Aqui está um agregado de muitas das respostas abaixo que eu uso regularmente (não são necessárias importações).

# Print iterations progress
def printProgressBar (iteration, total, prefix = '', suffix = '', decimals = 1, length = 100, fill = '█', printEnd = "\r"):
    """
    Call in a loop to create terminal progress bar
    @params:
        iteration   - Required  : current iteration (Int)
        total       - Required  : total iterations (Int)
        prefix      - Optional  : prefix string (Str)
        suffix      - Optional  : suffix string (Str)
        decimals    - Optional  : positive number of decimals in percent complete (Int)
        length      - Optional  : character length of bar (Int)
        fill        - Optional  : bar fill character (Str)
        printEnd    - Optional  : end character (e.g. "\r", "\r\n") (Str)
    """
    percent = ("{0:." + str(decimals) + "f}").format(100 * (iteration / float(total)))
    filledLength = int(length * iteration // total)
    bar = fill * filledLength + '-' * (length - filledLength)
    print('\r%s |%s| %s%% %s' % (prefix, bar, percent, suffix), end = printEnd)
    # Print New Line on Complete
    if iteration == total: 
        print()

Nota: Isto é para Python 3; veja os comentários para obter detalhes sobre como usá-lo no Python 2.

Uso da amostra

import time

# A List of Items
items = list(range(0, 57))
l = len(items)

# Initial call to print 0% progress
printProgressBar(0, l, prefix = 'Progress:', suffix = 'Complete', length = 50)
for i, item in enumerate(items):
    # Do stuff...
    time.sleep(0.1)
    # Update Progress Bar
    printProgressBar(i + 1, l, prefix = 'Progress:', suffix = 'Complete', length = 50)

Saída de amostra:

Progress: |█████████████████████████████████████████████-----| 90.0% Complete

Atualizar

Houve discussão nos comentários sobre uma opção que permite que a barra de progresso se ajuste dinamicamente à largura da janela do terminal. Embora eu não recomendo isso, aqui está uma essência que implementa esse recurso (e observa as advertências).


21
Este trecho funciona muito bem! I fez encontrar um casal pequenas questões, então eu fiz algumas edições menores (PEP-8, codificação padrão para caracteres não-ascii) e os jogou em uma essência aqui: gist.github.com/aubricus/f91fb55dc6ba5557fbab06119420dd6a
Aubricus

3
Vale notar que a declaração UTF-8 não é necessária a menos que seu usando Python 2 @Aubricus
galho verde

2
@MattClimbs Escrito para Python 3, que usa a codificação UTF-8 por padrão. Você pode alterar o parâmetro de preenchimento padrão da função, que é um caractere UTF-8, ou usar a declaração UTF-8. Veja a essência no comentário acima para obter um exemplo de como deve ser uma declaração UTF-8.
galho verde

1
Obrigado, bom resumo, também a detecção do tamanho do terminal pode ser útil, pois esta função # Size of terminal rows, columns = [int(x) for x in os.popen('stty size', 'r').read().split()] columnsdeve ser passada ao comprimento para ajustar o tamanho da barra de progresso à janela do terminal. Embora o comprimento de progredindo parte de barra deve ser diminuída (por comprimento de prefixo, sufixo, por cento e caracteres adicionais nesta cadeia'\r%s |%s| %s%% %s'
Arleg

3
Para que isso funcione em alguns IDEs (por exemplo, PyCharm no Windows), você pode precisar mudar end = '\r'para end = ''.
thomas88wp

312

Escrever '\ r' moverá o cursor de volta ao início da linha.

Isso exibe um contador de porcentagem:

import time
import sys

for i in range(100):
    time.sleep(1)
    sys.stdout.write("\r%d%%" % i)
    sys.stdout.flush()

3
Colou isso e correu. Imprime para uma nova linha de cada vez. Quero que o número seja atualizado na mesma linha. :)
bobber205

8
Este exemplo também produz um OBOB que termina carregando em99%
Glenn Dayton

10
@moose Significa "Off by one bug"
Glenn Dayton


3
Para acrescentar ao que @IoannisFilippidis disse, printtambém tem um flushargumento: docs.python.org/3/library/functions.html#print
Wso


113

Escreva um \rno console. Isso é um "retorno de carro" que faz com que todo o texto depois seja ecoado no início da linha. Algo como:

def update_progress(progress):
    print '\r[{0}] {1}%'.format('#'*(progress/10), progress)

o que lhe dará algo como: [ ########## ] 100%


19
Faça \re escreva a linha inteira novamente. Basicamente: print("\rProgress: [{0:50s}] {1:.1f}%".format('#' * int(amtDone * 50), amtDone * 100)), onde amtDoneé uma flutuação entre 0 e 1.
Mike DeSimone

13
Melhor usar do sys.stdout.writeque print. Com printeu tenho novas linhas.
Gill Bates

14
acrescente uma vírgula ,no final dos printtrabalhos para mim.
Chunliang Lyu

10
em python3 use print (...., end = '') e você não terá nenhuma nova linha #
graywolf

7
Resumindo para python3 ex contribuições: print("\rProgress: [{0:50s}] {1:.1f}%".format('#' * int(workdone * 50), workdone*100), end="", flush=True), onde workdoneé um flutuador entre 0 e 1, por exemplo,workdone = parsed_dirs/total_dirs
khyox

70

É menos de 10 linhas de código.

A essência aqui: https://gist.github.com/vladignatyev/06860ec2040cb497f0f3

import sys


def progress(count, total, suffix=''):
    bar_len = 60
    filled_len = int(round(bar_len * count / float(total)))

    percents = round(100.0 * count / float(total), 1)
    bar = '=' * filled_len + '-' * (bar_len - filled_len)

    sys.stdout.write('[%s] %s%s ...%s\r' % (bar, percents, '%', suffix))
    sys.stdout.flush()  # As suggested by Rom Ruben

insira a descrição da imagem aqui


2
adiciona "sys.stdout.flush ()" ao final da função.
Romruben 07/07/2015

para mim, ele entra em uma nova linha
GM

@GM, qual SO / plataforma você usa?
Vladimir Ignatyev

Não sei por que, se eu executá-lo a partir do spyder ide, ele não funciona, mas se eu executá-lo no console ipython, ele funciona!
GM

62

Experimente a biblioteca de cliques criada pelo Mozart of Python, Armin Ronacher.

$ pip install click # both 2 and 3 compatible

Para criar uma barra de progresso simples:

import click

with click.progressbar(range(1000000)) as bar:
    for i in bar:
        pass 

Isto é o que parece:

# [###-------------------------------]    9%  00:01:14

Personalize para o seu coração o conteúdo:

import click, sys

with click.progressbar(range(100000), file=sys.stderr, show_pos=True, width=70, bar_template='(_(_)=%(bar)sD(_(_| %(info)s', fill_char='=', empty_char=' ') as bar:
    for i in bar:
        pass

Aparência personalizada:

(_(_)===================================D(_(_| 100000/100000 00:00:02

Existem ainda mais opções, consulte os documentos da API :

 click.progressbar(iterable=None, length=None, label=None, show_eta=True, show_percent=None, show_pos=False, item_show_func=None, fill_char='#', empty_char='-', bar_template='%(label)s [%(bar)s] %(info)s', info_sep=' ', width=36, file=None, color=None)

33

Percebo que estou atrasado para o jogo, mas aqui está um que eu escrevi (Red Hat), um pouco Yum (não indo para 100% de precisão aqui, mas se você estiver usando uma barra de progresso para esse nível de precisão, então você de qualquer maneira):

import sys

def cli_progress_test(end_val, bar_length=20):
    for i in xrange(0, end_val):
        percent = float(i) / end_val
        hashes = '#' * int(round(percent * bar_length))
        spaces = ' ' * (bar_length - len(hashes))
        sys.stdout.write("\rPercent: [{0}] {1}%".format(hashes + spaces, int(round(percent * 100))))
        sys.stdout.flush()

Deve produzir algo parecido com isto:

Percent: [##############      ] 69%

... onde os colchetes permanecem estacionários e apenas os hashes aumentam.

Isso pode funcionar melhor como decorador. Por mais um dia ...


2
Ótima solução! Funciona perfeitamente! Muito obrigado!
Vasilije Bursac 23/02

18

Confira esta biblioteca: clint

possui muitos recursos, incluindo uma barra de progresso:

from time import sleep  
from random import random  
from clint.textui import progress  
if __name__ == '__main__':
    for i in progress.bar(range(100)):
        sleep(random() * 0.2)

    for i in progress.dots(range(100)):
        sleep(random() * 0.2)

este link fornece uma visão geral rápida de seus recursos


12

Aqui está um bom exemplo de uma barra de progresso escrita em Python: http://nadiana.com/animated-terminal-progress-bar-in-python

Mas se você quiser escrever você mesmo. Você pode usar o cursesmódulo para facilitar as coisas :)

[editar] Talvez mais fácil não seja a palavra para maldições. Mas se você deseja criar um cui completo, as maldições cuidam de muitas coisas para você.

[edit] Como o link antigo está inoperante, criei minha própria versão de uma barra de progresso Python, obtenha-a aqui: https://github.com/WoLpH/python-progressbar


14
curses? Mais fácil? Hmmm ....
aviraldg

Um excelente artigo, eu estava indo para dar um link para ele, mas não conseguia encontrar em meus favoritos :)
Andy Mikhaylenko

@ Aviral Dasgupta: justo, mais fácil pode não ser a palavra certa aqui. No entanto, você pode economizar muito trabalho, mas realmente depende do que você está procurando.
Wolph

Não estou procurando nada perto disso envolvido, mas obrigado de qualquer maneira. :)
bobber205

2
Dead link, esse é o preço de não postar o conteúdo link'ed em sua resposta -__-
ThorSummoner

11
import time,sys

for i in range(100+1):
    time.sleep(0.1)
    sys.stdout.write(('='*i)+(''*(100-i))+("\r [ %d"%i+"% ] "))
    sys.stdout.flush()

resultado

[29%] ===================


7

e, apenas para adicionar à pilha, aqui está um objeto que você pode usar

import sys

class ProgressBar(object):
    DEFAULT_BAR_LENGTH = 65
    DEFAULT_CHAR_ON  = '='
    DEFAULT_CHAR_OFF = ' '

    def __init__(self, end, start=0):
        self.end    = end
        self.start  = start
        self._barLength = self.__class__.DEFAULT_BAR_LENGTH

        self.setLevel(self.start)
        self._plotted = False

    def setLevel(self, level):
        self._level = level
        if level < self.start:  self._level = self.start
        if level > self.end:    self._level = self.end

        self._ratio = float(self._level - self.start) / float(self.end - self.start)
        self._levelChars = int(self._ratio * self._barLength)

    def plotProgress(self):
        sys.stdout.write("\r  %3i%% [%s%s]" %(
            int(self._ratio * 100.0),
            self.__class__.DEFAULT_CHAR_ON  * int(self._levelChars),
            self.__class__.DEFAULT_CHAR_OFF * int(self._barLength - self._levelChars),
        ))
        sys.stdout.flush()
        self._plotted = True

    def setAndPlot(self, level):
        oldChars = self._levelChars
        self.setLevel(level)
        if (not self._plotted) or (oldChars != self._levelChars):
            self.plotProgress()

    def __add__(self, other):
        assert type(other) in [float, int], "can only add a number"
        self.setAndPlot(self._level + other)
        return self
    def __sub__(self, other):
        return self.__add__(-other)
    def __iadd__(self, other):
        return self.__add__(other)
    def __isub__(self, other):
        return self.__add__(-other)

    def __del__(self):
        sys.stdout.write("\n")

if __name__ == "__main__":
    import time
    count = 150
    print "starting things:"

    pb = ProgressBar(count)

    #pb.plotProgress()
    for i in range(0, count):
        pb += 1
        #pb.setAndPlot(i + 1)
        time.sleep(0.01)
    del pb

    print "done"

resulta em:

starting things:
  100% [=================================================================]
done

Geralmente, isso é considerado "exagerado", mas é útil quando você o usa muito


Obrigado por isso. Pequena correção, o método plotProgress deve usar a linha sys.stdout.flush (), caso contrário a barra de progresso poderá não ser desenhada até que a tarefa seja concluída (como ocorre no terminal mac).
Osnoz 04/12/2014

Eu amo isto!!! Bastante fácil de usar !!! Obrigado
Microos

7

Instale tqdm. ( pip install tqdm) E use-o da seguinte maneira:

import time
from tqdm import tqdm
for i in tqdm(range(1000)):
    time.sleep(0.01)

Essa é uma barra de progresso de 10 segundos que produzirá algo como isto:

47%|██████████████████▊                     | 470/1000 [00:04<00:05, 98.61it/s]

6

Execute isso na linha de comando Python ( não em qualquer ambiente de desenvolvimento ou IDE):

>>> import threading
>>> for i in range(50+1):
...   threading._sleep(0.5)
...   print "\r%3d" % i, ('='*i)+('-'*(50-i)),

Funciona bem no meu sistema Windows.



4

Estou usando o progresso do reddit . Gosto porque ele pode imprimir o progresso de cada item em uma linha e não deve apagar as impressões do programa.

Editar: link fixo


1
Seu link está quebrado - a linha real no código-fonte é 1274, não a 1124! Portanto, o link correto é este: github.com/reddit/reddit/blob/master/r2/r2/lib/utils/…
Vladimir Ignatyev

Essa variante tem o melhor design para o meu gosto: usa iteradores e funciona possivelmente com qualquer tipo de trabalho mensurável, mostra o tempo decorrido.
Vladimir Ignatyev

3

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

Em resumo, o código é este:

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 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%


3

Eu recomendo usar o tqdm - https://pypi.python.org/pypi/tqdm - que simplifica transformar qualquer iterável ou processo em uma barra de progresso e lida com toda a bagunça nos terminais necessários.

Na documentação: "O tqdm pode facilmente suportar retornos de chamada / ganchos e atualizações manuais. Veja um exemplo com o urllib"

import urllib
from tqdm import tqdm

def my_hook(t):
  """
  Wraps tqdm instance. Don't forget to close() or __exit__()
  the tqdm instance once you're done with it (easiest using `with` syntax).

  Example
  -------

  >>> with tqdm(...) as t:
  ...     reporthook = my_hook(t)
  ...     urllib.urlretrieve(..., reporthook=reporthook)

  """
  last_b = [0]

  def inner(b=1, bsize=1, tsize=None):
    """
    b  : int, optional
        Number of blocks just transferred [default: 1].
    bsize  : int, optional
        Size of each block (in tqdm units) [default: 1].
    tsize  : int, optional
        Total size (in tqdm units). If [default: None] remains unchanged.
    """
    if tsize is not None:
        t.total = tsize
    t.update((b - last_b[0]) * bsize)
    last_b[0] = b
  return inner

eg_link = 'http://www.doc.ic.ac.uk/~cod11/matryoshka.zip'
with tqdm(unit='B', unit_scale=True, miniters=1,
          desc=eg_link.split('/')[-1]) as t:  # all optional kwargs
    urllib.urlretrieve(eg_link, filename='/dev/null',
                       reporthook=my_hook(t), data=None)


3

Uma solução muito simples é colocar esse código em seu loop:

Coloque isso no corpo (ou seja, no topo) do seu arquivo:

import sys

Coloque isso no corpo do seu loop:

sys.stdout.write("-") # prints a dash for each iteration of loop
sys.stdout.flush() # ensures bar is displayed incrementally

2
import sys
def progresssbar():
         for i in range(100):
            time.sleep(1)
            sys.stdout.write("%i\r" % i)

progressbar()

OBSERVAÇÃO: se você executar isso no interceptador interativo, obterá números extras impressos


2

lol eu acabei de escrever uma coisa toda para isso aqui está o código tenha em mente que você não pode usar unicode ao fazer bloco ascii eu uso cp437

import os
import time
def load(left_side, right_side, length, time):
    x = 0
    y = ""
    print "\r"
    while x < length:
        space = length - len(y)
        space = " " * space
        z = left + y + space + right
        print "\r", z,
        y += "█"
        time.sleep(time)
        x += 1
    cls()

e você chama assim

print "loading something awesome"
load("|", "|", 10, .01)

então fica assim

loading something awesome
|█████     |

2

Com os ótimos conselhos acima, elaboro a barra de progresso.

No entanto, gostaria de salientar algumas deficiências

  1. Toda vez que a barra de progresso é liberada, ela inicia em uma nova linha

    print('\r[{0}]{1}%'.format('#' * progress* 10, progress))  

    assim:
    [] 0%
    [#] 10%
    [##] 20%
    [###] 30%

2.O colchete ']' e o número da porcentagem no lado direito mudam para a direita à medida que o '###' fica mais longo.
3. Ocorrerá um erro se a expressão 'progress / 10' não puder retornar um número inteiro.

E o código a seguir irá corrigir o problema acima.

def update_progress(progress, total):  
    print('\r[{0:10}]{1:>2}%'.format('#' * int(progress * 10 /total), progress), end='')

1

Código para barra de progresso do terminal python

import sys
import time

max_length = 5
at_length = max_length
empty = "-"
used = "%"

bar = empty * max_length

for i in range(0, max_length):
    at_length -= 1

    #setting empty and full spots
    bar = used * i
    bar = bar+empty * at_length

    #\r is carriage return(sets cursor position in terminal to start of line)
    #\0 character escape

    sys.stdout.write("[{}]\0\r".format(bar))
    sys.stdout.flush()

    #do your stuff here instead of time.sleep
    time.sleep(1)

sys.stdout.write("\n")
sys.stdout.flush()

1

eu escrevi uma barra de progresso simples:

def bar(total, current, length=10, prefix="", filler="#", space=" ", oncomp="", border="[]", suffix=""):
    if len(border) != 2:
        print("parameter 'border' must include exactly 2 symbols!")
        return None

    print(prefix + border[0] + (filler * int(current / total * length) +
                                      (space * (length - int(current / total * length)))) + border[1], suffix, "\r", end="")
    if total == current:
        if oncomp:
            print(prefix + border[0] + space * int(((length - len(oncomp)) / 2)) +
                  oncomp + space * int(((length - len(oncomp)) / 2)) + border[1], suffix)
        if not oncomp:
            print(prefix + border[0] + (filler * int(current / total * length) +
                                        (space * (length - int(current / total * length)))) + border[1], suffix)

como você pode ver, ele possui: comprimento da barra, prefixo e sufixo, preenchimento, espaço, texto na barra em 100% (oncomp) e bordas

aqui um exemplo:

from time import sleep, time
start_time = time()
for i in range(10):
    pref = str((i+1) * 10) + "% "
    complete_text = "done in %s sec" % str(round(time() - start_time))
    sleep(1)
    bar(10, i + 1, length=20, prefix=pref, oncomp=complete_text)

em andamento:

30% [######              ]

em completo:

100% [   done in 9 sec   ] 

1

Reunindo algumas das idéias que encontrei aqui e adicionando tempo estimado restante:

import datetime, sys

start = datetime.datetime.now()

def print_progress_bar (iteration, total):

    process_duration_samples = []
    average_samples = 5

    end = datetime.datetime.now()

    process_duration = end - start

    if len(process_duration_samples) == 0:
        process_duration_samples = [process_duration] * average_samples

    process_duration_samples = process_duration_samples[1:average_samples-1] + [process_duration]
    average_process_duration = sum(process_duration_samples, datetime.timedelta()) / len(process_duration_samples)
    remaining_steps = total - iteration
    remaining_time_estimation = remaining_steps * average_process_duration

    bars_string = int(float(iteration) / float(total) * 20.)
    sys.stdout.write(
        "\r[%-20s] %d%% (%s/%s) Estimated time left: %s" % (
            '='*bars_string, float(iteration) / float(total) * 100,
            iteration,
            total,
            remaining_time_estimation
        ) 
    )
    sys.stdout.flush()
    if iteration + 1 == total:
        print 


# Sample usage

for i in range(0,300):
    print_progress_bar(i, 300)

1

Para python 3:

def progress_bar(current_value, total):
    increments = 50
    percentual = ((current_value/ total) * 100)
    i = int(percentual // (100 / increments ))
    text = "\r[{0: <{1}}] {2}%".format('=' * i, increments, percentual)
    print(text, end="\n" if percentual == 100 else "")

0

Bem, aqui está o código que funciona e eu testei antes de postar:

import sys
def prg(prog, fillchar, emptchar):
    fillt = 0
    emptt = 20
    if prog < 100 and prog > 0:
        prog2 = prog/5
        fillt = fillt + prog2
        emptt = emptt - prog2
        sys.stdout.write("\r[" + str(fillchar)*fillt + str(emptchar)*emptt + "]" + str(prog) + "%")
        sys.stdout.flush()
    elif prog >= 100:
        prog = 100
        prog2 = prog/5
        fillt = fillt + prog2
        emptt = emptt - prog2
        sys.stdout.write("\r[" + str(fillchar)*fillt + str(emptchar)*emptt + "]" + str(prog) + "%" + "\nDone!")
        sys.stdout.flush()
    elif prog < 0:
        prog = 0
        prog2 = prog/5
        fillt = fillt + prog2
        emptt = emptt - prog2
        sys.stdout.write("\r[" + str(fillchar)*fillt + str(emptchar)*emptt + "]" + str(prog) + "%" + "\nHalted!")
        sys.stdout.flush()

Prós:

  • Barra de 20 caracteres (1 caractere para cada 5 (número))
  • Caracteres de preenchimento personalizados
  • Caracteres vazios personalizados
  • Parar (qualquer número abaixo de 0)
  • Concluído (100 e qualquer número acima de 100)
  • Contagem de progresso (0-100 (abaixo e acima usado para funções especiais))
  • Número percentual ao lado da barra e é uma única linha

Contras:

  • Suporta apenas números inteiros (embora possa ser modificado para suportá-los, tornando a divisão uma divisão inteira, basta alterar prog2 = prog/5para prog2 = int(prog/5))

0

Aqui está a minha solução Python 3:

import time
for i in range(100):
    time.sleep(1)
    s = "{}% Complete".format(i)
    print(s,end=len(s) * '\b')

'\ b' é uma barra invertida, para cada caractere em sua string. Isso não funciona na janela do cmd do Windows.


0

função do Greenstick para 2.7:

def printProgressBar (iteration, total, prefix = '', suffix = '',decimals = 1, length = 100, fill = '#'):

percent = ("{0:." + str(decimals) + "f}").format(100 * (iteration / float(total)))
filledLength = int(length * iteration // total)
bar = fill * filledLength + '-' * (length - filledLength)
print'\r%s |%s| %s%% %s' % (prefix, bar, percent, suffix),
sys.stdout.flush()
# Print New Line on Complete                                                                                                                                                                                                              
if iteration == total:
    print()

0

A barra de progresso do módulo python é uma ótima opção. Aqui está o meu código típico:

import time
import progressbar

widgets = [
    ' ', progressbar.Percentage(),
    ' ', progressbar.SimpleProgress(format='(%(value_s)s of %(max_value_s)s)'),
    ' ', progressbar.Bar('>', fill='.'),
    ' ', progressbar.ETA(format_finished='- %(seconds)s  -', format='ETA: %(seconds)s', ),
    ' - ', progressbar.DynamicMessage('loss'),
    ' - ', progressbar.DynamicMessage('error'),
    '                          '
]

bar = progressbar.ProgressBar(redirect_stdout=True, widgets=widgets)
bar.start(100)
for i in range(100):
    time.sleep(0.1)
    bar.update(i + 1, loss=i / 100., error=i)
bar.finish()
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.