কনসোলে পাঠ্য অগ্রগতি বার [বন্ধ]

Question

আমি এফটিপিপ্লিব ব্যবহার করে কোনও এফটিপি সার্ভার থেকে ফাইলগুলি আপলোড এবং ডাউনলোড করতে একটি সাধারণ কনসোল অ্যাপ লিখেছিলাম।

আমি চাই অ্যাপটি ব্যবহারকারীর জন্য এর ডাউনলোড / আপলোড অগ্রগতির কিছু দৃশ্যায়ন দেখায়; প্রতিবার কোনও ডেটা অংশ ডাউনলোড হয়ে গেলে, আমি এটির অগ্রগতির আপডেট সরবরাহ করতে চাই, এমনকি এটি যদি শতাংশের মতো সংখ্যাগত উপস্থাপনা থাকে।

গুরুত্বপূর্ণভাবে, আমি পূর্ববর্তী লাইনে কনসোলে মুদ্রিত সমস্ত পাঠ মুছে ফেলা এড়াতে চাই (যেমন আমি আপডেট অগ্রগতি মুদ্রণের সময় পুরো টার্মিনালটি "সাফ" করতে চাই না) want

এটি মোটামুটি সাধারণ কাজ বলে মনে হচ্ছে - আমি কীভাবে অগ্রগতি বার বা অনুরূপ ভিজ্যুয়ালাইজেশন তৈরি করতে যাব যা পূর্ববর্তী প্রোগ্রাম আউটপুট সংরক্ষণের সময় আমার কনসোলকে আউটপুট দেয়?

Comments

হুম, গতকাল জিজ্ঞাসা করা এই প্রশ্নের সদৃশটির মতো চেহারা: stackoverflow.com/questions/3160699/python-progress-bar/3162864 সুতরাং, আপনার ফিশ পিপিআইপিথন.আর.পিপি

— এটিয়েন

"কেবল একটি জিইউআই ব্যবহার করুন" ভুল ধারণাটি বোঝায় যে জিইউআইগুলি কিছু পরিস্থিতিতে দুর্দান্ত (দ্রুত শিখনের বক্ররেখা, অ্যাড-হক এক্সপ্লোরেশন বা ইন্টারেক্টিভ বা এক-অফ ক্রিয়াকলাপ) রয়েছে যখন কমান্ড-লাইন সরঞ্জামগুলি অন্যদের জন্য দুর্দান্ত (বিশেষজ্ঞ ব্যবহারকারীগণ, অ্যাড-হক অ্যাপ্লিকেশনগুলি রচনা করছেন) বহুবার সাবধানে সংজ্ঞায়িত অপারেশন করার জন্য

— জোনাথন হার্টলে

আমি আবার খুলতে ভোট দিয়েছি। প্রশ্ন আমাকে খুব বিস্তৃত হিসাবে আঘাত করে না।

— ফ্রাঙ্ক ডারননকোর্ট

আমি মনে করি আপনি যা খুঁজছেন তা টিকিডিএম ... যদিও আমি জানি না কেন এসও আমাকে বছরের পুরানো প্রশ্নগুলিতে পুনরায় ভোট পুনরায় পর্যালোচনা করতে অনুরোধ করছে।

— কুংফু

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

— রসলমেই

Answer 1

একটি সাধারণ, স্বনির্ধারিত অগ্রগতি বার Bar

নীচে আমি নিয়মিত ব্যবহার করি এমন অনেকগুলি উত্তরের সমষ্টি এখানে রয়েছে (কোনও আমদানির প্রয়োজন নেই)।

# 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

হালনাগাদ

এমন একটি বিকল্পের বিষয়ে মন্তব্যে আলোচনা হয়েছিল যা অগ্রগতি বারটিকে গতিশীলভাবে টার্মিনাল উইন্ডো প্রস্থের সাথে সামঞ্জস্য করতে দেয়। যদিও আমি এটি প্রস্তাব দিচ্ছি না, এখানে একটি গিস্ট রয়েছে যা এই বৈশিষ্ট্যটি কার্যকর করে (এবং ক্যাভেটগুলি নোট করে)।

Comments

