Python İlerleme Çubuğu

Betiğim zaman alacak bir görev yaparken nasıl bir ilerleme çubuğu kullanabilirim?

Örneğin, tamamlanması biraz zaman alan ve Truebittiğinde dönen bir işlev . İşlev yürütülürken ilerleme çubuğunu nasıl görüntüleyebilirim?

Bunun gerçek zamanlı olması için gerekli olduğuna dikkat edin, bu yüzden ne yapacağımı anlayamıyorum. Bunun threadiçin bir ihtiyacım var mı? Hiç bir fikrim yok.

Şu anda işlev yürütülürken hiçbir şey yazdırmıyorum, ancak bir ilerleme çubuğu iyi olurdu. Ayrıca bu nasıl bir kod bakış açısından yapılabilir daha ilgileniyorum.

Belirli kütüphaneler var ( buradaki gibi ) ama belki çok basit bir şey yapardı:

import time
import sys

toolbar_width = 40

# setup toolbar
sys.stdout.write("[%s]" % (" " * toolbar_width))
sys.stdout.flush()
sys.stdout.write("\b" * (toolbar_width+1)) # return to start of line, after '['

for i in xrange(toolbar_width):
    time.sleep(0.1) # do real work here
    # update the bar
    sys.stdout.write("-")
    sys.stdout.flush()

sys.stdout.write("]\n") # this ends the progress bar

Not: progressbar2 , yıllarca korunmayan bir progressbar çataldır .

Tqdm ile bir saniyede döngülerinize bir ilerleme ölçer ekleyebilirsiniz:

In [1]: import time

In [2]: from tqdm import tqdm

In [3]: for i in tqdm(range(10)):
   ....:     time.sleep(3)

 60%|██████    | 6/10 [00:18<00:12,  0.33 it/s]

Ayrıca, tqdm'nin grafiksel bir sürümü vardır v2.0.0( d977a0c):

In [1]: import time

In [2]: from tqdm import tqdm_gui

In [3]: for i in tqdm_gui(range(100)):
  ....:     time.sleep(3)

Ancak dikkatli olun, çünkü bir tqdm_guiyükseltebilir TqdmExperimentalWarning: GUI is experimental/alpha, kullanarak yok sayabilirsiniz warnings.simplefilter("ignore"), ancak bundan sonra kodunuzdaki tüm uyarıları yok sayacaktır.

Yukarıdaki öneriler oldukça iyi, ancak çoğu insanın sadece harici paketlere bağımlı olmayan hazır bir çözüm istediğini, ancak tekrar kullanılabilir olduğunu düşünüyorum.

Yukarıdakilerin hepsinin en iyi noktalarını aldım ve bir test senaryosuyla birlikte bir işleve getirdim.

Kullanmak için "def update_progress (progress)" altındaki satırları kopyalayın, ancak test komut dosyasını kopyalamayın. Sys'i almayı unutmayın. İlerleme çubuğunu görüntülemeniz veya güncellemeniz gerektiğinde bunu çağırın.

Bu, imleci başlangıca geri taşımak için doğrudan konsola "\ r" sembolü göndererek çalışır. python "print" bu amaç için yukarıdaki sembolü tanımaz, bu yüzden 'sys'

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


# update_progress test script
print "progress : 'hello'"
update_progress("hello")
time.sleep(1)

print "progress : 3"
update_progress(3)
time.sleep(1)

print "progress : [23]"
update_progress([23])
time.sleep(1)

print ""
print "progress : -10"
update_progress(-10)
time.sleep(2)

print ""
print "progress : 10"
update_progress(10)
time.sleep(2)

print ""
print "progress : 0->1"
for i in range(101):
    time.sleep(0.1)
    update_progress(i/100.0)

print ""
print "Test completed"
time.sleep(10)

Test komut dosyasının sonucu budur (Son ilerleme çubuğu canlandırılır):

