Pythonプログレスバー

スクリプトで時間がかかる可能性のあるタスクを実行しているときに、プログレスバーを使用するにはどうすればよいですか？

たとえば、完了するまでしばらく時間がかかり、完了時に戻る関数Trueです。関数の実行中に進行状況バーを表示するにはどうすればよいですか？

これはリアルタイムで行う必要があるため、どうすればよいかわからないことに注意してください。threadこれにはが必要ですか？何も思いつきません。

現在、関数の実行中は何も印刷していませんが、進行状況バーがいいです。また、これをコードの観点からどのように行うことができるかについても興味があります。

特定のライブラリー（この例のようにここにあります）がありますが、おそらく非常に単純なもので十分です。

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」記号をコンソールに直接送信して、カーソルを最初に戻します。Pythonの「印刷」は、この目的のために上記のシンボルを認識しません。したがって、「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

この回答は外部パッケージに依存していません。ほとんどの人は既製のコードを必要としていると思います。以下のコードは'#'、バープログレスシンボル、バーsize、テキスト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

• 2番目のスレッドは必要ありません。上記のいくつかのソリューション/パッケージには必要です。jupyter notebookたとえば、の場合、2番目のスレッドが問題になることがあります。

• イテラブルで動作し、それは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を取得するには、ステップ数を宣言できる必要があります。

それで、あなたの計算関数は別のスレッドにありますが、それをいくつかの論理的なステップに分割できますか？そのコードを変更できますか？

それをリファクタリングしたり、実際のメソッドで分割したりする必要はありません。戦略的なyieldをいくつかの場所に配置するだけでよいのです。高価な関数にforループがある場合 1つだけ入れます。最良の結果を得るには、最終的にどのくらいの利回りが得られるかを知っているだけです。

そうすれば、関数は次のようになります。

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

楽しんで！

以下のコードは非常に一般的なソリューションであり、経過時間と残り時間の見積もりも含まれています。あなたはそれとともにイテラブルを使うことができます。プログレスバーのサイズは25文字に固定されていますが、フル、ハーフ、クォーターのブロック文字を使用して、更新を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"

必要に応じて、タイミングの精度を上げることができます。

私はガブリエルの答えが好きですが、柔軟に変更しました。バーの長さを関数に送信し、任意の長さのプログレスバーを取得できます。また、ゼロまたは負の長さのプログレスバーはありません。また、この関数をガブリエルアンサーのように使用できます（例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で転送している場合、特定のサイズのバッファー（128Kなど）を取得するようにftplibに指示し、128kが表すファイルサイズのパーセンテージをプログレスバーに追加できます。CLIを使用していて、進行状況メーターが20文字の場合、ファイルの1/20が転送されたときに1文字追加します。

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