Barres de progression en Python : Un guide complet avec des exemples

Dans les applications d'aujourd'hui, les utilisateurs veulent un retour d'information immédiat, en particulier lorsque les tâches prennent beaucoup de temps. Les barres de progression Python sont un moyen clair et facile de montrer que quelque chose se passe en arrière-plan. Une barre de progression solide permet à un programme d'être plus rapide, d'ajouter une touche professionnelle et d'améliorer la convivialité. 

Dans cet article, vous apprendrez à mettre en œuvre des barres de progression Python en utilisant des bibliothèques populaires comme tqdm, progress, progressbar2, alive-progress, et Tkinter, ainsi que les meilleures pratiques pour améliorer l'expérience de l'utilisateur et la performance de l'application.

Pour en savoir plus sur les concepts de Python d'une manière pratique, consultez notre Curriculum vitae sur les principes fondamentaux de la programmation Python.

Que sont les barres de progression en Python ?

Les barres de progression sont omniprésentes. Ils sont souvent utilisés pour les téléchargements de fichiers, les installations de logiciels et les pipelines ETL. Ils sont également utiles pour suivre la progression de la formation des modèles d'apprentissage automatique.

La barre de progression indique le degré d'achèvement d'une tâche et ce qu'il reste à faire. Elle peut apparaître sous forme de texte dans une interface de ligne de commande (CLI) ou sous forme de barre visuelle dans une interface utilisateur graphique (GUI).

Les barres de progression améliorent l'expérience de l'utilisateur. Ils fournissent des mises à jour en temps réel, montrant aux utilisateurs leur progression dans le processus. En cas de retard, les utilisateurs peuvent décider d'intervenir ou d'attendre. Cette visibilité réduit la frustration et fait paraître les temps d'attente plus courts. Les utilisateurs ne regardent pas un écran statique en se demandant s'il se passe quelque chose ; ils restent impliqués et se sentent rassurés par les progrès accomplis.

Les cursus utilisent des barres de progression pour suivre les performances des applications. Ils permettent d'identifier les goulets d'étranglement, d'évaluer le code et de suivre la durée des tâches. Les barres de progression dans les scripts et les flux de travail affichent des mises à jour claires de l'état d'avancement. Ils aident les utilisateurs à mieux comprendre les processus de longue durée. Ils améliorent également la convivialité des outils interactifs et des carnets de notes.

Les barres de progression peuvent également constituer une forme simple de suivi des performances. Ils indiquent la durée de chaque tâche. Cela permet aux développeurs de repérer les phases de ralentissement et de mesurer l'efficacité. Cela permet de comparer facilement les différentes mises en œuvre. 

Barres de progression de la ligne de commande

Les barres de progression de la ligne de commande fournissent un retour d'information visuel pour les tâches de longue durée directement dans le terminal, ce qui rend les scripts plus informatifs et plus conviviaux. Python propose plusieurs bibliothèques, chacune présentant des atouts en termes de rapidité, de personnalisation et de style visuel. Nous en examinerons quatre : tqdm, progress, progressbar2, et alive-progress. 

Tqdm : la norme en matière de rapidité et de simplicité

tqdm est une bibliothèque populaire en Python qui permet de créer des barres de progression. Il fournit des indicateurs de progression rapides et polyvalents pour les boucles et les itérables. Il cursus les itérations et calcule à la fois le temps restant et le temps écoulé. Ces informations mettent à jour la barre en temps réel. tqdm fonctionne en arrière-plan. Il prédit le temps restant et saute les mises à jour qui ne sont pas nécessaires. Il est simple à apprendre, léger en termes d'utilisation de la mémoire et soutenu par une communauté solide. 

Processus d'installation

Une façon simple d'installer tqdm est d'utiliser le programme d'installation pip. Tapez la commande suivante dans le terminal.

pip install tqdm

Imprimez le numéro de version pour vous assurer que la bibliothèque est correctement installée.

import tqdm
print(tqdm.__version__)

4.67.1

Utilisation de base de tqdm

tqdm est simple à utiliser. Importez la bibliothèque. Enveloppez n'importe quel itérable avec tqdm(itérable) pour afficher une barre de progression.

Au lieu d'écrire tqdm(range(n)), vous pouvez utiliser l'abréviation trange(n) pour plus de commodité.

from tqdm import trange
import time

for _ in trange(100, desc="Processing"):
    # Do stuff here
    time.sleep(0.05)  # simulate a task

