Konsoldaki Metin İlerleme Çubuğu [kapalı]

Ftplib kullanarak bir FTP sunucusundan dosya yüklemek ve indirmek için basit bir konsol uygulaması yazdım.

Uygulamanın kullanıcı için indirme / yükleme ilerlemesinin bazı görselleştirmelerini göstermesini istiyorum; bir veri yığını her indirildiğinde, bir yüzde gibi sayısal bir gösterim olsa bile, bir ilerleme güncellemesi sağlamasını isterim.

Daha da önemlisi, önceki satırlarda konsola yazdırılan tüm metni silmekten kaçınmak istiyorum (yani, güncellenen ilerlemeyi yazdırırken tüm terminali "temizlemek" istemiyorum).

Bu oldukça yaygın bir görev gibi görünüyor - önceki program çıktısını korurken konsoluma çıkan bir ilerleme çubuğu veya benzer bir görselleştirme yapmaya nasıl devam edebilirim?

Basit, Özelleştirilebilir İlerleme Çubuğu

Aşağıda, düzenli olarak kullandığım cevapların çoğunun bir toplamı (ithalat gerekmez).

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

Not: Bu Python 3 içindir; bunu Python 2'de kullanma hakkındaki ayrıntılar için yorumlara bakın.

Örnek Kullanımı

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)

Örnek Çıktı:

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

Güncelleme

Yorumlar bölümünde ilerleme çubuğunun terminal penceresi genişliğine dinamik olarak ayarlanmasına izin veren bir seçenekle ilgili tartışma vardı. Bunu tavsiye etmese de, bu özelliği uygulayan bir özgeçmiş (ve uyarıları not ediyor).

'\ R' yazmak imleci satırın başına götürecektir.

Bu bir yüzde sayacı görüntüler:

import time
import sys

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

tqdm: saniyelerinize döngülerinize bir ilerleme ölçer ekleyin :

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

\rKonsola bir yazın . Bu, satır başlangıcında tüm metnin yankılanmasına neden olan bir "satır başı" dır . Gibi bir şey:

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

hangi gibi bir şey verecektir: [ ########## ] 100%

10 satırdan az kod.

Buradaki öz: 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

Python Mozart Armin Ronacher tarafından yazılan tıklama kütüphanesini deneyin .

$ pip install click # both 2 and 3 compatible

Basit bir ilerleme çubuğu oluşturmak için:

import click

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

Öyle görünüyor:

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

Kalplerinizin içeriğini özelleştirin:

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

Özel görünüm:

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

Daha da fazla seçenek var, API belgelerine bakın :

 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)

Oyuna geç kaldığımı fark ettim, ama burada yazdığım biraz Yum tarzı (Kırmızı Şapka) (burada% 100 doğruluk için gitmiyorum, ancak bu doğruluk seviyesi için bir ilerleme çubuğu kullanıyorsanız, o zaman zaten YANLIŞSIN):

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

Şuna benzer bir şey üretmelidir:

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

... köşeli parantezler sabit durur ve sadece karmalar artar.

Bu bir dekoratör olarak daha iyi çalışabilir. Başka bir gün için...

Bu kütüphaneyi kontrol et: clint

ilerleme çubuğu da dahil olmak üzere birçok özelliğe sahiptir:

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)

bu bağlantı özelliklerine hızlı bir genel bakış sağlar

Python'da yazılmış bir ilerleme çubuğuna güzel bir örnek: http://nadiana.com/animated-terminal-progress-bar-in-python

Ama kendiniz yazmak istiyorsanız. cursesİşleri kolaylaştırmak için modülü kullanabilirsiniz :)

Muhtemelen daha kolay lanetlerin sözcüğü değildir. Ama lanetlerden daha iyi bir cui oluşturmak istiyorsanız, sizin için birçok şeyle ilgilenir.

Eski bağlantı öldüğünden, kendi Python Progressbar sürümümü oluşturdum, buradan edinin : 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()

çıktı

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

ve sadece yığına eklemek için kullanabileceğiniz bir nesne var

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"

sonuç:

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

Bu genellikle "üstte" olarak kabul edilir, ancak çok kullandığınızda kullanışlıdır

