पायथन प्रोग्रेस बार

Question

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

उदाहरण के लिए, एक फ़ंक्शन जो पूरा होने में कुछ समय लेता है और Trueजब किया जाता है तो वापस लौटता है। जिस समय फ़ंक्शन निष्पादित किया जा रहा है, उस समय मैं एक प्रगति बार कैसे प्रदर्शित कर सकता हूं?

ध्यान दें कि मुझे वास्तविक समय में इसकी आवश्यकता है, इसलिए मैं यह पता नहीं लगा सकता कि इसके बारे में क्या करना है। क्या मुझे इसके लिए आवश्यकता है thread? मुझे पता नहीं है।

अभी मैं कुछ भी नहीं छाप रहा हूं जबकि फ़ंक्शन निष्पादित किया जा रहा है, हालांकि एक प्रगति बार अच्छा होगा। इसके अलावा मुझे इस बात में अधिक दिलचस्पी है कि यह एक कोड बिंदु से कैसे किया जा सकता है।

Comments

क्या आप केवल GUI टूलकिट या CLI का उपयोग कर रहे हैं?

— बॉबी

CLI। लेकिन मैं एक तीसरे पक्ष के पुस्तकालय का उपयोग कर सकता हूं, यह कोई मुद्दा नहीं है। जीयूआई के साथ मैं यह कर सकता हूं, लेकिन मुझे सीएलआई भाग में दिलचस्पी थी।

— user225312

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

— ग्रीनस्टिक

यहाँ एक बृहस्पति नोटबुक के भीतर के लिए एक समाधान है: mikulskibartosz.name/…

— स्टीवन सी। हॉवेल

मैंने एक नई तरह की प्रगति पट्टी प्रकाशित की है, जिसे आप प्रिंट कर सकते हैं, थ्रूपुट और एटा को देख सकते हैं, यहां तक ​​कि बहुत शांत एनिमेशन के अलावा इसे रोक सकते हैं! कृपया देखें: github.com/rsalmei/alive-progress ! जीवित-प्रगति

— rsalmei

Answer 1

विशिष्ट पुस्तकालय हैं ( जैसे यह यहाँ है ) लेकिन शायद कुछ बहुत ही सरल होगा:

import time
import sys

toolbar_width = 40

# setup toolbar
sys.stdout.write("[%s]" % (" " * toolbar_width))
sys.stdout.flush()
sys.stdout.write("\b" * (toolbar_width+1)) # return to start of line, after '['

for i in xrange(toolbar_width):
    time.sleep(0.1) # do real work here
    # update the bar
    sys.stdout.write("-")
    sys.stdout.flush()

sys.stdout.write("]\n") # this ends the progress bar

नोट: progressbar2 का एक कांटा है प्रगतिबार है जो साल में नहीं रखा गया है।

Comments

यह कई चरणों के लिए पैमाना नहीं है ... pypi.python.org/pypi/progress उपयोग करने के लिए बहुत आसान है

— m13r

मैंने इस कोड की कोशिश की, और इसने एक NameError: name 'xrange' is not definedत्रुटि फेंक दी । क्या मुझे कोई मॉड्यूल याद आ रहा है?

— मशरूम मैन

@ GokuMcSpock9733 पायथन के किस संस्करण का आप उपयोग कर रहे हैं? अजगर का 2 xrangeपायथन का 3 है range।

— quapka

यह शीर्ष उत्तर नहीं होना चाहिए। अन्य उत्तर (tqdm के साथ) मेरे लिए कम से कम बेहतर है।

— फ्लोरियन

पायथन 3 में गरीबों की प्रगति पट्टी:print('■', end='', flush=True)

— पैट्रिकटी

Answer 2

Tqdm के साथ आप एक दूसरे में अपने छोरों के लिए प्रगति मीटर जोड़ सकते हैं:

In [1]: import time

In [2]: from tqdm import tqdm

In [3]: for i in tqdm(range(10)):
   ....:     time.sleep(3)

 60%|██████    | 6/10 [00:18<00:12,  0.33 it/s]

इसके अलावा, वहाँ tqdm का एक चित्रमय संस्करण है v2.0.0( d977a0c):

In [1]: import time

In [2]: from tqdm import tqdm_gui

In [3]: for i in tqdm_gui(range(100)):
  ....:     time.sleep(3)

लेकिन सावधान रहें, चूंकि आप tqdm_guiइसे उठा सकते हैं TqdmExperimentalWarning: GUI is experimental/alpha, आप इसका उपयोग करके इसे अनदेखा कर सकते हैं warnings.simplefilter("ignore"), लेकिन इसके बाद आपके कोड में सभी चेतावनियों को अनदेखा कर देगा।

Comments

यह एकमात्र ऐसा समाधान है जो मुझे टर्मिनल, क्यूटनकोस और नोटबुक के साथ काम करने के लिए मिला

— Ivelin

यह किसी भी चलने के साथ काम करता है? मुझे स्ट्रिंग्स की सूची के साथ काम करने में परेशानी हो रही है।