এই স্নিপেট দুর্দান্ত কাজ করে! আমি বেশ কয়েকটি ছোটখাটো সমস্যার মুখোমুখি হয়েছি তাই আমি কিছু ছোটখাটো সম্পাদনা করেছি (পিইপি -8, অ-এসকি চরিত্রের জন্য ডিফল্ট এনকোডিং) এবং এগুলিকে

— অ্যাব্রিকাস

আপনার পাইথন 2 @ অস্ট্রিকাস ব্যবহার না করা অবধি ইউটিএফ -8 ঘোষণার প্রয়োজন নেই

— গ্রিনস্টিক

@ ম্যাটক্লেমবস এটি পাইথন 3 এর জন্য রচিত যা ডিফল্টরূপে ইউটিএফ -8 এনকোডিং ব্যবহার করে। আপনি হয় ফাংশনটির ডিফল্ট ফিল প্যারামিটারটি পরিবর্তন করতে পারেন, এটি একটি ইউটিএফ -8 অক্ষর, বা ইউটিএফ -8 ঘোষণাটি ব্যবহার করতে পারেন। কোনও ইউটিএফ -8 ঘোষণাপত্রটি কেমন হওয়া উচিত তার উদাহরণের জন্য উপরের মন্তব্যে সারাংশটি দেখুন।

— গ্রিনস্টিক

ধন্যবাদ, দুর্দান্ত সংক্ষিপ্তসার, টার্মিনাল আকার সনাক্তকরণও কার্যকর হতে পারে এই ফাংশনটির জন্য # Size of terminal rows, columns = [int(x) for x in os.popen('stty size', 'r').read().split()] columnsপ্রগতি বারের আকারটি টার্মিনাল উইন্ডোতে সামঞ্জস্য করতে দৈর্ঘ্যে প্রেরণ করা উচিত। যদিও বারের অগ্রগতির অংশের দৈর্ঘ্য হ্রাস করা উচিত (এই স্ট্রিংয়ের উপসর্গ, প্রত্যয়, শতাংশ এবং অতিরিক্ত অক্ষর দ্বারা দৈর্ঘ্য'\r%s |%s| %s%% %s'

— Arleg

কিছু আইডিইতে এটি কাজ করার জন্য (যেমন উইন্ডোতে পাইচার্ম) আপনার এটিকে পরিবর্তন end = '\r'করতে হবে end = ''।

— thomas88wp

Answer 2

'' R 'লিখলে কার্সারটি লাইনের শুরুতে ফিরে যাবে।

এটি একটি শতাংশের কাউন্টার প্রদর্শন করে:

import time
import sys

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

Comments

পেস্ট করে দৌড়ে গেল। এটি প্রতিবার একটি নতুন লাইনে প্রিন্ট করে। আমি চাই একই লাইনে নম্বরটি আপডেট করা হোক। :)

— bobber205

এই উদাহরণটি একটি ওবিওবিও উত্পাদন করে এটি লোডিং শেষ করে99%

— গ্লেন ডেটন

@ মুস এটি "এক বাগ দ্বারা বন্ধ" এর জন্য দাঁড়িয়েছে

— গ্লেন ডেটন

printএকটি হয়েছে end: যুক্তি stackoverflow.com/a/8436827/1959808

— Ioannis Filippidis

@ ইওনিসফিলিপিসিস যা বলেছেন তাতে যুক্ত করার জন্য, printতারও একটি flushযুক্তি রয়েছে: ডকস.পিথথন.আর

— /

Answer 3

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]

Comments

অজগর শেলটি আপনি কী ব্যবহার করেন?

— xotonic

@ এক্সটোনিক লিঙ্কটি জানিয়েছে এটি পিটিপিথন

— jfs

Answer 4

\rকনসোলে একটি লিখুন । এটি একটি "ক্যারেজ রিটার্ন" যা লাইনের শুরুতে সমস্ত পাঠ্য প্রতিধ্বনিত করার পরে তৈরি করে। কিছুটা এইরকম:

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