progress : 'hello'
Percent: [----------] 0% error: progress var must be float
progress : 3
Percent: [##########] 100% Done...
progress : [23]
Percent: [----------] 0% error: progress var must be float

progress : -10
Percent: [----------] 0% Halt...

progress : 10
Percent: [##########] 100% Done...

progress : 0->1
Percent: [##########] 100% Done...
Test completed

Bu cevap harici paketlere dayanmıyor, aynı zamanda çoğu insanın sadece hazır bir kod parçası istediğini düşünüyorum . Aşağıdaki kod, özelleştirerek ihtiyaçlarınıza göre uyarlanabilir: çubuk ilerleme sembolü '#', çubuk size, metin prefixvb.

import sys

def progressbar(it, prefix="", size=60, file=sys.stdout):
    count = len(it)
    def show(j):
        x = int(size*j/count)
        file.write("%s[%s%s] %i/%i\r" % (prefix, "#"*x, "."*(size-x), j, count))
        file.flush()        
    show(0)
    for i, item in enumerate(it):
        yield item
        show(i+1)
    file.write("\n")
    file.flush()

Kullanımı:

import time

for i in progressbar(range(15), "Computing: ", 40):
    time.sleep(0.1) # any calculation you need

Çıktı:

Computing: [################........................] 4/15

• İkinci bir iş parçacığı gerektirmez . Yukarıdaki bazı çözümler / paketler gerekir. İkinci bir iş parçacığı, örneğin bir sorun olabilir jupyter notebook.

• Kullanılabilir her şeyle çalışır, kullanılabilecek her şey anlamına gelir len(). A list, a dictherhangi bir şey örneğin['a', 'b', 'c' ... 'g']

Dosyayı sys.stderrörneğin olarak değiştirerek çıktıyı da değiştirebilirsiniz.

benzer bir uygulama için (bir döngüde ilerlemeyi izlemek) Ben sadece python-progressbar kullanılır :

Örnekleri böyle bir şeye gider,

from progressbar import *               # just a simple progress bar


widgets = ['Test: ', Percentage(), ' ', Bar(marker='0',left='[',right=']'),
           ' ', ETA(), ' ', FileTransferSpeed()] #see docs for other options

pbar = ProgressBar(widgets=widgets, maxval=500)
pbar.start()

for i in range(100,500+1,50):
    # here do something long at each iteration
    pbar.update(i) #this adds a little symbol at each iteration
pbar.finish()
print

Https://pypi.python.org/pypi/progress adresinden ilerlemeyi deneyin .

from progress.bar import Bar

bar = Bar('Processing', max=20)
for i in range(20):
    # Do some work
    bar.next()
bar.finish()

Sonuç aşağıdaki gibi bir çubuk olacaktır:

Processing |#############                   | 42/100

Burada eşdeğer bir çözüm aradıktan sonra ihtiyaçlarım için basit bir ilerleme sınıfı yaptım. Bunu iyi bir şekilde gönderebileceğimi düşündüm.

from __future__ import print_function
import sys
import re


class ProgressBar(object):
    DEFAULT = 'Progress: %(bar)s %(percent)3d%%'
    FULL = '%(bar)s %(current)d/%(total)d (%(percent)3d%%) %(remaining)d to go'

    def __init__(self, total, width=40, fmt=DEFAULT, symbol='=',
                 output=sys.stderr):
        assert len(symbol) == 1

        self.total = total
        self.width = width
        self.symbol = symbol
        self.output = output
        self.fmt = re.sub(r'(?P<name>%\(.+?\))d',
            r'\g<name>%dd' % len(str(total)), fmt)

        self.current = 0

    def __call__(self):
        percent = self.current / float(self.total)
        size = int(self.width * percent)
        remaining = self.total - self.current
        bar = '[' + self.symbol * size + ' ' * (self.width - size) + ']'

        args = {
            'total': self.total,
            'bar': bar,
            'current': self.current,
            'percent': percent * 100,
            'remaining': remaining
        }
        print('\r' + self.fmt % args, file=self.output, end='')

    def done(self):
        self.current = self.total
        self()
        print('', file=self.output)

Misal :

from time import sleep

progress = ProgressBar(80, fmt=ProgressBar.FULL)

for x in xrange(progress.total):
    progress.current += 1
    progress()
    sleep(0.1)
progress.done()

Aşağıdakileri yazdıracaktır:

[======== ] 17/80 ( 21%) 63 to go

Brian Khuu'nun sadeliği ve dış paketlere ihtiyaç duymamasının cevabını seviyorum . Biraz değiştirdim, bu yüzden versiyonumu buraya ekliyorum:

import sys
import time


def updt(total, progress):
    """
    Displays or updates a console progress bar.

    Original source: https://stackoverflow.com/a/15860757/1391441
    """
    barLength, status = 20, ""
    progress = float(progress) / float(total)
    if progress >= 1.:
        progress, status = 1, "\r\n"
    block = int(round(barLength * progress))
    text = "\r[{}] {:.0f}% {}".format(
        "#" * block + "-" * (barLength - block), round(progress * 100, 0),
        status)
    sys.stdout.write(text)
    sys.stdout.flush()


runs = 300
for run_num in range(runs):
    time.sleep(.1)
    updt(runs, run_num + 1)

Toplam run ( total) sayısını ve şimdiye kadar ( progress) varsayılan işlenen run sayısını alır total >= progress. Sonuç şuna benzer:

[#####---------------] 27%

Tqdm'yi kullanabilirsiniz :

from tqdm import tqdm

with tqdm(total=100, desc="Adding Users", bar_format="{l_bar}{bar} [ time left: {remaining} ]") as pbar:
    for i in range(100):
        time.sleep(3)
        pbar.update(1)

Bu örnekte ilerleme çubuğu 5 dakika çalışıyor ve şu şekilde gösteriliyor:

Adding Users:   3%|█████▊                                     [ time left: 04:51 ]                                                                                                        

Değiştirebilir ve istediğiniz gibi özelleştirebilirsiniz.

Herhangi bir ilerleme çubuğu çerçevesini yararlı bir şekilde kullanmak için, yani gerçek bir ilerleme yüzdesi ve tahmini bir ETA elde etmek için, kaç adımda olacağını bildirmeniz gerekir.

Yani, başka bir iş parçacığında hesaplama işleviniz, bunu bir dizi mantıksal adımda bölebiliyor musunuz? Kodunu değiştirebilir misiniz?

Yeniden düzenlemenize veya gerçek yöntemlere bölmenize gerek yok, yieldiçindeki bazı yerlere bazı stratejik noktalar koyabilirsiniz ! Pahalı işlevin bir for döngüsü varsa , içine bir tane koyun. En iyi sonuçları elde etmek için sonunda ne kadar verim yapacağınızı bilmelisiniz.

Bu şekilde, işleviniz böyle bir şey olabilir:

def compute():
    time.sleep(1)  # some processing here
    yield  # insert these
    time.sleep(1)
    yield
    time.sleep(1)
    yield

veya bu:

def compute():
    for i in range(1000):
        time.sleep(.1)  # some processing here
        yield  # insert these

Bu tür bir işlevle şunları yükleyebilirsiniz:

pip install alive-progress

Ve şöyle kullanın:

from alive_progress import alive_bar

with alive_bar(3) as bar:  # or a 1000 in the loop example.
    for i in compute():
        bar()

Serin bir ilerleme çubuğu almak için!

|█████████████▎                          | ▅▃▁ 1/3 [33%] in 1s (1.0/s, eta: 2s)

Feragatname: alive_progress'in yazarıyım, ancak sorununuzu güzel bir şekilde çözmeli. Https://github.com/rsalmei/alive-progress adresindeki belgeleri okuyun , işte neler yapabileceğine bir örnek:

Kullanımı çok basit olduğu için python-progressbar'ı gerçekten çok seviyorum .

En basit durum için, sadece:

import progressbar
import time

progress = progressbar.ProgressBar()
for i in progress(range(80)):
    time.sleep(0.01)

Görünüm özelleştirilebilir ve tahmini kalan süreyi görüntüleyebilir. Bir örnek için yukarıdakiyle aynı kodu kullanın ancak:

progress = progressbar.ProgressBar(widgets=[progressbar.Bar('=', '[', ']'), ' ',
                                            progressbar.Percentage(), ' ',
                                            progressbar.ETA()])

Çok fazla zaman alan sabit bir yinelemeye sahip büyük bir döngü ise, yaptığım bu işlevi kullanabilirsiniz. Her döngü tekrarı ilerleme sağlar. Sayım, döngünün geçerli yinelemesi olduğunda, toplam döngü yaptığınız değerdir ve boyut (int), çubuğu 10'luk artışlarla ne kadar büyük istediğinizdir (boyut 1 = 10 karakter, boyut 2 = 20 karakter)

import sys
def loadingBar(count,total,size):
    percent = float(count)/float(total)*100
    sys.stdout.write("\r" + str(int(count)).rjust(3,'0')+"/"+str(int(total)).rjust(3,'0') + ' [' + '='*int(percent/10)*size + ' '*(10-int(percent/10))*size + ']')

misal:

for i in range(0,100):
     loadingBar(i,100,2)
     #do some code 

çıktı:

i = 50
>> 050/100 [==========          ]

Şu kütüphaneyi kullanın: fish( GitHub ).

Kullanımı:

>>> import fish
>>> while churning:
...     churn_churn()
...     fish.animate()

İyi eğlenceler!

Aşağıdaki kod oldukça genel bir çözümdür ve ayrıca geçen bir zaman ve tahmini kalan süreye sahiptir. Onunla herhangi bir yinelenebilir kullanabilirsiniz. İlerleme çubuğu 25 karakterlik sabit bir boyuta sahiptir, ancak tam, yarım ve çeyrek blok karakterleri kullanarak% 1'lik adımlarla güncellemeleri gösterebilir. Çıktı şöyle görünür:

 18% |████▌                    | \ [0:00:01, 0:00:06]

Örnek kod:

import sys, time
from numpy import linspace

def ProgressBar(iterObj):
  def SecToStr(sec):
    m, s = divmod(sec, 60)
    h, m = divmod(m, 60)
    return u'%d:%02d:%02d'%(h, m, s)
  L = len(iterObj)
  steps = {int(x):y for x,y in zip(linspace(0, L, min(100,L), endpoint=False),
                                   linspace(0, 100, min(100,L), endpoint=False))}
  qSteps = ['', u'\u258E', u'\u258C', u'\u258A'] # quarter and half block chars
  startT = time.time()
  timeStr = '   [0:00:00, -:--:--]'
  activity = [' -',' \\',' |',' /']
  for nn,item in enumerate(iterObj):
    if nn in steps:
      done = u'\u2588'*int(steps[nn]/4.0)+qSteps[int(steps[nn]%4)]
      todo = ' '*(25-len(done))
      barStr = u'%4d%% |%s%s|'%(steps[nn], done, todo)
    if nn>0:
      endT = time.time()
      timeStr = ' [%s, %s]'%(SecToStr(endT-startT),
                             SecToStr((endT-startT)*(L/float(nn)-1)))
    sys.stdout.write('\r'+barStr+activity[nn%4]+timeStr); sys.stdout.flush()
    yield item
  barStr = u'%4d%% |%s|'%(100, u'\u2588'*25)
  timeStr = '   [%s, 0:00:00]\n'%(SecToStr(time.time()-startT))
  sys.stdout.write('\r'+barStr+timeStr); sys.stdout.flush()

# Example
s = ''
for c in ProgressBar(list('Disassemble and reassemble this string')):
  time.sleep(0.2)
  s += c
print(s)

İyileştirme önerileri veya diğer yorumlar için teşekkür ederiz. Şerefe!

Bu sayfayı beğendim .

Basit bir örnekle başlar ve çok iş parçacıklı bir sürüme geçer. Kutudan çıkar çıkmaz çalışır. Üçüncü taraf paketleri gerekmez.

Kod şöyle görünecektir:

import time
import sys

def do_task():
    time.sleep(1)

def example_1(n):
    for i in range(n):
        do_task()
        print '\b.',
        sys.stdout.flush()
    print ' Done!'

print 'Starting ',
example_1(10)

Veya program çalışırken dönen yükleme çubuğunu çalıştırmak için iş parçacıklarını kullanmak için örnek:

import sys
import time
import threading

class progress_bar_loading(threading.Thread):

    def run(self):
            global stop
            global kill
            print 'Loading....  ',
            sys.stdout.flush()
            i = 0
            while stop != True:
                    if (i%4) == 0: 
                        sys.stdout.write('\b/')
                    elif (i%4) == 1: 
                        sys.stdout.write('\b-')
                    elif (i%4) == 2: 
                        sys.stdout.write('\b\\')
                    elif (i%4) == 3: 
                        sys.stdout.write('\b|')

                    sys.stdout.flush()
                    time.sleep(0.2)
                    i+=1

            if kill == True: 
                print '\b\b\b\b ABORT!',
            else: 
                print '\b\b done!',


kill = False      
stop = False
p = progress_bar_loading()
p.start()

try:
    #anything you want to run. 
    time.sleep(1)
    stop = True
except KeyboardInterrupt or EOFError:
         kill = True
         stop = True

Python3'te oldukça basittir:

   import time
   import math

    def show_progress_bar(bar_length, completed, total):
        bar_length_unit_value = (total / bar_length)
        completed_bar_part = math.ceil(completed / bar_length_unit_value)
        progress = "*" * completed_bar_part
        remaining = " " * (bar_length - completed_bar_part)
        percent_done = "%.2f" % ((completed / total) * 100)
        print(f'[{progress}{remaining}] {percent_done}%', end='\r')

    bar_length = 30
    total = 100
    for i in range(0, total + 1):
        show_progress_bar(bar_length, i, total)
        time.sleep(0.1)

    print('\n')

Jupyter defterlerde çalışırken, normal tqdm kullanımı çıktıyı birden çok satıra yazdığı için çalışmaz. Bunun yerine şunu kullanın:

import time
from tqdm import tqdm_notebook as tqdm

for i in tqdm(range(100))
    time.sleep(0.5)

İşiniz ölçülebilir parçalara bölünemezse, işlevinizi yeni bir iş parçacığında ve ne kadar sürdüğü ile çağırabilirsiniz:

import thread
import time
import sys

def work():
    time.sleep( 5 )

def locked_call( func, lock ):
    lock.acquire()
    func()
    lock.release()

lock = thread.allocate_lock()
thread.start_new_thread( locked_call, ( work, lock, ) )

# This part is icky...
while( not lock.locked() ):
    time.sleep( 0.1 )

while( lock.locked() ):
    sys.stdout.write( "*" )
    sys.stdout.flush()
    time.sleep( 1 )
print "\nWork Done"

Zamanlama hassasiyetini gerektiği gibi artırabilirsiniz.

Gabriel'in cevabını seviyorum ama esnek olacak şekilde değiştirdim. İşleve çubuk uzunluğu gönderebilir ve ilerleme çubuğunuzu istediğiniz uzunlukta alabilirsiniz. Sıfır veya negatif uzunlukta bir ilerleme çubuğunuz olamaz. Ayrıca, Gabriel yanıtı gibi bu işlevi kullanabilirsiniz (Örnek # 2'ye bakın).

import sys
import time

def ProgressBar(Total, Progress, BarLength=20, ProgressIcon="#", BarIcon="-"):
    try:
        # You can't have a progress bar with zero or negative length.
        if BarLength <1:
            BarLength = 20
        # Use status variable for going to the next line after progress completion.
        Status = ""
        # Calcuting progress between 0 and 1 for percentage.
        Progress = float(Progress) / float(Total)
        # Doing this conditions at final progressing.
        if Progress >= 1.:
            Progress = 1
            Status = "\r\n"    # Going to the next line
        # Calculating how many places should be filled
        Block = int(round(BarLength * Progress))
        # Show this
        Bar = "[{}] {:.0f}% {}".format(ProgressIcon * Block + BarIcon * (BarLength - Block), round(Progress * 100, 0), Status)
        return Bar
    except:
        return "ERROR"

def ShowBar(Bar):
    sys.stdout.write(Bar)
    sys.stdout.flush()

if __name__ == '__main__':
    print("This is a simple progress bar.\n")

    # Example #1:
    print('Example #1')
    Runs = 10
    for i in range(Runs + 1):
        progressBar = "\rProgress: " + ProgressBar(10, i, Runs)
        ShowBar(progressBar)
        time.sleep(1)

    # Example #2:
    print('\nExample #2')
    Runs = 10
    for i in range(Runs + 1):
        progressBar = "\rProgress: " + ProgressBar(10, i, 20, '|', '.')
        ShowBar(progressBar)
        time.sleep(1)

    print('\nDone.')

# Example #2:
Runs = 10
for i in range(Runs + 1):
    ProgressBar(10, i)
    time.sleep(1)

Sonuç:

Bu basit bir ilerleme çubuğu.

Örnek 1

İlerleme durumu: [### -------]% 30

Örnek 2

İlerleme durumu: [|||||||||||| ........]% 60

Bitti.

format()Bir yük çubuğu yapmak için yöntem kullandım . İşte benim çözümüm:

import time

loadbarwidth = 23

for i in range(1, loadbarwidth + 1):
    time.sleep(0.1) 

    strbarwidth = '[{}{}] - {}\r'.format(
        (i * '#'),
        ((loadbarwidth - i) * '-'),
        (('{:0.2f}'.format(((i) * (100/loadbarwidth))) + '%'))
    )

    print(strbarwidth ,end = '')

print()

Çıktı:

[#######################] - 100.00%

Yükleme çubuğunu programlı olarak oluşturan kısa bir çözüm (ne kadar süre istediğinize karar vermelisiniz).

import time

n = 33  # or however many loading slots you want to have
load = 0.01  # artificial loading time!
loading = '.' * n  # for strings, * is the repeat operator

for i in range(n+1):
    # this loop replaces each dot with a hash!
    print('\r%s Loading at %3d percent!' % (loading, i*100/n), end='')
    loading = loading[:i] + '#' + loading[i+1:]
    time.sleep(load)

PyProg'u deneyin. PyProg, Python'un süper özelleştirilebilir ilerleme göstergeleri ve çubukları oluşturması için açık kaynaklı bir kütüphanedir.

Şu anda 1.0.2 sürümündedir; Github'da barındırılmaktadır ve PyPI'de bulunmaktadır (Aşağıdaki bağlantılar). Python 3 ve 2 ile uyumludur ve Qt Console ile de kullanılabilir.

Kullanımı gerçekten çok kolay. Aşağıdaki kod:

import pyprog
from time import sleep

# Create Object
prog = pyprog.ProgressBar(" ", "", 34)
# 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()

üretecek:

Initial State:
Progress: 0% --------------------------------------------------

When half done:
Progress: 50% #########################-------------------------

Final State:
Progress: 100% ##################################################

Aslında PyProg yaptım çünkü basit ama süper özelleştirilebilir bir ilerleme çubuğu kütüphanesine ihtiyacım vardı. Kolayca ile yükleyebilirsiniz: pip install pyprog.

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

Aydınlatmayı da kullanabilirsiniz . Ana avantajı, ilerleme çubuğunuzun üzerine yazmadan aynı anda oturum açabilmenizdir.

import time
import enlighten

manager = enlighten.Manager()
pbar = manager.counter(total=100)

for num in range(1, 101):
    time.sleep(0.05)
    print('Step %d complete' % num)
    pbar.update()

Ayrıca çoklu ilerleme çubuklarını da işler.

import time
import enlighten

manager = enlighten.Manager()
odds = manager.counter(total=50)
evens = manager.counter(total=50)

for num in range(1, 101):
    time.sleep(0.05)
    if num % 2:
        odds.update()
    else:
        evens.update()

İlerleme kütüphanesini kullanın !

pip install progress

İşte ETA / Geçen süreleri daha iyi okunabilir bir formatta formatlamak için yazdığım özel bir alt sınıf:

import datetime
from progress.bar import IncrementalBar


class ProgressBar(IncrementalBar):
    '''
    My custom progress bar that:
       - Show %, count, elapsed, eta
       - Time is shown in H:M:S format
    '''

    message = 'Progress'
    suffix  = '%(percent).1f%% (%(index)d/%(max)d) -- %(elapsed_min)s (eta: %(eta_min)s)'

    def formatTime(self, seconds):
        return str(datetime.timedelta(seconds=seconds))

    @property
    def elapsed_min(self):
        return self.formatTime(self.elapsed)

    @property
    def eta_min(self):
        return self.formatTime(self.eta)

if __name__=='__main__':
    counter = 120
    bar     = ProgressBar('Processing', max=counter)

    for i in range(counter):
        bar.next()
        time.sleep(1)

    bar.finish()

Bu benim basit çözümüm:

import time

def progress(_cur, _max):
    p = round(100*_cur/_max)
    b = f"Progress: {p}% - ["+"."*int(p/5)+" "*(20-int(p/5))+"]"
    print(b, end="\r")

# USAGE:
for i in range(0,101):
    time.sleep(0.1) 
    progress(i,100)

print("..."*5, end="\r")
print("Done")

İlerleme çubuğunu mevcut göreve bağlamalısınız (ilerlemeyi ölçer: D). Örneğin, bir dosyaya FTP gönderiyorsanız, ftplib'den belirli bir boyut arabelleğini almasını söyleyebilir, 128K diyelim ve 128k dosya boyutunun yüzde kaçını temsil ediyorsa ilerleme çubuğunuza ekleyebilirsiniz. CLI kullanıyorsanız ve ilerleme ölçeriniz 20 karakter uzunluğundaysa, dosyanın 1 / 20'si aktarıldığında bir karakter eklersiniz.

@Massagran: Programlarımda iyi çalışıyor. Ayrıca, döngü sürelerini belirtmek için bir sayaç eklememiz gerekir. Bu sayaç yöntemin argümanı olarak oynar update. Örneğin: bir test dosyasının tüm satırlarını okuyun ve bir şey üzerinde işlem yapın. Fonksiyonun dosth()değişkenle ilgili olmadığını varsayalım i.

lines = open(sys.argv[1]).readlines()
i = 0
widgets=[Percentage(), Bar()]
pbar = ProgressBar(widgets=widgets,maxval=len(lines)).start()
pbar.start()
for line in lines:<pre>
    dosth();
    i += 1
    pbar.update(i)</pre>
pbar.finish()

Değişken yöntemi üzerinden idurumunu kontrol ederpbarupdate

jelde015'in biraz daha genel cevabı (elbette ona kredi)

yükleme çubuğunu manuel olarak güncellemek için :

import sys
from math import *


def loadingBar(i, N, size):
    percent = float(i) / float(N)
    sys.stdout.write("\r"
                     + str(int(i)).rjust(3, '0')
                     +"/"
                     +str(int(N)).rjust(3, '0')
                     + ' ['
                     + '='*ceil(percent*size)
                     + ' '*floor((1-percent)*size)
                     + ']')

ve onu şöyle çağırır:

loadingBar(7, 220, 40)

sonuçlanacak:

007/220 [=                                       ]  

sadece mevcut ideğerle istediğiniz zaman çağırın .

sizeçubuğunun olması gereken karakter sayısı olarak ayarlayın

Sanırım biraz geç kaldım ama bu Python 3.6 PEP 498'de tanıtıldığı gibi "f-dizeleri" kullandığından, python 3'ün mevcut sürümleriyle çalışan insanlar için çalışmalıdır :

kod

from numpy import interp

class Progress:
    def __init__(self, value, end, title='Downloading',buffer=20):
        self.title = title
        #when calling in a for loop it doesn't include the last number
        self.end = end -1
        self.buffer = buffer
        self.value = value
        self.progress()

    def progress(self):
        maped = int(interp(self.value, [0, self.end], [0, self.buffer]))
        print(f'{self.title}: [{"#"*maped}{"-"*(self.buffer - maped)}]{self.value}/{self.end} {((self.value/self.end)*100):.2f}%', end='\r')

Misal

#some loop that does perfroms a task
for x in range(21)  #set to 21 to include until 20
    Progress(x, 21)

Çıktı

Downloading: [########------------] 8/20 40.00%

Bu, bir ilerleme çubuğu oluşturmanın basit bir yoludur

import time,sys
toolbar_width = 50
# setting up toolbar [-------------------------------------]
sys.stdout.write("[%s]"%(("-")*toolbar_width))
sys.stdout.flush()
# each hash represents 2 % of the progress
for i in range(toolbar_width):
    sys.stdout.write("\r") # return to start of line
    sys.stdout.flush()
    sys.stdout.write("[")#Overwrite over the existing text from the start 
    sys.stdout.write("#"*(i+1))# number of # denotes the progress completed 
    sys.stdout.flush()
    time.sleep(0.1)