दिलचस्प पोस्ट
एंड्रॉइड 4.3: BLE: startLeScan का फ़िल्टरिंग व्यवहार () HTML में एक स्ट्रिंग प्रस्तुत करें और रिक्त स्थान और नई लाइनों को संरक्षित करें क्या मैं AngularJS में एक और एक के अंदर एक एनजी-ऐप का उपयोग कर सकता हूं? जेवीएम विकल्प -XSS – यह बिल्कुल क्या करता है? मैं जावा में बैंडविड्थ कैसे सीमित कर सकता हूं? पायथन मानचित्र ऑब्जेक्ट सबस्क्रिप्टेबल नहीं है सामग्री डिजाइन नेविगेशन ड्रॉवर में हैमबर्गर आइकन का रंग कैसे बदल सकता है एंड्रॉइड बाइनरी फ़ाइल समस्याएं डाउनलोड करें आप स्ट्रिंग से गैर- ASCII वर्ण कैसे पट्टी कर सकते हैं? (सी # में) आईडी में वर्ग कोष्ठक शामिल होने पर ID द्वारा DOM तत्व ढूंढें? क्या LINQ "OrderBy" द्वारा सॉर्टिंग एल्गोरिथ्म का उपयोग किया जाता है? गैर कोणीयोज़ वेबसाइट पर प्रोट्रेक्टर का उपयोग कैसे करें? मैं आईओएस में एक कस्टम फ़ाइल प्रकार कैसे पंजीकृत करूं? MySQL बनाम MongoDB 1000 पढ़ता है मोंगोज़ _id और स्ट्रिंग्स की तुलना करना

कंसोल में पाठ प्रगति पट्टी

क्या निम्नलिखित करने का एक अच्छा तरीका है?

मैंने एफटीपीएल का इस्तेमाल करते हुए किसी एफ़टीपी सर्वर से फाइल अपलोड करने और डाउनलोड करने के लिए एक सरल कंसोल ऐप लिखा है।

हर बार कुछ डेटा खंड डाउनलोड किए जाते हैं, मैं एक टेक्स्ट प्रगति बार अपडेट करना चाहता हूं, भले ही यह केवल एक नंबर हो।

लेकिन मैं कंसोल में मुद्रित सभी पाठ को मिटा नहीं करना चाहता। ("स्पष्ट" करना और अपडेट किए गए प्रतिशत का मुद्रण करना।)

Solutions Collecting From Web of "कंसोल में पाठ प्रगति पट्टी"

यहां नीचे दिए गए कई उत्तरों का एक समेकन है जो कि मैं नियमित रूप से उपयोग करता हूं।

# Print iterations progress def printProgressBar (iteration, total, prefix = '', suffix = '', decimals = 1, length = 100, fill = '█'): """ 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) """ 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 = '\r') # Print New Line on Complete if iteration == total: print() # # Sample Usage # from time import sleep # 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... sleep(0.1) # Update Progress Bar printProgressBar(i + 1, l, prefix = 'Progress:', suffix = 'Complete', length = 50) # Sample Output Progress: |█████████████████████████████████████████████-----| 90.0% Complete 

'\ R' लिखना, कर्सर को लाइन की शुरुआत में ले जाएगा

यह प्रतिशत काउंटर प्रदर्शित करता है:

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

कंसोल में एक \r लिखें यह "कैरिज रिटर्न" है, जो इसके बाद सभी पाठ को लाइन की शुरुआत में प्रतिध्वनित करने का कारण बनता है। कुछ इस तरह:

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

जो आपको कुछ देना होगा: [ ########## ] 100%

tqdm: एक दूसरे में अपने छोरों के लिए एक प्रगति मीटर जोड़ें :

 >>> 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] 

यह कोड की 10 पंक्ति से कम है

यहां सार: 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 

यहां छवि विवरण दर्ज करें

Mozath of Python, Armin Ronacher द्वारा लिखित क्लिक पुस्तकालय को आज़माएं

 $ pip install click # both 2 and 3 compatible 

सरल प्रगति पट्टी बनाने के लिए:

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

यह है जो ऐसा लग रहा है:

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

अपने दिल की सामग्री को अनुकूलित करें:

 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 

कस्टम देखो:

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

यहां और भी अधिक विकल्प हैं, एपीआई दस्तावेज़ देखें:

  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) 