যা আপনাকে এরকম কিছু দেবে: [ ########## ] 100%

Comments

করুন \rএবং তারপরে আবার পুরো লাইনটি লিখুন। মূলত:, print("\rProgress: [{0:50s}] {1:.1f}%".format('#' * int(amtDone * 50), amtDone * 100))যেখানে amtDone0 এবং 1 এর মধ্যে ভাসমান

— মাইক ডিসিমোন

উন্নত ব্যবহার করতে sys.stdout.writeচেয়ে print। সঙ্গে printআমি নতুন লাইন পেয়েছিলাম।

— গিল বেটস

আমার জন্য কাজ ,শেষে একটি কমা যুক্ত printকরুন।

— চুনলিয়াং লিউ

পাইথন 3 এ মুদ্রণ ব্যবহার করুন (...., শেষ = '') এবং আপনার কোনও নতুন লাইন থাকবে না

— গ্রেওয়াল্ফ

পাইথন 3 প্রাক্তন অবদানের সংক্ষিপ্তসার:, print("\rProgress: [{0:50s}] {1:.1f}%".format('#' * int(workdone * 50), workdone*100), end="", flush=True)যেখানে workdone0 এবং 1 এর মধ্যে একটি ভাসা থাকে যেমন,workdone = parsed_dirs/total_dirs

— খায়ক্স

Answer 5

এটি কোডের 10 লাইনেরও কম।

এখানে বক্তব্য: https://gist.github.com/vladignatyev/06860ec2040cb497f0f3

import sys


def progress(count, total, suffix=''):
    bar_len = 60
    filled_len = int(round(bar_len * count / float(total)))

    percents = round(100.0 * count / float(total), 1)
    bar = '=' * filled_len + '-' * (bar_len - filled_len)

    sys.stdout.write('[%s] %s%s ...%s\r' % (bar, percents, '%', suffix))
    sys.stdout.flush()  # As suggested by Rom Ruben

Comments

ফাংশনের শেষে "sys.stdout.flush ()" যুক্ত করে।

— রোমুবেন

আমার জন্য এটি একটি নতুন লাইনে যায়

— জিএম

@ জিএম আপনি কি ওএস / প্ল্যাটফর্ম ব্যবহার করেন?

— ভ্লাদিমির ইগনাতিয়েভ

আমি জানি না যে আমি যদি এটি স্পাইডার আইডি থেকে চালিত করি তবে এটি কাজ করে না তবে আমি আইপথন কনসোল থেকে চালালে এটি কাজ করে!

— জিএম

Answer 6

ব্যবহার করে দেখুন ক্লিক Python- র মোৎসার্ট, আরমিন 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)

Answer 7

আমি বুঝতে পেরেছি যে আমি খেলায় দেরী হয়েছি, তবে আমি এখানে লিখেছি কিছুটা ইয়াম স্টাইল (রেড হ্যাট) এখানে রয়েছে (এখানে 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%

... যেখানে বন্ধনী স্থির থাকে এবং কেবল হ্যাশগুলি বৃদ্ধি পায়।

এটি ডেকরেটার হিসাবে আরও ভাল কাজ করতে পারে। আর এক দিনের জন্য ...

Comments

দুর্দান্ত সমাধান! পুরোপুরি কাজ করে! আপনাকে অনেক ধন্যবাদ!

— ভাসিলিজে বার্সাক

Answer 8

এই পাঠাগারটি পরীক্ষা করুন: ক্লিন্ট

এটিতে একটি অগ্রগতি বার সহ অনেকগুলি বৈশিষ্ট্য রয়েছে:

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)

এই লিঙ্কটি এর বৈশিষ্ট্যগুলির একটি দ্রুত ওভারভিউ সরবরাহ করে

Answer 9

এখানে একটি progressbar পাইথন লেখা একটি চমৎকার উদাহরণ আছে: http://nadiana.com/animated-terminal-progress-bar-in-python

তবে আপনি নিজেই এটি লিখতে চান। আপনি cursesজিনিসগুলি সহজ করতে মডিউলটি ব্যবহার করতে পারেন :)

[সম্পাদনা] শাপের শব্দটি সম্ভবত সহজ নয়। তবে আপনি যদি অভিশাপগুলির চেয়ে আপনার জন্য একটি পূর্ণ প্রসন্ন কিউই তৈরি করতে চান তবে আপনার জন্য প্রচুর স্টাফের যত্ন নেয়।