tqdm. ( pip install tqdm) ' İ kurun ve aşağıdaki gibi kullanın:

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

Bu, böyle bir şey çıktılayacak 10 saniyelik bir ilerleme çubuğu:

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

Bu çalıştır Python komut satırına ( değil herhangi IDE veya geliştirme ortamında):

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

Windows sistemimde iyi çalışıyor.

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

Ve googled için bekleyen bir sürü öğretici.

Ben kullanıyorum reddit gelen ilerleme . Bunu seviyorum çünkü tek satırdaki her öğe için ilerleme yazdırabilir ve çıktıları programdan silmemelidir.

Düzenleme: sabit bağlantı

Bu paketi yüklemeyi deneyin 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

Yukarıdaki yanıtlara ve CLI ilerleme çubuğu ile ilgili diğer benzer sorulara dayanarak, hepsine genel bir ortak yanıt aldım. Https://stackoverflow.com/a/15860757/2254146 adresinden kontrol edin

Özetle, kod şudur:

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

Gibi görünüyor

Yüzde: [##########]% 99.0

Tqdm - https://pypi.python.org/pypi/tqdm - kullanmanızı öneririm .

Belgelerden: "tqdm geri çağrıları / kancaları ve manuel güncellemeleri kolayca destekleyebilir. İşte urllib ile bir örnek"

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)

Çok basit bir çözüm, bu kodu döngünüze yerleştirmektir:

Bunu dosyanızın gövdesine (üst kısmına) koyun:

import sys

Bunu döngünüzün gövdesine koyun:

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

NOT: Bunu etkileşimli interepter'da çalıştırırsanız, ekstra numaralar yazdırılır

lol ben sadece bu heres için bir şey yazdı kod aklınızda tutmak blok ascii kullanırken cp437 kullanırken unicode kullanamazsınız

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

ve öyle diyorsun

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

yani böyle görünüyor

loading something awesome
|█████     |

Yukarıdaki harika tavsiyeler ile ilerleme çubuğunu çalışıyorum.

Ancak bazı eksikliklere dikkat çekmek istiyorum

1. İlerleme çubuğu her temizlendiğinde yeni bir satıra başlar

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

   bunun gibi:
   []% 0
   [#]% 10
   [##]% 20
   [###]% 30

2. '###' uzadıkça köşeli parantez ']' ve sağ taraftaki yüzde sayısı sağa kayar.
3. 'progress / 10' ifadesi bir tamsayı döndüremezse bir hata oluşur.

Ve aşağıdaki kod yukarıdaki sorunu çözecektir.

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

Python terminali ilerleme çubuğu kodu

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

basit bir ilerleme çubuğu yazdım:

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)

gördüğünüz gibi, çubuk uzunluğu, önek ve sonek, dolgu, boşluk,% 100 (oncomp) üzerinde bar metni ve kenarlıklar

burada bir örnek:

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)

devam ediyor:

30% [######              ]

tamamlandığında:

100% [   done in 9 sec   ] 

Burada bulduğum bazı fikirleri bir araya getirmek ve tahmini kalan süreyi eklemek:

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)

Python 3 için:

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

Peki burada çalışan kod ve göndermeden önce test:

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

Artıları:

• 20 karakter çubuğu (her 5 için 1 karakter (akıllıca)
• Özel dolgu karakterleri
• Özel boş karakterler
• Durdur (0'ın altındaki herhangi bir sayı)
• Yapıldı (100 ve 100'ün üzerindeki herhangi bir sayı)
• İlerleme sayısı (0-100 (aşağıda ve yukarıda özel işlevler için kullanılır))
• Çubuğun yanındaki yüzde sayısı ve tek bir satır

Eksileri:

• Destekler tamsayılar sadece (o yüzden değiştirmek bölünme bir tamsayı bölme yaparak, gerçi onları desteklemek için değiştirilebilir prog2 = prog/5içinprog2 = int(prog/5) )

İşte benim Python 3 çözümüm:

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

'\ b', dizenizdeki her karakter için ters eğik çizgidir. Bu, Windows cmd penceresinde çalışmaz.

2.7 için Greenstick fonksiyonu:

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

Python modülü ilerleme çubuğu iyi bir seçimdir. İşte benim tipik kod:

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