Question

当我的脚本执行可能需要一些时间的任务时，如何使用进度条？

例如，一个需要一些时间才能完成的函数，并在完成后返回True。如何在执行功能期间显示进度条？

请注意，我需要这是实时的，所以我无法弄清楚如何处理它。我需要thread吗？我不知道。

现在我正在执行函数时不打印任何内容，但是进度条会很好。此外，我更感兴趣的是从代码的角度来看如何做到这一点。

Answer 1

使用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")忽略它，但在此之后它会忽略代码中的所有警告。

Answer 2

有特定的库（like this one 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

注意：此进度条是progressbar的分支，多年来一直没有维护。

Answer 3

上述建议非常好，但我认为大多数人只是想要一个现成的解决方案，不依赖于外部包，但也可以重用。

我得到了以上所有内容的最佳分数，并将其作为一个函数和测试用例。

要使用它，只需复制“def update_progress（progress）”下的行，但不要复制测试脚本。不要忘记导入sys。无论何时需要显示或更新进度条，都要调用此方法。

这可以直接将“\ r”符号发送到控制台，将光标移回开头。 python中的“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(100):
    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: [##########] 99.0%
Test completed

Answer 4

对于类似的应用程序（跟踪循环中的进度）我只是使用了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

Answer 5

在这里搜索一个等效的解决方案后，我刚刚为我的需求做了一个简单的进度课程。我以为我可能会发布它。

$.ajax

示例：

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

Answer 6

这个答案不依赖于外部软件包，我也认为大多数人只想要一条现成的代码。下面的代码可以通过自定义来调整以满足您的需求：条形进度符号'#'，条形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

不需要第二个帖子。上面的一些解决方案/包需要。例如，对于jupyter notebook，第二个线程可能是个问题。
适用于任何可迭代的，这意味着可以使用len()的任何内容。一个list，一个dict的任何内容，例如['a', 'b', 'c' ... 'g']

您还可以通过将文件更改为sys.stderr来更改输出，例如

Answer 7

从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

Answer 8

我喜欢Brian Khuu's answer，因为它简单而且不需要外部包。我稍微改了一下，所以我在这里添加我的版本：

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%

Answer 9

我非常喜欢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()])

Answer 10

如果它是一个具有固定迭代次数的大循环，需要花费很多时间才能使用我所做的这个功能。循环的每次迭代都会增加进度。其中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 [==========          ]

Answer 11

要以有用的方式使用任何进度条框架，即获取实际进度百分比和估计的ETA，您需要能够声明将要执行的步骤数。

那么，您的计算功能在另一个线程中，是否可以将其拆分为多个逻辑步骤？您可以修改其代码吗？

您不需要重构它或将其拆分为实际方法，只需在其中的某些位置放置一些策略性yield即可！如果昂贵的函数有一个 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:
    for i in compute():
        bar()

要获得一个很棒的进度条！

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

免责声明：我是alive_bar的作者，但它应该可以很好地解决您的问题。阅读https://github.com/rsalmei/alive-progress上的文档，这是它可以做什么的示例：

alive-progress

Answer 12

您可以使用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 ]

您可以根据需要对其进行更改和自定义。

Answer 13

使用此库：fish（GitHub）。

用法：

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

玩得开心！

Answer 14

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

Answer 15

我喜欢这个page。

从简单示例开始，转到多线程版本。开箱即用。不需要第三方包裹。

代码看起来像这样：

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

Answer 16

以下代码是一个非常通用的解决方案，并且还有一段时间和剩余时间估算。你可以使用任何iterable。进度条的固定大小为25个字符，但它可以使用完整，半个和四分之一块字符以1％的步长显示更新。输出如下：

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

代码示例：

import sys, time
from numpy import linspace

def ProgressBar(iterObj, refreshTime=10):
  #refreshTime=10: refresh the time estimate at least every 10 sec.
  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(np.linspace(0,L,  min(100,L),endpoint=False), 
                                     np.linspace(0,100,min(100,L),endpoint=False))}
  qSteps  = ['', u'\u258E',u'\u258C',u'\u258A'] # quarter and half block chars
  startT  = endT = time.time()
  timeStr = ' [0:00:00, -:--:--]'
  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+timeStr); sys.stdout.flush()
    elif time.time()-endT > refreshTime:
      endT    = time.time()
      timeStr = ' [%s, %s]'%(SecToStr(endT-startT), SecToStr((endT-startT)*(L/float(nn)-1)))
      sys.stdout.write('\r'+barStr+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 op in ProgressBar(list('Disassemble and reassemble this string')):
  time.sleep(0.5)
  s += op
print s

欢迎提出改进建议或其他意见。玩得开心。

Answer 17

在jupyter笔记本中运行时，无法正常使用tqdm，因为它会在多行上写入输出。改用它：

beta

Answer 18

这是我的简单解决方案：

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

Answer 19

如果您的工作无法分解为可测量的块，您可以在新线程中调用您的函数并计算所需的时间：

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"

显然，您可以根据需要提高计时精度。

Answer 20

使用progress library！

height

这是我编写的一个自定义子类，用于将ETA /经过时间格式化为更好的可读格式：

blur

Answer 21

一种非常简单的方法：

def progbar(count: int) -> None:
    for i in range(count):
        print(f"[{i*'#'}{(count-1-i)*' '}] - {i+1}/{count}", end="\r")
        yield i
    print('\n')

用法：

from time import sleep

for i in progbar(10):
    sleep(0.2) #whatever task you need to do

Answer 22

我使用了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%

Answer 23

尝试PyProg。 PyProg是一个Python的开源库，可以创建超级自定义的进度指示器。杆

目前版本为1.0.2;它托管在Github上，可在PyPI上获得（下面的链接）。它与Python 3＆amp; 2，它也可以用于Qt控制台。

它非常易于使用。以下代码：

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/

Answer 24

我喜欢Gabriel回答，但我改变它是灵活的。您可以向该功能发送条形长度，并获得您想要的任何长度的进度条。并且您不能拥有零或负长度的进度条。此外，您可以使用此功能，如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％

完成。

Answer 25

这是一个以编程方式构建加载栏的简短解决方案（您必须决定需要多长时间）。

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)