Ce code produit une barre de progression en direct pendant l'exécution.

La barre de progression indique

• Pourcentage de réussite (22%)
• Nombre d'itérations réalisées sur le total (224/1000)
• Temps écoulé et estimation du temps restant (12 secondes écoulées, 42 secondes restantes)
• Itérations par seconde (18,09 it/s).

Pour ajouter une description à la barre de progression, spécifiez l'option desc.

for i in trange(1000, desc='Processing'):  # description
    # Simulate a task
    time.sleep(0.05)

Barres de progression imbriquées 

Les barres de progression imbriquées dans tqdm vous permettent de suivre la progression de plusieurs boucles. Ils sont également utiles lorsque vous devez suivre plusieurs étapes de travail. Les exemples incluent le traitement par lots, les boucles imbriquées et l'apprentissage de modèles. 

Enveloppez chaque boucle dans une boucle imbriquée avec tqdm. Utilisez les arguments position et leave pour contrôler la façon dont ils apparaissent.

• position: Définit la position verticale de chaque barre de progression. position=0 correspond à la barre la plus haute, position=1 apparaît en dessous, et ainsi de suite.
• leave: Si leave=True, la barre de progression reste à l'écran après la fin de l'opération. Si leave=False, il disparaît pour éviter l'encombrement.

for i in trange(3, desc='Outer loop', leave=True):
    for j in trange(5, desc='Inner loop', leave=False):
        for j in trange(4, desc='Inner inner loop', leave=False):
            time.sleep(0.05)

Les barres de progression imbriquées présentent une hiérarchie claire. Ils vous aident à visualiser les différentes étapes d'une tâche. Ils fournissent des informations détaillées à différents niveaux. Cela permet aux développeurs d'identifier facilement les ralentissements ou les goulets d'étranglement.

Intégration de Pandas

Tqdm s'intègre bien à pandas. Il offre un moyen simple d'ajouter des barres de progression aux tâches DataFrame et séries. Il indique la progression en temps réel des fonctions telles que apply, groupby, et map. Ces fonctions peuvent être lentes avec de grands ensembles de données.

Pour activer cette fonctionnalité, appelez tqdm.pandas(). Ensuite, utilisez progress_apply au lieu de la méthode habituelle de pandas apply. Une barre de progression s'affichera au fur et à mesure que votre fonction s'exécutera sur des lignes ou des colonnes. Vous verrez l'évolution de l'opération sans réécrire votre code.

Dans le programme suivant, nous créons un DataFrame avec une colonne nommée "nombres". Cette colonne contient des nombres entiers compris entre 0 et 1000. Nous générons ensuite une nouvelle colonne en appliquant une opération "lente" appelée slow_squared. 

Au lieu d'utiliser la fonction standard pandas apply, nous utilisons progress_apply de tqdm. Une barre de progression s'affiche pendant l'opération. Il fournit des mises à jour en temps réel sur l'état d'avancement du traitement.

import pandas as pd
from tqdm import tqdm
import time

# Simulate a time-consuming operation
def slow_square(x):
    time.sleep(0.01)
    return x**2

# Create a sample DataFrame
df = pd.DataFrame({'numbers': range(1000)})

# Initialize tqdm for pandas
tqdm.pandas(desc="Processing")

# Use progress_apply instead of apply
df['slow_squared'] = df['numbers'].progress_apply(slow_square)
# Print the result
print(df.head())

La sortie du code est la suivante.

Nous pouvons utiliser progress_apply pour d'autres opérations DataFrame telles que groupby.

grouped = df.groupby('numbers').progress_apply(lambda g: g.sum())

Options de personnalisation

Tqdm vous permet de personnaliser les barres de progression pour les adapter à différents environnements et aux besoins des utilisateurs. Vous pouvez ajuster la largeur à l'aide de ncols. Le site bar_format argument vous permet de contrôler entièrement la mise en page du texte. En outre, le paramètre dynamic_ncols=True permet de redimensionner automatiquement la barre pour qu'elle s'adapte au terminal.

Considérations sur les performances spécifiques au tqdm

Tqdm est rapide et léger. Il ajoute peu de surcharge, même dans les boucles rapides. Vous pouvez désactiver les barres de progression à l'aide de disable=True. Ceci est utile dans les environnements de production où la performance est essentielle. Pour les boucles rapides, la mise à jour de la barre à chaque fois peut être trop importante. Ainsi, tqdm vous permet de contrôler la fréquence des mises à jour. Vous pouvez utiliser des paramètres tels que mininterval et maxinterval. 

