from tqdm import tqdm
for i in tqdm(range(10000)):
    ...

from tqdm import tqdm
from time import sleep

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

from tqdm import trange

for i in trange(100):
    sleep(0.01)

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

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

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

class tqdm():
  """
  装饰一个可迭代对象，返回一个迭代器，该迭代器与原始可迭代对象完全相同，
  但每次请求一个值时都会显示一个动态更新的
  进度条。
  """

  @envwrap("TQDM_")  # 通过环境变量覆盖默认值
  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, write_bytes=False,
               lock_args=None, nrows=None, colour=None, delay=0):

class tqdm():
  def update(self, n=1):
      """
      手动更新进度条，适用于读取文件的流等情况。
      例如：
      >>> t = tqdm(total=filesize) # 初始化
      >>> for current_buffer in stream:
      ...    ...
      ...    t.update(len(current_buffer))
      >>> t.close()
      强烈推荐最后一行，但如果 ``t.update()`` 的调用方式使得
      ``filesize`` 被精确达到并打印，则可能不是必需的。

      参数
      ----------
      n  : 整数或浮点数, 可选
          要添加到内部迭代计数器中的增量
          [默认值: 1]。如果使用浮点数，请考虑在 ``bar_format`` 中
          指定 ``{n:.3f}`` 或类似格式，或指定 ``unit_scale``。

      返回值
      -------
      out  : 布尔值或 None
          如果触发了 ``display()``，则为 True。
      """

  def close(self):
      """清理并（如果 leave=False）关闭进度条。"""

  def clear(self, nomove=False):
      """清除当前进度条显示。"""

  def refresh(self):
      """
      强制刷新此进度条的显示。

      参数
      ----------
      nolock  : 布尔值, 可选
          如果为 ``True``，则不锁定。
          如果 [默认值: ``False``]：调用内部锁的 ``acquire()``。
      lock_args  : 元组, 可选
          传递给内部锁的 ``acquire()``。
          如果指定，则仅在 ``acquire()`` 返回 ``True`` 时才 ``display()``。
      """

  def unpause(self):
      """从上次打印时间重新启动 tqdm 定时器。"""

  def reset(self, total=None):
      """
      重置为 0 次迭代，以便重复使用。

      考虑与 ``leave=True`` 结合使用。

      参数
      ----------
      total  : 整数或浮点数, 可选。用于新进度条的总数。
      """

  def set_description(self, desc=None, refresh=True):
      """
      设置/修改进度条的描述。

      参数
      ----------
      desc  : 字符串, 可选
      refresh  : 布尔值, 可选
          强制刷新 [默认值: True]。
      """

  def set_postfix(self, ordered_dict=None, refresh=True, **tqdm_kwargs):
      """
      设置/修改后缀（附加统计信息）
      并根据数据类型自动格式化。

      参数
      ----------
      ordered_dict  : 字典或 OrderedDict, 可选
      refresh  : 布尔值, 可选
          强制刷新 [默认值: True]。
      kwargs  : 字典, 可选
      """

  @classmethod
  def write(cls, s, file=sys.stdout, end="\n"):
      """通过 tqdm 打印消息（避免与进度条重叠）。"""

  @property
  def format_dict(self):
      """公共 API，用于只读成员访问。"""

  def display(self, msg=None, pos=None):
      """
      使用 ``self.sp`` 在指定的 ``pos`` 位置显示 ``msg``。

      考虑在继承时重载此函数，例如使用：
      ``self.some_frontend(**self.format_dict)`` 而不是 ``self.sp``。

      参数
      ----------
      msg  : 字符串, 可选。要显示的内容（默认值：``repr(self)``）。
      pos  : 整数, 可选。要 ``moveto`` 的位置
        （默认值：``abs(self.pos)``）。
      """

  @classmethod
  @contextmanager
  def wrapattr(cls, stream, method, total=None, bytes=True, **tqdm_kwargs):
      """
      stream  : 文件类对象。
      method  : 字符串，"read" 或 "write"。``read()`` 的结果和
          ``write()`` 的第一个参数应该具有 ``len()``。

      >>> with tqdm.wrapattr(file_obj, "read", total=file_obj.size) as fobj:
      ...     while True:
      ...         chunk = fobj.read(chunk_size)
      ...         if not chunk:
      ...             break
      """

  @classmethod
  def pandas(cls, *targs, **tqdm_kwargs):
      """将当前 `tqdm` 类注册到 `pandas`。"""

