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

435

मैंने ftplib का उपयोग करके एक FTP सर्वर से फ़ाइलों को अपलोड और डाउनलोड करने के लिए एक सरल कंसोल ऐप लिखा है।

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

महत्वपूर्ण रूप से, मैं पिछली पंक्तियों में कंसोल पर मुद्रित किए गए सभी पाठों को मिटाने से बचना चाहता हूं (यानी मैं अद्यतन प्रगति को प्रिंट करते समय पूरे टर्मिनल को "साफ़" नहीं करना चाहता)।

यह एक काफी सामान्य कार्य लगता है - मैं एक प्रगति बार या इसी तरह के दृश्य बनाने के बारे में कैसे जा सकता हूं जो पूर्व प्रोग्राम आउटपुट को संरक्षित करते समय मेरे कंसोल को आउटपुट करता है?

python  console  progress  updating 
— bobber205
स्रोत
हम्म, कल पूछे गए इस प्रश्न के डुप्लिकेट की तरह देखें: stackoverflow.com/questions/3160699/python-progress-bar/3162864 इसलिए, आपको
— Etienne
29
"बस एक जीयूआई का उपयोग करें" गलतफहमी है कि जीयूआई कुछ स्थितियों (त्वरित सीखने की अवस्था, तदर्थ खोज या इंटरैक्टिव या एक-बंद गतिविधियों) में महान हैं जबकि कमांड-लाइन टूल दूसरों के लिए महान हैं (विशेषज्ञ उपयोगकर्ता, एड-हॉक एप्लिकेशन की रचना करते हैं मक्खी कई बार ध्यान से परिभाषित ऑपरेशन करने के लिए।)
— जोनाथन हार्टले
14
मैंने फिर से खोलने के लिए मतदान किया। सवाल मुझे बहुत व्यापक के रूप में हड़ताल नहीं करता है।
— फ्रेंक डर्नोनकोर्ट
मुझे लगता है कि आप जिस चीज़ की तलाश कर रहे हैं वह tqdm है ... हालांकि मुझे यह भी नहीं पता कि एसओ मुझे साल भर पुराने सवालों पर फिर से वोटों की समीक्षा करने के लिए क्यों प्रेरित कर रहे हैं।
— कुंगफू
मैंने एक नई तरह की प्रगति पट्टी प्रकाशित की है, जिसे आप प्रिंट कर सकते हैं, थ्रूपुट और एटा को देख सकते हैं, यहां तक ​​कि बहुत शांत एनिमेशन के अलावा, इसे रोक सकते हैं! कृपया देखें: github.com/rsalmei/alive-progress ! जीवित-प्रगति
— rsalmei

जवाबों:

464

एक सरल, अनुकूलन प्रगति पट्टी

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

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

नोट: यह पायथन 3 के लिए है; पायथन 2 में इसका उपयोग करने के विवरण के लिए टिप्पणियां देखें।

नमूना उपयोग

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)

नमूना आउटपुट:

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

अपडेट करें

एक विकल्प के बारे में टिप्पणियों में चर्चा हुई थी जो प्रगति पट्टी को टर्मिनल विंडो चौड़ाई में गतिशील रूप से समायोजित करने की अनुमति देता है। जबकि मैं इसकी अनुशंसा नहीं करता, यहाँ एक जिस्ट है जो इस सुविधा को लागू करता है (और नोटों को नोट करता है)।

