Barra de progreso de texto en la consola [cerrado]

Escribí una aplicación de consola simple para cargar y descargar archivos desde un servidor FTP usando ftplib.

Me gustaría que la aplicación muestre cierta visualización de su progreso de descarga / carga para el usuario; cada vez que se descarga un fragmento de datos, me gustaría que proporcione una actualización de progreso, incluso si es solo una representación numérica como un porcentaje.

Es importante destacar que quiero evitar borrar todo el texto que se ha impreso en la consola en líneas anteriores (es decir, no quiero "borrar" todo el terminal mientras imprimo el progreso actualizado).

Esto parece una tarea bastante común: ¿cómo puedo hacer una barra de progreso o una visualización similar que salga a mi consola mientras se preserva la salida anterior del programa?

Una barra de progreso simple y personalizable

Aquí hay un agregado de muchas de las respuestas a continuación que uso regularmente (no se requieren importaciones)

# 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: Esto es para Python 3; vea los comentarios para obtener detalles sobre el uso de esto en Python 2.

Uso de muestra

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)

Salida de muestra:

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

Actualizar

Hubo discusión en los comentarios sobre una opción que permite que la barra de progreso se ajuste dinámicamente al ancho de la ventana del terminal. Si bien no recomiendo esto, aquí hay una idea general que implementa esta característica (y toma nota de las advertencias).

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

Esto muestra un contador de porcentaje:

import time
import sys

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

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]

Escribe un \ra la consola. Es un "retorno de carro" que hace que todo el texto después de que se repita al comienzo de la línea. Algo como:

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

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

Tiene 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 de clics 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 a tu gusto el contenido:

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

Incluso hay 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 poco de estilo Yum (Red Hat) que escribí (no con una precisión del 100% aquí, pero si estás usando una barra de progreso para ese nivel de precisión, entonces tú 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 hash.

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

Mira esta biblioteca: clint

tiene muchas características, incluida 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 descripción general rápida de sus características

Aquí hay 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. Podrías usar el cursesmódulo para facilitar las cosas :)

[editar] Quizás más fácil no es la palabra para maldiciones. Pero si quieres crear un cui completo, las maldiciones se encargan de muchas cosas por ti.

[editar] Dado que el enlace anterior está inactivo, he puesto mi propia versión de una barra de progreso de Python, obténgala 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 puedes 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 comúnmente como "exagerado", pero es útil cuando lo está usando mucho.

Instalar tqdm. ( pip install tqdm) Y usarlo de la siguiente manera:

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

Esa es una barra de progreso de 10 segundos que generará algo como esto:

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

Ejecute esto en la línea de comandos de Python ( no en ningún entorno IDE o 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.

• 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 buscados en Google.

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

Editar: enlace fijo

Intenta instalar este paquete pip install progressbar2:

import time
import progressbar

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

barra de progreso github: https://github.com/WoLpH/python-progressbar

basado en las respuestas anteriores y otras preguntas similares sobre la barra de progreso de la CLI, creo que obtuve una respuesta común general a todas ellas. Compruébelo 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 - que simplifica la conversión de cualquier iterable o proceso en una barra de progreso, y maneja todos los problemas con los terminales necesarios.

De la documentación: "tqdm puede admitir fácilmente devoluciones de llamada / ganchos y actualizaciones manuales. Aquí hay 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)

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

Pon esto en el cuerpo (es decir, la parte superior) 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

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

progressbar()

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

lol, acabo de escribir una cosita completa para esto, aquí está el código, tenga en cuenta que no puede usar Unicode cuando hago bloque ascii, 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í se ve así

loading something awesome
|█████     |

Con los excelentes consejos anteriores, calculo la barra de progreso.

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

1. Cada vez que se vacía la barra de progreso, 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 de porcentaje en el lado derecho se desplazan a la derecha a medida que '###' se alarga.
3. Se producirá un error si la expresión 'progreso / 10' no puede devolver un número 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 la barra de progreso del 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()

Escribí una barra de progreso simple:

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 barra, prefijo y sufijo, relleno, espacio, texto en barra al 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)

fuera en progreso:

30% [######              ]

fuera completo:

100% [   done in 9 sec   ] 

Reuniendo algunas de las ideas que encontré aquí, y sumando el tiempo 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)

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

Bueno, aquí hay un código que funciona y lo probé antes de publicar:

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

Pros:

• Barra de 20 caracteres (1 carácter por cada 5 (número sabio))
• Personajes de relleno personalizados
• Personajes vacíos personalizados
• Detener (cualquier número debajo de 0)
• Listo (100 y cualquier número superior a 100)
• Cuenta de progreso (0-100 (abajo y arriba usado para funciones especiales))
• Número de porcentaje junto a la barra, y es una sola línea

Contras:

• Solo admite números enteros (sin embargo, se puede modificar para admitirlos, haciendo que la división sea una división entera, así que simplemente cambie prog2 = prog/5a prog2 = int(prog/5))

Aquí está mi solución 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()

La barra de progreso del módulo de Python 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()