Progress bar is not working good in python

I'm trying to make a progress bar when deleting files in python. This python script print the count of the files in a directory and then it will delete them while showing a progress bar. When deleting 10 or 11 files it is working good. But when the file count is larger like
20, It is showing this mess,

Found 20 files.
Deleting[########################################################################################################
.........Deleting[###############################################################################################
##################Deleting[######################################################################################
###########################Deleting[#############################################################################
####################################Deleting[####################################################################
#############################################Deleting[###########################################################
######################################################Deleting[##################################################
#################################################################################################################
###############################################]100.0%

But I want to print it like this,

Found 20 files.
Deleting[####################.............]75%

Here is my code ,

import os
import sys
import time

out = sys.stdout

path_ = input("Enter the path: ")
count_ = 0
files = []
for path in os.listdir(path_):
    if os.path.isfile(os.path.join(path_, path)):
        count_ += 1
        files.append(path)

print(f"Found {count_} files.")
hashes = ""
count = 0
hash = 0
spaces = ".." * 20
for item in files:
    item = path_ + "\\" + item
    os.remove(item)
    count += 1
    per = count/count_ * 100
    for i in range(int(per)):
        hash += 1
        if hash == 10:
            hash = 0
            spaces = ".." * (count_ - count)
            hashes += "##"
    print("{}[{}{}]{}{}".format("Deleting", hashes, spaces, per, "%"), end='\r', file=out, flush=True)
    time.sleep(1)

print("\n")

What am I doing wrong here? please help.

If you'd prefer not to use tqdm, here's an example using f-strings. The :-<{BAR_LEN} part of the string means "fill the rest of the string, up to BAR_LEN characters (in this case, 20), with -"

from time import sleep


iterable = range(101)  # this is the iterable you want to loop over
count = len(iterable) - 1
BAR_LEN = 20  # this is the length of your progress bar

for n in iterable:
    # print the progress bar
    # "#" is your fill character, '-' is your empty segment
    print(
        '\r',
        f'Deleting[{"#" * round(n / (count / BAR_LEN)):-<{BAR_LEN}}]'  # bar
        f'{(n * 100) // count}%',  # percentage
        end='', 
        flush=True,
    )
    sleep(0.2)  # optional - just simulates something happening in the background

I found something that works for me , hope the comments make it understandable.
This solution doesn't use os.system to clear the printed lines so it should work in your IDE.

Still, I strongly suggest looking into tqdm as it's very easy to use and optimized. for this kind of things.

Feel free to ask further questions if needed. Don't forget to accept an answer if it solved your issue !

import os
import sys
import time

out = sys.stdout

path_ = input("Enter the path: ")
count_ = 0
files = []
for path in os.listdir(path_):
	if os.path.isfile(os.path.join(path_, path)):
		count_ += 1
		files.append(path)

print(f"Found {count_} files.")
count = 0
hash_counter = 0
	#avoid creating a variable named 'hash', as it is a method name.
spaces = ".." * 20
for item in files:
	item = path_ + "\\" + item
	os.remove(item)
	count += 1
	per = count/count_ * 100
	is_last_file = (count==count_)
		#this variable checks if the number of deleted files (count) si equal to the total number of files (count_),
		#so it will return True only when we're deleting the last file of the directory.
	for i in range(int(per)):
		hash += 1
		if hash == 10:
			hash = 0
			number_of_hashes = int(round(per/5, 0))
				#first we calculate the number of hashes ("##") in our progress bar.
				#we divide the percentage by five because we have a percentage x/100 but we want to display it on a divider of 20 (x/20),
				#so we divide your percentage by 5 (e.g 40% of 20 = 5 hashes)
			hashes = "##" * number_of_hashes
			spaces = ".." * (20-number_of_hashes)
				#we calculate easily the number of spaces : it's 20 (the size of our progress bar) minus the number of hashes.
	print(f"{'Deleting' if not is_last_file else 'Deleted'} [{hashes}{spaces}] {per:.1f}%", end=('\r' if not is_last_file else '\n'), file=out, flush=True)
		#using f-strings here is more pythonic ! ;)
		#Also as you can see i used ":.1f" after the percentage. this way we have only one decimal after our float.
	time.sleep(1)
		#you can remove this from your code afterwards.

print("\n")

The main issue is in your inner for loop.

First, because you don't reset hashes, it over counts the necessary number of hashes. E.g. at 10%, it adds two hashes and then at 20% it counts both 10% and 20% and adds four additional hashes for a total of six hashes. I don't believe you intend this.

Second, I don't think the hash is counting as you desire either. For example, at one file removed out of 20 (5%), hash goes to 5. Then at the second file removed (10%), hash resumes incrementing from 5 and resets midway and ends at 5.

hash is a keyword and don't reassign it. Your code is very inefficient and inelegant.

I have refactored your code.

import os
from collections import deque

def cyan(text):
    return f'\x1b[36m{text}\x1b[0m'

def recur_dir(folder, path):
    files = deque()
    for entry in os.scandir(folder):
        if entry.is_file():
            files.append(f'{path}/{entry.name}')
        elif entry.is_dir():
            files.extend(recur_dir(entry, f'{path}/{entry.name}'))
    return files

def delete(folder):
    files = recur_dir(folder, folder)
    total = len(files)
    for i, file in enumerate(files, start=1):
        os.remove(file)
        progress = i/total*100
        print(f"\rDeleting[{cyan('█' * round(progress)):·<109}] {progress:.2f}%", end='', flush=True)

Use like this: delete('path/to/folder').

Progress bar:

Deleting[██████████████████████████████████████████████████████████████······································] 61.97%

With color:

Note that the folder path cannot end with '/'.

To get all files you can use a simple recursive function. Your code doesn't list all files under the given directory recursively, meaning it won't delete files inside the subdirectories of the given folder.

My code lists all files inside the given directory recursively.

To get the count of elements inside a collection just use len(lst). You don't have to repeated increment a variable manually.

Then you can use enumerate to calculate progress, the progress is simply the total divided by index (if you use one-based indexing). It is that simple.

Update

That magic number needs to be 109, not 100, because after coloring the text, the string will contain ANSI codes, the ANSI codes won't be printed, instead they change the color of the text, but they will still be counted as characters when calculating length, and they account for 9 extra characters.

The less than sign indicates the string should be left justified, since there are 9 extra characters, the progress bar will only be 91 characters long until the progress is 91%, because you only need 91 characters to left pad to 100 characters. So using 109 will make the progress bar always 100 characters long.

Using the f-string format. It will delete faster. It can delete more than 20 files.

Change this on line 31:
print("{}[{}{}]{}{}".format("Deleting", hashes, spaces, per, "%"), end='\r', file=out, flush=True)

to:

print(f"Deleting {hashes} {spaces}, {per}% \r", file=out, flush=True)

Output:
Found 10 files.
Deleting ## .................., 10.0%

Deleting ###### ................, 20.0% 

Deleting ############ .............., 30.0% 

Deleting #################### ............, 40.0% 

Deleting ############################## .........., 50.0% 

Deleting ########################################## ........, 60.0% 

Deleting ######################################################## ......, 70.0% 

Deleting ######################################################################## ...., 80.0% 

Deleting ########################################################################################## .., 90.0% 

Deleting ############################################################################################################## , 100.0% 

Another this is removing harsh.

print(f"Deleting {spaces} {per}% \r", file=out, flush=True)

Output:

Found 20 files.
Deleting ........................................ 5.0% 

Deleting .................................... 10.0% 

Deleting .................................. 15.0% 

Deleting ................................ 20.0% 

Deleting .............................. 25.0% 

Deleting ............................ 30.0% 

Deleting .......................... 35.0% 

Deleting ........................ 40.0% 

Deleting ...................... 45.0% 

Deleting .................... 50.0% 

Deleting .................. 55.00000000000001% 

Deleting ................ 60.0% 

Deleting .............. 65.0% 

Deleting ............ 70.0% 

Deleting .......... 75.0% 

Deleting ........ 80.0% 

Deleting ...... 85.0% 

Deleting .... 90.0% 

Deleting .. 95.0% 

Deleting  100.0%