Thanh tiến trình văn bản trong bảng điều khiển [đã đóng]

Tôi đã viết một ứng dụng bảng điều khiển đơn giản để tải lên và tải xuống các tệp từ máy chủ FTP bằng cách sử dụng ftplib.

Tôi muốn ứng dụng hiển thị một số hình ảnh về tiến trình tải xuống / tải lên của nó cho người dùng; mỗi khi một đoạn dữ liệu được tải xuống, tôi muốn nó cung cấp một bản cập nhật tiến độ, ngay cả khi đó chỉ là một biểu diễn số như tỷ lệ phần trăm.

Điều quan trọng, tôi muốn tránh xóa tất cả văn bản đã được in ra bàn điều khiển trong các dòng trước đó (nghĩa là tôi không muốn "xóa" toàn bộ thiết bị đầu cuối trong khi in tiến trình cập nhật).

Đây có vẻ là một nhiệm vụ khá phổ biến - làm cách nào tôi có thể tạo một thanh tiến trình hoặc trực quan hóa tương tự xuất ra bảng điều khiển của mình trong khi duy trì đầu ra chương trình trước đó?

Một thanh tiến trình đơn giản, có thể tùy chỉnh

Đây là tổng hợp của nhiều câu trả lời dưới đây mà tôi sử dụng thường xuyên (không yêu cầu nhập khẩu).

