Barre de progression du texte dans la console [fermé]

J'ai écrit une application console simple pour télécharger et télécharger des fichiers à partir d'un serveur FTP en utilisant le ftplib.

Je voudrais que l'application montre une visualisation de sa progression de téléchargement / téléchargement pour l'utilisateur; chaque fois qu'un morceau de données est téléchargé, je voudrais qu'il fournisse une mise à jour de progression, même si c'est juste une représentation numérique comme un pourcentage.

Surtout, je veux éviter d'effacer tout le texte qui a été imprimé sur la console dans les lignes précédentes (c'est-à-dire que je ne veux pas "effacer" tout le terminal lors de l'impression de la progression mise à jour).

Cela semble une tâche assez courante - comment puis-je faire une barre de progression ou une visualisation similaire qui sort sur ma console tout en préservant la sortie du programme précédent?

Une barre de progression simple et personnalisable

Voici un ensemble de nombreuses réponses ci-dessous que j'utilise régulièrement (aucune importation requise).

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

Remarque: c'est pour Python 3; voir les commentaires pour plus de détails sur l'utilisation de ceci dans Python 2.

Exemple d'utilisation

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)

Exemple de sortie:

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

Mise à jour

Il y a eu une discussion dans les commentaires concernant une option qui permet à la barre de progression de s'adapter dynamiquement à la largeur de la fenêtre du terminal. Bien que je ne le recommande pas, voici un résumé qui implémente cette fonctionnalité (et note les mises en garde).

L'écriture de '\ r' ramènera le curseur au début de la ligne.

Cela affiche un compteur de pourcentage:

import time
import sys

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

tqdm: ajoutez un indicateur de progression à vos boucles en une seconde :

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

Écrivez un \rsur la console. Il s'agit d'un "retour chariot" qui fait écho à tout le texte qui le suit au début de la ligne. Quelque chose comme:

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

ce qui vous donnera quelque chose comme: [ ########## ] 100%

C'est moins de 10 lignes de code.

L'essentiel ici: 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

Essayez la bibliothèque de clics écrite par le Mozart de Python, Armin Ronacher.

$ pip install click # both 2 and 3 compatible

Pour créer une barre de progression simple:

import click

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

Voici à quoi ça ressemble:

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

Personnalisez le contenu de votre cœur:

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

Look personnalisé:

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

Il y a encore plus d'options, consultez la documentation de l' 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)

Je me rends compte que je suis en retard dans le jeu, mais voici un style légèrement Yum (Red Hat) que j'ai écrit (ne recherchant pas une précision de 100% ici, mais si vous utilisez une barre de progression pour ce niveau de précision, alors vous vous avez tort de toute façon):

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

Devrait produire quelque chose ressemblant à ceci:

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

... où les supports restent immobiles et seuls les hachages augmentent.

Cela pourrait mieux fonctionner en tant que décorateur. Pour un autre jour ...

Consultez cette bibliothèque: clint

il possède de nombreuses fonctionnalités dont une barre de progression:

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)

ce lien donne un aperçu rapide de ses fonctionnalités

Voici un bel exemple d'une barre de progression écrite en Python: http://nadiana.com/animated-terminal-progress-bar-in-python

Mais si vous voulez l'écrire vous-même. Vous pouvez utiliser le cursesmodule pour faciliter les choses :)

[modifier] Peut-être plus facile n'est pas le mot pour les malédictions. Mais si vous voulez créer un cui à part entière, curses s'occupe de beaucoup de choses pour vous.

[edit] Puisque l'ancien lien est mort, j'ai mis en place ma propre version d'une barre de progression Python, téléchargez-la ici: 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()

production

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

et, juste pour ajouter à la pile, voici un objet que vous pouvez utiliser

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"

résulte en:

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

Ce serait le plus souvent considéré comme «par-dessus», mais c'est pratique lorsque vous l'utilisez beaucoup

Installez tqdm. ( pip install tqdm) Et utilisez-le comme suit:

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