def trange(*args, **tqdm_kwargs):
    """`tqdm(range(*args), **tqdm_kwargs)` 的快捷方式。"""

def tqdm.contrib.tenumerate(iterable, start=0, total=None,
                            tqdm_class=tqdm.auto.tqdm, **tqdm_kwargs):
    """等同于 `numpy.ndenumerate` 或内置 `enumerate`。"""

def tqdm.contrib.tzip(iter1, *iter2plus, **tqdm_kwargs):
    """等同于内置 `zip`。"""

def tqdm.contrib.tmap(function, *sequences, **tqdm_kwargs):
    """等同于内置 `map`。"""

class tqdm.notebook.tqdm(tqdm.tqdm):
    """IPython/Jupyter Notebook 小部件。"""

class tqdm.auto.tqdm(tqdm.tqdm):
    """自动在 `tqdm.notebook` 和 `tqdm.tqdm` 之间进行选择。"""

class tqdm.asyncio.tqdm(tqdm.tqdm):
  """异步版本。"""
  @classmethod
  def as_completed(cls, fs, *, loop=None, timeout=None, total=None,
                   **tqdm_kwargs):
      """`asyncio.as_completed` 的包装器。"""

class tqdm.gui.tqdm(tqdm.tqdm):
    """Matplotlib GUI 版本。"""

class tqdm.tk.tqdm(tqdm.tqdm):
    """Tkinter GUI 版本。"""

class tqdm.rich.tqdm(tqdm.tqdm):
    """`rich.progress` 版本。"""

class tqdm.keras.TqdmCallback(keras.callbacks.Callback):
    """用于 epoch 和 batch 进度的 Keras 回调。"""

class tqdm.dask.TqdmCallback(dask.callbacks.Callback):
    """用于 task 进度的 Dask 回调。"""

from tqdm import tqdm, trange
from random import random, randint
from time import sleep

with trange(10) as t:
    for i in t:
        # 描述将显示在左侧
        t.set_description('GEN %i' % i)
        # 对其将显示在右侧，
        # 根据参数的数据类型自动格式化
        t.set_postfix(loss=random(), gen=randint(1,999), str='h',
                      lst=[1, 2])
        sleep(0.1)

with tqdm(total=10, bar_format="{postfix[0]} {postfix[1][value]:>8.2g}",
          postfix=["Batch", {"value": 0}]) as t:
    for i in range(10):
        sleep(0.1)
        t.postfix[1]["value"] = i / 2
        t.update()

from tqdm import tqdm
class TqdmExtraFormat(tqdm):
    """Provides a `total_time` format parameter"""
    @property
    def format_dict(self):
        d = super().format_dict
        total_time = d["elapsed"] * (d["total"] or 0) / max(d["n"], 1)
        d.update(total_time=self.format_interval(total_time) + " in total")
        return d

for i in TqdmExtraFormat(
      range(9), ascii=" .oO0",
      bar_format="{total_time}: {percentage:.0f}%|{bar}{r_bar}"):
    if i == 4:
        break

from tqdm.auto import trange
from time import sleep

for i in trange(4, desc='1st loop'):
    for j in trange(5, desc='2nd loop'):
        for k in trange(50, desc='3rd loop', leave=False):
            sleep(0.01)

from time import sleep
from tqdm import trange, tqdm
from multiprocessing import Pool, RLock, freeze_support

L = list(range(9))

def progresser(n):
    interval = 0.001 / (n + 2)
    total = 5000
    text = f"#{n}, est. {interval * total:<04.2}s"
    for _ in trange(total, desc=text, position=n):
        sleep(interval)

