পাইথন প্রগতি বার

Question

আমার স্ক্রিপ্টটি এমন কিছু কাজ করতে পারে যাতে সম্ভবত সময় লাগবে?

উদাহরণস্বরূপ, একটি ফাংশন যা সম্পূর্ণ হতে কিছু সময় নেয় এবং Trueহয়ে গেলে ফিরে আসে । ফাংশনটি কার্যকর হওয়ার সময় আমি কীভাবে একটি অগ্রগতি বারটি প্রদর্শন করতে পারি?

মনে রাখবেন যে আসল সময়ে আমার এটি হওয়া দরকার, সুতরাং এটি সম্পর্কে কী করা উচিত তা আমি বুঝতে পারি না। এর threadজন্য আমার কি দরকার ? আমার কোন ধারণা নাই.

এই মুহুর্তে আমি ফাংশনটি সম্পাদন করার সময় কোনও কিছু মুদ্রণ করছি না, তবে একটি অগ্রগতি বারটি দুর্দান্ত হবে। এছাড়াও কোডের দৃষ্টিকোণ থেকে এটি কীভাবে করা যায় তাতে আমি আরও আগ্রহী।

Comments

আপনি কি কেবল জিইউআই সরঞ্জামকিট বা সিএলআই ব্যবহার করছেন?

— ববি

CLI। তবে আমি তৃতীয় পক্ষের লাইব্রেরিটি ব্যবহার করতে পারি, এটি কোনও সমস্যা নয়। জিইউআই দিয়ে আমি এটি করতে পারি, তবে আমি সি এল এল অংশে আগ্রহী ছিলাম।

— ব্যবহারকারী225312

কনসোলে পাঠ্য অগ্রগতি বারের সম্ভাব্য সদৃশ নোটটি নোট করুন যে এই প্রশ্নটি তিন দিন আগে পোস্ট করা হয়েছিল, লিঙ্কিত প্রশ্নটি আরও ঘন ঘন দেখা হয়।

— গ্রিনস্টিক

এখানে একটি বৃহত্তর

— স্টিভেন সি হাওল

আমি একটি নতুন ধরণের প্রগতি বার প্রকাশ করেছি, যা আপনি প্রিন্ট করতে পারেন, থ্রুপুট এবং এটা দেখতে পারেন, এমনকি এটি থামিয়ে দিতে পারেন, খুব শীতল অ্যানিমেশন ছাড়াও! দয়া করে একবার দেখুন: github.com/rsalmei/alive-progress ! জীবিত-অগ্রগতি

— রসলমেই

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

দ্রষ্টব্য: প্রগতিবার 2 অগ্রগতির একটি কাঁটা যা বছরের পর বছর ধরে রক্ষিত হয়নি।

Comments

এটি অনেক পদক্ষেপের জন্য স্কেল করে না ... pypi.python.org/pypi/progress ব্যবহার করা অনেক সহজ

— m13r

আমি এই কোডটি চেষ্টা করেছি এবং এটি একটি NameError: name 'xrange' is not definedত্রুটি ছুঁড়েছে । আমি কি একটি মডিউল অনুপস্থিত?

— মাশরুম ম্যান

@ গোকুএমসিএসপোক 9733 আপনি পাইথনের কোন সংস্করণ ব্যবহার করছেন? পাইথনের 2 xrangeটি পাইথনের 3 range।

— কোয়াপকা

এটি শীর্ষ উত্তর হওয়া উচিত নয়। অন্য উত্তর (টিকিডিএম সহ) আমার পক্ষে কমপক্ষে অনেক ভাল।

— ফ্লোরিয়ান

পাইথন 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]

এছাড়াও, v2.0.0( d977a0c) থেকে tqdm এর একটি গ্রাফিকাল সংস্করণ রয়েছে :

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

টার্মিনাল, কিউটকনসোল এবং নোটবুক নিয়ে কাজ করার জন্য এটিই আমি একমাত্র সমাধান পেয়েছি

— আইভলিন

এটি কোনও পুনরাবৃত্তির সাথে কাজ করে? স্ট্রিংগুলির একটি তালিকা নিয়ে কাজ করতে আমার সমস্যা হয়েছে।