Answer 26

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设置为小节的字符数

Answer 27

使用os_sys库：

我将其用于多种类型的酒吧，例如：

from os_sys.progress import bar as Bar bar = Bar('progresing: ', max=20) for i in range(20): #do somthing bar.next() bar.finish() 您的输出将是：

procesing:  |######                          | 2/10

在os_sys的说明中了解更多信息

Answer 28

猜猜我来晚了一点，但这应该适用于使用当前版本的python 3 的人们，因为它使用了“ f-strings” ，如介绍的那样在Python 3.6 PEP 498中：

代码

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%

Answer 29

这是创建进度条的简单方法

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)

Answer 30

您也可以使用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()

Answer 31

此进度条显示每完成2％的点数和每完成10％的点数。

import sys

def ProgressBar (num, total, nextPercent, nextPoint):
    num = float (num)
    total = float (total) - 1
    if not nextPoint:
        nextPoint = 0.0
    if not nextPercent:
        nextPoint += 2.0
        sys.stdout.write ("[0%")
        nextPercent = 10
    elif num == total:
        sys.stdout.write ("100%]\n")
        nextPercent += 10
    elif not nextPoint:
        nextPoint = 0.0
    elif num / total * 100 >= nextPercent:
        sys.stdout.write (str(int (nextPercent)) + "%")
        nextPercent += 10
    elif num / total * 100 >= nextPoint:
        sys.stdout.write (":")
        nextPoint += 2
    return (nextPercent, nextPoint)

nextPercent, nextPoint = 0, 0
total = 1000

for num in range (total):
    nextPercent, nextPoint = ProgressBar (num, total, nextPercent, nextPoint)

结果：

>>> 
[0%::::10%:::::20%:::::30%:::::40%:::::50%:::::60%:::::70%:::::80%:::::90%:::::100%]
>>>

Answer 32

@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的状态

Answer 33

一个简单的解决方案！

void = '-'
fill = '#'
count = 100/length
increaseCount = 0
for i in range(length):
    print('['+(fill*i)+(void*(length-i))+'] '+str(int(increaseCount))+'%',end='\r')
    increaseCount += count
    time.sleep(0.1)
print('['+(fill*(i+1))+(void*(length-(i+1)))+'] '+str(int(increaseCount))+'%',end='\n')

注意：您可以根据需要修改填充和“空”字符。

The loading bar (picture)

Answer 34

您应该将进度条链接到手头的任务（以便它测量进度：D）。例如，如果你正在FTP文件，你可以告诉ftplib获取一个特定大小的缓冲区，假设128K，然后你添加到你的进度条128k所代表的文件大小百分比。如果您使用的是CLI，并且进度表长度为20个字符，则在传输文件的1/20时添加一个字符。

Answer 35

我使用 wget，如果在 mac 或 linux 上，您必须在 windows 或终端的 cmd 提示符中安装模块

pip install wget

很简单，只需使用download()函数

import wget
url = input("Enter Url to download: ")
wget.download(url)

tqdm 也是一个选项，你也必须下载模块。

pip install tqdm

现在确保导入模块，设置范围并通过

from tqdm import tqdm
for i in tqdm(range(int(9e7))):
    pass

Answer 36

iterrows 的进度条。 @eusoubrasileiro 代码的改编，用于在循环遍历数据帧的行时显示进度。此外还显示百分比、第 i 个/计数、经过的秒数、迭代次数/秒、剩余秒数。允许指定第 n 个更新计数（每个）。

import time
import sys
def progressbar_iterrows(df, prefix="", size=60, file=sys.stdout, per=1000):
    count = len(df)
    t = 0
    def show(j,elapsed):
        avg = 0 if elapsed == 0 else j/elapsed
        remaining = 0 if avg == 0 else (count-j)/avg
        x = int(size*j/count)
        file.write("%s[%s%s] %i%% %i/%i elapsed:%i %i/sec remaining:%i\r" % (prefix, "#"*x, "."*(size-x), j/count, j, count, elapsed, avg, remaining))
        file.flush()
    file.write("Initializing ...\r")
    file.flush()
    for i, item in df.iterrows():
        yield i,item
        if t == 0:
            t = time.time()
        if i % per == 0:
            show(i,time.time()-t)
    file.write("\n")
    file.flush()

用法：

    for n,r in progressbar_iterrows(br_b_sections_df, "Processed: "):
        # do something

输出：

Processed: [........................] 0% 5000/28751240 elapsed:12 413/sec remaining:55054

Answer 37

0    orange
1     mango
2    orange
3     apple
4     apple
5     apple
6     apple
dtype: object

output

Answer 38

这是一个非常简单的版本，以防万一您有一个循环并且只想了解迭代的进展情况，例如每进行5000次迭代就有一个点。

my_list = range(0,100000)

counter = 0
for x in my_list:
    #your code here

    counter = counter + 1
    if counter % 5000 == 0:
        print(".", end="") # end="" avoids a newline, keeps dots together

print() #this makes sure whatever you print next is in a new line

my_list不属于该计划。无论您要遍历什么，都可以使用自己的可迭代对象。此版本不会提前告诉您总迭代次数。

Python进度条

38 个答案: