Python zum Ausdrucken der Statusleiste und des Prozentsatzes

So implementieren Sie eine Statusleiste wie folgt:

[==========                ]  45%
[================          ]  60%
[==========================] 100%

Ich möchte, dass dies in stdout ausgedruckt wird und weiterhin aktualisiert wird, nicht in einer anderen Zeile gedruckt wird. Wie macht man das?

Es ist ein Python - Modul , dass Sie von bekommen PyPI genannt , progressbardass Geräte eine solche Funktionalität. Wenn es Ihnen nichts ausmacht, eine Abhängigkeit hinzuzufügen, ist dies eine gute Lösung. Andernfalls gehen Sie mit einer der anderen Antworten.

Ein einfaches Beispiel für die Verwendung:

import progressbar
from time import sleep
bar = progressbar.ProgressBar(maxval=20, \
    widgets=[progressbar.Bar('=', '[', ']'), ' ', progressbar.Percentage()])
bar.start()
for i in xrange(20):
    bar.update(i+1)
    sleep(0.1)
bar.finish()

Um es zu installieren, können Sie verwenden easy_install progressbar, oder pip install progressbarwenn Sie pip bevorzugen.

Das '\r'Zeichen (Wagenrücklauf) setzt den Cursor auf den Zeilenanfang zurück und ermöglicht es Ihnen, über das zu schreiben, was zuvor in der Zeile stand.

from time import sleep
import sys

for i in range(21):
    sys.stdout.write('\r')
    # the exact output you're looking for:
    sys.stdout.write("[%-20s] %d%%" % ('='*i, 5*i))
    sys.stdout.flush()
    sleep(0.25)

Ich bin nicht 100% sicher, ob dies auf allen Systemen vollständig portierbar ist, aber es funktioniert zumindest unter Linux und OSX.

Ich fand nützliche Bibliothek tqdm ( https://github.com/tqdm/tqdm/ , zuvor: https://github.com/noamraph/tqdm ). Es schätzt automatisch die Fertigstellungszeit und kann als Iterator verwendet werden.

Verwendung:

import tqdm
import time

for i in tqdm.tqdm(range(1000)):
    time.sleep(0.01)
    # or other long operations

Ergebnisse in:

|####------| 450/1000  45% [elapsed: 00:04 left: 00:05, 99.15 iters/sec]

tqdm kann jedes iterable umschließen.

Sie können verwenden \r( Wagenrücklauf ). Demo:

import sys
total = 10000000
point = total / 100
increment = total / 20
for i in xrange(total):
    if(i % (5 * point) == 0):
        sys.stdout.write("\r[" + "=" * (i / increment) +  " " * ((total - i)/ increment) + "]" +  str(i / point) + "%")
        sys.stdout.flush()

Hier können Sie folgenden Code als Funktion verwenden:

def drawProgressBar(percent, barLen = 20):
    sys.stdout.write("\r")
    progress = ""
    for i in range(barLen):
        if i < int(barLen * percent):
            progress += "="
        else:
            progress += " "
    sys.stdout.write("[ %s ] %.2f%%" % (progress, percent * 100))
    sys.stdout.flush()

Bei Verwendung von .format:

def drawProgressBar(percent, barLen = 20):
    # percent float from 0 to 1. 
    sys.stdout.write("\r")
    sys.stdout.write("[{:<{}}] {:.0f}%".format("=" * int(barLen * percent), barLen, percent * 100))
    sys.stdout.flush()

Aufgrund der obigen Antworten und anderer ähnlicher Fragen zum CLI-Fortschrittsbalken habe ich eine allgemeine Antwort auf alle Fragen erhalten. Überprüfen Sie es unter https://stackoverflow.com/a/15860757/2254146

Hier ist eine Kopie der Funktion, die jedoch an Ihren Stil angepasst wurde:

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

Sieht aus wie

Prozent: [===================] 99,0%

Wenn Sie eine Befehlszeilenschnittstelle entwickeln, empfehle ich Ihnen, einen Blick darauf zu werfen, clickwas sehr schön ist:

import click
import time

for filename in range(3):
    with click.progressbar(range(100), fill_char='=', empty_char=' ') as bar:
        for user in bar:
            time.sleep(0.01)

Hier die Ausgabe, die Sie erhalten:

$ python test.py
  [====================================]  100%
  [====================================]  100%
  [=========                           ]   27%

Weitere Verbesserung durch Verwendung einer Funktion als:

import sys

def printProgressBar(i,max,postText):
    n_bar =10 #size of progress bar
    j= i/max
    sys.stdout.write('\r')
    sys.stdout.write(f"[{'=' * int(n_bar * j):{n_bar}s}] {int(100 * j)}%  {postText}")
    sys.stdout.flush()

Aufrufbeispiel:

total=33
for i in range(total):
    printProgressBar(i,total,"blah")
    sleep(0.05)  

Ausgabe:

[================================================  ] 96%  blah  

Ich bin heute auf diesen Thread gestoßen, nachdem ich diese Lösung von Mark Rushakoff ausprobiert hatte

from time import sleep
import sys

for i in range(21):
sys.stdout.write('\r')
# the exact output you're looking for:
sys.stdout.write("[%-20s] %d%%" % ('='*i, 5*i))
sys.stdout.flush()
sleep(0.25)

Ich kann sagen, dass dies auf W7-64 mit Python 3.4.3 64-Bit gut funktioniert, aber nur in der nativen Konsole. Bei Verwendung der integrierten Konsole von spyder 3.0.0dev sind die Zeilenumbrüche jedoch weiterhin vorhanden. Da ich einige Zeit gebraucht habe, um dies herauszufinden, möchte ich diese Beobachtung hier berichten.

Aufbauend auf einigen der Antworten hier und anderswo habe ich diese einfache Funktion geschrieben, die einen Fortschrittsbalken und die verstrichene / geschätzte verbleibende Zeit anzeigt. Sollte auf den meisten Unix-basierten Computern funktionieren.

import time
import sys

percent = 50.0
start = time.time()
draw_progress_bar(percent, start)


def draw_progress_bar(percent, start, barLen=20):
sys.stdout.write("\r")
progress = ""
for i in range(barLen):
    if i < int(barLen * percent):
        progress += "="
    else:
        progress += " "

elapsedTime = time.time() - start;
estimatedRemaining = int(elapsedTime * (1.0/percent) - elapsedTime)

if (percent == 1.0):
    sys.stdout.write("[ %s ] %.1f%% Elapsed: %im %02is ETA: Done!\n" % 
        (progress, percent * 100, int(elapsedTime)/60, int(elapsedTime)%60))
    sys.stdout.flush()
    return
else:
    sys.stdout.write("[ %s ] %.1f%% Elapsed: %im %02is ETA: %im%02is " % 
        (progress, percent * 100, int(elapsedTime)/60, int(elapsedTime)%60,
         estimatedRemaining/60, estimatedRemaining%60))
    sys.stdout.flush()
    return

Dies ist ein recht einfacher Ansatz, der mit jeder Schleife verwendet werden kann.

#!/usr/bin/python
for i in range(100001):
    s =  ((i/5000)*'#')+str(i)+(' %')
    print ('\r'+s),

Am einfachsten ist es noch

import sys
total_records = 1000
for i in range (total_records):
    sys.stdout.write('\rUpdated record: ' + str(i) + ' of ' + str(total_records))
    sys.stdout.flush()

Der Schlüssel ist, den Integer-Typ in einen String zu konvertieren.

Wie in Mark Rushakoffs Lösung beschrieben , können Sie das Wagenrücklaufzeichen ausgeben sys.stdout.write('\r'), um den Cursor auf den Zeilenanfang zurückzusetzen. Um diese Lösung zu verallgemeinern und gleichzeitig die f-Strings von Python 3 zu implementieren , können Sie sie verwenden

from time import sleep
import sys

n_bar = 50
iterable = range(33)  # for demo purposes
n_iter = len(iterable)
for i, item in enumerate(iterable):
    j = (i + 1) / n_iter

    sys.stdout.write('\r')
    sys.stdout.write(f"[{'=' * int(n_bar * j):{n_bar}s}] {int(100 * j)}%")
    sys.stdout.flush()

    sleep(0.05)  
    # do something with <item> here

Versuchen Sie PyProg. PyProg ist eine Open-Source-Bibliothek für Python, mit der Sie super anpassbare Fortschrittsanzeigen und Balken erstellen können.

Es ist derzeit in Version 1.0.2; Es wird auf Github gehostet und ist auf PyPI verfügbar (Links unten). Es ist kompatibel mit Python 3 & 2 und kann auch mit Qt Console verwendet werden.

Es ist wirklich einfach zu bedienen. Der folgende Code:

import pyprog
from time import sleep

# Create Object
prog = pyprog.ProgressBar(" ", " ", total=34, bar_length=26, complete_symbol="=", not_complete_symbol=" ", wrap_bar_prefix=" [", wrap_bar_suffix="] ", progress_explain="", progress_loc=pyprog.ProgressBar.PROGRESS_LOC_END)
# Update Progress Bar
prog.update()

for i in range(34):
    # Do something
    sleep(0.1)
    # Set current status
    prog.set_stat(i + 1)
    # Update Progress Bar again
    prog.update()

# Make the Progress Bar final
prog.end()

produziert genau das, was Sie wollen (sogar die Stablänge!):

[===========               ] 45%
[===============           ] 60%
[==========================] 100%

Weitere Optionen zum Anpassen des Fortschrittsbalkens finden Sie auf der Github-Seite dieser Website.

Ich habe PyProg tatsächlich gemacht, weil ich eine einfache, aber super anpassbare Fortschrittsbalkenbibliothek brauchte. Sie können es einfach installieren mit : pip install pyprog.

PyProg Github: https://github.com/Bill13579/pyprog
PyPI: https://pypi.python.org/pypi/pyprog/

Mit der Antwort von @ Mark-Rushakoff habe ich einen einfacheren Ansatz erarbeitet, ohne die sys-Bibliothek aufrufen zu müssen. Es funktioniert mit Python 3. Getestet in Windows:

from time import sleep
for i in range(21):
    # the exact output you're looking for:
    print ("\r[%-20s] %d%%" % ('='*i, 5*i), end='')
    sleep(0.25)

Hier ist etwas, das ich mit der Lösung von @ Mark-Rushakoff gemacht habe. Adaptive Anpassung an die Klemmenbreite.

from time import sleep
import os
import sys
from math import ceil

l = list(map(int,os.popen('stty size','r').read().split()))
col = l[1]
col = col - 6

for i in range(col):
    sys.stdout.write('\r')
    getStr = "[%s " % ('='*i)
    sys.stdout.write(getStr.ljust(col)+"]"+"%d%%" % (ceil((100/col)*i)))
    sys.stdout.flush()
    sleep(0.25)
print("")