python的Tqdm模块的使用

python -m pip install -U pip 

pip install tqdm 

pip install -e git+https://github.com/tqdm/tqdm.git@master#egg=tqdm 

from tqdm import tqdm 
for i in tqdm(range(10000)): 
   sleep(0.01) 

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

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

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

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

$ time find . -name '*.py' -exec cat {} ; | wc -l 
857365 
 
real  0m3.458s 
user  0m0.274s 
sys   0m3.325s 
 
$ time find . -name '*.py' -exec cat {} ; | tqdm | wc -l 
857366it [00:03,246471.31it/s] 
857365 
 
real  0m3.585s 
user  0m0.862s 
sys   0m3.358s 

$ find . -name '*.py' -exec cat {} ; | 
  tqdm --unit loc --unit_scale --total 857366 >> /dev/null 
100%|| 857K/857K [00:04<00:00,246Kloc/s] 

$ 7z a -bd -r backup.7z docs/ | grep Compressing | 
  tqdm --total $(find docs/ -type f | wc -l) --unit files >> backup.log 
100%|| 8014/8014 [01:37<00:00,82.29files/s] 

__all__ = ['tqdm','tqdm_gui','trange','tgrange','tqdm_pandas','tqdm_notebook','tnrange','main','TqdmKeyError','TqdmTypeError','__version__'] 

def __init__(self,iterable=None,desc=None,total=None,leave=True,file=sys.stderr,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,gui=False,**kwargs): 

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. 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). 
预期的迭代数目，默认为None，则尽可能的迭代下去，如果gui设置为True，这里则需要后续的更新，将需要指定为一个初始随意值较大的正整数，例如int(9e9) 
leave : bool,optional 
If [default: True],keeps all traces of the progressbar 
upon termination of iteration. 
保留进度条存在的痕迹，简单来说就是会把进度条的最终形态保留下来，默认为True 
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. 
指定消息的输出 
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). 
整个输出消息的宽度。如果指定，动态调整的进度停留在这个边界。如果未指定，尝试使用环境的宽度。如果为0，将不打印任何东西（只统计）。 
mininterval : float,optional 
Minimum progress update interval,in seconds [default: 0.1]. 
最小进度更新间隔，以秒为单位（默认值：0.1）。 
maxinterval : float,optional 
Maximum progress update interval,in seconds [default: 10.0]. 
最大进度更新间隔，以秒为单位（默认值：10）。 
miniters : int,in iterations. 
If specified,will set mininterval to 0. 
最小进度更新周期 
ascii : bool,optional 
If unspecified or False,use unicode (smooth blocks) to fill 
the meter. The fallback is to use ASCII characters 1-9 #. 
如果不设置，默认为unicode编码 
disable : bool,optional 
Whether to disable the entire progressbar wrapper 
[default: False]. 
是否禁用整个进度条包装(如果为True，进度条不显示) 
unit : str,optional 
String that will be used to define the unit of each iteration 
[default: it]. 
将被用来定义每个单元的字符串？？？ 
unit_scale : bool,optional 
If set,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]. 
如果设置，迭代的次数会自动按照十、百、千来添加前缀，默认为false 
dynamic_ncols : bool,constantly alters ncols to the environment (allowing 
for window resizes) [default: False]. 
不断改变ncols环境，允许调整窗口大小 
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. 
If unspecified,will use ‘{l_bar}{bar}{r_bar}',where l_bar is 
‘{desc}{percentage:3.0f}%|' and r_bar is 
‘| {n_fmt}/{total_fmt} [{elapsed_str}<{remaining_str},{rate_fmt}]' 
Possible vars: bar,n,n_fmt,total,total_fmt,percentage,rate,rate_fmt,elapsed,remaining,l_bar,r_bar,desc. 
自定义栏字符串格式化…默认会使用{l_bar}{bar}{r_bar}的格式，格式同上 
 
initial : int,optional 
The initial counter value. Useful when restarting a progress 
bar [default: 0]. 
初始计数器值，默认为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). 
指定偏移，这个功能在多个条中有用 
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]. 
内部参数… 
Returns 
out : decorated iterator. 
返回为一个迭代器 

