Progress Bar в Python: улучшаем UX скриптов для контроля процессов

Для кого эта статья:

• Python-разработчики, стремящиеся улучшить пользовательский опыт своих приложений
• Студенты и обучающиеся, интересующиеся современными методами разработки на Python

• Профессионалы, желающие оптимизировать производительность своих скриптов и приложений

  Знакомо ли вам чувство беспомощности, когда скрипт Python выполняется неопределенно долго, а вы даже не представляете, на каком этапе находится процесс? Progress bar — это тот спасательный круг, который превращает хаотичное ожидание в структурированный процесс, давая пользователю точное понимание хода выполнения программы. От простейших консольных приложений до сложных GUI-систем, индикатор прогресса не только улучшает UX, но и помогает разработчикам контролировать длительные операции. Освоив эту технику, вы подниметесь на новый уровень профессионализма в создании Python-приложений. 🚀

Хотите не просто добавлять индикаторы прогресса, а создавать полноценные интерактивные приложения? Обучение Python-разработке от Skypro — это практический подход к программированию, где вы освоите не только базовые элементы интерфейса, но и научитесь разрабатывать профессиональные веб-приложения с использованием современных технологий и фреймворков. Начните путь к карьере Python-разработчика с экспертной поддержкой преподавателей-практиков!

Основы progress bar в Python: назначение и преимущества

Progress bar (индикатор прогресса) — интерфейсный элемент, визуализирующий степень завершенности процесса, критически важный при работе с длительными операциями. Когда ваш Python-скрипт обрабатывает гигабайты данных или выполняет сложные вычисления, пользователь оценит визуальное подтверждение того, что система не зависла, а методично выполняет задачу. 📊

Ключевые преимущества использования progress bar:

• Информативность — пользователь точно знает, сколько процентов задачи выполнено и сколько осталось
• Улучшение UX — ожидание становится предсказуемым и менее раздражающим
• Контроль выполнения — разработчик может отслеживать прогресс длительных процессов
• Отладка — индикатор прогресса может помочь обнаружить узкие места в производительности
• Профессиональный вид — даже простое консольное приложение выглядит законченным продуктом

Существует множество способов реализации progress bar в Python — от простейших самописных решений до продвинутых библиотек с богатым функционалом.

Выбор конкретного решения зависит от требований проекта, сложности задачи и предпочтений разработчика. Но независимо от выбора, добавление progress bar — это инвестиция в удобство как конечных пользователей, так и самих программистов.

Встроенные инструменты: создаем простой индикатор прогресса

Python не имеет встроенной функции для создания progress bar, но позволяет реализовать базовый индикатор прогресса с использованием стандартных библиотек. Ниже приведены несколько подходов к созданию простого progress bar без внешних зависимостей.

Простейший вариант консольного индикатора прогресса использует управляющие символы терминала:

import sys
import time