मुझे पता है कि मैं खेल के लिए देर कर रहा हूं, लेकिन यहां एक यम-स्टाइल (रेड हैट) है जो मैंने लिखा था (100% शुद्धता के लिए नहीं जा रहा है, लेकिन अगर आप उस स्तर के सटीकता के लिए प्रगति बार का उपयोग कर रहे हैं, तो आप 'फिर भी गलत हो):

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

कुछ इस तरह दिखना चाहिए:

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

… जहां ब्रैकेट स्थिर रहते हैं और केवल हैश बढ़ाते हैं

यह डेकोरेटर के रूप में बेहतर काम कर सकता है दूसरे दिन …

इस पुस्तकालय की जाँच करें: क्लिंट

इसमें एक प्रगति पट्टी सहित कई सुविधाएं हैं:

 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) 

यह लिंक अपनी विशेषताओं का त्वरित अवलोकन प्रदान करता है

पायथन में लिखा गया एक प्रगति पट्टी का यह एक अच्छा उदाहरण है: http://nadiana.com/animated-terminal-progress-bar-in-python

लेकिन अगर आप इसे स्वयं लिखना चाहते हैं चीजों को आसान बनाने के लिए आप curses मॉड्यूल का उपयोग कर सकते हैं 🙂

[संपादित करें] शाप के लिए शब्द शायद आसान नहीं है। लेकिन यदि आप शाप की तुलना में एक पूर्ण विकसित हुई सीईई बनाना चाहते हैं तो आपके लिए बहुत सारी चीजों का ख्याल रखता है

पुरानी लिंक मर गई है, इसलिए [संपादित करें] मैंने एक पायथन प्रोग्रेसबार का अपना खुद का संस्करण रखा है, यहां इसे प्राप्त करें: https://github.com/WoLpH/python-progressbar

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

उत्पादन

[2 9%] ===================

और, बस ढेर को जोड़ने के लिए, यहां एक वस्तु है जिसे आप उपयोग कर सकते हैं

 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" 

का परिणाम:

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

यह सबसे अधिक "शीर्ष पर" माना जाता है, लेकिन जब आप इसे बहुत कुछ का उपयोग कर रहे हैं तो यह आसान है

इसे पायथन कमांड लाइन पर चलाएं (किसी भी IDE या विकास वातावरण में नहीं):

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

मेरे विंडोज सिस्टम पर ठीक काम करता है

और बहुत सारे ट्यूटोरियल्स की प्रतीक्षा की जा रही है

मैं reddit से प्रगति का उपयोग कर रहा हूँ मुझे यह पसंद है क्योंकि यह एक पंक्ति में प्रत्येक वस्तु के लिए प्रगति को प्रिंट कर सकता है, और इसे प्रोग्राम से प्रिंटआउट नहीं मिटा देना चाहिए।

संपादित करें: तय लिंक

ऊपर दिए गए उत्तर और सीएलआई प्रगति बार के बारे में अन्य समान प्रश्नों के आधार पर, मुझे लगता है कि मुझे उन सभी को सामान्य उत्तर मिला है। इसे https://stackoverflow.com/a/15860757/2254146 पर देखें

संक्षेप में, कोड यह है:

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

जैसा दिखता है