— জোশ উসরে

@ জোশিউস্রে হ্যাঁ এটি যে কোনও পুনরাবৃত্তির সাথে কাজ করা উচিত, এই মুহুর্তের জন্য আমি কোনও শ্রুতিমধুর এটি দেখতে পেলাম না। তবে, ইটিএ (বাকি সময়) এর প্রদর্শনের জন্য কোনও __len__সম্পত্তি থাকার জন্য পুনরাবৃত্ত হওয়া প্রয়োজন বা ব্যবহারকারীর পক্ষে totalযুক্তি সরবরাহ করতে হবে tqdm। অন্যথায়, বারটি কাজ করবে তবে কোনও ইটিএ নেই।

— চমত্কার

@ গাবরস: কীভাবে এ আসবে শীর্ষ ভোট দেওয়া উত্তর নয়? এই সহজ সমাধানটি টার্মিনাল এবং জপিটার নোটবুক উভয় ক্ষেত্রে উপরের উত্তরের মতো নয়।

— আইজাক

একটি Jupyter নোটবুক ব্যবহার চালানোর জন্য from tqdm import tqdm_notebook as tqdm। অন্যথায় এটি এক লাইনে লিখবেন না।

— জ্যাকস ম্যালাপ্রেডে

Answer 3

উপরের পরামর্শগুলি বেশ ভাল, তবে আমি মনে করি বেশিরভাগ লোকেরা কেবল প্রস্তুত সমাধান চায়, বাহ্যিক প্যাকেজগুলির উপর নির্ভরতা না থাকলেও এটি পুনরায় ব্যবহারযোগ্য।

আমি উপরের সমস্তটির সেরা পয়েন্ট পেয়েছি এবং একটি পরীক্ষার কেস সহ এটি একটি ফাংশনে পরিণত করেছি।

এটি ব্যবহার করতে, কেবল "Def আপডেট_progress (অগ্রগতি)" এর অধীনে লাইনগুলি অনুলিপি করুন তবে পরীক্ষার স্ক্রিপ্ট নয়। সিস আমদানি করতে ভুলবেন না আপনার যখনই অগ্রগতি বারটি প্রদর্শন বা আপডেট করার প্রয়োজন হয় তখন এটিকে কল করুন।

এটি কার্সারটিকে আবার শুরুতে ফিরে যেতে কনসোলে সরাসরি "\ r" প্রতীক পাঠিয়ে কাজ করে। পাইথনের "মুদ্রণ" এই উদ্দেশ্যে উপরের প্রতীকটি পুনরায় সংশ্লেষ করে না, সুতরাং আমাদের 'সিএস' দরকার

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ইত্যাদি fit

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 সেক্ষেত্রে ( generators) আপনাকে এটি একটি দিয়ে মুড়ে ফেলতে হবে list()। পছন্দ করুনfor i in progressbar(list(your_generator), "Computing: ", 40):

— ইউসৌব্রাসিরিও

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। দুঃখিত, তবে আমি সঠিক সমস্যাটি তদন্ত করে দেখিনি।

— আর্থার 14

এটি আমার উবুন্টু কনসোলে প্রতিটি অগ্রগতির জন্য একটি লাইন মুদ্রণ করে, উদাহরণস্বরূপ, যদি সর্বোচ্চ = 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

দুর্দান্ত, এর জন্য আপনাকে ধন্যবাদ। বিটিডাব্লু, আপনি মূল কোড থেকে আরও বেশি করে অবজেক্টের সাথে ইন্টারঅ্যাকশন সীমাবদ্ধ করতে progress.currentশেষে ইনক্রিমেন্টিং যুক্ত করতে পারেন __call__।

— এনপিট

এই কোডটি সহজ, সংক্ষিপ্ত এবং দরকারী! ধন্যবাদ!

— ইয়ান রেহুইনেল

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)

দাবি অস্বীকার: আমি জীবিত_প্রযুক্তির লেখক, তবে এটি আপনার সমস্যাটি সুন্দরভাবে সমাধান করা উচিত। 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