def basic_progress_bar(iteration, total, length=50, fill='█'):
percent = ("{0:.1f}").format(100 * (iteration / float(total)))
filled_length = int(length * iteration // total)
bar = fill * filled_length + '-' * (length – filled_length)
sys.stdout.write(f'\r|{bar}| {percent}% Complete')
sys.stdout.flush()

# Пример использования
total_items = 50
for i in range(total_items + 1):
basic_progress_bar(i, total_items)
time.sleep(0.1) # Имитация работы
print() # Новая строка после завершения

Этот код создает минималистичный прогресс-бар, который обновляется в той же строке консоли, создавая эффект анимации. Символ '\r' возвращает каретку в начало строки, что позволяет перезаписывать ту же область консоли.

Для более информативного индикатора можно добавить расчет оставшегося времени:

import sys
import time

def advanced_progress_bar(iteration, total, start_time, length=50, fill='█'):
percent = ("{0:.1f}").format(100 * (iteration / float(total)))
filled_length = int(length * iteration // total)
bar = fill * filled_length + '-' * (length – filled_length)

elapsed_time = time.time() – start_time
if iteration > 0:
eta = elapsed_time * (total / iteration – 1)
eta_str = f"ETA: {eta:.1f}s"
else:
eta_str = "ETA: calculating..."

sys.stdout.write(f'\r|{bar}| {percent}% {eta_str}')
sys.stdout.flush()

# Пример использования
total_items = 50
start = time.time()
for i in range(total_items + 1):
advanced_progress_bar(i, total_items, start)
time.sleep(0.1) # Имитация работы
print() # Новая строка после завершения

Александр Петров, технический лид Python-команды

Когда мы начинали проект по анализу миллионов медицинских записей, наша первая версия скрипта просто работала без какой-либо индикации. Один из наших заказчиков постоянно звонил с вопросом: "Ваш скрипт работает или завис?" После третьего звонка я потратил 20 минут на написание простого progress bar.

Код был элементарным:

Python

Скопировать код

for i, record in enumerate(huge_dataset):
process_record(record)
print(f"\rProcessing: {i}/{len(huge_dataset)} records ({i/len(huge_dataset)*100:.1f}%)", end="")

Этого хватило, чтобы звонки прекратились. Спустя неделю мы интегрировали полноценную библиотеку tqdm, но даже такой простой индикатор сэкономил нам часы разъяснений и перезапусков скрипта по запросу клиента. Иногда самые простые решения приносят наибольшую пользу.

При работе с объектами, которые можно итерировать, удобно создать класс-обертку для отображения прогресса:

class ProgressIterator:
def __init__(self, iterable, total=None):
self.iterable = iterable
self.total = total or len(iterable)
self.current = 0
self.start_time = time.time()

def __iter__(self):
return self

def __next__(self):
if self.current < self.total:
value = next(self.iterable)
self.current += 1
advanced_progress_bar(self.current, self.total, self.start_time)
return value
else:
print() # Новая строка после завершения
raise StopIteration

# Пример использования
numbers = range(50)
for num in ProgressIterator(iter(numbers)):
time.sleep(0.1) # Имитация работы

Такая реализация позволяет легко интегрировать progress bar в существующий код, просто оборачивая итерируемые объекты в класс ProgressIterator.

Встроенные инструменты хороши для быстрых решений, но для серьезных проектов рекомендуется использовать специализированные библиотеки, которые предлагают больше функциональности при меньших затратах на разработку.

TQDM библиотека: мощные индикаторы с минимумом кода

Библиотека tqdm — признанный стандарт для создания индикаторов прогресса в Python. Название происходит от арабского taqadum (تقدّم), что означает "прогресс". Эта библиотека обеспечивает максимальную функциональность при минимальных усилиях интеграции. 🔄

Для начала работы установите tqdm через pip:

pip install tqdm

Базовое использование tqdm поражает своей простотой:

from tqdm import tqdm
import time

for i in tqdm(range(100)):
time.sleep(0.1) # Имитация работы

Этот код автоматически создаст интерактивный progress bar с процентом выполнения, скоростью обработки и оценкой оставшегося времени. tqdm интеллектуально определяет, запущен ли скрипт в интерактивном терминале, и выбирает оптимальный способ отображения.

Для более гибкой настройки tqdm предлагает множество параметров:

from tqdm import tqdm
import time

for i in tqdm(range(100), desc="Processing", unit="item", 
colour="green", ncols=100, leave=False):
time.sleep(0.1) # Имитация работы

Параметры позволяют настроить внешний вид и поведение индикатора:

• desc — описание операции, отображаемое перед индикатором
• unit — единица измерения для итераций (файлы, записи, байты и т.д.)
• colour — цвет прогресс-бара (поддерживаются разные цвета в зависимости от терминала)
• ncols — фиксированная ширина всего индикатора
• leave — сохранять ли индикатор после завершения

Для случаев, когда невозможно использовать цикл for, tqdm предоставляет ручное управление:

from tqdm import tqdm
import time

with tqdm(total=100, desc="Manual control") as pbar:
for i in range(10):
# Выполняем часть работы
time.sleep(0.5)
# Обновляем индикатор на 10 единиц
pbar.update(10)

# Можно также изменять описание во время выполнения
pbar.set_description(f"Processing batch {i+1}/10")

Tqdm также прекрасно интегрируется с pandas для обработки данных:

import pandas as pd
from tqdm import tqdm

# Интеграция с pandas
tqdm.pandas()

# Теперь любая операция apply в pandas будет показывать прогресс
df = pd.DataFrame({'A': range(1000)})
df['B'] = df['A'].progress_apply(lambda x: x**2)

Для ноутбуков Jupyter библиотека предлагает специальную версию, использующую JavaScript-виджеты для плавной анимации:

from tqdm.notebook import tqdm as tqdm_notebook

for i in tqdm_notebook(range(100)):
time.sleep(0.1) # Имитация работы

Tqdm выделяется среди библиотек для создания progress bar благодаря сбалансированному сочетанию простоты использования и богатой функциональности. Она стала стандартом де-факто для Python-разработчиков, работающих с длительными операциями.

Progress bar в консольных и GUI Python-приложениях

Реализация индикаторов прогресса существенно различается в зависимости от типа приложения. Консольные интерфейсы требуют одного подхода, а графические интерфейсы — совершенно другого. Рассмотрим оба варианта подробнее.

Марина Ковалева, Python-разработчик в сфере data science

Наша команда работала над приложением для анализа геномных данных. В консольной версии мы использовали tqdm, и клиенты были довольны. Но когда пришло время создать GUI-версию, мы столкнулись с проблемой: индикатор в консоли больше не подходил.

Первая наша попытка была наивной — просто запустить обработку данных в основном потоке с Tkinter progress bar:

Python

Скопировать код

import tkinter as tk
from tkinter import ttk
import time

def process_with_progress():
progress['value'] = 0
for i in range(100):
# Выполняем длительную операцию
time.sleep(0.1)
progress['value'] += 1
root.update_idletasks()

root = tk.Tk()
progress = ttk.Progressbar(root, length=300)
progress.pack(pady=10)
button = tk.Button(root, text="Start", command=process_with_progress)
button.pack(pady=10)
root.mainloop()

Код работал, но интерфейс замирал во время обработки. Решением стало использование многопоточности:

Python

Скопировать код

import threading

def start_process():
threading.Thread(target=process_with_progress).start()

Это был важный урок: в GUI прогресс-бар должен обновляться независимо от основного процесса обработки данных.

Для консольных приложений существует несколько специализированных библиотек помимо tqdm. Библиотека progressbar2 предлагает более гибкую настройку внешнего вида индикатора:

import progressbar
import time

widgets = [
' [', progressbar.Timer(), '] ',
progressbar.Bar(),
' (', progressbar.ETA(), ') ',
]

with progressbar.ProgressBar(max_value=100, widgets=widgets) as bar:
for i in range(100):
time.sleep(0.1)
bar.update(i + 1)

Библиотека Rich предлагает еще более продвинутые возможности для создания красивых консольных интерфейсов:

from rich.progress import Progress, TextColumn, BarColumn, TimeElapsedColumn
import time

with Progress(
TextColumn("[bold blue]{task.description}"),
BarColumn(),
TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
TimeElapsedColumn()
) as progress:
task = progress.add_task("[cyan]Processing...", total=100)

for i in range(100):
time.sleep(0.1)
progress.update(task, advance=1)

Для GUI-приложений подходы существенно отличаются. Рассмотрим реализацию progress bar в популярных GUI-фреймворках:

Tkinter — стандартная GUI-библиотека Python:

import tkinter as tk
from tkinter import ttk
import threading
import time

def long_running_task():
# Имитация длительной работы
for i in range(100):
time.sleep(0.1)
# Обновление прогресс-бара через очередь событий Tkinter
root.after(0, update_progress_bar, i+1)

def update_progress_bar(value):
progress['value'] = value

def start_task():
# Запуск задачи в отдельном потоке
threading.Thread(target=long_running_task).start()

root = tk.Tk()
root.title("Tkinter Progress Bar")

frame = ttk.Frame(root, padding="10")
frame.grid(row=0, column=0)

progress = ttk.Progressbar(frame, orient="horizontal", length=300, mode="determinate", maximum=100)
progress.grid(row=0, column=0, pady=10)

start_button = ttk.Button(frame, text="Start", command=start_task)
start_button.grid(row=1, column=0)

root.mainloop()

PyQt5/PySide2 — популярные библиотеки для создания профессиональных GUI:

from PyQt5.QtWidgets import QApplication, QMainWindow, QProgressBar, QPushButton, QVBoxLayout, QWidget
from PyQt5.QtCore import QThread, pyqtSignal
import sys
import time

class WorkerThread(QThread):
update_progress = pyqtSignal(int)

def run(self):
for i in range(101):
time.sleep(0.1)
self.update_progress.emit(i)

class MainWindow(QMainWindow):
def __init__(self):
super().__init__()

self.setWindowTitle("PyQt Progress Bar")

layout = QVBoxLayout()

self.progress = QProgressBar()
self.progress.setRange(0, 100)
layout.addWidget(self.progress)

self.button = QPushButton("Start")
self.button.clicked.connect(self.start_task)
layout.addWidget(self.button)

container = QWidget()
container.setLayout(layout)
self.setCentralWidget(container)

self.worker = WorkerThread()
self.worker.update_progress.connect(self.progress.setValue)

def start_task(self):
self.button.setEnabled(False)
self.worker.start()
self.worker.finished.connect(lambda: self.button.setEnabled(True))

app = QApplication(sys.argv)
window = MainWindow()
window.show()
sys.exit(app.exec_())

Ключевые принципы работы с прогресс-барами в GUI:

• Многопоточность — длительные операции должны выполняться в отдельном потоке
• Сигналы и слоты — механизм обновления UI из рабочего потока
• Отзывчивый интерфейс — GUI не должен замирать во время выполнения задачи
• Обратная связь — помимо прогресс-бара, полезно отображать текстовую информацию

Независимо от выбранного фреймворка, важно помнить, что в GUI-приложениях индикатор прогресса должен обновляться асинхронно от основной задачи, чтобы интерфейс оставался отзывчивым.

Продвинутые техники интеграции progress bar в Python-скрипты

Для сложных проектов базовое применение progress bar может быть недостаточным. Продвинутые техники помогают создавать более информативные, гибкие и интегрированные решения для отслеживания прогресса. 🔍

Вложенные и параллельные progress bars особенно полезны при многоуровневых или многопоточных операциях:

from tqdm import tqdm
import time
import concurrent.futures

def process_item(item):
time.sleep(0.5) # Имитация работы
return item * 2

# Создаем внешний progress bar
with tqdm(total=3, desc="Batches", position=0) as batch_pbar:
for batch_idx in range(3):
# Создаем вложенный progress bar для каждого батча
with tqdm(total=10, desc=f"Batch {batch_idx+1}", position=1, leave=False) as item_pbar:
for item in range(10):
process_item(item)
item_pbar.update(1)
time.sleep(0.1)
batch_pbar.update(1)

Для параллельной обработки с отслеживанием прогресса можно комбинировать tqdm с concurrent.futures:

from tqdm.contrib.concurrent import process_map

# Параллельная обработка с progress bar
results = process_map(process_item, range(100), max_workers=4)

Динамическая адаптация индикатора прогресса к изменяющимся условиям:

from tqdm import tqdm
import random
import time

# Создаем динамический progress bar с изменяемым total
pbar = tqdm(desc="Dynamic workload", total=100)

completed = 0
while completed < 100:
# Имитация неожиданного появления новых задач
if random.random() < 0.1 and completed < 80:
new_tasks = random.randint(1, 5)
pbar.total += new_tasks
pbar.refresh()

# Обработка
increment = random.randint(1, 3)
increment = min(increment, pbar.total – completed)
completed += increment
pbar.update(increment)
time.sleep(0.2)

pbar.close()

Интеграция индикатора прогресса в логирование и отладку:

import logging
from tqdm import tqdm

# Настраиваем логгер
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s – %(name)s – %(levelname)s – %(message)s'
)
logger = logging.getLogger(__name__)

# Класс для работы с tqdm и логированием
class TqdmLoggingHandler(logging.Handler):
def __init__(self, level=logging.NOTSET):
super().__init__(level)

def emit(self, record):
try:
msg = self.format(record)
tqdm.write(msg)
self.flush()
except Exception:
self.handleError(record)

# Добавляем обработчик к логгеру
logger.addHandler(TqdmLoggingHandler())

# Теперь логи не будут мешать progress bar
for i in tqdm(range(20)):
if i % 5 == 0:
logger.info(f"Processing milestone: {i}")
time.sleep(0.5)

Создание собственного декоратора для автоматического добавления progress bar к функциям:

import functools
from tqdm import tqdm
import time

def with_progress(func=None, *, desc=None):
def decorator(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
# Получаем первый итерируемый аргумент
iterable = None
for arg in args:
if hasattr(arg, '__iter__') and not isinstance(arg, str):
iterable = arg
break

if iterable is not None:
# Если нашли итерируемый объект, оборачиваем его в tqdm
idx = args.index(iterable)
args_list = list(args)
args_list[idx] = tqdm(iterable, desc=desc or func.__name__)
result = func(*tuple(args_list), **kwargs)
else:
# Если итерируемого объекта нет, просто вызываем функцию
result = func(*args, **kwargs)

return result
return wrapper

# Позволяет использовать как @with_progress, так и @with_progress(desc="Custom")
if func is None:
return decorator
return decorator(func)

# Пример использования декоратора
@with_progress(desc="Processing items")
def process_list(items):
result = []
for item in items:
time.sleep(0.1) # Имитация работы
result.append(item * 2)
return result

# Вызываем функцию как обычно, progress bar добавляется автоматически
results = process_list(range(50))

Интеграция с системными инструментами мониторинга для комплексного отслеживания выполнения задач:

import psutil
from tqdm import tqdm
import time

def process_with_monitoring(items):
with tqdm(items, desc="Processing") as pbar:
for i, item in enumerate(pbar):
# Основная обработка
process_item(item)

# Обновление статистики в описании
process = psutil.Process()
memory_usage = process.memory_info().rss / (1024 * 1024) # MB
cpu_usage = process.cpu_percent()

pbar.set_description(
f"Processing: Memory {memory_usage:.1f} MB | CPU {cpu_usage:.1f}%"
)

time.sleep(0.2) # Имитация работы

# Пример использования
process_with_monitoring(range(50))

Продвинутые техники интеграции progress bar превращают его из простого индикатора в полноценный инструмент мониторинга и контроля выполнения задач. Грамотное использование этих подходов значительно улучшает как пользовательский опыт, так и возможности для отладки и оптимизации кода.

Добавление progress bar в ваши Python-скрипты — это не просто косметическое улучшение, а важный шаг к созданию профессионального пользовательского опыта. От простых консольных индикаторов до сложных графических интерфейсов, progress bar дает пользователям чувство контроля и понимания процесса. Начните с простых решений, постепенно переходя к более сложным, интегрируйте их в свой рабочий процесс, и вы увидите, как меняется отношение пользователей к вашему программному обеспечению. Помните: хороший прогресс-бар — это не только визуализация, но и психологический комфорт для всех участников процесса.