— greenstick
स्रोत
21
यह स्निपेट शानदार काम करता है! मैंने कुछ मामूली मुद्दों का सामना किया, इसलिए मैंने कुछ छोटे संपादन किए (PEP-8, गैर- अस्की
— A स्नेहस
3
जब तक कि पायथन 2 @ एबिकस
— ग्रीनस्टिक
2
@MattClimbs यह पायथन 3 के लिए लिखा गया है जो डिफ़ॉल्ट रूप से UTF-8 एन्कोडिंग का उपयोग करता है। आप या तो फ़ंक्शन के डिफ़ॉल्ट भरण पैरामीटर को बदल सकते हैं, जो UTF-8 वर्ण है, या UTF-8 घोषणा का उपयोग करें। ऊपर टिप्पणी में gist देखें कि UTF-8 की घोषणा क्या दिखती है।
— ग्रीनस्टिक
1
धन्यवाद, अच्छा सारांश, टर्मिनल आकार का भी पता लगाना उपयोगी हो सकता है इस कार्य के # Size of terminal rows, columns = [int(x) for x in os.popen('stty size', 'r').read().split()] columnsलिए टर्मिनल विंडो में प्रगति बार आकार को समायोजित करने के लिए लंबाई को पारित किया जाना चाहिए। हालांकि बार के प्रगति वाले हिस्से की लंबाई कम की जानी चाहिए (इस स्ट्रिंग में उपसर्ग, प्रत्यय, प्रतिशत और अतिरिक्त वर्णों की लंबाई से'\r%s |%s| %s%% %s'
— Arleg
3
कुछ IDEs (उदाहरण के लिए विंडोज पर PyCharm) में काम करने के लिए आपको इसे बदलने की आवश्यकता हो सकती end = '\r'है end = ''।
— thomas88wp
312

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

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

import time
import sys

for i in range(100):
    time.sleep(1)
    sys.stdout.write("\r%d%%" % i)
    sys.stdout.flush()
— स्टीफन
स्रोत
3
पास्ट किया और दौड़ा। यह हर बार एक नई लाइन को प्रिंट करता है। मैं चाहता हूं कि उसी लाइन पर नंबर अपडेट किया जाए। :)
— bobber205
8
यह उदाहरण एक OBOB का भी निर्माण करता है, जिसका लोडिंग समाप्त होता है99%
— ग्लेन डेटन
10
@moose इसका अर्थ है "ऑफ बाय वन बग"
— ग्लेन डेटन
3
printएक endतर्क है: stackoverflow.com/a/8436827/1959808
— Ioannis Filippidis
3
@IoannisFilippidis ने जो कहा, उसे जोड़ने के लिए, printएक flushतर्क भी दिया : docs.python.org/3/library/functions.html#print
— Wso
189

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]

tqdm उत्तर सत्र

— JFS
स्रोत
अजगर के खोल का आप क्या उपयोग करते हैं?
— 1
1
@xotonic लिंक यह है कहते हैं ptpython
— JFS
113

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

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

जो आपको कुछ इस तरह देगा: [ ########## ] 100%

— aviraldg
स्रोत
19
करो \rऔर फिर पूरी लाइन फिर से लिखो। मूल रूप से: print("\rProgress: [{0:50s}] {1:.1f}%".format('#' * int(amtDone * 50), amtDone * 100))जहां amtDone0 और 1. के बीच एक फ्लोट है
— माइक डीसमोन
13
बेहतर उपयोग करने के लिए sys.stdout.writeकी तुलना में print। के साथ printमैंने नई सुर्खियां बटोरीं।
— गिल बेट्स
14
मेरे लिए कार्यों ,के अंत में एक अल्पविराम संलग्न printकरें।
— चुनियानग लयु ३१'१२ को u:०४
10
python3 में प्रिंट का उपयोग करें (...., अंत = '') और आपके पास कोई
— नया अंक
7
Python3 के लिए पूर्ववर्ती समराइज़र print("\rProgress: [{0:50s}] {1:.1f}%".format('#' * int(workdone * 50), workdone*100), end="", flush=True), जहाँ workdone0 और 1 के बीच एक फ्लोट है, जैसे,workdone = parsed_dirs/total_dirs
— खियोक्स
70

यह कोड की 10 लाइनों से कम है।

यहाँ दी गिस्ट: https://gist.github.com/vladignatyev/06860ec2040cb49717003

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

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

— व्लादिमीर इग्नाटयेव
स्रोत
2
फ़ंक्शन के अंत में "sys.stdout.flush ()" जोड़ता है।
— रोमेनूबेन
मेरे लिए यह एक नई लाइन में चला जाता है
— जीएम
@GM आप किस OS / प्लेटफॉर्म का उपयोग करते हैं?
— व्लादिमीर इग्नाटयेव
मुझे नहीं पता कि अगर मैं इसे स्पाइडर आइड से चलाता हूं तो यह काम नहीं करता है लेकिन अगर मैं इसे ipython कंसोल से चलाता हूं तो यह काम करता है!
— GM
62

अजगर, अर्मिन 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)
— द अनफ़न कैट
स्रोत
33

मुझे लगता है कि मुझे खेल में देर हो गई है, लेकिन यहां थोड़ा यम-शैली (रेड हैट) है जिसे मैंने लिखा था (यहां 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%

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

यह डेकोरेटर के रूप में बेहतर काम कर सकता है। एक और दिन के लिए ...

— JoeLinux
स्रोत
2
महान समाधान! अच्छी तरह से काम! आपका बहुत बहुत धन्यवाद!
— वासलीजे बरसाक
18

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

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

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)

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

— स्क्रिप्ट
स्रोत
12

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

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

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

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

