software - python tutorial pdf




পাইথন অগ্রগতি বার (18)

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

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

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

মনে রাখবেন যে আমি বাস্তব সময়ে এটি প্রয়োজন, তাই আমি এটি সম্পর্কে কি করতে হবে তা বুঝতে পারছি না। আমি এই জন্য একটি thread প্রয়োজন? আমার কোন ধারণা নাই.

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


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

import time
from tqdm import tqdm_notebook as tqdm

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

অনুরূপ অ্যাপ্লিকেশনের জন্য (একটি লুপে অগ্রগতির ট্র্যাক রাখা) আমি কেবল python-progressbar ব্যবহার করেছি:

তাদের উদাহরণ এই মত কিছু যায়,

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

আপনি 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 ]                                                                                                        

আপনি এটি পরিবর্তন এবং পছন্দ হিসাবে এটি কাস্টমাইজ করতে পারেন।


আপনি অগ্রগতি বারটিকে টাস্কের সাথে যুক্ত করতে হবে (যাতে এটি অগ্রগতির পরিমাপ করে: D)। উদাহরণস্বরূপ, যদি আপনি কোনও ফাইল এফটিপিআইটিং করেন তবে আপনি একটি নির্দিষ্ট আকারের বাফারটি ধরতে ftplib কে বলতে পারেন, 128K কে বলুন, এবং তারপরে আপনি আপনার অগ্রগতি বারে যোগ করুন 128k ফাইলাইলাইজের যে শতাংশের প্রতিনিধিত্ব করে। আপনি যদি CLI ব্যবহার করেন এবং আপনার অগ্রগতি মিটার ২0 অক্ষরের দীর্ঘ হয় তবে ফাইলটির 1/20 তম স্থান স্থানান্তরিত হলে আপনি একটি চরিত্র যুক্ত করবেন।


আমি Gabriel উত্তর পছন্দ করি, কিন্তু আমি এটি নমনীয় হতে পরিবর্তন। আপনি ফাংশনে বার-দৈর্ঘ্য পাঠাতে পারেন এবং আপনার অগ্রগতি বারটি যেকোন দৈর্ঘ্যের সাথে পেতে পারেন। এবং আপনি শূন্য বা নেতিবাচক দৈর্ঘ্য সঙ্গে একটি অগ্রগতি বার থাকতে পারে না। এছাড়াও, আপনি এই ফাংশনটি Gabriel উত্তরের মত ব্যবহার করতে পারেন (উদাহরণ # 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%

সম্পন্ন.


আমি একটু দেরী করছি কিন্তু এই পাইথন 3 এর বর্তমান সংস্করণগুলির সাথে কাজ করার জন্য কাজ করা উচিত, এটি পাইথন 3.6 PEP 498 এ উপস্থাপিত "F-strings" ব্যবহার করে , কারণ:

কোড

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%

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

import sys
import time


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

    Original source: https://.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%

আমি সমতুল্য সমাধানের জন্য এখানে অনুসন্ধানের পরে আমার প্রয়োজনগুলির জন্য একটি সহজ অগ্রগতির ক্লাস তৈরি করেছি। আমি ভেবেছিলাম আমি ভাল পোস্ট করতে পারি।

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


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

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

এটি ব্যবহার করতে, "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(100):
    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: [##########] 99.0%
Test completed

এখানে একটি সংক্ষিপ্ত সমাধান যা লোডিং বারটি প্রোগ্রাম্যাটিক্যাল করে তোলে (আপনি কতক্ষণ এটি চান তা স্থির করতে হবে)।

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)

এটা Python3 মধ্যে বেশ সহজবোধ্য:

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

নির্দিষ্ট লাইব্রেরি আছে ( এটি এখানে একটি মত ) কিন্তু হয়তো খুব সহজ কিছু করবে:

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

দ্রষ্টব্য: এই প্রগতিবারটি প্রগতিবারের একটি ফর্ক যা কয়েক বছর ধরে রক্ষণাবেক্ষণ করা হয়নি।


নীচের কোডটি বেশ সাধারণ সমাধান এবং এটি একটি সময় অতিবাহিত এবং সময় বাকি অনুমান। আপনি এটির সাথে কোন পুনরাবৃত্তি ব্যবহার করতে পারেন। অগ্রগতি বারটিতে 25 টি অক্ষরের একটি নির্দিষ্ট আকার রয়েছে কিন্তু এটি পূর্ণ, অর্ধ এবং চতুর্থাংশ ব্লক অক্ষরের ব্যবহার করে 1% পদক্ষেপগুলিতে আপডেটগুলি প্রদর্শন করতে পারে। আউটপুট এই মত দেখাচ্ছে:

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

উদাহরণ সহ কোড:

import sys, time
from numpy import linspace

def ProgressBar(iterObj, refreshTime=10):
  #refreshTime=10: refresh the time estimate at least every 10 sec.
  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(np.linspace(0,L,  min(100,L),endpoint=False), 
                                     np.linspace(0,100,min(100,L),endpoint=False))}
  qSteps  = ['', u'\u258E',u'\u258C',u'\u258A'] # quarter and half block chars
  startT  = endT = time.time()
  timeStr = ' [0:00:00, -:--:--]'
  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+timeStr); sys.stdout.flush()
    elif time.time()-endT > refreshTime:
      endT    = time.time()
      timeStr = ' [%s, %s]'%(SecToStr(endT-startT), SecToStr((endT-startT)*(L/float(nn)-1)))
      sys.stdout.write('\r'+barStr+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 op in ProgressBar(list('Disassemble and reassemble this string')):
  time.sleep(0.5)
  s += op
print s

উন্নতি বা অন্যান্য মন্তব্যের জন্য পরামর্শ স্বাগত জানাই। আনন্দ কর.


যদি এটি একটি বড় লুপ থাকে যা একটি নির্দিষ্ট পরিমাণ পুনরাবৃত্তি হয় যা অনেক সময় নেয় তবে আপনি এই ফাংশনটি ব্যবহার করতে পারেন। লুপ প্রতি পুনরাবৃত্তি অগ্রগতি যোগ করে। যেখানে গণনাটি লুপের বর্তমান পুনরাবৃত্তি হয়, মোট মানটি আপনি লুপ করছেন এবং আকারটি (int) কত বার আপনি বারের চেয়ে বৃদ্ধি চান (অর্থাৎ 1 = 10 অক্ষর, আকার ২ = ২0 অক্ষর)

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

tqdm আপনি একটি সেকেন্ডের মধ্যে আপনার loops একটি অগ্রগতি মিটার যোগ করতে পারেন:

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 ) থেকে v2.0.0 এর গ্রাফিকাল সংস্করণ রয়েছে:

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 বাড়াতে TqdmExperimentalWarning: GUI is experimental/alpha , আপনি warnings.simplefilter("ignore") ব্যবহার করে এটি উপেক্ষা করতে পারেন তবে এটি পরে আপনার কোডের সমস্ত সতর্কতা উপেক্ষা করবে।


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

এই উত্তর বহিরাগত প্যাকেজ উপর নির্ভর করে না , আমি মনে করি যে অধিকাংশ মানুষ শুধু কোড একটি প্রস্তুত তৈরি টুকরা চান । নীচের কোডটি কাস্টমাইজ করে আপনার চাহিদাগুলি মাপসই করা যেতে পারে: বার অগ্রগতি চিহ্ন '#' , বার 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 , উদাহরণস্বরূপ ['a', 'b', 'c' ... 'g']

উদাহরণস্বরূপ আপনি sys.stderr ফাইলটি পরিবর্তন করে আউটপুট পরিবর্তন করতে পারেন





python