파이썬 진행률 표시 줄

스크립트에서 시간이 걸리는 작업을 수행 할 때 진행률 표시 줄을 어떻게 사용합니까?

예를 들어 완료하는 데 시간이 걸리고 완료되면 반환되는 함수입니다 True. 함수가 실행되는 동안 진행률 표시 줄을 표시하려면 어떻게해야합니까?

실시간으로해야하므로 어떻게해야하는지 알 수 없습니다. thread이것을 위해 필요 합니까? 나도 몰라

현재 함수가 실행되는 동안 아무것도 인쇄하지 않지만 진행률 표시 줄은 좋을 것입니다. 또한 코드 관점 에서이 작업을 수행하는 방법에 더 관심이 있습니다.

특정 라이브러리 ( here와 같은 )가 있지만 매우 간단한 작업이 있습니다.

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

참고 : progressbar2 는 몇 년 동안 유지되지 않은 진행률 표시 줄 입니다.

tqdm 을 사용하면 순식간에 루프에 진행 미터를 추가 할 수 있습니다.

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]

또한 v2.0.0( d977a0c) 이후 tqdm의 그래픽 버전이 있습니다 .

In [1]: import time

In [2]: from tqdm import tqdm_gui

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

그러나 tqdm_gui를 올릴 TqdmExperimentalWarning: GUI is experimental/alpha수 있으므로을 사용하여 무시할 수는 warnings.simplefilter("ignore")있지만 코드 이후의 모든 경고는 무시합니다.

위의 제안은 꽤 좋지만 대부분의 사람들은 외부 패키지에 의존하지 않고 이미 준비된 솔루션을 원하지만 재사용 할 수 있다고 생각합니다.

나는 위의 모든 것의 가장 좋은 점을 얻었고 그것을 테스트 케이스와 함께 기능으로 만들었습니다.

사용하려면 테스트 스크립트가 아닌 "def update_progress (progress)"아래의 행을 복사하십시오. sys를 가져 오는 것을 잊지 마십시오. 진행률 표시 줄을 표시하거나 업데이트해야 할 때마다 이것을 호출하십시오.

이것은 "\ r"기호를 콘솔에 직접 전송하여 커서를 시작으로 다시 이동시키는 방식으로 작동합니다. 파이썬의 "print"는 이러한 목적으로 위의 기호를 기억하지 않으므로 '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)

테스트 스크립트 결과는 다음과 같습니다 (마지막 진행률 표시 줄 애니메이션).

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

이 답변은 외부 패키지에 의존하지 않으며 대부분의 사람들은 기성품 코드를 원한다고 생각합니다 . 아래 코드는 bar progress symbol '#', bar size, text prefix등 을 사용자 정의하여 필요에 맞게 조정할 수 있습니다 .

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

용법:

import time

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

산출:

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

• 두 번째 스레드가 필요하지 않습니다 . 위의 일부 솔루션 / 패키지에 필요합니다. jupyter notebook예를 들어 두 번째 스레드는 문제가 될 수 있습니다 .

• iterable과 함께len() 사용할 수 있으며 사용할 수있는 모든 것을 의미 합니다. A list, dict예를 들어 무엇이든['a', 'b', 'c' ... 'g']

sys.stderr예를 들어 파일을 변경하여 출력을 변경할 수도 있습니다

비슷한 응용 프로그램 (루프에서 진행 상황을 추적)을 위해 간단히 python-progressbar 를 사용했습니다 .

그들의 예는 다음과 같습니다.

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 에서 진행 하십시오 .

from progress.bar import Bar

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

결과는 다음과 같은 막대가됩니다.

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

방금 동등한 솔루션을 검색 한 후 내 요구에 맞는 간단한 진행 클래스를 만들었습니다. 나는 그것을 잘 게시 할 수 있다고 생각했습니다.

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)

예 :

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

다음을 인쇄합니다 :

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

나는 단순성과 외부 패키지가 필요하지 않은 Brian Khuu의 대답 을 좋아 합니다. 조금 변경하여 여기에 내 버전을 추가하고 있습니다.

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)