C'est une barre de progression de 10 secondes qui produira quelque chose comme ceci:

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

Exécutez ceci sur la ligne de commande Python ( pas dans un environnement de développement ou IDE):

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

Fonctionne très bien sur mon système 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)

Et beaucoup de tutoriels attendent d'être googlé.

J'utilise les progrès de reddit . Je l'aime parce qu'il peut imprimer la progression de chaque élément sur une seule ligne, et il ne devrait pas effacer les impressions du programme.

Modifier: lien fixe

Essayez d'installer ce package 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

sur la base des réponses ci-dessus et d'autres questions similaires sur la barre de progression CLI, je pense avoir obtenu une réponse commune générale à toutes. Vérifiez-le sur https://stackoverflow.com/a/15860757/2254146

En résumé, le code est le suivant:

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

Ressemble à

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

Je recommande d'utiliser tqdm - https://pypi.python.org/pypi/tqdm - qui simplifie la transformation de tout itérable ou processus en barre de progression et gère tous les problèmes avec les terminaux nécessaires.

D'après la documentation: "tqdm peut facilement prendre en charge les rappels / hooks et les mises à jour manuelles. Voici un exemple avec 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)

Une solution très simple consiste à mettre ce code dans votre boucle:

Mettez ceci dans le corps (c'est-à-dire en haut) de votre fichier:

import sys

Mettez cela dans le corps de votre boucle:

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

REMARQUE: si vous exécutez cela dans un interepter interactif, vous obtenez des numéros supplémentaires imprimés

lol je viens d'écrire tout un truc pour ceci voici le code gardez à l'esprit que vous ne pouvez pas utiliser unicode lorsque vous faites le bloc ascii j'utilise 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()

et vous l'appelez comme ça

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

donc ça ressemble à ça

loading something awesome
|█████     |

Avec les bons conseils ci-dessus, je travaille sur la barre de progression.

Cependant, je voudrais souligner quelques lacunes

1. Chaque fois que la barre de progression est effacée, elle démarre sur une nouvelle ligne

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

   comme ceci:
   [] 0%
   [#] 10%
   [##] 20%
   [###] 30%

2.Le crochet carré "]" et le pourcentage sur le côté droit se déplacent vers la droite à mesure que le "###" s'allonge.
3. Une erreur se produira si l'expression «progress / 10» ne peut pas renvoyer un entier.

Et le code suivant résoudra le problème ci-dessus.

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

Code pour la barre de progression du 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()

j'ai écrit une barre de progression 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)

comme vous pouvez le voir, il a: longueur de la barre, préfixe et suffixe, remplissage, espace, texte en barre à 100% (oncomp) et bordures

voici un exemple:

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 cours:

30% [######              ]

sur complet:

100% [   done in 9 sec   ] 

Rassembler certaines des idées que j'ai trouvées ici, et ajouter le temps restant estimé:

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)

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

Eh bien voici du code qui fonctionne et je l'ai testé avant de poster:

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

Avantages:

• Barre de 20 caractères (1 caractère pour 5 (nombre))
• Caractères de remplissage personnalisés
• Personnages vides personnalisés
• Arrêter (tout nombre inférieur à 0)
• Terminé (100 et tout nombre supérieur à 100)
• Nombre de progrès (0-100 (ci-dessous et au-dessus utilisés pour les fonctions spéciales))
• Pourcentage à côté de la barre, et c'est une seule ligne

Les inconvénients:

• Ne prend en charge que les entiers (il peut être modifié pour les prendre en charge, en faisant de la division une division entière, il suffit donc de passer prog2 = prog/5à prog2 = int(prog/5))

Voici ma solution Python 3:

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

'\ b' est une barre oblique inverse, pour chaque caractère de votre chaîne. Cela ne fonctionne pas dans la fenêtre cmd de Windows.

fonction de Greenstick pour 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 barre de progression du module python est un bon choix. Voici mon code typique:

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