前言

之所以了解到了這個，是因為使用了一個依賴tqdm的包，然后好奇就查了一下。對于python中的進度條也是經常使用的，例如包的安裝，一些模型的訓練也會通過進度條的方式體現在模型訓練的進度。總之，使用進度條能夠更加錦上添花，提升使用體驗吧。至于更多tqdm內容可以參考tqdm官網[1]下面就來看看吧。 

1 簡單了解

先來看看效果，使用循環顯示一個智能的進度條-只需用tqdm(iterable)包裝任何可迭代就可完成，如下： 

相關代碼如下： 

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

官方也給了一張圖，來看看： 

run2

看起來還不錯吧，現在我們詳細地了解一下。

2 使用

安裝就不用說了，使用pip install tqdm即可。tqdm主要有以下三種用法。

2.1 基于迭代器的(iterable-based)

使用案例如下，使用tqdm()傳入任何可迭代的參數： 

from tqdm import tqdm 
from time import sleep 
 
 
text = "" 
for char in tqdm(["a", "b", "c", "d"]): 
    sleep(0.25) 
    text = text + char 

tqdm(range(i))的一個特殊優化案例： 

from time import sleep 
from tqdm import trange 
 
for i in trange(100): 
    sleep(0.01) 

這樣就可以不同傳入range(100)這樣的迭代器了，trange()自己去構建。 除此之外，可以用tqdm()在循環外手動控制一個可迭代類型，如下： 

pbar = tqdm(["a", "b", "c", "d"]) 
for char in pbar: 
    sleep(0.25) 
    pbar.set_description("Processing %s" % char) 

這里還使用了.set_description()，結果如下：

Processing d: 100%|██████████| 4/4 [00:01<00:00,  3.99it/s] 

相關參數容后再介紹。

2.2 手工操作(Manual)

使用with語句手動控制tqdm的更新，可以根據具體任務來更新進度條的進度。 

with tqdm(total=100) as pbar: 
    for i in range(10): 
        sleep(0.1) 
        pbar.update(10) 

當然with這個語句想必大家都知道(想想使用with打開文件就知道了)，也可以不使用with進行，則有如下操作： 

pbar = tqdm(total=100) 
for i in range(10): 
    sleep(0.1) 
    pbar.update(10) 
pbar.close() 

那么這個時候，就不要忘了在結束后關閉，或者del tqdm對象了。

2.3 模塊(Module)

也許tqdm的最妙用法是在腳本中或在命令行中。只需在管道之間插入tqdm(或python -m tqdm)，即可將所有stdin傳遞到stdout，同時將進度打印到stderr。具體如何操作，我們來看看，下面也是官方給出的例子。 以下示例演示了對當前目錄中所有Python文件中的行數進行計數，其中包括計時信息。(為了能夠在windows系統中使用linux命令，這是使用git打開)，也是當前項目路徑。

time find . -name '*.py' -type f -exec cat \{} \; | wc -l 

linux命令補充： time[2]，find[3](-exec 使用其后參數操作查找到的文件);wc[4].

使用tqdm命令來試一試：

time find . -name '*.py' -type f -exec cat \{} \; | tqdm | wc -l 

則有： 

tqdm

注意，也可以指定tqdm的常規參數。如下： 

就暫時說到這吧，感覺內容有點超綱了，如果對tqdm有興趣的話可以訪問官方文檔深入了解。

3 參數

官方的類初始化代碼如下： 

class tqdm(): 
  """ 
  Decorate an iterable object, returning an iterator which acts exactly 
  like the original iterable, but prints a dynamically updating 
  progressbar every time a value is requested. 
  """ 
 
  def __init__(self, iterable=None, desc=None, total=None, leave=True, 
               file=None, ncols=None, mininterval=0.1, 
               maxinterval=10.0, miniters=None, ascii=None, disable=False, 
               unit='it', unit_scale=False, dynamic_ncols=False, 
               smoothing=0.3, bar_format=None, initial=0, position=None, 
               postfix=None, unit_divisor=1000): 

官方對各個參數介紹如下： 

