Texte de la Barre de Progression dans la Console

Voici un agrégat de nombreuses réponses ci-dessous que j'utilise régulièrement.

# Print iterations progress
def printProgressBar (iteration, total, prefix = '', suffix = '', decimals = 1, length = 100, fill = '█'):
    """
    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)
    """
    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 = '\r')
    # Print New Line on Complete
    if iteration == total: 
        print()

Exemple D'Utilisation:

from time import sleep

# 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...
    sleep(0.1)
    # Update Progress Bar
    printProgressBar(i + 1, l, prefix = 'Progress:', suffix = 'Complete', length = 50)

Exemple De Sortie:

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

OriginalL'auteur Greenstick

tqdm: ajouter une barre de progression de vos boucles dans un deuxième:

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

OriginalL'auteur jfs

Il 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

OriginalL'auteur Vladimir Ignatyev

Je me rends compte que je suis en retard pour le jeu, mais voici un peu de Yum-style (Red Hat) celui que j'ai écrit (ne pas aller pour une précision de 100% ici, mais si vous utilisez une barre de progression pour ce niveau de précision, alors 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 qui ressemble à ceci:

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

... où les supports de rester immobile et seul le hachage augmentation.

Ce pourrait mieux travailler comme décorateur. Pour un autre jour...

OriginalL'auteur JoeLinux

Voici un bel exemple d'une progressbar écrit en Python: http://nadiana.com/animated-terminal-progress-bar-in-python

Mais si vous voulez l'écrire vous-même. Vous pouvez utiliser le curses module pour faciliter les choses 🙂

[modifier]
Peut-être plus facile n'est pas la parole de malédictions. Mais si vous voulez créer un véritable cui que les malédictions prend soin de beaucoup de choses pour vous.

[modifier]
Depuis l'ancien lien est mort, j'ai mis en place ma propre version de Python Progressbar, l'obtenir ici: https://github.com/WoLpH/python-progressbar

OriginalL'auteur Wolph

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ésultats dans:

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

Ce serait plus couramment être considéré comme "over the top", mais c'est très pratique lorsque vous êtes en utilisant un lot de

OriginalL'auteur FraggaMuffin

Installer tqdm.(pip install tqdm)
et de l'utiliser comme suit:

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

Que c'est un 10 secondes de la barre de progression qui va de la sortie de quelque chose comme ceci:

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

OriginalL'auteur Tux

Je suis en utilisant les progrès de reddit. Je l'aime parce qu'il peut la progression de l'impression pour chaque élément dans une ligne, et il ne devrait pas effacer les impressions à partir du programme.

Edit: correction du lien

OriginalL'auteur Ib33X

Je recommande d'utiliser tqdm - https://pypi.python.org/pypi/tqdm - ce qui le rend simple pour transformer n'importe quel itérable ou le processus dans une barre de progression, et gère tous les faire du tort à des terminaux nécessaires.

À partir de la documentation: "tqdm peut facilement prendre en charge les rappels/crochets et des 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)

OriginalL'auteur Malcolm Box

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

REMARQUE: si vous exécutez cette interactives interepter vous obtenez plus de numéros imprimés

OriginalL'auteur Ramchandra Apte

Avec les grands conseils ci-dessus je travaille la barre de progression.

Cependant, je tiens à souligner certaines lacunes

1. À chaque fois que la barre de progression est vidé, il va commencer sur une nouvelle ligne

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

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

2.Le crochet ']' et le pourcentage de nombre sur la droite décalage à droite comme le "# # # " obtenir plus.

3. Une erreur se produit si l'expression "progrès /10' ne peut pas retourner un entier.

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

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

OriginalL'auteur Storm-Eyes

Code python terminal barre de progression

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

OriginalL'auteur emd_22

Bien voici le 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()

Pour:

• 20 barre de caractères (1 caractère pour chaque 5 (nombre de sages))
• Personnalisé des caractères de remplissage
• Personnalisé caractères vides
• Arrêter (tout nombre inférieur à 0)
• Fait (100 et un nombre supérieur à 100)
• Progrès count (0-100 (en dessous et au-dessus utilisé pour des fonctions spéciales))
• Certain nombre de pourcentage, à côté du bar, et c'est une seule ligne

Contre:

• Prend en charge des nombres entiers (Il peut être modifié pour prendre en charge eux, bien que, par la division de la division entière, donc il suffit de changer prog2 = prog/5 à prog2 = int(prog/5))

OriginalL'auteur Cold Diamondz

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

OriginalL'auteur Edmond de Martimprey

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

Progressbar2 est une bonne bibliothèque pour ascii de base progressbar pour la ligne de commande
le délai d'importation
importation progressbar

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

https://pypi.python.org/pypi/tqdm

tqdm est une alternative de progressbar2 et je pense que c'utilisation dans pip3 mais je n'en suis pas sûr

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

OriginalL'auteur Antoine Boucher