Barra de progreso de texto en la consola [cerrado]

435

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?

bobber205
fuente
Hmm, parece un duplicado de esta pregunta que se hizo ayer: stackoverflow.com/questions/3160699/python-progress-bar/3162864 Entonces, debes usar fish pypi.python.org/pypi/fish
Etienne
29
"solo use una GUI" no comprende que las GUI son excelentes en algunas situaciones (curva de aprendizaje rápido, exploración ad-hoc o actividades interactivas o puntuales) mientras que las herramientas de línea de comandos son excelentes para otros (usuarios expertos, componiendo aplicaciones ad-hoc en la mosca para realizar una operación cuidadosamente definida muchas veces.)
Jonathan Hartley
14
Voté para reabrir. La pregunta no me parece demasiado amplia.
Franck Dernoncourt el
Creo que lo que estás buscando es tqdm ... aunque tampoco sé por qué SO me está impulsando a volver a abrir los votos en preguntas de hace un año.
kungphu
¡He publicado un nuevo tipo de barra de progreso, que puedes imprimir, ver el rendimiento y el eta, incluso pausarlo, además de las animaciones geniales! Por favor, eche un vistazo: github.com/rsalmei/alive-progress !
live

Respuestas:

465

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

Tallo verde
fuente
21
¡Este fragmento funciona muy bien! Encontré un par de problemas menores, así que realicé algunas ediciones menores (PEP-8, codificación predeterminada para caracteres que no son ascii) y las arrojé en un resumen
Aubricus el
3
Vale la pena señalar que la declaración UTF-8 no es necesaria a menos que use Python 2 @Aubricus
Greenstick el
2
@MattClimbs Esto está escrito para Python 3 que usa la codificación UTF-8 de manera predeterminada. Puede cambiar el parámetro de relleno predeterminado de la función, que es un carácter UTF-8, o usar la declaración UTF-8. Vea la esencia en el comentario anterior para ver un ejemplo de cómo debería ser una declaración UTF-8.
Greenstick
1
Gracias, resumen agradable, también la detección del tamaño del terminal podría ser útil para esta función que # Size of terminal rows, columns = [int(x) for x in os.popen('stty size', 'r').read().split()] columnsdebería pasarse a la longitud para ajustar el tamaño de la barra de progreso a la ventana del terminal. Aunque la longitud de la parte progresiva de la barra debe reducirse (por la longitud del prefijo, sufijo, porcentaje y caracteres adicionales en esta cadena'\r%s |%s| %s%% %s'
Arleg
3
Para que esto funcione en algunos IDEs (por ejemplo, PyCharm en Windows), es posible que deba cambiar end = '\r'a end = ''.
thomas88wp
312

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()
Stephen
fuente
3
Pegó eso y corrió. Se imprime en una nueva línea cada vez. Quiero que el número se actualice en la misma línea. :)
bobber205
8
Este ejemplo también produce un OBOB en el que termina de cargarse99%
Glenn Dayton
10
@moose Significa "Off by one bug"
Glenn Dayton
3
printtiene un endargumento: stackoverflow.com/a/8436827/1959808
Ioannis Filippidis
3
Para agregar a lo que @IoannisFilippidis dijo, printtambién tiene un flushargumento: docs.python.org/3/library/functions.html#print
Wso
113

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%

aviraldg
fuente
19
Haga \ry luego escriba toda la línea nuevamente. Básicamente: ¿ print("\rProgress: [{0:50s}] {1:.1f}%".format('#' * int(amtDone * 50), amtDone * 100))dónde amtDonehay un flotador entre 0 y 1.
Mike DeSimone
13
Mejor usar sys.stdout.writeque print. Con printtengo nuevas líneas.
Gill Bates
14
agregue una coma ,al final de los printtrabajos para mí.
Chunliang Lyu
10
en python3 use print (...., end = '') y no tendrá nuevas líneas
graywolf
77
Resumiendo para las contribuciones anteriores de Python3: print("\rProgress: [{0:50s}] {1:.1f}%".format('#' * int(workdone * 50), workdone*100), end="", flush=True)donde workdonees un flotante entre 0 y 1, por ejemplo,workdone = parsed_dirs/total_dirs
khyox
70

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

ingrese la descripción de la imagen aquí

Vladimir Ignatyev
fuente
2
agrega "sys.stdout.flush ()" al final de la función.
romruben
para mí va en una nueva línea
GM
@GM, ¿qué sistema operativo / plataforma utiliza?
Vladimir Ignatyev
No sé por qué si lo ejecuto desde spyder ide no funciona, pero si lo ejecuto desde la consola ipython, ¡funciona!
GM
62

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)
El gato no divertido
fuente
33

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

JoeLinux
fuente
2
¡Gran solución! ¡Funciona perfectamente! ¡Muchas gracias!
Vasilije Bursac
18

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

guiones
fuente
12

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

Wolph
fuente
14
curses? ¿Más fácil? Hmmm ....
aviraldg
Un excelente artículo, iba a darle un enlace, pero no pude encontrarlo en mis marcadores :)
Andy Mikhaylenko
@Aviral Dasgupta: bastante justo, más fácil podría no ser la palabra correcta aquí. Sin embargo, puede ahorrarle mucho trabajo, pero realmente depende de lo que esté buscando.
Wolph el
No busco nada cerca de esto, pero gracias de todos modos. :)
bobber205
2
Enlace inactivo, ese es el precio de no publicar el contenido vinculado en su respuesta -__-
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()

salida

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

ashish2py
fuente
7

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.

FraggaMuffin
fuente
Gracias por esto. Pequeña corrección, el método plotProgress debería usar la línea sys.stdout.flush () de lo contrario, la barra de progreso podría no dibujarse hasta que se haya completado la tarea (como ocurre en el terminal mac).
osnoz
¡¡¡Me encanta esto!!! Bastante fácil de usar! Gracias
Microos
7

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]
Tux
fuente
6

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.

PaulMcG
fuente
4

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

Ib33X
fuente
1
Su enlace está roto: ¡la línea real en el código fuente es la 1274a, no la 1124a! Entonces, el enlace correcto es este: github.com/reddit/reddit/blob/master/r2/r2/lib/utils/…
Vladimir Ignatyev
Esta variante tiene el mejor diseño a mi gusto: utiliza iteradores y posiblemente funciona con cualquier tipo de trabajo medible, muestra el tiempo transcurrido.
Vladimir Ignatyev
3

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%

Brian Khuu
fuente
3

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)
Caja Malcolm
fuente
3

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
Richard Hayman-Joyce
fuente
2
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

Ramchandra Apte
fuente
2

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
|█████     |
Ryan
fuente
2

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='')
Ojos de tormenta
fuente
1

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()
emd_22
fuente
1

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   ] 
jenkins
fuente
1

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)
Ivan Chaer
fuente
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 "")
Rodrigo López
fuente
0

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))
Cold Diamondz
fuente
0

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.

Matt-the-Bat
fuente
0

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()
Edmond de Martimprey
fuente
0

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()
Aimin Huang
fuente