총 실행 횟수 ( total)와 지금까지 처리 된 실행 횟수 ( progress)를 가정 total >= progress합니다. 결과는 다음과 같습니다.

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

tqdm 을 사용할 수 있습니다 :

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)

이 예제에서 진행률 표시 줄은 5 분 동안 실행되며 다음과 같이 표시됩니다.

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

원하는대로 변경하고 사용자 지정할 수 있습니다.

진행률 표시 줄 프레임 워크를 유용한 방식으로 사용하려면 (예 : 실제 진행률 및 예상 ETA를 얻으려면) 얼마나 많은 단계를 수행해야하는지 선언 할 수 있어야합니다.

따라서 다른 스레드에서 계산 함수를 여러 논리 단계로 나눌 수 있습니까? 코드를 수정할 수 있습니까?

리팩토링하거나 실제 방법으로 나눌 필요가 없습니다. 전략적 yields를 내부의 일부 위치에 넣을 수 있습니다! 고가의 함수에 for 루프 가 있으면 하나만 넣으십시오. 최상의 결과를 얻으려면 수율이 얼마나 될지 마지막에 알아야합니다.

그런 식으로 함수는 다음과 같습니다.

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

아니면 이거:

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

이러한 종류의 기능으로 다음을 설치할 수 있습니다.

pip install alive-progress

그리고 그것을 다음과 같이 사용하십시오 :

from alive_progress import alive_bar

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

멋진 진행률 표시 줄을 얻으려면!

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

면책 조항 : 저는 alive_progress의 저자이지만 문제를 잘 해결해야합니다. https://github.com/rsalmei/alive-progress 의 설명서를 읽으십시오. 여기에 수행 할 수있는 작업의 예가 있습니다.

사용하기 매우 간단하기 때문에 python-progressbar 정말 좋아합니다 .

가장 간단한 경우는 다음과 같습니다.

import progressbar
import time

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

모양을 사용자 지정할 수 있으며 남은 예상 시간을 표시 할 수 있습니다. 예를 들어 위와 동일한 코드를 사용하지만 다음과 함께 사용하십시오.

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

시간이 많이 걸리는 고정 된 반복 횟수의 큰 루프 인 경우이 기능을 사용할 수 있습니다. 루프가 반복 될 때마다 진행 상황이 추가됩니다. count가 루프의 현재 반복 인 경우 total은 루프하는 값이고 size (int)는 10 씩 증가하는 막대의 크기를 원하는 크기입니다 (예 : 크기 1 = 10 자, 크기 2 = 20 자)

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 + ']')

예:

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

산출:

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

이 라이브러리를 사용하십시오 : fish( GitHub ).

용법:

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

즐기세요!

아래 코드는 매우 일반적인 솔루션이며 시간이 경과하고 남은 시간이 추정됩니다. iterable과 함께 사용할 수 있습니다. 진행률 표시 줄의 크기는 25 자로 고정되어 있지만 전체, 반 및 1/4 블록 문자를 사용하여 1 % 단계로 업데이트를 표시 할 수 있습니다. 결과는 다음과 같습니다.

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

예제 코드 :

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)

개선 제안이나 다른 의견에 감사드립니다. 건배!

나는이 페이지를 좋아한다 .

간단한 예제로 시작하여 멀티 스레드 버전으로 이동합니다. 상자 밖으로 작동합니다. 타사 패키지가 필요하지 않습니다.

코드는 다음과 같습니다.

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)

또는 다음은 프로그램이 실행되는 동안 회전 로딩 바를 실행하기 위해 스레드를 사용하는 예입니다.

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에서는 매우 간단합니다.

   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 노트북에서 실행할 때 일반 tqdm을 사용하면 출력이 여러 줄에 기록되므로 작동하지 않습니다. 대신 이것을 사용하십시오 :

import time
from tqdm import tqdm_notebook as tqdm

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

작업을 측정 가능한 덩어리로 나눌 수없는 경우 새 스레드에서 시간이 걸리는 함수를 호출 할 수 있습니다.

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"