Progrès : Des styles et des effets de rotation personnalisables

Les Progress en Python vous permet de créer facilement des barres de progression textuelles pour la ligne de commande. Il est doté d'une API simple. Il supporte à la fois les barres de progression et les spinners et permet une personnalisation de base de la sortie. Il est petit, rapide et n'a pas de dépendances. Il est donc idéal pour les scripts rapides et les configurations simples. 

La bibliothèque progress comprend sept styles intégrés de barres de progression : Bar, ChargingBar, FillingSquaresBar, FillingCirclesBar, IncrementalBar, PixelBar et Shadybar. 

Pour l'installer, utilisez pip install.

pip install progress

Pour l'utiliser, importez le style souhaité, instanciez une variable, utilisez .next() dans la boucle et .finish() une fois le processus terminé. Par exemple, pour utiliser une ChargingBar, utilisez le code suivant.

import time
from progress.bar import ChargingBar
bar = ChargingBar('Processing', max=20)
for i in range(20):
    # Do some work
    time.sleep(0.5)
    
    bar.next()
bar.finish()
`

Progress comprend également des rouleaux pour les tâches dont la durée est inconnue. Le code permettant d'implémenter un spinner est simple.

import time
from progress.spinner import Spinner

spinner = Spinner('Processing... ')

# Spinner during a task of unknown duration.
for _ in range(50): 
    # Do stuff 
    time.sleep(0.1)  # simulate a running task

    spinner.next()

spinner.finish()

Ce code aboutit à la description ("Processing...") suivie d'une barre de défilement.

La bibliothèque de progrès est simple et légère, mais elle présente certaines limites à prendre en compte. Il ne prend pas en charge les blocs-notes Jupyter et ne peut pas être redimensionné de manière dynamique. De plus, elle offre moins d'options de personnalisation que des bibliothèques comme tqdm. Il fonctionne bien pour les tâches de base en ligne de commande, mais il peut s'avérer difficile pour les tâches complexes ou à haute performance.

Barre de progression2 : Personnalisation et compatibilité accrues

Progressbar2 est une puissante bibliothèque Python. Il vous aide à créer des barres de progression flexibles et personnalisables pour les applications en ligne de commande. Il dispose de nombreux widgets, tels que le pourcentage, l'heure d'arrivée prévue, les marqueurs animés et les compteurs. Il est donc idéal pour les tâches CLI plus complexes ou plus élaborées. 

Progressbar2 offre plus de contrôle et d'options de formatage que les bibliothèques plus simples comme progress. Il fonctionne également mieux avec la journalisation et les flux de travail multithreads.

Pour l'installer, utilisez pip install.

pip install progressbar2

La classe ProgressBar de la barre de progression 2 affiche l'état de progression actuel. Pour ce faire, il dispose d'un ensemble de widgets personnalisables. 

Un widget est un élément modulaire qui se met à jour en fonction de l'état de la barre de progression. Il s'agit du pourcentage de réalisation, du temps écoulé et de l'estimation du temps restant. 

Vous pouvez choisir parmi de nombreux types de widgets. Il s'agit notamment d'étiquettes de texte, de marqueurs de progression, de compteurs, de chronomètres, d'indicateurs de rotation et de formateurs personnalisés. Cette variété vous permet de personnaliser l'aspect et la fonction de la barre pour votre application.

L'utilisation de base de Progressbar2 est assez simple. 

import time
import progressbar

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

La sortie affiche le pourcentage d'achèvement, les itérations terminées/les itérations totales, le temps écoulé et l'estimation du temps restant.

Les bibliothèques de barres de progression s'appuient généralement sur la mise à jour d'une seule ligne dans le terminal à l'aide de retours chariot (\r). Cela signifie que les déclarations régulières de print() peuvent interférer en poussant la barre vers le bas ou en corrompant sa sortie. La bibliothèque progressbar2 permet d'imprimer des messages en toute sécurité sans interférer avec la barre de progression.

import time
import progressbar

bar = progressbar.ProgressBar(redirect_stdout=True)
for i in range(10):
    # Do some task
    time.sleep(0.1)

    # Print statement
    print(f'Loop #{i}')
    bar.update(i)

La bibliothèque progressbar2 offre des possibilités de personnalisation étendues grâce à son système modulaire de widgets. Les widgets affichent des détails dans la barre de progression, notamment le pourcentage d'achèvement, le temps écoulé, l'estimation du temps restant, les compteurs ou les animations de la barre. Vous pouvez combiner ces widgets pour créer une barre de progression personnalisée. Par exemple, vous pouvez afficher le pourcentage et l'heure d'arrivée prévue. Vous pouvez également ajouter d'autres détails tels que des noms de fichiers, des horodatages ou des indicateurs. 

import time
import progressbar

# Define a custom set of widgets
widgets = [
    'Progress: ',                                # Description text
    progressbar.Percentage(),         # Show percentage completed
    ' ',                              
    progressbar.Bar(marker=':'),      # Custom bar with specified marker
    ' ',
    progressbar.ETA(),                    # Estimated time remaining
    ' | ',
    progressbar.Timer(),                  # Time elapsed
]

# Initialize the progress bar with widgets
bar = progressbar.ProgressBar(widgets=widgets, max_value=50)

# Task
for i in range(50):
    # Do stuff
    time.sleep(0.1)  # Simulate task
    
    bar.update(i + 1)

Alive-progress : animations dynamiques pour les terminaux modernes

Alive-progress affiche des barres de progression animées qui changent en temps réel. Cela donne aux applications de ligne de commande un aspect moderne et réactif. La barre se déplace vers l'avant et affiche des mesures utiles en temps réel. Il affiche le pourcentage d'achèvement, le temps écoulé, le temps restant estimé et la vitesse d'itération. Il est donc à la fois attrayant et informatif.

Pour installer l'application alive-progress installez-la à l'aide du logiciel pip.

pip install alive-progress

Comme indiqué sur sa page GitHub, pour voir une démonstration de ses capacités, utilisez le code suivant.

from alive_progress.styles import showtime

showtime()

Vous obtiendrez un résultat similaire à celui qui suit.

Alive-progress a la capacité d'afficher et de gérer plusieurs barres de progression simultanément.

from alive_progress import alive_bar
import time
import threading

# Simulate a task
def simulate_task(name, total):
    with alive_bar(total, title=name) as bar:
        for _ in range(total):
            # Do something
            time.sleep(0.5)

            bar()

# Define threads
threads = [
    threading.Thread(target=simulate_task, args=('Task A', 50)),
    threading.Thread(target=simulate_task, args=('Task B', 70)),
    threading.Thread(target=simulate_task, args=('Task C', 40)),
]

# Start each thread
for t in threads:
    t.start()

# Block the main thread until the program is finished
for t in threads:
    t.join()

La bibliothèque alive-progress comprend plusieurs thèmes intégrés. Les thèmes contrôlent des éléments tels que le style d'animation, les caractères utilisés pour remplir la barre et l'effet de mouvement général. Les thèmes communs sont classic, pulse, et brackets.

import time
from alive_progress import alive_bar

with alive_bar(100, bar='blocks') as bar:
    for _ in range(100):
        # Do something
        time.sleep(0.02)
        
        bar()

Pause/reprise - arrêt temporaire et reprise de la progression sans perte d'état

from alive_progress import alive_bar
import time

# Run a task...
with alive_bar(100) as bar:
    for i in range(50):
        # Do something
        time.sleep(0.02)

        bar()
    
    # Pause
    bar.text('Temporarily pausing...')
    time.sleep(1)

    # Resume
    bar.text('Resuming...')
    for i in range(50):
        time.sleep(0.02)
        bar()

Barres de progression GUI avec Tkinter

Tkinter est la boîte à outils standard de Python pour les interfaces graphiques. La conception comprend des fonctions intégrées et est prête à l'emploi, de sorte que vous n'avez pas besoin d'installer quoi que ce soit d'autre. Vous pouvez créer des fenêtres, des boutons, des champs de texte, des menus, des barres de progression, etc. Tkinter est idéal pour créer des applications de bureau simples, des outils interactifs et des prototypes. 

Une barre de progression de base peut être créée à l'aide du code suivant. 

import tkinter as tk
from tkinter import ttk
import time

def start_progress():
    progress["value"] = 0
    root.update_idletasks()
    for i in range(101):
        time.sleep(0.02)
        progress["value"] = i
        root.update_idletasks()

# Set up the window
root = tk.Tk()
root.title("Progress Bar")
root.geometry("300x100")

# Create a progress bar
progress = ttk.Progressbar(root, orient="horizontal", length=250, mode="determinate")
progress.pack(pady=20)

# Create a start button
start_button = ttk.Button(root, text="Start", command=start_progress)
start_button.pack()

# Start the tkinter loop
root.mainloop()

Sortie sur mon Mac :

Deux modes sont disponibles avec ttk.Progressbar : déterminé et indéterminé. Le mode déterminé est utilisé lorsque la durée ou le nombre d'étapes d'une tâche est connu. Le mode indéterminé est utilisé lorsque la durée de la tâche est inconnue ou ne peut être mesurée par étapes.

Le code ci-dessus est pour un mode déterminé, puisque nous savions que la longueur de la tâche était de 250 étapes. Voici un exemple de mode indéterminé.

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

def start_indeterminate():
    def run():
        # 10 ms between moves
        progress.start(10)

        # Simulate task of unknown duration
        time.sleep(10)

        # Stop
        progress.stop()
    
    # Run in a thread, else the tkinter GUI loop is unresponsive
    threading.Thread(target=run).start()

# Set up the GUI
root = tk.Tk()
root.title("Indeterminate Progress Bar")
root.geometry("300x100")

# Create an indeterminate progress bar
progress = ttk.Progressbar(root, mode='indeterminate', length=250)
progress.pack(pady=20)

# Start button
start_button = ttk.Button(root, text="Start", command=start_indeterminate)
start_button.pack()

# Run the tkinter loop
root.mainloop()

Notez que la barre de progression a été exécutée dans un thread séparé. Si nous utilisions run() directement dans le thread principal, l'appel à time.sleep() bloquerait la boucle d'événements principale de Tkinter et entraînerait le gel de l'ensemble de l'interface graphique, y compris les clics sur les boutons, les redessins de la fenêtre et l'animation de la barre de progression.

Considérations sur les performances et optimisation

Quelle bibliothèque devriez-vous utiliser pour votre barre de progression ? La décision dépend en partie de vos exigences en matière de frais généraux et de votre cas d'utilisation.

Pour améliorer les performances, optimisez la fréquence des mises à jour. Une méthode consiste à ne pas mettre à jour la barre à chaque itération. Ceci est particulièrement important pour les boucles rapides ou à haute fréquence. Utilisez la logique conditionnelle pour mettre à jour toutes les N étapes, par exemple, toutes les 100 itérations.

Dans les paramètres de performance critiques ou dans le code de production, désactivez les barres de progression. Le retour d'information visuel n'est pas nécessaire ici. Cela permet d'économiser des ressources tout en garantissant que la logique reste la même pour le développement ou le débogage. 

La réduction des opérations d'E/S est essentielle à la performance. L'écriture sur le terminal, le disque ou le réseau peut ralentir les choses. Voici quelques stratégies pour réduire les E/S dans les tâches critiques pour les performances.

• Mettez en mémoire tampon la sortie et écrivez par lots au lieu de le faire par itération.
• Ne mettez à jour qu'à intervalles fixes ou dans des conditions spécifiques.
• Réduisez ou désactivez print() à l'intérieur des boucles.
• Ajoutez des drapeaux pour supprimer les sorties inutiles en production.
• Séparez les E/S et les calculs à l'aide de threads ou de multiprocessus.
• Compresser ou grouper les écritures volumineuses pour réduire la fréquence des E/S sur disque.

Bonnes pratiques pour des barres de progression efficaces

Jetons un coup d'œil à quelques-unes des meilleures pratiques à garder à l'esprit lors de la création de barres de progression en Python. 

Pourquoi utiliser des barres de progression ?

Il existe de nombreuses bonnes raisons d'utiliser des barres de progression dans vos applications. Tout d'abord, ils fournissent un retour d'information en temps réel, rassurant les utilisateurs sur la progression des tâches et réduisant l'incertitude. Cette visibilité améliore l'expérience de l'utilisateur, en rendant les temps d'attente plus courts et les interactions plus intuitives. 

Deuxièmement, en suivant visuellement l'achèvement des tâches, les barres de progression facilitent le contrôle des performances, ce qui permet aux utilisateurs et aux développeurs de repérer rapidement les goulets d'étranglement ou les processus bloqués au cours d'opérations de longue durée. Enfin, l'intégration de barres de progression rehausse le professionnalisme de l'interface de votre application et témoigne d'une clarté et d'une approche de conception réfléchie et centrée sur l'utilisateur.

Tâches de durée connue ou inconnue

Utilisez une barre de progression déterminée pour les tâches qui ont une durée déterminée. Il peut s'agir de traitement de fichiers, de boucles ou d'époques de formation à l'apprentissage automatique. Ce type de barre se remplit sur la base de progrès mesurables et donne aux utilisateurs une idée claire de la quantité de travail qu'il reste à accomplir.

Pour les tâches dont la durée est inconnue, comme les appels API ou les vérifications d'antécédents, utilisez une roulette ou une barre indéterminée. Ils indiquent visuellement que le processus est en cours, même si nous ne pouvons pas prédire combien de temps il durera.

Quelle bibliothèque dois-je utiliser ?

La bibliothèque La bibliothèque que vous utilisez dépend des tâches que vous essayez d'accomplir.

Personnalisation

Lorsque vous personnalisez les barres de progression, privilégiez la clarté et l'utilité des informations. Essayez de trouver un bon équilibre entre les deux. Une barre claire et simple avec des indicateurs clés est généralement préférable à une barre surchargée d'informations. 

Vous pouvez utiliser des bibliothèques comme progressbar2 et alive-progress. Ils vous permettent de modifier la disposition, la couleur et l'animation de vos barres de progression. Utiliser des thèmes ou des formats pour améliorer l'expérience de l'utilisateur. Évitez d'encombrer l'écran avec trop de widgets ou de visuels complexes. L'objectif est de donner un retour d'information utile. Nous voulons éviter de distraire l'utilisateur ou de le submerger.

Traitement des exceptions et tests de compatibilité

Enveloppez la logique de la barre de progression dans des blocs try-except. Cela permet d'éviter les dysfonctionnements de l'interface utilisateur ou les pannes si une erreur se produit au cours d'une tâche. Ceci est essentiel pour les scripts qui s'exécutent pendant une longue période ou lorsque vous utilisez des dépendances externes incertaines.

Testez également vos barres de progression dans différents environnements. Vérifiez les différents systèmes d'exploitation, types de terminaux et largeurs d'affichage. Vous pourrez ainsi vous assurer que leur comportement reste cohérent.

Certaines bibliothèques se comportent différemment dans les notebooks Jupyter, les terminaux distants ou les shells d'interface graphique. Une vérification précoce de la compatibilité peut permettre d'éviter des problèmes inattendus. Ainsi, les utilisateurs auront une expérience plus fluide de la production.

Considérations sur l'accessibilité

Lorsque vous créez des indicateurs de progrès, tenez compte de l'accessibilité. Cela permet à tous les utilisateurs de recevoir un retour d'information clair. Quelques suggestions :

• Ne vous fiez pas uniquement à la couleur ou à l'animation pour montrer les progrès accomplis. Ajoutez des éléments de texte tels que des pourcentages, des nombres d'étapes ou des estimations de temps.
• Utilisez des visuels clairs et contrastés pour une meilleure lisibilité.
• Assurez-vous que vos barres de progression fonctionnent bien avec les lecteurs d'écran dans les applications graphiques.
• Pour les outils de ligne de commande, envisagez des options de verbosité permettant d'afficher les mises à jour de la progression en texte clair.

Faire de l'accessibilité une priorité renforce l'utilisabilité. Cela rend également vos outils plus inclusifs et plus professionnels.

Conclusion 

Les barres de progression sont une fonctionnalité simple mais forte pour toute application Python. Ils donnent un retour d'information instantané, améliorent l'expérience de l'utilisateur et permettent de suivre les performances et la clarté du code. Il est essentiel de choisir la bonne bibliothèque de barres de progression. Il peut améliorer votre logiciel, qu'il s'agisse d'un script rapide, d'un outil en ligne de commande ou d'une application à interface graphique complète. Une mise en œuvre réfléchie peut améliorer la vitesse, le professionnalisme et la convivialité de votre logiciel. En donnant la priorité à la personnalisation, aux performances, à la compatibilité et à l'accessibilité, les barres de progression sont plus que de simples éléments visuels. Ils deviennent une partie importante de la façon dont les utilisateurs s'engagent dans votre travail.

Pour continuer à apprendre, consultez ces ressources :

• Python : Un guide avec des exemples pratiques 
• Introduction à l'interface graphique avec Tkinter en Python 
• Principes de base de la programmation en Python