if __name__ == '__main__':
    freeze_support()  # for Windows support
    tqdm.set_lock(RLock())  # for managing output contention
    p = Pool(initializer=tqdm.set_lock, initargs=(tqdm.get_lock(),))
    p.map(progresser, L)

from time import sleep
from tqdm import tqdm, trange
from concurrent.futures import ThreadPoolExecutor

L = list(range(9))

def progresser(n):
    interval = 0.001 / (n + 2)
    total = 5000
    text = f"#{n}, est. {interval * total:<04.2}s"
    for _ in trange(total, desc=text):
        sleep(interval)
    if n == 6:
        tqdm.write("n == 6 completed.")
        tqdm.write("`tqdm.write()` is thread-safe in py3!")

if __name__ == '__main__':
    with ThreadPoolExecutor() as p:
        p.map(progresser, L)

import urllib, os
from tqdm import tqdm
urllib = getattr(urllib, 'request', urllib)

class TqdmUpTo(tqdm):
    """提供 `update_to(n)`，它使用 `tqdm.update(delta_n)`。"""
    def update_to(self, b=1, bsize=1, tsize=None):
        """
        b  : int, optional
            已传输块数 [默认值: 1]。
        bsize  : int, optional
            每个块的大小（以 tqdm 单位计）[默认值: 1]。
        tsize  : int, optional
            总大小（以 tqdm 单位计）。如果为 [默认值: None]，则保持不变。
        """
        if tsize is not None:
            self.total = tsize
        return self.update(b * bsize - self.n)  # 也设置 self.n = b * bsize

eg_link = "https://caspersci.uk.to/matryoshka.zip"
with TqdmUpTo(unit='B', unit_scale=True, unit_divisor=1024, miniters=1,
              desc=eg_link.split('/')[-1]) as t:  # 所有可选参数
    urllib.urlretrieve(eg_link, filename=os.devnull,
                       reporthook=t.update_to, data=None)
    t.total = t.n

从 tqdm.auto 导入 tqdm
从 tqdm.utils 导入 CallbackIOWrapper

与 tqdm(合计=file_obj.大小,
          单位='B', 单位比例=True, 单位除数=1024) 作为 t:
    fobj = CallbackIOWrapper(t.更新, file_obj, "读取")
    当 True:
        块 = fobj.读取(块大小)
        如果 不 块:
            中断
    t.重置()
    # ... 继续将 `t` 用于其他用途

导入 urllib, os
从 tqdm 导入 tqdm

示例链接 = "https://caspersci.uk.to/matryoshka.zip"
响应 = getattr(urllib, 'request', urllib).urlopen(示例链接)
与 tqdm.wrapattr(open(os.devnull, "wb"), "写入",
                   最小迭代次数=1, 描述=示例链接.split('/')[-1],
                   合计=getattr(响应, '长度', None)) 作为 fout:
    对于 块 在 响应:
        fout.写入(块)

from tqdm.asyncio import tqdm

with tqdm(range(9)) as pbar:
    async for i in pbar:
        if i == 2:
            break

import pandas as pd
import numpy as np
from tqdm import tqdm

df = pd.DataFrame(np.random.randint(0, 100, (100000, 6)))

# 使用 `tqdm` 注册 `pandas.progress_apply` 和 `pandas.Series.map_apply`
# （可以使用 `tqdm.gui.tqdm`, `tqdm.notebook.tqdm`, 可选的 kwargs 等）
tqdm.pandas(desc="my bar!")

# 现在您可以使用 `progress_apply` 代替 `apply`
# 并使用 `progress_map` 代替 `map`
df.progress_apply(lambda x: x**2)
# 也可以进行 groupby：
# df.groupby(0).progress_apply(lambda x: x**2)

from tqdm.keras import TqdmCallback

...

model.fit(..., verbose=0, callbacks=[TqdmCallback()])

from tqdm.dask import TqdmCallback

with TqdmCallback(desc="compute"):
    ...
    arr.compute()