필요에 따라 타이밍 정밀도를 분명히 높일 수 있습니다.

나는 가브리엘의 대답을 좋아 하지만 유연하게 변경했습니다. 막대 길이를 함수에 보내고 원하는 길이의 진행 막대를 가져올 수 있습니다. 길이가 0이거나 음수 인 진행률 표시 줄을 가질 수 없습니다. 또한 Gabriel 답변 과 같은이 기능을 사용할 수 있습니다 (예제 2 참조).

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)

결과:

간단한 진행 표시 줄입니다.

실시 예 # 1

진행률 : [### -------] 30 %

실시 예 # 2

진행률 : [|||||||||||| ........] 60 %

끝난.

내가 사용하는 format()로드 바를 만드는 방법. 내 해결책은 다음과 같습니다.

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

산출:

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

프로그래밍 방식으로 로딩 바를 만드는 짧은 솔루션이 있습니다 (원하는 길이를 결정해야 함).

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를 사용해보십시오. PyProg는 Python이 오픈 소스 라이브러리로 사용자 정의 가능한 진행률 표시기 및 막대를 생성합니다.

현재 버전은 1.0.2입니다. Github에서 호스팅되며 PyPI에서 사용할 수 있습니다 (아래 링크 참조). Python 3 & 2와 호환되며 Qt Console과 함께 사용할 수도 있습니다.

정말 사용하기 쉽습니다. 다음 코드 :

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

생산할 것이다 :

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

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

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

간단하지만 매우 사용자 정의 가능한 진행률 표시 줄 라이브러리가 필요했기 때문에 실제로 PyProg를 만들었습니다. 다음과 같이 쉽게 설치할 수 있습니다 pip install pyprog..

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

enlighten 을 사용할 수도 있습니다 . 주요 이점은 진행률 표시 줄을 덮어 쓰지 않고 동시에 로그인 할 수 있다는 것입니다.

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

또한 여러 진행률 표시 줄을 처리합니다.

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

진행 라이브러리를 사용하십시오 !

pip install progress

다음은 ETA / 경과 시간을 더 읽기 쉬운 형식으로 형식화하기 위해 작성한 사용자 정의 서브 클래스입니다.

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

이것은 내 간단한 해결책입니다.

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

진행률 표시 줄을 현재 작업에 연결해야합니다 (진행률을 측정하려면 : D). 예를 들어, 파일을 FTP하는 경우 ftplib에 특정 크기의 버퍼를 가져 와서 128K라고 말한 다음 파일 크기의 128k가 나타내는 비율을 진행률 표시 줄에 추가 할 수 있습니다. CLI를 사용하고 진행 미터의 길이가 20자인 경우 파일의 1/20이 전송 될 때 하나의 문자를 추가합니다.

@ Massagran : 내 프로그램에서 잘 작동합니다. 또한 루프 시간을 나타 내기 위해 카운터를 추가해야합니다. 이 카운터는 메소드의 인수로 사용 update됩니다. 예를 들어 : 테스트 파일의 모든 줄을 읽고 무언가를 처리하십시오. 함수 dosth()가 변수에 관여하지 않는다고 가정 하십시오 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()

변수 i는 pbar방법 을 통해 상태를 제어합니다update

jelde015에 대한 좀 더 일반적인 대답 (물론 그에게 신용)

로딩 바를 수동으로 업데이트하는 방법 은 다음과 같습니다.

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)
                     + ']')

그리고 그것을 호출 :

loadingBar(7, 220, 40)

결과 :

007/220 [=                                       ]  

현재 i값으로 원할 때마다 호출하십시오 .

size바의 문자 수로 설정

내가 조금 늦었다 고 생각하지만 이것은 Python 3.6 PEP 498에 소개 된 것처럼 "f-strings"를 사용하기 때문에 현재 버전의 python 3을 사용하는 사람들에게 효과적이어야합니다 .

암호

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

예

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

산출

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

진행률 표시 줄을 만드는 간단한 방법입니다.

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)