Parameters 
        ---------- 
        iterable  : iterable, optional 
            Iterable to decorate with a progressbar. 
            Leave blank to manually manage the updates. 
        desc  : str, optional 
            Prefix for the progressbar. 
        total  : int, optional 
            The number of expected iterations. If unspecified, 
            len(iterable) is used if possible. If float("inf") or as a last 
            resort, only basic progress statistics are displayed 
            (no ETA, no progressbar). 
            If `gui` is True and this parameter needs subsequent updating, 
            specify an initial arbitrary large positive integer, 
            e.g. int(9e9). 
        leave  : bool, optional 
            If [default: True], keeps all traces of the progressbar 
            upon termination of iteration. 
        file  : `io.TextIOWrapper` or `io.StringIO`, optional 
            Specifies where to output the progress messages 
            (default: sys.stderr). Uses `file.write(str)` and `file.flush()` 
            methods.  For encoding, see `write_bytes`. 
        ncols  : int, optional 
            The width of the entire output message. If specified, 
            dynamically resizes the progressbar to stay within this bound. 
            If unspecified, attempts to use environment width. The 
            fallback is a meter width of 10 and no limit for the counter and 
            statistics. If 0, will not print any meter (only stats). 
        mininterval  : float, optional 
            Minimum progress display update interval [default: 0.1] seconds. 
        maxinterval  : float, optional 
            Maximum progress display update interval [default: 10] seconds. 
            Automatically adjusts `miniters` to correspond to `mininterval` 
            after long display update lag. Only works if `dynamic_miniters` 
            or monitor thread is enabled. 
        miniters  : int, optional 
            Minimum progress display update interval, in iterations. 
            If 0 and `dynamic_miniters`, will automatically adjust to equal 
            `mininterval` (more CPU efficient, good for tight loops). 
            If > 0, will skip display of specified number of iterations. 
            Tweak this and `mininterval` to get very efficient loops. 
            If your progress is erratic with both fast and slow iterations 
            (network, skipping items, etc) you should set miniters=1. 
        ascii  : bool or str, optional 
            If unspecified or False, use unicode (smooth blocks) to fill 
            the meter. The fallback is to use ASCII characters " 123456789#". 
        disable  : bool, optional 
            Whether to disable the entire progressbar wrapper 
            [default: False]. If set to None, disable on non-TTY. 
        unit  : str, optional 
            String that will be used to define the unit of each iteration 
            [default: it]. 
        unit_scale  : bool or int or float, optional 
            If 1 or True, the number of iterations will be reduced/scaled 
            automatically and a metric prefix following the 
            International System of Units standard will be added 
            (kilo, mega, etc.) [default: False]. If any other non-zero 
            number, will scale `total` and `n`. 
        dynamic_ncols  : bool, optional 
            If set, constantly alters `ncols` to the environment (allowing 
            for window resizes) [default: False]. 
        smoothing  : float, optional 
            Exponential moving average smoothing factor for speed estimates 
            (ignored in GUI mode). Ranges from 0 (average speed) to 1 
            (current/instantaneous speed) [default: 0.3]. 
        bar_format  : str, optional 
            Specify a custom bar string formatting. May impact performance. 
            [default: '{l_bar}{bar}{r_bar}'], where 
            l_bar='{desc}: {percentage:3.0f}%|' and 
            r_bar='| {n_fmt}/{total_fmt} [{elapsed}<{remaining}, ' 
              '{rate_fmt}{postfix}]' 
            Possible vars: l_bar, bar, r_bar, n, n_fmt, total, total_fmt, 
              percentage, rate, rate_fmt, rate_noinv, rate_noinv_fmt, 
              rate_inv, rate_inv_fmt, elapsed, elapsed_s, remaining, 
              remaining_s, desc, postfix, unit. 
            Note that a trailing ": " is automatically removed after {desc} 
            if the latter is empty. 
        initial  : int, optional 
            The initial counter value. Useful when restarting a progress 
            bar [default: 0]. 
        position  : int, optional 
            Specify the line offset to print this bar (starting from 0) 
            Automatic if unspecified. 
            Useful to manage multiple bars at once (eg, from threads). 
        postfix  : dict or *, optional 
            Specify additional stats to display at the end of the bar. 
            Calls `set_postfix(**postfix)` if possible (dict). 
        unit_divisor  : float, optional 
            [default: 1000], ignored unless `unit_scale` is True. 
        write_bytes  : bool, optional 
            If (default: None) and `file` is unspecified, 
            bytes will be written in Python 2. If `True` will also write 
            bytes. In all other cases will default to unicode. 
        gui  : bool, optional 
            WARNING: internal parameter - do not use. 
            Use tqdm_gui(...) instead. If set, will attempt to use 
            matplotlib animations for a graphical output [default: False]. 

更多功能則可根據以上參數發揮你的想象力了。