— Wolph
स्रोत
14
curses? आसान?
— हम्मम
एक उत्कृष्ट लेख, मैं इसे एक लिंक देने जा रहा था लेकिन मेरे बुकमार्क में नहीं मिला :)
— एंडी मिखाइलेंको
@ अविरल दासगुप्ता: पर्याप्त निष्पक्ष, आसान यहाँ सही शब्द नहीं हो सकता है। यह आपको बहुत काम बचा सकता है, लेकिन यह वास्तव में इस बात पर निर्भर करता है कि आप क्या खोज रहे हैं।
— वोल्फ
इस शामिल के पास कुछ भी नहीं खोज रहे हैं, लेकिन वैसे भी धन्यवाद। :)
— bobber205
2
मृत लिंक, आपका जवाब में link'ed सामग्री पोस्ट नहीं की -__- कीमत है कि
— ThorSummoner
11 
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()

उत्पादन

[२ ९%] ===================

— ashish2py
स्रोत
7

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

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

यह आमतौर पर "ओवर द टॉप" माना जाता है, लेकिन जब आप इसे बहुत अधिक उपयोग कर रहे होते हैं तो यह आसान होता है

— FraggaMuffin
स्रोत
इसके लिए धन्यवाद। छोटा फिक्स, प्लॉटप्रोग्रेड विधि को लाइन sys.stdout.flush () का उपयोग करना चाहिए अन्यथा कार्य पूरा होने तक प्रगति पट्टी नहीं खींची जा सकती (जैसा कि मैक टर्मिनल में होता है)।
— असनोज
मुझे यह पसंद है!!! उपयोग करने के लिए काफी आसान !!! ठनक यू
— Microos
7

स्थापित करें 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]
— टक्स
स्रोत
6

इस भागो अजगर आदेश पंक्ति पर ( नहीं किसी भी आईडीई या विकास के वातावरण में):

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

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

— PaulMcG
स्रोत
4

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

संपादित करें: निश्चित लिंक

— Ib33X
स्रोत
1
आपका लिंक टूट गया है - स्रोत कोड में वास्तविक रेखा 1274 वीं है, 1124 वें नहीं! तो, सही लिंक यह है: github.com/reddit/reddit/blob/master/r2/r2/lib/utils/…
— व्लादिमीर इग्नाटयेव
इस संस्करण में मेरे स्वाद पर सबसे अच्छा डिज़ाइन है: यह पुनरावृत्तियों का उपयोग करता है और संभवतः किसी भी प्रकार के औसत दर्जे का काम करता है, यह बीता हुआ समय दर्शाता है।
— व्लादिमीर इग्नाटयेव
3

उपरोक्त उत्तर और सीएलआई प्रगति बार के बारे में इसी तरह के अन्य प्रश्नों के आधार पर, मुझे लगता है कि मुझे उन सभी के लिए एक सामान्य सामान्य उत्तर मिला। इसे 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%

— ब्रायन खुउ
स्रोत
3

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

प्रलेखन से: "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)
— मैल्कम बॉक्स
स्रोत
3

एक बहुत ही सरल उपाय है इस कोड को अपने पाश में रखना:

इसे अपनी फ़ाइल के मुख्य भाग (अर्थात शीर्ष) में रखें:

import sys

इसे अपने पाश के शरीर में रखें:

sys.stdout.write("-") # prints a dash for each iteration of loop
sys.stdout.flush() # ensures bar is displayed incrementally
— रिचर्ड हेमन-जॉयस
स्रोत
2 
import sys
def progresssbar():
         for i in range(100):
            time.sleep(1)
            sys.stdout.write("%i\r" % i)

progressbar()

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

— रामचंद्र आप्टे
स्रोत
2

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

उपर्युक्त महान सलाह के साथ मैं प्रगति बार पर काम करता हूं।

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

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

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

    इस तरह:
    [] ०%
    [#] १०%
    [##] २०%
    [###] ३०%

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

और निम्नलिखित कोड ऊपर की समस्या को ठीक करेगा। 

def update_progress(progress, total):  
    print('\r[{0:10}]{1:>2}%'.format('#' * int(progress * 10 /total), progress), end='')
— तूफान-आंखें
स्रोत
1

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

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()
— emd_22
स्रोत
1

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

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   ]
— जेनकींस
स्रोत
1

यहां मुझे मिले कुछ विचारों को एक साथ रखा गया है, और अनुमानित समय को छोड़ दिया जाए:

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)
— इवान चेर
स्रोत
1

अजगर 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 "")
— रोड्रिगो लोपेज
स्रोत
0

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

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))
— कोल्ड डायमंडज
स्रोत
0

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

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

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

— मैट-बल्ले
स्रोत
0

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()
— एडमंड डी मार्टिम्प्रे
स्रोत
0

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

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()
— हुआंग को हटा दिया
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.