— जोश उस्रे

@JoshUsre हाँ यह किसी भी चलने के साथ काम करना चाहिए, पल के लिए मैं किसी भी iterable पर इसे देखा नहीं देखा था। हालांकि, ईटीए (शेष समय) के प्रदर्शन के लिए चलने योग्य __len__होना आवश्यक है एक संपत्ति या उपयोगकर्ता को totalतर्क की आपूर्ति करनी चाहिए tqdm। इसके अलावा, बार काम करेगा लेकिन कोई ईटीए के साथ नहीं।

— ३०'१६

@ विवरण: यह कैसे आया शीर्ष मतदान का जवाब नहीं है? यह सरल समाधान शीर्ष उत्तर के विपरीत टर्मिनल और जुपिटर नोटबुक दोनों में काम करता है।

— 04बे इसाक

एक जूपीटर नोटबुक उपयोग में चलाने के लिए from tqdm import tqdm_notebook as tqdm। अन्यथा यह एक पंक्ति पर नहीं लिखता है।

— जैक्स मालप्रेड

Answer 3

उपरोक्त सुझाव बहुत अच्छे हैं, लेकिन मुझे लगता है कि ज्यादातर लोग सिर्फ तैयार किए गए समाधान चाहते हैं, बाहरी पैकेजों पर कोई निर्भरता नहीं है, लेकिन यह पुन: प्रयोज्य भी है।

मुझे उपरोक्त सभी का सबसे अच्छा अंक मिला, और एक परीक्षण मामलों के साथ, इसे एक समारोह में बनाया।

इसका उपयोग करने के लिए, बस "def update_progress (प्रगति)" के तहत लाइनों की प्रतिलिपि बनाएँ, लेकिन परीक्षण स्क्रिप्ट नहीं। एसईएस आयात करने के लिए मत भूलना। जब भी आपको प्रगति पट्टी प्रदर्शित करने या अपडेट करने की आवश्यकता हो तो इसे कॉल करें।

यह कर्सर को प्रारंभ में वापस ले जाने के लिए सांत्वना देने के लिए सीधे "\ r" प्रतीक भेजकर काम करता है। अजगर में "प्रिंट" इस उद्देश्य के लिए उपरोक्त प्रतीक को फिर से नहीं बताता है, इसलिए हमें 'sys' की आवश्यकता है

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


# update_progress test script
print "progress : 'hello'"
update_progress("hello")
time.sleep(1)

print "progress : 3"
update_progress(3)
time.sleep(1)

print "progress : [23]"
update_progress([23])
time.sleep(1)

print ""
print "progress : -10"
update_progress(-10)
time.sleep(2)

print ""
print "progress : 10"
update_progress(10)
time.sleep(2)

print ""
print "progress : 0->1"
for i in range(101):
    time.sleep(0.1)
    update_progress(i/100.0)

print ""
print "Test completed"
time.sleep(10)

परीक्षण स्क्रिप्ट शो का परिणाम यही होता है (अंतिम प्रगति बार ऐनिमेट्स):

