Barra de progreso de texto en la consola [cerrado]

Escribir '\r' moverá el cursor al principio de la línea.

Esto muestra un contador de porcentajes:

import time
import sys

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

Escribe un \r en la consola. Eso es un "retorno de carro" que hace que todo el texto después de él se haga eco al principio de la línea. Algo como:

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

Que te dará algo como: [ ########## ] 100%

Tqdm: agrega un medidor de progreso a tus bucles en un segundo :

>>> import time
>>> from tqdm import tqdm
>>> for i in tqdm(range(100)):
...     time.sleep(1)
... 
|###-------| 35/100  35% [elapsed: 00:35 left: 01:05,  1.00 iters/sec]

Es menos de 10 líneas de código.

La esencia aquí: 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

Pruebe la biblioteca click escrita por el Mozart de Python, Armin Ronacher.

$ pip install click # both 2 and 3 compatible

Para crear una barra de progreso simple:

import click

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

Esto es lo que parece:

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

Personaliza el contenido de tu corazón:

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

Aspecto personalizado:

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

Hay aún más opciones, consulte los documentos de la 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)

Me doy cuenta de que llego tarde al juego, pero aquí hay un estilo ligeramente Delicioso (Red Hat) que escribí (no voy por 100% de precisión aquí, pero si estás usando una barra de progreso para ese nivel de precisión, entonces estás EQUIVOCADO de todos modos):

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()

Debería producir algo parecido a esto:

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

... donde los soportes permanecen estacionarios y solo aumentan los hashes.

Esto podría funcionar mejor como decorador. Para otro día...

Compruebe esta biblioteca: clint

Tiene muchas características incluyendo una barra de progreso:

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 enlace proporciona una visión general rápida de sus características

Este es un buen ejemplo de una barra de progreso escrita en Python: http://nadiana.com/animated-terminal-progress-bar-in-python

Pero si quieres escribirlo tú mismo. Puedes usar el módulo curses para hacer las cosas más fáciles:)

[editar] Tal vez más fácil no es la palabra para maldiciones. Pero si quieres crear un cui completo que curses se encarga de un montón de cosas para ti.

[editar] Desde que el viejo enlace está muerto he puesto mi propia versión de un Python Progressbar, consíguelo aquí: https://github.com/WoLpH/python-progressbar

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()

Salida

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

Y, solo para agregar a la pila, aquí hay un objeto que puede 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"

Resultados en:

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

Esto se consideraría más comúnmente como "exagerado", pero es útil cuando lo estás usando mucho

Ejecute esto en la línea de comandos de Python (no en ningún IDE o entorno de desarrollo):

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

Funciona bien en mi sistema Windows.

Instalar tqdm.(pip install tqdm) y utilizarlo de la siguiente manera:

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

Eso es una barra de progreso de 10 segundos que producirá algo como esto:

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

• http://code.activestate.com/recipes/168639-progress-bar-class/ (2002)
• http://code.activestate.com/recipes/299207-console-text-progress-indicator-class/ (2004)
• http://pypi.python.org/pypi/progressbar (2006)

Y muchos tutoriales esperando ser googleados.

Estoy usando progreso de reddit. Me gusta porque puede imprimir el progreso de cada elemento en una línea, y no debe borrar las impresiones del programa.

Editar: enlace fijo

Basado en las respuestas anteriores y otras preguntas similares sobre la barra de progreso de CLI, creo que tengo una respuesta general común a todas ellas. Compruébalo en https://stackoverflow.com/a/15860757/2254146

En resumen, el código es 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

Porcentaje: [##########] 99.0%

Recomiendo usar tqdm - https://pypi.python.org/pypi/tqdm - lo que hace que sea sencillo convertir cualquier iterable o proceso en una barra de progreso, y se encarga de todo el juego con los terminales necesarios.

De la documentación: "tqdm puede soportar fácilmente callbacks/hooks y actualizaciones manuales. He aquí un ejemplo con 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)

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

progressbar()

NOTA: si ejecuta esto en interactive interepter, obtendrá números adicionales impresos

Lol acabo de escribir una cosa entera para esto aquí el código tenga en cuenta que no puede usar unicode al hacer bloque ascii yo 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()

Y lo llamas así

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

Así que se ve así

loading something awesome
|█████     |

Con los grandes consejos anteriores, trabajo la barra de progreso.

Sin Embargo, me gustaría señalar algunas deficiencias

1. Cada vez que la barra de progreso se vacía, comenzará en una nueva línea

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

   Así:
   [] 0%
   [#]10%
   [##]20%
   [###]30%

2.El corchete ']' y el número porcentual en el lado derecho cambian a la derecha a medida que el '# # # ' se hace más largo.
3. Se producirá un error si la expresión 'progress / 10' no se puede devolver un entero.

Y el siguiente código solucionará el problema anterior.

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

Código para python terminal progress bar

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()

Juntando algunas de las ideas que encontré aquí, y agregando el tiempo estimado que queda:

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)

Intente instalar este paquete: pip install progressbar2 :

import time
import progressbar

for i in progressbar.progressbar(range(100)):
    time.sleep(0.02)

Progresssbar github: https://github.com/WoLpH/python-progressbar

Una solución muy simple es poner este código en su bucle:

Pon esto en el cuerpo (es decir, arriba) de tu archivo:

import sys

Pon esto en el cuerpo de tu bucle:

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

Bueno, aquí está el código que funciona y lo probé antes de publicarlo:

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()

Ventajas:

• barra de 20 caracteres (1 carácter por cada 5 (número sabio))
• Caracteres de relleno personalizados
• Caracteres vacíos personalizados
• Halt (cualquier número por debajo de 0)
• Hecho (100 y cualquier número por encima de 100)
• Cuenta de progreso (0-100 (abajo y arriba utilizados para funciones especiales))
• Número de porcentaje al lado de la barra, y es un solo línea

Contras:

• Soporta enteros solamente (Puede ser modificado para soportarlos sin embargo, haciendo la división una división entera, así que simplemente cambie prog2 = prog/5 a prog2 = int(prog/5))

Aquí está mi solución de Python 3:

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

'\b' es una barra invertida, para cada carácter en su cadena. Esto no funciona dentro de la ventana cmd de Windows.

Función de 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()

El módulo python progressbar es una buena opción. Aquí está mi 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()

Https://pypi.python.org/pypi/progressbar2/3.30.2

Progressbar2 es una buena biblioteca para ascii base progressbar para la línea de comandos tiempo de importación importar progressbar

bar = progressbar.ProgressBar()
for i in bar(range(100)):
    time.sleep(0.02)
bar.finish()

Https://pypi.python.org/pypi/tqdm

Tqdm es una alternativa de progressbar2 y creo que se usa en pip3 pero no estoy seguro de eso

from tqdm import tqdm
for i in tqdm(range(10000)):
...

Escribí una simple barra de progreso:

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 puede ver, tiene: longitud de la barra, prefijo y sufijo, relleno, espacio, texto en la barra en 100%(oncomp) y bordes

Aquí un ejemplo:

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)

En curso:

30% [######              ]

Salida completa:

100% [   done in 9 sec   ]