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

435

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?

bobber205
la source
Hmm, ressemble à un double de cette question posée hier: stackoverflow.com/questions/3160699/python-progress-bar/3162864 Donc, vous devriez utiliser fish pypi.python.org/pypi/fish
Etienne
29
«utilisez simplement une interface graphique» méconnaît que les interfaces graphiques sont excellentes dans certaines situations (courbe d'apprentissage rapide, activités exploratoires ou interactives ad-hoc ou ponctuelles) alors que les outils de ligne de commande sont excellents pour les autres (utilisateurs experts, composition d'applications ad hoc sur à la volée pour effectuer plusieurs fois une opération soigneusement définie.)
Jonathan Hartley
14
J'ai voté pour la réouverture. La question ne me semble pas trop large.
Franck Dernoncourt
Je pense que ce que vous recherchez est tqdm ... bien que je ne sache pas non plus pourquoi SO m'incite à revoir les votes de réouverture sur des questions vieilles d'un an.
kungphu
J'ai publié un nouveau type de barre de progression, que vous pouvez imprimer, voir le débit et eta, même la mettre en pause, en plus des animations très cool! Veuillez jeter un œil: github.com/rsalmei/alive-progress ! alive-progress
rsalmei

Réponses:

465

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

Greenstick
la source
21
Cet extrait fonctionne très bien! J'ai rencontré quelques problèmes mineurs, j'ai donc apporté quelques modifications mineures (PEP-8, encodage par défaut pour les caractères non ascii) et les ai
Aubricus
3
Il convient de noter que la déclaration UTF-8 n'est pas nécessaire, sauf si vous utilisez Python 2 @Aubricus
Greenstick
2
@MattClimbs Ceci est écrit pour Python 3 qui utilise le codage UTF-8 par défaut. Vous pouvez soit modifier le paramètre de remplissage par défaut de la fonction, qui est un caractère UTF-8, soit utiliser la déclaration UTF-8. Voir l'essentiel dans le commentaire ci-dessus pour un exemple de ce à quoi une déclaration UTF-8 devrait ressembler.
Greenstick le
1
Merci, beau résumé, la détection de la taille du terminal pourrait également être utile car cette fonction # Size of terminal rows, columns = [int(x) for x in os.popen('stty size', 'r').read().split()] columnsdevrait être passée à la longueur pour ajuster la taille de la barre de progression à la fenêtre du terminal. Bien que la longueur de la partie de la barre qui progresse devrait être réduite (par la longueur du préfixe, du suffixe, du pourcentage et des caractères supplémentaires dans cette chaîne'\r%s |%s| %s%% %s'
Arleg
3
Pour que cela fonctionne dans certains IDE (par exemple PyCharm sous Windows), vous devrez peut-être passer end = '\r'à end = ''.
thomas88wp
312

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()
Stephen
la source
3
Collé et couru. Il imprime sur une nouvelle ligne à chaque fois. Je veux que le numéro soit mis à jour sur la même ligne. :)
bobber205
8
Cet exemple produit également un OBOB dont le chargement se termine à99%
Glenn Dayton
10
@moose Il signifie "Off by one bug"
Glenn Dayton
3
printa un endargument: stackoverflow.com/a/8436827/1959808
Ioannis Filippidis
3
Pour ajouter à ce que @IoannisFilippidis a dit, a printégalement un flushargument: docs.python.org/3/library/functions.html#print
Wso
113

É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%

aviraldg
la source
19
Faites \r, puis réécrivez la ligne entière. Fondamentalement:, print("\rProgress: [{0:50s}] {1:.1f}%".format('#' * int(amtDone * 50), amtDone * 100))amtDoneest un flotteur entre 0 et 1.
Mike DeSimone
13
Mieux vaut utiliser sys.stdout.writeque print. Avec, printj'ai des nouvelles lignes.
Gill Bates
14
ajouter une virgule ,à la fin des printtravaux pour moi.
Chunliang Lyu
10
en python3 utilisez print (...., end = '') et vous n'aurez aucune nouvelle ligne
graywolf
7
Résumé pour les anciennes contributions Python3:, print("\rProgress: [{0:50s}] {1:.1f}%".format('#' * int(workdone * 50), workdone*100), end="", flush=True)workdoneest un flottant entre 0 et 1, par exemple,workdone = parsed_dirs/total_dirs
khyox
70

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

entrez la description de l'image ici

Vladimir Ignatyev
la source
2
ajoute "sys.stdout.flush ()" à la fin de la fonction.
romruben
pour moi, il va dans une nouvelle ligne
GM
@GM quel OS / plateforme utilisez-vous?
Vladimir Ignatyev
Je ne sais pas pourquoi si je l'exécute à partir de spyder, cela ne fonctionne pas, mais si je l'exécute à partir de la console ipython, cela fonctionne!
GM
62

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)
Le chat unfun
la source
33

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

JoeLinux
la source
2
Excellente solution! Marche parfaitement! Merci beaucoup!
Vasilije Bursac
18

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

scripts
la source
12

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

Wolph
la source
14
curses? Plus facile? Hmmm ....
aviraldg
Un excellent article, j'allais lui donner un lien mais je ne l'ai pas trouvé dans mes favoris :)
Andy Mikhaylenko
@Aviral Dasgupta: assez bien, plus simple n'est peut-être pas le bon mot ici. Cela peut vous faire économiser beaucoup de travail, mais cela dépend vraiment de ce que vous recherchez.
Wolph
Je ne cherchais rien à ce sujet, mais merci quand même. :)
bobber205
2
Lien mort, c'est le prix de ne pas publier le contenu lié dans votre réponse
-__-
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()

production

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

ashish2py
la source
7

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

FraggaMuffin
la source
Merci pour cela. Petite correction, la méthode plotProgress devrait utiliser la ligne sys.stdout.flush () sinon la barre de progression pourrait ne pas être dessinée tant que la tâche n'est pas terminée (comme cela se produit dans le terminal mac).
osnoz
J'aime cela!!! Assez facile à utiliser !!! Merci
Microos
7

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]
Smoking
la source
6

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.

PaulMcG
la source
4

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

Ib33X
la source
1
Votre lien est rompu - la ligne réelle dans le code source est le 1274e, pas le 1124e! Donc, le bon lien est celui-ci: github.com/reddit/reddit/blob/master/r2/r2/lib/utils/…
Vladimir Ignatyev
Cette variante a le meilleur design à mon goût: elle utilise des itérateurs et fonctionne éventuellement avec tout type de travail mesurable, elle montre le temps écoulé.
Vladimir Ignatyev
4

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

Chris Cui
la source
3

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%

Brian Khuu
la source
3

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)
Malcolm Box
la source
3

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

Ramchandra Apte
la source
2

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
|█████     |
ryan
la source
2

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='')
Storm-Eyes
la source
1

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

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   ] 
jenkins
la source
1

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)
Ivan Chaer
la source
1

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 "")
Rodrigo López
la source
0

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

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.

Matt-the-Bat
la source
0

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

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