Barra di avanzamento del testo nella console [chiusa]

Ho scritto una semplice app console per caricare e scaricare file da un server FTP utilizzando ftplib.

Vorrei che l'app mostrasse una visualizzazione dei suoi progressi di download / upload per l'utente; ogni volta che viene scaricato un blocco di dati, vorrei che fornisse un aggiornamento sui progressi, anche se è solo una rappresentazione numerica come una percentuale.

È importante sottolineare che voglio evitare di cancellare tutto il testo che è stato stampato sulla console nelle righe precedenti (cioè non voglio "cancellare" l'intero terminale mentre stampo l'avanzamento aggiornato).

Questo sembra un compito abbastanza comune: come posso fare per fare una barra di avanzamento o una visualizzazione simile che emetta sulla mia console preservando l'output del programma precedente?

Una barra di avanzamento semplice e personalizzabile

Ecco un aggregato di molte delle risposte di seguito che uso regolarmente (non sono necessarie importazioni).

# 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: questo è per Python 3; vedere i commenti per i dettagli sull'uso di questo in Python 2.

Esempio di utilizzo

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)

Uscita campione:

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

Aggiornare

Si è discusso nei commenti riguardo a un'opzione che consente alla barra di avanzamento di adattarsi dinamicamente alla larghezza della finestra del terminale. Anche se non lo consiglio, ecco un riassunto che implementa questa funzione (e osserva le avvertenze).

Scrivere '\ r' riporta il cursore all'inizio della riga.

Questo visualizza un contatore percentuale:

import time
import sys

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

tqdm: aggiungi un indicatore di progresso ai tuoi loop in un secondo :

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

Scrivi \ra sulla console. Questo è un "ritorno a capo" che fa eco a tutto il testo dopo di esso all'inizio della riga. Qualcosa di simile a:

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

che ti darà qualcosa del tipo: [ ########## ] 100%

È inferiore a 10 righe di codice.

L'essenza qui: 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

Prova la libreria di clic scritta dal Mozart di Python, Armin Ronacher.

$ pip install click # both 2 and 3 compatible

Per creare una semplice barra di avanzamento:

import click

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

Ecco come appare:

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

Personalizza il contenuto del tuo cuore:

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

Aspetto personalizzato:

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

Ci sono anche più opzioni, vedi i documenti 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)

Mi rendo conto di essere in ritardo al gioco, ma eccone uno in stile leggermente Yum (Red Hat) che ho scritto (non andando per la precisione del 100% qui, ma se stai usando una barra di avanzamento per quel livello di precisione, allora tu comunque SBAGLIATO):

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

Dovrebbe produrre qualcosa di simile a questo:

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

... dove le parentesi rimangono fisse e aumentano solo gli hash.

Questo potrebbe funzionare meglio come decoratore. Per un altro giorno ...

Controlla questa libreria: clint

ha molte funzionalità tra cui una barra di avanzamento:

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)

questo link fornisce una rapida panoramica delle sue funzionalità

Ecco un bell'esempio di una barra di avanzamento scritta in Python: http://nadiana.com/animated-terminal-progress-bar-in-python

Ma se vuoi scriverlo da solo. È possibile utilizzare il cursesmodulo per semplificare le cose :)

[modifica] Forse più facile non è la parola maledizioni. Ma se vuoi creare un vero e proprio che maledizioni si prende cura di molte cose per te.

[modifica] Dato che il vecchio link è morto, ho creato la mia versione di una Python Progressbar, scaricala qui: 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()

produzione

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

e, solo per aggiungere alla pila, ecco un oggetto che puoi usare

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"

risulta in:

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

Questo sarebbe comunemente considerato "esagerato", ma è utile quando lo usi molto

Installa tqdm. ( pip install tqdm) E utilizzalo come segue:

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

Questa è una barra di avanzamento di 10 secondi che genererà qualcosa del genere:

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

Eseguilo dalla riga di comando di Python ( non in alcun IDE o ambiente di sviluppo):

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

Funziona bene sul mio 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)

E molti tutorial in attesa di essere cercati su Google.

Sto usando i progressi da reddit . Mi piace perché può stampare i progressi per ogni elemento in una riga e non dovrebbe cancellare le stampe dal programma.

Modifica: collegamento fisso

Prova a installare questo pacchetto 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

sulla base delle risposte di cui sopra e di altre domande simili sulla barra di avanzamento della CLI, penso di avere una risposta comune generale a tutte. Controllalo su https://stackoverflow.com/a/15860757/2254146

In sintesi, il codice è questo:

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

Sembra

Percentuale: [##########] 99,0%

Consiglio di usare tqdm - https://pypi.python.org/pypi/tqdm - che semplifica la trasformazione di qualsiasi iterabile o processo in una barra di avanzamento e gestisce tutti i problemi con i terminali necessari.

Dalla documentazione: "tqdm può facilmente supportare callback / hook e aggiornamenti manuali. Ecco un esempio 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 soluzione molto semplice è quella di inserire questo codice nel tuo ciclo:

Metti questo nel corpo (cioè in alto) del tuo file:

import sys

Metti questo nel corpo del tuo loop:

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: se si esegue questo nell'interfaccia interattiva si ottengono i numeri extra stampati

lol ho appena scritto una cosa intera per questo qui il codice tieni a mente che non puoi usare unicode quando faccio blocco ascii io 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 lo chiami così

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

quindi sembra così

loading something awesome
|█████     |

Con i grandi consigli di cui sopra, elaborerò la barra di avanzamento.

Tuttavia, vorrei sottolineare alcune carenze

1. Ogni volta che la barra di avanzamento viene svuotata, si avvierà su una nuova riga

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

   in questo modo:
   [] 0%
   [#] 10%
   [##] 20%
   [###] 30%

2.La parentesi quadra ']' e il numero percentuale sul lato destro si spostano a destra man mano che '###' si allunga.
3. Si verificherà un errore se l'espressione 'progress / 10' non può restituire un numero intero.

E il seguente codice risolverà il problema sopra.

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

Codice per la barra di avanzamento del terminale 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()

ho scritto una semplice barra di avanzamento:

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)

come puoi vedere, ha: lunghezza della barra, prefisso e suffisso, riempimento, spazio, testo nella barra al 100% (oncomp) e bordi

qui un esempio:

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)

fuori in corso:

30% [######              ]

fuori completo:

100% [   done in 9 sec   ] 

Mettendo insieme alcune delle idee che ho trovato qui e aggiungendo il tempo rimanente stimato:

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)

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

Bene, ecco il codice che funziona e l'ho testato prima di pubblicare:

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

Professionisti:

• 20 barra dei caratteri (1 carattere per ogni 5 (in base al numero))
• Caratteri di riempimento personalizzati
• Personaggi vuoti personalizzati
• Halt (qualsiasi numero inferiore a 0)
• Fatto (100 e qualsiasi numero superiore a 100)
• Conteggio dei progressi (0-100 (inferiore e superiore utilizzato per funzioni speciali))
• Numero percentuale accanto alla barra ed è una riga singola

Contro:

• Supporta solo numeri interi (può essere modificato per supportarli, trasformando la divisione in divisione di numeri interi, quindi basta cambiare prog2 = prog/5in prog2 = int(prog/5))

Ecco la mia soluzione Python 3:

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

'\ b' è una barra rovesciata, per ogni carattere nella tua stringa. Questo non funziona all'interno della finestra cmd di Windows.

funzione di Greenstick per 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 di avanzamento del modulo python è una buona scelta. Ecco il mio codice tipico:

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