[সম্পাদনা] যেহেতু পুরানো লিঙ্কটি মারা গেছে আমি পাইথন প্রগ্রেসবারের নিজস্ব সংস্করণ স্থাপন করেছি, এটি এখানে পান: https://github.com/WoLpH/python-progressbar

Comments

curses? সহজ?

— হুমম

একটি চমৎকার নিবন্ধ, আমি এটির একটি লিঙ্ক দিতে যাচ্ছিলাম তবে আমার বুকমার্কগুলিতে খুঁজে

— পেল

@ অ্যাভেরাল দাশগুপ্ত: পর্যাপ্ত পরিমাণে, সহজ এখানে সঠিক শব্দ নাও হতে পারে। এটি আপনাকে প্রচুর কাজ বাঁচাতে পারে তবে এটি আপনি যা খুঁজছেন তার উপর নির্ভর করে।

— ওল্ফ

এই জড়িত কাছাকাছি কিছু জন্য সন্ধান না, তবে যাইহোক ধন্যবাদ। :)

— bobber205

মৃত লিঙ্ক, এটি আপনার উত্তরটিতে লিঙ্কযুক্ত সামগ্রী পোস্ট না করার জন্য মূল্য --__-

— থারস্মমনার

Answer 10

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

আউটপুট

[২৯%] ====================

Answer 11

এবং, কেবল স্তূপে যুক্ত করার জন্য, আপনি ব্যবহার করতে পারেন এমন একটি উপাদান এখানে

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

এটি বেশিরভাগ ক্ষেত্রে "ওপরের শীর্ষ" হিসাবে বিবেচিত হবে তবে আপনি যখন এটি ব্যবহার করছেন তখন তা কার্যকর

Comments

এর জন্য ধন্যবাদ. ছোট ফিক্স, প্লটপ্রোগ্রেস পদ্ধতিতে sys.stdout.flush () লাইনটি ব্যবহার করা উচিত অন্যথায় টাস্কটি সম্পন্ন না হওয়া পর্যন্ত অগ্রগতি বারটি টানা না যেতে পারে (যেমনটি ম্যাক টার্মিনালে ঘটে)।

— osnoz

আমি এটা ভালোবাসি!!! ব্যবহার করা মোটামুটি সহজ !!! আপনাকে ধন্যবাদ

— Microos

Answer 12

ইনস্টল করুন 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]

Answer 13

এই চালান পাইথন কমান্ড লাইনে ( না কোনো আইডিই বা উন্নয়ন পরিবেশে):

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

আমার উইন্ডোজ সিস্টেমে সূক্ষ্মভাবে কাজ করে।

Answer 14

• http://code.activestate.com/recines/168639-progress-bar-class/ (2002)
• http://code.activestate.com/recines/299207-console-text-progress-indicator-class/ (2004)
• http://pypi.python.org/pypi/progressbar (2006)

এবং প্রচুর টিউটোরিয়াল গুগল হওয়ার জন্য অপেক্ষা করছে।

Answer 15

আমি reddit থেকে অগ্রগতি ব্যবহার করছি । আমি এটি পছন্দ করি কারণ এটি প্রতিটি আইটেমের জন্য এক লাইনে অগ্রগতি মুদ্রণ করতে পারে এবং এটি প্রোগ্রাম থেকে মুদ্রণগুলি মুছবে না।

সম্পাদনা: স্থির লিঙ্ক

Comments

আপনার লিঙ্কটি নষ্ট হয়েছে - সোর্স কোডের আসল লাইনটি 1274 তম, 1124 তম নয়! সুতরাং, ডান লিংকটি হ'ল: github.com/reddit/reddit/blob/master/r2/r2/lib/utils/…

— ভ্লাদিমির

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

— ভ্লাদিমির ইগনাতিয়েভ

Answer 16

এই প্যাকেজটি ইনস্টল করার চেষ্টা করুন pip install progressbar2:

import time
import progressbar

for i in progressbar.progressbar(range(100)):
    time.sleep(0.02)

প্রগতি বার গিথুব: https://github.com/WoLpH/python-progressbar

Answer 17