# 或全局使用回调
cb = TqdmCallback(desc="global")
cb.register()
arr.compute()

from tqdm.notebook import trange, tqdm
from time import sleep

for i in trange(3, desc='1st loop'):
    for j in tqdm(range(100), desc='2nd loop'):
        sleep(0.01)

从 tqdm.notebook 导入 tqdm
pbar = tqdm(..., display=False)

# 不同的单元格
display(pbar.container)

从 tqdm.keras 导入 TqdmCallback
cbk = TqdmCallback(display=False)

# 不同的单元格
cbk.display()
model.fit(..., verbose=0, callbacks=[cbk])

从 tqdm.notebook 导入 tqdm
pbar = tqdm()

# 不同的单元格
iterable = range(100)
pbar.reset(total=len(iterable))  # 使用新的 `total` 进行初始化
for i in iterable:
    pbar.update()
pbar.refresh()  # 强制打印最终状态但不 `close()`

从 functools 导入 partial
从 tqdm 导入 tqdm 作为 std_tqdm
tqdm = partial(std_tqdm, dynamic_ncols=True)

从 tqdm 导入 tqdm
导入 os.path

定义 find_files_recursively(path, show_progress=True):
    files = []
    # total=1 假设 `path` 是一个文件
    t = tqdm(total=1, unit="file", disable=not show_progress)
    如果 not os.path.exists(path):
        引发 IOError("找不到:" + path)

    定义 append_found_file(f):
        files.append(f)
        t.update()

    定义 list_found_dir(path):
        """假设 os.path.isdir(path) 返回 os.listdir(path)"""
        listing = os.listdir(path)
        # 减去 1，因为我们找到的一个“文件”实际上是这个目录
        t.total += len(listing) - 1
        # 获得信息的技巧，而无需强制刷新
        t.set_postfix(dir=path[-10:], refresh=False)
        t.update(0)  # 可能会触发刷新
        返回 listing

    定义 recursively_search(path):
        如果 os.path.isdir(path):
            对于 f 在 list_found_dir(path):
                recursively_search(os.path.join(path, f))
        否则:
            append_found_file(path)

    recursively_search(path)
    t.set_postfix(dir=path)
    t.close()
    返回 files

from tqdm.auto import tqdm, trange
from time import sleep

bar = trange(10)
for i in bar:
    # 使用 tqdm 类方法 .write() 打印
    sleep(0.1)
    if not (i % 3):
        tqdm.write("Done task %i" % i)
    # 也可以使用 bar.write()

from time import sleep
import contextlib
import sys
from tqdm import tqdm
from tqdm.contrib import DummyTqdmFile


@contextlib.contextmanager
def std_out_err_redirect_tqdm():
    orig_out_err = sys.stdout, sys.stderr
    try:
        sys.stdout, sys.stderr = map(DummyTqdmFile, orig_out_err)
        yield orig_out_err[0]
    # 传递异常
    except Exception as exc:
        raise exc
    # 始终在需要时恢复 sys.stdout/err
    finally:
        sys.stdout, sys.stderr = orig_out_err

def some_fun(i):
    print("Fee, fi, fo,".split()[i])

# 将 stdout 重定向到 tqdm.write() (不要忘记 `as save_stdout`)
with std_out_err_redirect_tqdm() as orig_stdout:
    # tqdm 需要原始 stdout
    # 并且 dynamic_ncols=True 以自动检测控制台宽度
    for i in tqdm(range(3), file=orig_stdout, dynamic_ncols=True):
        sleep(.5)
        some_fun(i)

# 在 `with` 语句之后，打印功能已恢复
print("Done!")

import logging
from tqdm import trange
from tqdm.contrib.logging import logging_redirect_tqdm

LOG = logging.getLogger(__name__)

if __name__ == '__main__':
    logging.basicConfig(level=logging.INFO)
    with logging_redirect_tqdm():
        for i in trange(9):
            if i == 4:
                LOG.info("console logging redirected to `tqdm.write()`")
    # logging 已恢复