যদি এটি একটি নির্দিষ্ট পরিমাণ পুনরাবৃত্তির সাথে একটি বড় লুপ হয় যা অনেক সময় নিচ্ছে আপনি আমার তৈরি এই ফাংশনটি ব্যবহার করতে পারেন। লুপের প্রতিটি পুনরাবৃত্তি অগ্রগতি যোগ করে। যেখানে গণনাটি লুপটির বর্তমান পুনরাবৃত্তি, মোটটি হ'ল আপনি যে মানটি লুপ করছেন এবং আকার (ইন্ট) এটি হ'ল আপনি 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( গিটহাব )।

ব্যবহার:

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

আমি এটি পছন্দ করি পৃষ্ঠা ।

সাধারণ উদাহরণ দিয়ে শুরু হয় এবং একাধিক-থ্রেড সংস্করণে চলে আসে। বাক্সের বাইরে কাজ করে। কোন তৃতীয় পক্ষের প্যাকেজ প্রয়োজন।

কোডটি এরকম কিছু দেখবে:

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

জুপিটারে চলার সময় নোটবুকগুলি সাধারণ tqdm ব্যবহার করে না কারণ এটি একাধিক লাইনে আউটপুট লেখায়। পরিবর্তে এটি ব্যবহার করুন:

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

উত্তরে কোডটি কোনটি পরিমাপ করতে হবে?

— unseen_rider

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

অগ্রগতি: [### -------] 30%

উদাহরণ # 2

অগ্রগতি: [|||दनाডিকেটবিজ্ঞাপন / নথিপত্র ........] 60%

সম্পন্ন.

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

পাইপ্রোগ চেষ্টা করুন। পাইপ্রাগ হ'ল পাইথনের একটি ওপেন সোর্স লাইব্রেরি সুপার কাস্টমাইজযোগ্য অগ্রগতি সূচক এবং বারগুলি তৈরি করতে।

এটি বর্তমানে 1.0.2 সংস্করণে রয়েছে; এটি গিথুবটিতে হোস্ট করা হয়েছে এবং পিপিআইতে উপলব্ধ রয়েছে (নীচে লিঙ্কগুলি)। এটি পাইথন 3 এবং 2 এর সাথে সামঞ্জস্যপূর্ণ এবং এটি Qt কনসোলের সাথেও ব্যবহার করা যেতে পারে।

এটি ব্যবহার করা সত্যই সহজ। নিম্নলিখিত কোড:

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% ##################################################

আমি পাইপগ্রোগটি আসলে তৈরি করেছি কারণ আমার একটি সাধারণ তবে সুপার কাস্টমাইজযোগ্য প্রগতি বার গ্রন্থাগার প্রয়োজন। আপনি সহজেই সঙ্গে এটি ইনস্টল করতে পারেন: pip install pyprog।

পাইপ্রোগ গিথুব: https://github.com/Bill13579/pyprog পাইপিআই
: 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

আমি ইটিএ / অতিবাহিত সময়গুলিকে আরও ভাল পঠনযোগ্য ফর্ম্যাটে ফর্ম্যাট করতে এখানে লিখেছি এমন একটি কাস্টম সাবক্লাস রয়েছে:

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

আমার ক্ষেত্রে আমি একটি এপিআই ব্যবহার করছি এবং এটি নির্দিষ্ট অংশগুলির জন্য কোনও সুবিধা সরবরাহ করে না। যদিও ধারণাটির জন্য ধন্যবাদ, এটি দুর্দান্ত।

— ব্যবহারকারী 225312

Answer 27

@ মাসাগ্রান: এটি আমার প্রোগ্রামগুলিতে ভাল কাজ করে। তদ্ব্যতীত, লুপ সময়গুলি নির্দেশ করতে আমাদের একটি কাউন্টার যুক্ত করতে হবে। এই কাউন্টারটি পদ্ধতির আর্গুমেন্ট হিসাবে অভিনয় করে 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স্থিতি নিয়ন্ত্রণ করেpbarupdate

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

অনুমান করুন আমি কিছুটা দেরি করেছি তবে পাইথন ৩ এর বর্তমান সংস্করণগুলি নিয়ে কাজ করা লোকদের পক্ষে এটি কাজ করা উচিত , যেহেতু এটি পাইথন ৩.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)