উপরের উত্তরগুলি এবং সিএলআই অগ্রগতি বার সম্পর্কে অন্যান্য অনুরূপ প্রশ্নের ভিত্তিতে, আমি মনে করি তাদের সকলের একটি সাধারণ সাধারণ উত্তর পেয়েছি think এটি পরীক্ষা করে দেখুন 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%

Answer 18

আমি 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)

Answer 19

খুব সহজ সমাধান হ'ল এই কোডটি আপনার লুপের মধ্যে রাখা:

এটি আপনার ফাইলের শরীরে (অর্থাৎ শীর্ষে) রাখুন:

import sys

এটি আপনার লুপের শরীরে রাখুন:

sys.stdout.write("-") # prints a dash for each iteration of loop
sys.stdout.flush() # ensures bar is displayed incrementally

Answer 20

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

progressbar()

দ্রষ্টব্য: আপনি যদি ইন্টারেক্টিভ ইন্টারেক্টিপ্টারে এটি চালান তবে আপনি অতিরিক্ত সংখ্যা মুদ্রণযোগ্য পাবেন

Answer 21

লল আমি কেবল এই বিষয়টির জন্য একটি সম্পূর্ণ জিনিস লিখেছিলাম কোডটি মনে রাখবেন আপনি ইউনিকোড ব্যবহার করতে পারবেন না যখন আপনি সিপি 437 ব্যবহার করেন

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

Answer 22

উপরের দুর্দান্ত পরামর্শ দিয়ে আমি অগ্রগতি বারটি নিয়ে কাজ করি।

তবে আমি কিছু ত্রুটিগুলি উল্লেখ করতে চাই

1. প্রতিবার অগ্রগতি বারটি ফ্লাশ করা হলে এটি নতুন লাইনে শুরু হবে

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

   এর মতো:
   [] 0%
   [#] 10%
   [##] 20%
   [###] 30%

২. # বর্গাকার বন্ধনী ']' এবং '###' দীর্ঘ হওয়ার সাথে সাথে ডান দিকের শিফ্টের শতাংশ সংখ্যা।
৩. 'অগ্রগতি / 10' এক্সপ্রেশনটি কোনও পূর্ণসংখ্যা ফেরত দিতে না পারলে একটি ত্রুটি ঘটবে।

এবং নীচের কোডটি উপরের সমস্যার সমাধান করবে।

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

Answer 23

পাইথন টার্মিনাল প্রগতি বারের জন্য কোড

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

Answer 24

আমি একটি সাধারণ অগ্রগতি লিখেছি:

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% (অনকম্প) এবং সীমানা

এখানে একটি উদাহরণ:

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   ] 

Answer 25

আমি এখানে পাওয়া কিছু ধারণাগুলি একত্রিত করছি এবং আনুমানিক সময় বাকী যোগ করছি:

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)

Answer 26

অজগর 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 "")

Answer 27

ঠিক আছে এখানে কোডটি কাজ করে এবং আমি পোস্ট করার আগে এটি পরীক্ষা করেছিলাম:

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 এর নিচে যে কোনও সংখ্যা)
• সম্পন্ন (১০০ এবং যে কোনও সংখ্যা ১০০ এর উপরে)
• অগ্রগতি গণনা (0-100 (বিশেষ ফাংশনের জন্য নীচে এবং উপরে ব্যবহৃত))
• বারের পাশের শতাংশ, এবং এটি একটি একক লাইন

কনস:

• কেবল পূর্ণসংখ্যার সমর্থন করে (বিভাগটিকে একটি পূর্ণসংখ্যা বিভাগ করে যদিও তাদের সমর্থন করার জন্য এটি সংশোধন করা যেতে পারে, কেবলমাত্র এতে পরিবর্তন prog2 = prog/5করুন prog2 = int(prog/5))

Answer 28

এখানে আমার পাইথন 3 সমাধান:

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

আপনার স্ট্রিংয়ের প্রতিটি অক্ষরের জন্য '\ বি' ব্যাকস্ল্যাশ। এটি উইন্ডোজ সিএমডি উইন্ডোর মধ্যে কাজ করে না।

Answer 29

গ্রীনস্টিক থেকে 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()

Answer 30

পাইথন মডিউল প্রগতিবারটি একটি দুর্দান্ত পছন্দ। এখানে আমার সাধারণ কোডটি রয়েছে:

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