progress : 'hello'
Percent: [----------] 0% error: progress var must be float
progress : 3
Percent: [##########] 100% Done...
progress : [23]
Percent: [----------] 0% error: progress var must be float

progress : -10
Percent: [----------] 0% Halt...

progress : 10
Percent: [##########] 100% Done...

progress : 0->1
Percent: [##########] 100% Done...
Test completed

Comments

एनिमेटेड परीक्षण (पिछले एक) को in range(101)100 नहीं कहना चाहिए , प्रगति 99% पर रुक जाती है और कभी भी प्रदर्शित नहीं होती है।

— निक हम्रीच

Answer 4

यह उत्तर बाहरी पैकेजों पर निर्भर नहीं करता है , मुझे यह भी लगता है कि ज्यादातर लोग बस तैयार-तैयार कोड चाहते हैं । नीचे दिए गए कोड को अनुकूलित करके अपनी आवश्यकताओं को फिट करने के लिए अनुकूलित किया जा सकता है: बार प्रगति प्रतीक '#', बार size, पाठ prefixआदि।

import sys

def progressbar(it, prefix="", size=60, file=sys.stdout):
    count = len(it)
    def show(j):
        x = int(size*j/count)
        file.write("%s[%s%s] %i/%i\r" % (prefix, "#"*x, "."*(size-x), j, count))
        file.flush()        
    show(0)
    for i, item in enumerate(it):
        yield item
        show(i+1)
    file.write("\n")
    file.flush()

उपयोग:

import time

for i in progressbar(range(15), "Computing: ", 40):
    time.sleep(0.1) # any calculation you need

आउटपुट:

Computing: [################........................] 4/15

• एक दूसरे धागे की आवश्यकता नहीं है । ऊपर कुछ समाधान / पैकेज की आवश्यकता होती है। jupyter notebookउदाहरण के लिए, एक दूसरा धागा एक समस्या हो सकती है ।

• किसी भी चलने योग्य के साथ काम करता है इसका मतलब है कि कुछ भी जिसका len()उपयोग किया जा सकता है। उदाहरण के लिए कुछ भी list, एdict['a', 'b', 'c' ... 'g']

sys.stderrउदाहरण के लिए फ़ाइल को बदलकर आप आउटपुट भी बदल सकते हैं

Comments

मुझे यह समाधान पसंद है, जनरेटर निम्नलिखित त्रुटि फेंक देंगे:TypeError: object of type 'generator' has no len()

— jabellcu

उस मामले में @jabellcu ( generators) आपको इसे एक के साथ लपेटना होगा list()। जैसेfor i in progressbar(list(your_generator), "Computing: ", 40):

— १19:०४ पर eusoubrasileiro

Answer 5

इसी तरह के अनुप्रयोग के लिए (एक लूप में प्रगति पर नज़र रखने के लिए) मैंने बस अजगर-प्रगतिबार का उपयोग किया :

उनका उदाहरण कुछ इस तरह है,

from progressbar import *               # just a simple progress bar


widgets = ['Test: ', Percentage(), ' ', Bar(marker='0',left='[',right=']'),
           ' ', ETA(), ' ', FileTransferSpeed()] #see docs for other options

pbar = ProgressBar(widgets=widgets, maxval=500)
pbar.start()

for i in range(100,500+1,50):
    # here do something long at each iteration
    pbar.update(i) #this adds a little symbol at each iteration
pbar.finish()
print

Comments

पायथन 3 संगतता के लिए, progressbar2पैकेज का प्रयास करें । ऊपर दिया गया कोड इसके साथ काम करेगा।

— d33tah

क्या आपने वास्तव में सिर्फ उपयोग किया है import *?

— एरिक

Answer 6

Https://pypi.python.org/pypi/progress से प्रगति का प्रयास करें ।

from progress.bar import Bar

bar = Bar('Processing', max=20)
for i in range(20):
    # Do some work
    bar.next()
bar.finish()

परिणाम निम्नलिखित की तरह एक बार होगा:

Processing |#############                   | 42/100

Comments

बस यही कोशिश की। बहुत आसान उपयोग करने के लिए। मुझे 2 मिनट (पिप इंस्टॉल इंप्रूवमेंट सहित) एक स्टेटस बार अप एंड रनिंग की तरह लगे।

— पेरेलिन

progressअच्छा सलाखों बनाता है, लेकिन यह विफल रहता है अगर अन्य सॉफ्टवेयर हेरफेर कर रहा है stderr। क्षमा करें, लेकिन मैंने सटीक समस्या की जांच नहीं की है।

— आर्थर

यह मेरे ubuntu कंसोल में प्रत्येक प्रगति के लिए एक लाइन प्रिंट करता है, उदाहरण के लिए, यदि अधिकतम = 20, यह 20 लाइनों को प्रिंट करता है ... मैं इसे केवल एक लाइन कैसे प्रिंट करता हूं?

— एल वर्ल्ड

Answer 7

मैंने बस एक समान समाधान के लिए यहां खोज करने के बाद अपनी आवश्यकताओं के लिए एक साधारण प्रगति वर्ग बनाया है। मुझे लगा कि मैं इसे अच्छी तरह से पोस्ट कर सकता हूं।

from __future__ import print_function
import sys
import re


class ProgressBar(object):
    DEFAULT = 'Progress: %(bar)s %(percent)3d%%'
    FULL = '%(bar)s %(current)d/%(total)d (%(percent)3d%%) %(remaining)d to go'

    def __init__(self, total, width=40, fmt=DEFAULT, symbol='=',
                 output=sys.stderr):
        assert len(symbol) == 1

        self.total = total
        self.width = width
        self.symbol = symbol
        self.output = output
        self.fmt = re.sub(r'(?P<name>%\(.+?\))d',
            r'\g<name>%dd' % len(str(total)), fmt)

        self.current = 0

    def __call__(self):
        percent = self.current / float(self.total)
        size = int(self.width * percent)
        remaining = self.total - self.current
        bar = '[' + self.symbol * size + ' ' * (self.width - size) + ']'

        args = {
            'total': self.total,
            'bar': bar,
            'current': self.current,
            'percent': percent * 100,
            'remaining': remaining
        }
        print('\r' + self.fmt % args, file=self.output, end='')

    def done(self):
        self.current = self.total
        self()
        print('', file=self.output)

---

उदाहरण :

from time import sleep

progress = ProgressBar(80, fmt=ProgressBar.FULL)

for x in xrange(progress.total):
    progress.current += 1
    progress()
    sleep(0.1)
progress.done()

निम्नलिखित प्रिंट करेंगे:

[======== ] 17/80 ( 21%) 63 to go

Comments

बहुत बढ़िया, इसके लिए धन्यवाद। BTW, आप मुख्य कोड से ऑब्जेक्ट के साथ इंटरैक्शन को सीमित करने progress.currentके __call__लिए इंक्रीमेंट को और भी अधिक जोड़ सकते हैं ।

— npit

यह कोड सरल, संक्षिप्त और उपयोगी है! धन्यवाद!

— इयान रिहिन्केल

Answer 8

मुझे इसकी सरलता के लिए ब्रायन खुउ का जवाब पसंद है और बाहरी पैकेज की आवश्यकता नहीं है। मैंने इसे थोड़ा बदल दिया है इसलिए मैं अपना संस्करण यहाँ जोड़ रहा हूँ:

import sys
import time


def updt(total, progress):
    """
    Displays or updates a console progress bar.

    Original source: https://stackoverflow.com/a/15860757/1391441
    """
    barLength, status = 20, ""
    progress = float(progress) / float(total)
    if progress >= 1.:
        progress, status = 1, "\r\n"
    block = int(round(barLength * progress))
    text = "\r[{}] {:.0f}% {}".format(
        "#" * block + "-" * (barLength - block), round(progress * 100, 0),
        status)
    sys.stdout.write(text)
    sys.stdout.flush()


runs = 300
for run_num in range(runs):
    time.sleep(.1)
    updt(runs, run_num + 1)

इसमें कुल रनों totalकी संख्या ( ) और अब तक संसाधित रनों की संख्या ( progress) है total >= progress। परिणाम इस तरह दिखता है:

[#####---------------] 27%

Answer 9

आप tqdm का उपयोग कर सकते हैं :

from tqdm import tqdm

with tqdm(total=100, desc="Adding Users", bar_format="{l_bar}{bar} [ time left: {remaining} ]") as pbar:
    for i in range(100):
        time.sleep(3)
        pbar.update(1)

इस उदाहरण में प्रगति बार 5 मिनट के लिए चल रहा है और इसे इस तरह दिखाया गया है:

Adding Users:   3%|█████▊                                     [ time left: 04:51 ]                                                                                                        

आप इसे बदल सकते हैं और इसे अपनी इच्छानुसार अनुकूलित कर सकते हैं।

Answer 10

किसी भी प्रगति-बार ढांचे का उपयोग एक उपयोगी तरीके से करने के लिए, अर्थात वास्तविक प्रगति प्रतिशत और अनुमानित ईटीए प्राप्त करने के लिए, आपको यह घोषित करने में सक्षम होने की आवश्यकता है कि इसके कितने चरण होंगे।

तो, एक और सूत्र में आपके गणना कार्य, क्या आप इसे कई तार्किक चरणों में विभाजित करने में सक्षम हैं? क्या आप इसके कोड को संशोधित कर सकते हैं?

आपको इसे रीफ़्रैक्टर करने या वास्तविक तरीकों में विभाजित करने की आवश्यकता नहीं है, आप बस yieldइसके अंदर कुछ स्थानों पर कुछ रणनीतिक एस डाल सकते हैं! यदि महंगे फ़ंक्शन में लूप है , तो बस इसमें एक डालें। आपको केवल अंत में पता होना चाहिए कि सर्वोत्तम परिणाम प्राप्त करने के लिए कितनी पैदावार की जाएगी।

इस तरह, आपका कार्य कुछ इस तरह हो सकता है:

def compute():
    time.sleep(1)  # some processing here
    yield  # insert these
    time.sleep(1)
    yield
    time.sleep(1)
    yield

या यह:

def compute():
    for i in range(1000):
        time.sleep(.1)  # some processing here
        yield  # insert these

उस प्रकार के फ़ंक्शन के साथ, आप स्थापित कर सकते हैं:

pip install alive-progress

और इसका उपयोग करें:

from alive_progress import alive_bar

with alive_bar(3) as bar:  # or a 1000 in the loop example.
    for i in compute():
        bar()

एक शांत प्रगति-बार पाने के लिए!

|█████████████▎                          | ▅▃▁ 1/3 [33%] in 1s (1.0/s, eta: 2s)

अस्वीकरण: मैं live_progress का लेखक हूं, लेकिन इसे आपकी समस्या को अच्छी तरह से हल करना चाहिए। Https://github.com/rsalmei/alive-progress पर प्रलेखन पढ़ें , यहाँ एक उदाहरण है कि यह क्या कर सकता है:

Answer 11

मुझे वास्तव में अजगर-प्रगतिबार पसंद है , क्योंकि यह उपयोग करने के लिए बहुत सरल है।

सबसे सरल मामले के लिए, यह सिर्फ है:

import progressbar
import time

progress = progressbar.ProgressBar()
for i in progress(range(80)):
    time.sleep(0.01)

उपस्थिति को अनुकूलित किया जा सकता है और यह अनुमानित शेष समय प्रदर्शित कर सकता है। एक उदाहरण के लिए ऊपर के साथ समान कोड का उपयोग करें:

progress = progressbar.ProgressBar(widgets=[progressbar.Bar('=', '[', ']'), ' ',
                                            progressbar.Percentage(), ' ',
                                            progressbar.ETA()])

Answer 12

यदि यह निश्चित मात्रा में पुनरावृत्तियों के साथ एक बड़ा लूप है जो आपके द्वारा किए गए इस फ़ंक्शन का उपयोग कर सकता है। लूप का प्रत्येक पुनरावृत्ति प्रगति को जोड़ता है। जहां गिनती लूप की वर्तमान पुनरावृत्ति है, कुल मूल्य है जिसे आप लूपिंग कर रहे हैं और आकार (int) कितना बड़ा है जो आप 10 के वेतन वृद्धि में चाहते हैं (आकार 1 = 10 वर्ण, आकार 2 = 20 वर्ण)

import sys
def loadingBar(count,total,size):
    percent = float(count)/float(total)*100
    sys.stdout.write("\r" + str(int(count)).rjust(3,'0')+"/"+str(int(total)).rjust(3,'0') + ' [' + '='*int(percent/10)*size + ' '*(10-int(percent/10))*size + ']')

उदाहरण:

for i in range(0,100):
     loadingBar(i,100,2)
     #do some code 

उत्पादन:

i = 50
>> 050/100 [==========          ]

Answer 13

इस पुस्तकालय का उपयोग करें: fish( GitHub )।

उपयोग:

>>> import fish
>>> while churning:
...     churn_churn()
...     fish.animate()

मज़े करो!

Comments

यह संभव है। आपको डेवलपर से पूछना चाहिए या टिकट छोड़ना चाहिए: github.com/lericson/fish ।

— एटिने

Answer 14

नीचे दिया गया कोड काफी सामान्य समाधान है और इसमें एक समय बीतने और समय शेष अनुमान भी है। आप इसके साथ किसी भी चलने का उपयोग कर सकते हैं। प्रगति बार में 25 अक्षरों का एक निश्चित आकार होता है, लेकिन यह पूर्ण, आधे और तिमाही ब्लॉक वर्णों का उपयोग करके 1% चरणों में अपडेट दिखा सकता है। आउटपुट इस तरह दिखता है:

 18% |████▌                    | \ [0:00:01, 0:00:06]

उदाहरण के साथ कोड:

import sys, time
from numpy import linspace

def ProgressBar(iterObj):
  def SecToStr(sec):
    m, s = divmod(sec, 60)
    h, m = divmod(m, 60)
    return u'%d:%02d:%02d'%(h, m, s)
  L = len(iterObj)
  steps = {int(x):y for x,y in zip(linspace(0, L, min(100,L), endpoint=False),
                                   linspace(0, 100, min(100,L), endpoint=False))}
  qSteps = ['', u'\u258E', u'\u258C', u'\u258A'] # quarter and half block chars
  startT = time.time()
  timeStr = '   [0:00:00, -:--:--]'
  activity = [' -',' \\',' |',' /']
  for nn,item in enumerate(iterObj):
    if nn in steps:
      done = u'\u2588'*int(steps[nn]/4.0)+qSteps[int(steps[nn]%4)]
      todo = ' '*(25-len(done))
      barStr = u'%4d%% |%s%s|'%(steps[nn], done, todo)
    if nn>0:
      endT = time.time()
      timeStr = ' [%s, %s]'%(SecToStr(endT-startT),
                             SecToStr((endT-startT)*(L/float(nn)-1)))
    sys.stdout.write('\r'+barStr+activity[nn%4]+timeStr); sys.stdout.flush()
    yield item
  barStr = u'%4d%% |%s|'%(100, u'\u2588'*25)
  timeStr = '   [%s, 0:00:00]\n'%(SecToStr(time.time()-startT))
  sys.stdout.write('\r'+barStr+timeStr); sys.stdout.flush()

# Example
s = ''
for c in ProgressBar(list('Disassemble and reassemble this string')):
  time.sleep(0.2)
  s += c
print(s)

सुधार या अन्य टिप्पणियों के सुझावों की सराहना की जाती है। चीयर्स!

Answer 15

मुझे यह पेज पसंद आया ।

सरल उदाहरण के साथ शुरू होता है और एक बहु-थ्रेडेड संस्करण पर चलता है। बॉक्स से बाहर काम करता है। कोई 3 पार्टी पैकेज की आवश्यकता नहीं है।

कोड कुछ इस तरह दिखेगा:

import time
import sys

def do_task():
    time.sleep(1)

def example_1(n):
    for i in range(n):
        do_task()
        print '\b.',
        sys.stdout.flush()
    print ' Done!'

print 'Starting ',
example_1(10)

या यहाँ उदाहरण के लिए धागे का उपयोग करने के क्रम में कताई लोडिंग बार चलाने के लिए जब कार्यक्रम चल रहा है:

import sys
import time
import threading

class progress_bar_loading(threading.Thread):

    def run(self):
            global stop
            global kill
            print 'Loading....  ',
            sys.stdout.flush()
            i = 0
            while stop != True:
                    if (i%4) == 0: 
                        sys.stdout.write('\b/')
                    elif (i%4) == 1: 
                        sys.stdout.write('\b-')
                    elif (i%4) == 2: 
                        sys.stdout.write('\b\\')
                    elif (i%4) == 3: 
                        sys.stdout.write('\b|')

                    sys.stdout.flush()
                    time.sleep(0.2)
                    i+=1

            if kill == True: 
                print '\b\b\b\b ABORT!',
            else: 
                print '\b\b done!',


kill = False      
stop = False
p = progress_bar_loading()
p.start()

try:
    #anything you want to run. 
    time.sleep(1)
    stop = True
except KeyboardInterrupt or EOFError:
         kill = True
         stop = True

Answer 16

यह पायथन 3 में काफी सीधा है:

   import time
   import math

    def show_progress_bar(bar_length, completed, total):
        bar_length_unit_value = (total / bar_length)
        completed_bar_part = math.ceil(completed / bar_length_unit_value)
        progress = "*" * completed_bar_part
        remaining = " " * (bar_length - completed_bar_part)
        percent_done = "%.2f" % ((completed / total) * 100)
        print(f'[{progress}{remaining}] {percent_done}%', end='\r')

    bar_length = 30
    total = 100
    for i in range(0, total + 1):
        show_progress_bar(bar_length, i, total)
        time.sleep(0.1)

    print('\n')

Answer 17

ज्यूपिटर नोटबुक में चलने पर सामान्य tdmdm का उपयोग काम नहीं करता है, क्योंकि यह कई लाइनों पर आउटपुट लिखता है। इसके बजाय इसका उपयोग करें:

import time
from tqdm import tqdm_notebook as tqdm

for i in tqdm(range(100))
    time.sleep(0.5)

Answer 18

यदि आपके काम को औसत दर्जे के विखंडू में नहीं तोड़ा जा सकता है, तो आप अपने कार्य को एक नए सूत्र और समय में कह सकते हैं:

import thread
import time
import sys

def work():
    time.sleep( 5 )

def locked_call( func, lock ):
    lock.acquire()
    func()
    lock.release()

lock = thread.allocate_lock()
thread.start_new_thread( locked_call, ( work, lock, ) )

# This part is icky...
while( not lock.locked() ):
    time.sleep( 0.1 )

while( lock.locked() ):
    sys.stdout.write( "*" )
    sys.stdout.flush()
    time.sleep( 1 )
print "\nWork Done"

आप स्पष्ट रूप से आवश्यकतानुसार समय की सटीकता बढ़ा सकते हैं।

Comments

उत्तर में कोड में मापा जाने वाला कार्य कहां होगा?

— अनदेखी 27

Answer 19

मुझे गेब्रियल जवाब पसंद है , लेकिन मैंने इसे लचीला होने के लिए बदल दिया। आप फ़ंक्शन को बार-लंबाई भेज सकते हैं और अपनी प्रगति बार को किसी भी लंबाई के साथ प्राप्त कर सकते हैं जो आप चाहते हैं। और आपके पास शून्य या नकारात्मक लंबाई के साथ प्रगति पट्टी नहीं हो सकती है। इसके अलावा, आप इस फ़ंक्शन का उपयोग कर सकते हैं जैसे गेब्रियल उत्तर (उदाहरण # 2 देखें)।

import sys
import time

def ProgressBar(Total, Progress, BarLength=20, ProgressIcon="#", BarIcon="-"):
    try:
        # You can't have a progress bar with zero or negative length.
        if BarLength <1:
            BarLength = 20
        # Use status variable for going to the next line after progress completion.
        Status = ""
        # Calcuting progress between 0 and 1 for percentage.
        Progress = float(Progress) / float(Total)
        # Doing this conditions at final progressing.
        if Progress >= 1.:
            Progress = 1
            Status = "\r\n"    # Going to the next line
        # Calculating how many places should be filled
        Block = int(round(BarLength * Progress))
        # Show this
        Bar = "[{}] {:.0f}% {}".format(ProgressIcon * Block + BarIcon * (BarLength - Block), round(Progress * 100, 0), Status)
        return Bar
    except:
        return "ERROR"

def ShowBar(Bar):
    sys.stdout.write(Bar)
    sys.stdout.flush()

if __name__ == '__main__':
    print("This is a simple progress bar.\n")

    # Example #1:
    print('Example #1')
    Runs = 10
    for i in range(Runs + 1):
        progressBar = "\rProgress: " + ProgressBar(10, i, Runs)
        ShowBar(progressBar)
        time.sleep(1)

    # Example #2:
    print('\nExample #2')
    Runs = 10
    for i in range(Runs + 1):
        progressBar = "\rProgress: " + ProgressBar(10, i, 20, '|', '.')
        ShowBar(progressBar)
        time.sleep(1)

    print('\nDone.')

# Example #2:
Runs = 10
for i in range(Runs + 1):
    ProgressBar(10, i)
    time.sleep(1)

परिणाम:

यह एक साधारण प्रगति पट्टी है।

उदाहरण 1

प्रगति: [### -------] ३०%

उदाहरण # 2

प्रगति: [||||||||

किया हुआ।

Answer 20

मैंने format()लोड बार बनाने के लिए विधि का उपयोग किया । यहाँ मेरा समाधान है:

import time

loadbarwidth = 23

for i in range(1, loadbarwidth + 1):
    time.sleep(0.1) 

    strbarwidth = '[{}{}] - {}\r'.format(
        (i * '#'),
        ((loadbarwidth - i) * '-'),
        (('{:0.2f}'.format(((i) * (100/loadbarwidth))) + '%'))
    )

    print(strbarwidth ,end = '')

print()

आउटपुट:

[#######################] - 100.00%

Answer 21

यहां एक छोटा समाधान है जो लोडिंग बार को प्रोग्रामेटिक रूप से बनाता है (आपको यह तय करना होगा कि आप इसे कब तक चाहते हैं)।

import time

n = 33  # or however many loading slots you want to have
load = 0.01  # artificial loading time!
loading = '.' * n  # for strings, * is the repeat operator

for i in range(n+1):
    # this loop replaces each dot with a hash!
    print('\r%s Loading at %3d percent!' % (loading, i*100/n), end='')
    loading = loading[:i] + '#' + loading[i+1:]
    time.sleep(load)

Answer 22

PyProg का प्रयास करें। PyProg Python के लिए सुपर अनुकूलन योग्य प्रगति संकेतक और बार बनाने के लिए एक ओपन-सोर्स लाइब्रेरी है।

यह वर्तमान में संस्करण 1.0.2 पर है; यह Github पर होस्ट किया गया है और PyPI (नीचे लिंक नीचे) पर उपलब्ध है। यह पायथन 3 और 2 के साथ संगत है और इसे क्यूटी कंसोल के साथ भी इस्तेमाल किया जा सकता है।

यह उपयोग करने के लिए वास्तव में आसान है। निम्नलिखित कोड:

import pyprog
from time import sleep

# Create Object
prog = pyprog.ProgressBar(" ", "", 34)
# Update Progress Bar
prog.update()

for i in range(34):
    # Do something
    sleep(0.1)
    # Set current status
    prog.set_stat(i + 1)
    # Update Progress Bar again
    prog.update()

# Make the Progress Bar final
prog.end()

उत्पादन करेंगे:

Initial State:
Progress: 0% --------------------------------------------------

When half done:
Progress: 50% #########################-------------------------

Final State:
Progress: 100% ##################################################

मैंने वास्तव में PyProg बनाया क्योंकि मुझे एक सरल लेकिन सुपर अनुकूलन योग्य प्रगति बार लाइब्रेरी की आवश्यकता थी। आप आसानी से के साथ स्थापित कर सकते हैं: pip install pyprog।

PyProg Github: https://github.com/Bill13579/pyprog
PyPI: https://pypi.python.org/pypi/pyprog/

Answer 23

आप प्रबुद्धता का उपयोग भी कर सकते हैं । मुख्य लाभ यह है कि आप अपनी प्रगति पट्टी को अधिलेखित किए बिना एक ही समय में लॉग इन कर सकते हैं।

import time
import enlighten

manager = enlighten.Manager()
pbar = manager.counter(total=100)

for num in range(1, 101):
    time.sleep(0.05)
    print('Step %d complete' % num)
    pbar.update()

यह कई प्रगति सलाखों को भी संभालता है।

import time
import enlighten

manager = enlighten.Manager()
odds = manager.counter(total=50)
evens = manager.counter(total=50)

for num in range(1, 101):
    time.sleep(0.05)
    if num % 2:
        odds.update()
    else:
        evens.update()

Answer 24

प्रगति पुस्तकालय का उपयोग करें !

pip install progress

यहाँ एक कस्टम उपवर्ग है जिसे मैंने ETA / बीता हुआ समय को बेहतर पठनीय प्रारूप में प्रारूपित करने के लिए लिखा है:

import datetime
from progress.bar import IncrementalBar


class ProgressBar(IncrementalBar):
    '''
    My custom progress bar that:
       - Show %, count, elapsed, eta
       - Time is shown in H:M:S format
    '''

    message = 'Progress'
    suffix  = '%(percent).1f%% (%(index)d/%(max)d) -- %(elapsed_min)s (eta: %(eta_min)s)'

    def formatTime(self, seconds):
        return str(datetime.timedelta(seconds=seconds))

    @property
    def elapsed_min(self):
        return self.formatTime(self.elapsed)

    @property
    def eta_min(self):
        return self.formatTime(self.eta)

if __name__=='__main__':
    counter = 120
    bar     = ProgressBar('Processing', max=counter)

    for i in range(counter):
        bar.next()
        time.sleep(1)

    bar.finish()

Answer 25

यह मेरा सरल उपाय है:

import time

def progress(_cur, _max):
    p = round(100*_cur/_max)
    b = f"Progress: {p}% - ["+"."*int(p/5)+" "*(20-int(p/5))+"]"
    print(b, end="\r")

# USAGE:
for i in range(0,101):
    time.sleep(0.1) 
    progress(i,100)

print("..."*5, end="\r")
print("Done")

Answer 26

आपको हाथ में प्रगति पट्टी को कार्य से जोड़ना चाहिए (ताकि यह प्रगति को मापें: डी)। उदाहरण के लिए, यदि आप किसी फ़ाइल को एफ़टीपी कर रहे हैं, तो आप एक निश्चित आकार के बफर को हथियाने के लिए ftplib को बता सकते हैं, चलो 128K को कहते हैं, और फिर आप अपनी प्रगति पट्टी में जोड़ते हैं, जो कि फाइल का 128 प्रतिशत प्रतिनिधित्व करता है। यदि आप सीएलआई का उपयोग कर रहे हैं, और आपका प्रगति मीटर 20 वर्ण लंबा है, तो आप एक वर्ण तब जोड़ सकते हैं जब फ़ाइल का 1/20 वां स्थानान्तरण हुआ हो।

Comments

मेरे मामले में मैं एक एपीआई का उपयोग कर रहा हूं और यह विशिष्ट चंक्स प्राप्त करने के लिए कोई सुविधा प्रदान नहीं करता है। इस विचार के लिए धन्यवाद, यह अच्छा है।

— user225312

Answer 27

@Magagran: यह मेरे कार्यक्रमों में अच्छा काम करता है। इसके अलावा, लूप के समय को इंगित करने के लिए हमें एक काउंटर जोड़ना होगा। यह काउंटर विधि के तर्क के रूप में खेलता है update। उदाहरण के लिए: एक परीक्षण फ़ाइल की सभी पंक्तियों को पढ़ें और उन्हें किसी चीज़ पर व्यवहार करें। मान लीजिए कि फ़ंक्शन dosth()चर में चिंता नहीं करता है i।

lines = open(sys.argv[1]).readlines()
i = 0
widgets=[Percentage(), Bar()]
pbar = ProgressBar(widgets=widgets,maxval=len(lines)).start()
pbar.start()
for line in lines:<pre>
    dosth();
    i += 1
    pbar.update(i)</pre>
pbar.finish()

चर विधि iके pbarमाध्यम से स्थिति को नियंत्रित करता हैupdate

Answer 28

jelde015 का थोड़ा और सामान्य उत्तर (निश्चित रूप से उसका श्रेय)

मैन्युअल रूप से लोडिंग बार को अपडेट करने के लिए यह होगा:

import sys
from math import *


def loadingBar(i, N, size):
    percent = float(i) / float(N)
    sys.stdout.write("\r"
                     + str(int(i)).rjust(3, '0')
                     +"/"
                     +str(int(N)).rjust(3, '0')
                     + ' ['
                     + '='*ceil(percent*size)
                     + ' '*floor((1-percent)*size)
                     + ']')

और इसे कॉल करके:

loadingBar(7, 220, 40)

परिणाम होगा:

007/220 [=                                       ]  

जब भी आप वर्तमान iमूल्य के साथ चाहें, बस इसे कॉल करें ।

sizeबार की संख्या जितनी होनी चाहिए निर्धारित करें

Answer 29

लगता है कि मुझे थोड़ी देर हो गई है लेकिन यह अजगर 3 के वर्तमान संस्करणों के साथ काम करने वाले लोगों के लिए काम करना चाहिए , क्योंकि यह "एफ-स्ट्रिंग्स" का उपयोग करता है , जैसा कि पायथन 3.6 पीईपी 498 में पेश किया गया है :

कोड

from numpy import interp

class Progress:
    def __init__(self, value, end, title='Downloading',buffer=20):
        self.title = title
        #when calling in a for loop it doesn't include the last number
        self.end = end -1
        self.buffer = buffer
        self.value = value
        self.progress()

    def progress(self):
        maped = int(interp(self.value, [0, self.end], [0, self.buffer]))
        print(f'{self.title}: [{"#"*maped}{"-"*(self.buffer - maped)}]{self.value}/{self.end} {((self.value/self.end)*100):.2f}%', end='\r')

उदाहरण

#some loop that does perfroms a task
for x in range(21)  #set to 21 to include until 20
    Progress(x, 21)

उत्पादन

Downloading: [########------------] 8/20 40.00%

Answer 30

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

import time,sys
toolbar_width = 50
# setting up toolbar [-------------------------------------]
sys.stdout.write("[%s]"%(("-")*toolbar_width))
sys.stdout.flush()
# each hash represents 2 % of the progress
for i in range(toolbar_width):
    sys.stdout.write("\r") # return to start of line
    sys.stdout.flush()
    sys.stdout.write("[")#Overwrite over the existing text from the start 
    sys.stdout.write("#"*(i+1))# number of # denotes the progress completed 
    sys.stdout.flush()
    time.sleep(0.1)