# Print iterations progress
def printProgressBar (iteration, total, prefix = '', suffix = '', decimals = 1, length = 100, fill = '█', printEnd = "\r"):
    """
    Call in a loop to create terminal progress bar
    @params:
        iteration   - Required  : current iteration (Int)
        total       - Required  : total iterations (Int)
        prefix      - Optional  : prefix string (Str)
        suffix      - Optional  : suffix string (Str)
        decimals    - Optional  : positive number of decimals in percent complete (Int)
        length      - Optional  : character length of bar (Int)
        fill        - Optional  : bar fill character (Str)
        printEnd    - Optional  : end character (e.g. "\r", "\r\n") (Str)
    """
    percent = ("{0:." + str(decimals) + "f}").format(100 * (iteration / float(total)))
    filledLength = int(length * iteration // total)
    bar = fill * filledLength + '-' * (length - filledLength)
    print('\r%s |%s| %s%% %s' % (prefix, bar, percent, suffix), end = printEnd)
    # Print New Line on Complete
    if iteration == total: 
        print()

Lưu ý: Đây là cho Python 3; xem các bình luận để biết chi tiết về cách sử dụng này trong Python 2.

Sử dụng mẫu

import time

# A List of Items
items = list(range(0, 57))
l = len(items)

# Initial call to print 0% progress
printProgressBar(0, l, prefix = 'Progress:', suffix = 'Complete', length = 50)
for i, item in enumerate(items):
    # Do stuff...
    time.sleep(0.1)
    # Update Progress Bar
    printProgressBar(i + 1, l, prefix = 'Progress:', suffix = 'Complete', length = 50)

Đầu ra mẫu:

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

Cập nhật

Đã có thảo luận trong các ý kiến ​​liên quan đến một tùy chọn cho phép thanh tiến trình điều chỉnh linh hoạt theo chiều rộng cửa sổ đầu cuối. Mặc dù tôi không khuyến nghị điều này, đây là một ý chính thực hiện tính năng này (và lưu ý các cảnh báo).

Viết '\ r' sẽ di chuyển con trỏ trở lại đầu dòng.

Điều này sẽ hiển thị một bộ đếm phần trăm:

import time
import sys

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

tqdm: thêm đồng hồ đo tiến độ vào các vòng lặp của bạn trong một giây :

>>> import time
>>> from tqdm import tqdm
>>> for i in tqdm(range(100)):
...     time.sleep(1)
... 
|###-------| 35/100  35% [elapsed: 00:35 left: 01:05,  1.00 iters/sec]

Viết một cái \rcho bàn điều khiển. Đó là một "trở về vận chuyển" làm cho tất cả các văn bản sau nó được lặp lại ở đầu dòng. Cái gì đó như:

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

sẽ cung cấp cho bạn một cái gì đó như: [ ########## ] 100%

Nó là ít hơn 10 dòng mã.

Ý chính ở đây: https://gist.github.com/vladignatyev/06860ec2040cb497f0f3

import sys


def progress(count, total, suffix=''):
    bar_len = 60
    filled_len = int(round(bar_len * count / float(total)))

    percents = round(100.0 * count / float(total), 1)
    bar = '=' * filled_len + '-' * (bar_len - filled_len)

    sys.stdout.write('[%s] %s%s ...%s\r' % (bar, percents, '%', suffix))
    sys.stdout.flush()  # As suggested by Rom Ruben

Hãy thử thư viện nhấp chuột được viết bởi Mozart of Python, Armin Ronacher.

$ pip install click # both 2 and 3 compatible

Để tạo một thanh tiến trình đơn giản:

import click

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

Đây là những gì nó trông giống như:

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

Tùy chỉnh nội dung trái tim của bạn:

import click, sys

with click.progressbar(range(100000), file=sys.stderr, show_pos=True, width=70, bar_template='(_(_)=%(bar)sD(_(_| %(info)s', fill_char='=', empty_char=' ') as bar:
    for i in bar:
        pass

Giao diện tùy chỉnh:

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

Thậm chí còn có nhiều tùy chọn hơn, xem tài liệu API :

 click.progressbar(iterable=None, length=None, label=None, show_eta=True, show_percent=None, show_pos=False, item_show_func=None, fill_char='#', empty_char='-', bar_template='%(label)s [%(bar)s] %(info)s', info_sep=' ', width=36, file=None, color=None)

Tôi nhận ra rằng tôi đã trễ trò chơi, nhưng đây là một kiểu hơi Yum (Mũ đỏ) mà tôi đã viết (sẽ không chính xác 100% ở đây, nhưng nếu bạn đang sử dụng thanh tiến trình cho mức độ chính xác đó, thì bạn dù sao cũng SAU):

import sys

def cli_progress_test(end_val, bar_length=20):
    for i in xrange(0, end_val):
        percent = float(i) / end_val
        hashes = '#' * int(round(percent * bar_length))
        spaces = ' ' * (bar_length - len(hashes))
        sys.stdout.write("\rPercent: [{0}] {1}%".format(hashes + spaces, int(round(percent * 100))))
        sys.stdout.flush()

Nên tạo ra một cái gì đó trông như thế này:

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

... Trong đó dấu ngoặc đứng yên và chỉ có giá trị băm tăng.

Điều này có thể làm việc tốt hơn như là một trang trí. Vào một ngày khác...

Kiểm tra thư viện này: clint

nó có rất nhiều tính năng bao gồm một thanh tiến trình:

from time import sleep  
from random import random  
from clint.textui import progress  
if __name__ == '__main__':
    for i in progress.bar(range(100)):
        sleep(random() * 0.2)

    for i in progress.dots(range(100)):
        sleep(random() * 0.2)

liên kết này cung cấp một cái nhìn tổng quan nhanh về các tính năng của nó

Đây là một ví dụ hay về thanh tiến trình được viết bằng Python: http://nadiana.com/animated-terminal-proTHER-bar-in-python

Nhưng nếu bạn muốn tự viết nó. Bạn có thể sử dụng cursesmô-đun để làm cho mọi thứ dễ dàng hơn :)

[sửa] Có lẽ dễ dàng hơn không phải là từ để nguyền rủa. Nhưng nếu bạn muốn tạo ra một cui đầy đủ hơn những lời nguyền thì sẽ chăm sóc rất nhiều thứ cho bạn.

[sửa] Vì liên kết cũ đã chết, tôi đã đưa ra phiên bản Python Progressbar của riêng mình, hãy truy cập vào đây: https://github.com/WoLpH/python-proTHERbar

import time,sys

for i in range(100+1):
    time.sleep(0.1)
    sys.stdout.write(('='*i)+(''*(100-i))+("\r [ %d"%i+"% ] "))
    sys.stdout.flush()

đầu ra

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

và, chỉ để thêm vào đống, đây là một đối tượng bạn có thể sử dụng

import sys

class ProgressBar(object):
    DEFAULT_BAR_LENGTH = 65
    DEFAULT_CHAR_ON  = '='
    DEFAULT_CHAR_OFF = ' '

    def __init__(self, end, start=0):
        self.end    = end
        self.start  = start
        self._barLength = self.__class__.DEFAULT_BAR_LENGTH

        self.setLevel(self.start)
        self._plotted = False

    def setLevel(self, level):
        self._level = level
        if level < self.start:  self._level = self.start
        if level > self.end:    self._level = self.end

        self._ratio = float(self._level - self.start) / float(self.end - self.start)
        self._levelChars = int(self._ratio * self._barLength)

    def plotProgress(self):
        sys.stdout.write("\r  %3i%% [%s%s]" %(
            int(self._ratio * 100.0),
            self.__class__.DEFAULT_CHAR_ON  * int(self._levelChars),
            self.__class__.DEFAULT_CHAR_OFF * int(self._barLength - self._levelChars),
        ))
        sys.stdout.flush()
        self._plotted = True

    def setAndPlot(self, level):
        oldChars = self._levelChars
        self.setLevel(level)
        if (not self._plotted) or (oldChars != self._levelChars):
            self.plotProgress()

    def __add__(self, other):
        assert type(other) in [float, int], "can only add a number"
        self.setAndPlot(self._level + other)
        return self
    def __sub__(self, other):
        return self.__add__(-other)
    def __iadd__(self, other):
        return self.__add__(other)
    def __isub__(self, other):
        return self.__add__(-other)

    def __del__(self):
        sys.stdout.write("\n")

if __name__ == "__main__":
    import time
    count = 150
    print "starting things:"

    pb = ProgressBar(count)

    #pb.plotProgress()
    for i in range(0, count):
        pb += 1
        #pb.setAndPlot(i + 1)
        time.sleep(0.01)
    del pb

    print "done"

kết quả trong:

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

Điều này thường được coi là "trên hết", nhưng nó rất tiện lợi khi bạn sử dụng nó nhiều

Cài đặt tqdm. ( pip install tqdm) Và sử dụng nó như sau:

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

Đó là thanh tiến trình 10 giây sẽ tạo ra thứ gì đó như thế này:

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

Chạy lệnh này tại dòng lệnh Python ( không phải trong bất kỳ môi trường IDE hoặc môi trường phát triển nào):

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

Hoạt động tốt trên hệ thống Windows của tôi.

• http://code.activestate.com/recipes/168639-proTHER-bar- class / (2002)
• http://code.activestate.com/recipes/299207-console-text-proTHER-indicator- class / (2004)
• http://pypi.python.org/pypi/proTHERbar (2006)

Và rất nhiều hướng dẫn đang chờ để được googled.

Tôi đang sử dụng tiến trình từ reddit . Tôi thích nó bởi vì nó có thể in tiến trình cho mọi mục trong một dòng và nó không nên xóa các bản in ra khỏi chương trình.

Chỉnh sửa: liên kết cố định

dựa trên các câu trả lời ở trên và các câu hỏi tương tự khác về thanh tiến trình CLI, tôi nghĩ rằng tôi đã có một câu trả lời chung cho tất cả chúng. Kiểm tra nó tại https://stackoverflow.com/a/15860757/2254146

Tóm lại, mã này là:

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

Giống như

Phần trăm: [##########] 99,0%

Tôi khuyên bạn nên sử dụng tqdm - https://pypi.python.org/pypi/tqdm - điều này giúp đơn giản để biến bất kỳ lần lặp hoặc xử lý nào thành một thanh tiến trình và xử lý tất cả các lỗi lộn xộn với các thiết bị đầu cuối cần thiết.

Từ tài liệu: "tqdm có thể dễ dàng hỗ trợ các cuộc gọi lại / hook và cập nhật thủ công. Đây là một ví dụ với urllib"

import urllib
from tqdm import tqdm

def my_hook(t):
  """
  Wraps tqdm instance. Don't forget to close() or __exit__()
  the tqdm instance once you're done with it (easiest using `with` syntax).

  Example
  -------

  >>> with tqdm(...) as t:
  ...     reporthook = my_hook(t)
  ...     urllib.urlretrieve(..., reporthook=reporthook)

  """
  last_b = [0]

  def inner(b=1, bsize=1, tsize=None):
    """
    b  : int, optional
        Number of blocks just transferred [default: 1].
    bsize  : int, optional
        Size of each block (in tqdm units) [default: 1].
    tsize  : int, optional
        Total size (in tqdm units). If [default: None] remains unchanged.
    """
    if tsize is not None:
        t.total = tsize
    t.update((b - last_b[0]) * bsize)
    last_b[0] = b
  return inner

eg_link = 'http://www.doc.ic.ac.uk/~cod11/matryoshka.zip'
with tqdm(unit='B', unit_scale=True, miniters=1,
          desc=eg_link.split('/')[-1]) as t:  # all optional kwargs
    urllib.urlretrieve(eg_link, filename='/dev/null',
                       reporthook=my_hook(t), data=None)

Hãy thử cài đặt gói này pip install progressbar2::

import time
import progressbar

for i in progressbar.progressbar(range(100)):
    time.sleep(0.02)

thanh tiến trình github: https://github.com/WoLpH/python-proTHERbar

Một giải pháp rất đơn giản là đặt mã này vào vòng lặp của bạn:

Đặt phần này vào phần thân (tức là trên cùng) của tệp của bạn:

import sys

Đặt cái này trong phần thân của vòng lặp của bạn:

sys.stdout.write("-") # prints a dash for each iteration of loop
sys.stdout.flush() # ensures bar is displayed incrementally

import sys
def progresssbar():
         for i in range(100):
            time.sleep(1)
            sys.stdout.write("%i\r" % i)

progressbar()

LƯU Ý: nếu bạn chạy cái này trong bộ tương tác, bạn sẽ nhận được thêm số

lol tôi chỉ viết toàn bộ điều này cho mã này, hãy nhớ rằng bạn không thể sử dụng unicode khi thực hiện chặn ascii tôi sử dụng cp437

import os
import time
def load(left_side, right_side, length, time):
    x = 0
    y = ""
    print "\r"
    while x < length:
        space = length - len(y)
        space = " " * space
        z = left + y + space + right
        print "\r", z,
        y += "█"
        time.sleep(time)
        x += 1
    cls()

và bạn gọi nó như vậy

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

nó trông như thế này

loading something awesome
|█████     |

Với những lời khuyên tuyệt vời ở trên, tôi tìm ra thanh tiến trình.

Tuy nhiên tôi muốn chỉ ra một số thiếu sót

1. Mỗi khi thanh tiến trình được tuôn ra, nó sẽ bắt đầu trên một dòng mới

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

   như thế này:
   [] 0%
   [#] 10%
   [##] 20%
   [###] 30%

2. Dấu ngoặc vuông ']' và số phần trăm ở bên phải dịch chuyển sang phải khi '###' dài hơn.
3. Một lỗi sẽ xảy ra nếu biểu thức 'tiến trình / 10' không thể trả về một số nguyên.

Và đoạn mã sau sẽ khắc phục vấn đề trên.

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

Mã cho thanh tiến trình thiết bị đầu cuối python

import sys
import time

max_length = 5
at_length = max_length
empty = "-"
used = "%"

bar = empty * max_length

for i in range(0, max_length):
    at_length -= 1

    #setting empty and full spots
    bar = used * i
    bar = bar+empty * at_length

    #\r is carriage return(sets cursor position in terminal to start of line)
    #\0 character escape

    sys.stdout.write("[{}]\0\r".format(bar))
    sys.stdout.flush()

    #do your stuff here instead of time.sleep
    time.sleep(1)

sys.stdout.write("\n")
sys.stdout.flush()

tôi đã viết một thanh tiến trình đơn giản:

def bar(total, current, length=10, prefix="", filler="#", space=" ", oncomp="", border="[]", suffix=""):
    if len(border) != 2:
        print("parameter 'border' must include exactly 2 symbols!")
        return None

    print(prefix + border[0] + (filler * int(current / total * length) +
                                      (space * (length - int(current / total * length)))) + border[1], suffix, "\r", end="")
    if total == current:
        if oncomp:
            print(prefix + border[0] + space * int(((length - len(oncomp)) / 2)) +
                  oncomp + space * int(((length - len(oncomp)) / 2)) + border[1], suffix)
        if not oncomp:
            print(prefix + border[0] + (filler * int(current / total * length) +
                                        (space * (length - int(current / total * length)))) + border[1], suffix)

như bạn có thể thấy, nó có: chiều dài của thanh, tiền tố và hậu tố, phụ, khoảng trắng, văn bản trong thanh trên 100% (oncomp) và viền

đây là một ví dụ:

from time import sleep, time
start_time = time()
for i in range(10):
    pref = str((i+1) * 10) + "% "
    complete_text = "done in %s sec" % str(round(time() - start_time))
    sleep(1)
    bar(10, i + 1, length=20, prefix=pref, oncomp=complete_text)

trong tiến trình:

30% [######              ]

hoàn thành

100% [   done in 9 sec   ] 

Tổng hợp một số ý tưởng tôi tìm thấy ở đây và thêm thời gian ước tính còn lại:

import datetime, sys

start = datetime.datetime.now()

def print_progress_bar (iteration, total):

    process_duration_samples = []
    average_samples = 5

    end = datetime.datetime.now()

    process_duration = end - start

    if len(process_duration_samples) == 0:
        process_duration_samples = [process_duration] * average_samples

    process_duration_samples = process_duration_samples[1:average_samples-1] + [process_duration]
    average_process_duration = sum(process_duration_samples, datetime.timedelta()) / len(process_duration_samples)
    remaining_steps = total - iteration
    remaining_time_estimation = remaining_steps * average_process_duration

    bars_string = int(float(iteration) / float(total) * 20.)
    sys.stdout.write(
        "\r[%-20s] %d%% (%s/%s) Estimated time left: %s" % (
            '='*bars_string, float(iteration) / float(total) * 100,
            iteration,
            total,
            remaining_time_estimation
        ) 
    )
    sys.stdout.flush()
    if iteration + 1 == total:
        print 


# Sample usage

for i in range(0,300):
    print_progress_bar(i, 300)

Đối với trăn 3:

def progress_bar(current_value, total):
    increments = 50
    percentual = ((current_value/ total) * 100)
    i = int(percentual // (100 / increments ))
    text = "\r[{0: <{1}}] {2}%".format('=' * i, increments, percentual)
    print(text, end="\n" if percentual == 100 else "")

Đây là mã hoạt động và tôi đã kiểm tra nó trước khi đăng:

import sys
def prg(prog, fillchar, emptchar):
    fillt = 0
    emptt = 20
    if prog < 100 and prog > 0:
        prog2 = prog/5
        fillt = fillt + prog2
        emptt = emptt - prog2
        sys.stdout.write("\r[" + str(fillchar)*fillt + str(emptchar)*emptt + "]" + str(prog) + "%")
        sys.stdout.flush()
    elif prog >= 100:
        prog = 100
        prog2 = prog/5
        fillt = fillt + prog2
        emptt = emptt - prog2
        sys.stdout.write("\r[" + str(fillchar)*fillt + str(emptchar)*emptt + "]" + str(prog) + "%" + "\nDone!")
        sys.stdout.flush()
    elif prog < 0:
        prog = 0
        prog2 = prog/5
        fillt = fillt + prog2
        emptt = emptt - prog2
        sys.stdout.write("\r[" + str(fillchar)*fillt + str(emptchar)*emptt + "]" + str(prog) + "%" + "\nHalted!")
        sys.stdout.flush()

Ưu điểm:

• Thanh 20 ký tự (1 ký tự cho mỗi 5 (số khôn ngoan))
• Nhân vật điền tùy chỉnh
• Ký tự trống tùy chỉnh
• Dừng lại (bất kỳ số nào dưới 0)
• Xong (100 và bất kỳ số nào trên 100)
• đếm Progress (0-100 (sau đây trở lên sử dụng cho các chức năng đặc biệt))
• Số phần trăm bên cạnh thanh và đó là một dòng duy nhất

Nhược điểm:

• Chỉ hỗ trợ số nguyên (Nó có thể được sửa đổi để hỗ trợ chúng, bằng cách làm cho phép chia thành một số nguyên, vì vậy chỉ cần thay đổi prog2 = prog/5thành prog2 = int(prog/5))

Đây là giải pháp Python 3 của tôi:

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

'\ b' là dấu gạch chéo ngược, cho mỗi ký tự trong chuỗi của bạn. Điều này không hoạt động trong cửa sổ cmd Windows.

chức năng từ Greenstick cho 2.7:

def printProgressBar (iteration, total, prefix = '', suffix = '',decimals = 1, length = 100, fill = '#'):

percent = ("{0:." + str(decimals) + "f}").format(100 * (iteration / float(total)))
filledLength = int(length * iteration // total)
bar = fill * filledLength + '-' * (length - filledLength)
print'\r%s |%s| %s%% %s' % (prefix, bar, percent, suffix),
sys.stdout.flush()
# Print New Line on Complete                                                                                                                                                                                                              
if iteration == total:
    print()

Thanh tiến trình mô-đun python là một lựa chọn tốt. Đây là mã tiêu biểu của tôi:

import time
import progressbar

widgets = [
    ' ', progressbar.Percentage(),
    ' ', progressbar.SimpleProgress(format='(%(value_s)s of %(max_value_s)s)'),
    ' ', progressbar.Bar('>', fill='.'),
    ' ', progressbar.ETA(format_finished='- %(seconds)s  -', format='ETA: %(seconds)s', ),
    ' - ', progressbar.DynamicMessage('loss'),
    ' - ', progressbar.DynamicMessage('error'),
    '                          '
]

bar = progressbar.ProgressBar(redirect_stdout=True, widgets=widgets)
bar.start(100)
for i in range(100):
    time.sleep(0.1)
    bar.update(i + 1, loss=i / 100., error=i)
bar.finish()