# -*- coding: utf-8 -*- 
"""Usage: 
 7zx.py [--help | options] <zipfiles>... 
Options: 
 -h,--help   Print this help and exit 
 -v,--version Print version and exit 
 -c,--compressed    Use compressed (instead of uncompressed) file sizes 
 -s,--silent  Do not print one row per zip file 
 -y,--yes   Assume yes to all queries (for extraction) 
 -D=<level>,--debug=<level> 
         Print various types of debugging information. Choices: 
             CRITICAL|FATAL 
             ERROR 
             WARN(ING) 
             [default: INFO] 
             DEBUG 
             NOTSET 
 -d,--debug-trace   Print lots of debugging information (-D NOTSET) 
""" 
from __future__ import print_function 
from docopt import docopt 
import logging as log 
import subprocess 
import re 
from tqdm import tqdm 
import pty 
import os 
import io 
__author__ = "Casper da Costa-Luis <casper.dcl@physics.org>" 
__licence__ = "MPLv2.0" 
__version__ = "0.2.0" 
__license__ = __licence__ 
 
 
RE_SCN = re.compile("([0-9]+)s+([0-9]+)s+(.*)$",flags=re.M) 
 
 
def main(): 
  args = docopt(__doc__,version=__version__) 
  if args.pop('--debug-trace',False): 
    args['--debug'] = "NOTSET" 
  log.basicConfig(level=getattr(log,args['--debug'],log.INFO),format='%(levelname)s: %(message)s') 
  log.debug(args) 
 
  # Get compressed sizes 
  zips = {} 
  for fn in args['<zipfiles>']: 
    info = subprocess.check_output(["7z","l",fn]).strip() 
    finfo = RE_SCN.findall(info) 
 
    # builtin test: last line should be total sizes 
    log.debug(finfo) 
    totals = map(int,finfo[-1][:2]) 
    # log.debug(totals) 
    for s in range(2): 
      assert(sum(map(int,(inf[s] for inf in finfo[:-1]))) == totals[s]) 
    fcomp = dict((n,int(c if args['--compressed'] else u)) 
           for (u,c,n) in finfo[:-1]) 
    # log.debug(fcomp) 
    # zips : {'zipname' : {'filename' : int(size)}} 
    zips[fn] = fcomp 
 
  # Extract 
  cmd7zx = ["7z","x","-bd"] 
  if args['--yes']: 
    cmd7zx += ["-y"] 
  log.info("Extracting from {:d} file(s)".format(len(zips))) 
  with tqdm(total=sum(sum(fcomp.values()) for fcomp in zips.values()),unit="B",unit_scale=True) as tall: 
    for fn,fcomp in zips.items(): 
      md,sd = pty.openpty() 
      ex = subprocess.Popen(cmd7zx + [fn],bufsize=1,stdout=md,# subprocess.PIPE,stderr=subprocess.STDOUT) 
      os.close(sd) 
      with io.open(md,mode="rU",buffering=1) as m: 
        with tqdm(total=sum(fcomp.values()),disable=len(zips) < 2,leave=False,unit_scale=True) as t: 
          while True: 
            try: 
              l_raw = m.readline() 
            except IOError: 
              break 
            l = l_raw.strip() 
            if l.startswith("Extracting"): 
              exname = l.lstrip("Extracting").lstrip() 
              s = fcomp.get(exname,0) # 0 is likely folders 
              t.update(s) 
              tall.update(s) 
            elif l: 
              if not any(l.startswith(i) for i in 
                    ("7-Zip ","p7zip Version ","Everything is Ok","Folders: ","Files: ","Size: ","Compressed: ")): 
                if l.startswith("Processing archive: "): 
                  if not args['--silent']: 
                    t.write(t.format_interval( 
                      t.start_t - tall.start_t) + ' ' + 
                      l.lstrip("Processing archive: ")) 
                else: 
                  t.write(l) 
      ex.wait() 
 
 
main.__doc__ = __doc__ 
 
 
if __name__ == "__main__": 
  main() 

"""An example of wrapping manual tqdm updates for urllib reporthook. 
# urllib.urlretrieve documentation 
> If present,the hook function will be called once 
> on establishment of the network connection and once after each block read 
> thereafter. The hook will be passed three arguments; a count of blocks 
> transferred so far,a block size in bytes,and the total size of the file. 
Usage: 
  tqdm_wget.py [options] 
Options: 
-h,--help 
  Print this help message and exit 
-u URL,--url URL : string,optional 
  The url to fetch. 
  [default: http://www.doc.ic.ac.uk/~cod11/matryoshka.zip] 
-o FILE,--output FILE : string,optional 
  The local file path in which to save the url [default: /dev/null]. 
""" 
 
import urllib 
from tqdm import tqdm 
from docopt import docopt 
 
 
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 
 
 
opts = docopt(__doc__) 
 
eg_link = opts['--url'] 
eg_file = eg_link.replace('/',' ').split()[-1] 
with tqdm(unit='B',unit_scale=True,miniters=1,desc=eg_file) as t: # all optional kwargs 
  urllib.urlretrieve(eg_link,filename=opts['--output'],reporthook=my_hook(t),data=None) 

""" 
# Simple tqdm examples and profiling 
# Benchmark 
for i in _range(int(1e8)): 
  pass 
# Basic demo 
import tqdm 
for i in tqdm.trange(int(1e8)): 
  pass 
# Some decorations 
import tqdm 
for i in tqdm.trange(int(1e8),miniters=int(1e6),ascii=True,desc="cool",dynamic_ncols=True): 
  pass 
# Nested bars 
from tqdm import trange 
for i in trange(10): 
  for j in trange(int(1e7),unit_scale=True): 
    pass 
# Experimental GUI demo 
import tqdm 
for i in tqdm.tgrange(int(1e8)): 
  pass 
# Comparison to https://code.google.com/p/python-progressbar/ 
try: 
  from progressbar.progressbar import ProgressBar 
except ImportError: 
  pass 
else: 
  for i in ProgressBar()(_range(int(1e8))): 
    pass 
# Dynamic miniters benchmark 
from tqdm import trange 
for i in trange(int(1e8),smoothing=0): 
  pass 
# Fixed miniters benchmark 
from tqdm import trange 
for i in trange(int(1e8),miniters=4500000,smoothing=0): 
  pass 
""" 
 
from time import sleep 
from timeit import timeit 
import re 
 
# Simple demo 
from tqdm import trange 
for i in trange(16,leave=True): 
  sleep(0.1) 
 
# Profiling/overhead tests 
stmts = filter(None,re.split(r'ns*#.*?n',__doc__)) 
for s in stmts: 
  print(s.replace('import tqdmn','')) 
  print(timeit(stmt='try:nt_range = xrange' 
           'nexcept:nt_range = rangen' + s,number=1),'seconds') 

import pandas as pd 
import numpy as np 
from tqdm import tqdm 
 
df = pd.DataFrame(np.random.randint(0,100,(100000,6))) 
 
# Register `pandas.progress_apply` and `pandas.Series.map_apply` with `tqdm` 
# (can use `tqdm_gui`,`tqdm_notebook`,optional kwargs,etc.) 
tqdm.pandas(desc="my bar!") 
 
# Now you can use `progress_apply` instead of `apply` 
# and `progress_map` instead of `map` 
df.progress_apply(lambda x: x**2) 
# can also groupby: 
# df.groupby(0).progress_apply(lambda x: x**2) 
 
 
# -- Source code for `tqdm_pandas` (really simple!) 
# def tqdm_pandas(t): 
#  from pandas.core.frame import DataFrame 
#  def inner(df,func,*args,**kwargs): 
#    t.total = groups.size // len(groups) 
#    def wrapper(*args,**kwargs): 
#      t.update(1) 
#      return func(*args,**kwargs) 
#    result = df.apply(wrapper,**kwargs) 
#    t.close() 
#    return result 
#  DataFrame.progress_apply = inner 

# How to import tqdm without enforcing it as a dependency 
try: 
  from tqdm import tqdm 
except ImportError: 
  def tqdm(*args,**kwargs): 
    if args: 
      return args[0] 
    return kwargs.get('iterable',None)