प्रतिशत: [#########] 99.0%

मैं tqdm – https://pypi.python.org/pypi/tqdm- का उपयोग करने की सलाह देता हूं – जो किसी भी गतिशील या प्रक्रिया को प्रगति पट्टी में बदलना आसान बनाता है, और आवश्यक टर्मिनलों के बारे में सभी गड़बड़ करता है

प्रलेखन से: "टीकडीएम आसानी से कॉलबैक / हुक और मैन्युअल अपडेट का समर्थन कर सकता है। यहाँ 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) 
 import sys def progresssbar(): for i in range(100): time.sleep(1) sys.stdout.write("%i\r" % i) progressbar() 

नोट: यदि आप इसे इंटरेक्टिव इंट्रिप्टर में चलाते हैं, तो आपको अतिरिक्त संख्याएं प्रिंट की जाती हैं

lol मैं सिर्फ इस बात के लिए एक पूरी चीज लिखा है कोड को ध्यान में रखें आप यूनिकोड का उपयोग नहीं कर सकते हैं जब ब्लॉक ascii मैं 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() 

और आप इसे इतना पसंद करते हैं

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

तो यह इस तरह दिखता है

 loading something awesome |█████ | 

ऊपर की महान सलाह के साथ मैं प्रगति बार का काम करता हूं

हालांकि मैं कुछ कमियों को इंगित करना चाहूंगा

  1. हर बार प्रगति पट्टी को प्लावित किया जाता है, यह एक नई लाइन पर शुरू होगा

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

    इस तरह:
    [] 0%
    [#] 10%
    [##] 20%
    [###] 30%

2. चौकोर ब्रैकेट ']' और सही संख्या में प्रतिशत संख्या सही '###' के रूप में लंबे समय तक मिलती है
3. एक त्रुटि उत्पन्न होगी यदि अभिव्यक्ति 'प्रगति / 10' एक पूर्णांक नहीं लौटा सकता है

और निम्न कोड ऊपर की समस्या को ठीक कर देंगे

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

अजगर टर्मिनल प्रगति बार के लिए कोड

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

मैं यहाँ पाया कुछ विचारों को एक साथ रखकर, और अनुमानित समय को छोड़ दिया:

 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) 

tqdm स्थापित करें। ( pip install tqdm ) और इसे निम्नानुसार उपयोग करें:

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

यह एक 10 सेकंड की प्रगति बार है जो इस तरह से कुछ आउटपुट देगा:

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

अच्छी तरह से यहाँ कोड है जो काम करता है और मैं इसे पोस्ट करने से पहले परीक्षण किया है:

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

पेशेवरों:

  • 20 वर्ण बार (प्रत्येक 5 के लिए 1 वर्ण (संख्यामान))
  • कस्टम भरण वर्ण
  • कस्टम खाली अक्षर
  • रोकें (नीचे कोई भी संख्या 0)
  • किया गया (100 और 100 से ऊपर कोई भी नंबर)
  • प्रगति गिनती (0-100 (विशेष कार्य के लिए उपयोग किए गए नीचे और ऊपर))
  • बार के आगे प्रतिशत संख्या, और यह एक पंक्ति है

विपक्ष:

  • केवल पूर्णांक का समर्थन करता है (विभाजन को एक पूर्णांक प्रभाग बनाकर, उन्हें समर्थन देने के लिए इसे संशोधित किया जा सकता है, इसलिए सिर्फ prog2 = prog/5 को prog2 = int(prog/5) बदलें)

यहां मेरा पायथन 3 समाधान है:

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

'\ b' आपके स्ट्रिंग में प्रत्येक वर्ण के लिए, एक बैकस्लैश है यह विंडोज सीएमडी विंडो के भीतर काम नहीं करता है

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

अजगर मॉड्यूल प्रगति पट्टी एक अच्छा विकल्प है। यहां मेरा विशिष्ट कोड है:

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

https://pypi.python.org/pypi/progressbar2/3.30.2

Progressbar2 कमांड लाइन आयात समय आयात की प्रगति के लिए ascii आधार प्रगति पट्टी के लिए एक अच्छा पुस्तकालय है

 bar = progressbar.ProgressBar() for i in bar(range(100)): time.sleep(0.02) bar.finish() 

https://pypi.python.org/pypi/tqdm

tqdm प्रगति पट्टी 2 का एक विकल्प है और मुझे लगता है कि यह पीपी 3 में उपयोग करता है लेकिन मैं इस बारे में निश्चित नहीं हूँ

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

मैंने एक साधारण प्रगति पट्टी लिखा है:

 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) 

जैसा कि आप देख सकते हैं, यह है: बार की लंबाई, उपसर्ग और प्रत्यय, भराव, स्थान, पाठ बार में 100% (oncomp) और सीमाओं पर

यहां एक उदाहरण है:

 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) 

प्रगति में है:

 30% [###### ] 

पूरा होने पर:

 100% [ done in 9 sec ]