cours
Python : Un guide avec des exemples pratiques
Vous êtes-vous déjà retrouvé dans une situation où un script Python de longue haleine vous amenait à vous demander s'il se passait quelque chose derrière l'écran ?
L'incertitude quant à la progression peut vous conduire à annuler une exécution presque complète ou à attendre indéfiniment l'exécution d'un script déjà interrompu.
Le site tqdm
Python répond à ce problème en fournissant des indicateurs de progression pour vos scripts.
Qu'est-ce que le tqdm ?
Tqdm est une bibliothèque Python qui fournit des barres de progression rapides et extensibles pour les boucles et les itérables. C'est un moyen simple de suivre l'avancement des tâches qui demandent beaucoup de temps.
Le nom de la bibliothèque signifie "progrès" en arabe (taqadum, تقدّم), et est une abréviation de "Je t'aime tellement" en espagnol (te quiero demasiado).
Le cursus suit la progression et met à jour l'affichage de la barre de progression en comptant les itérations, en calculant le temps écoulé ainsi que le temps restant, et en visualisant la progression globale dans le remplissage de la barre.
Il utilise des algorithmes intelligents pour prédire le temps restant, et saute les itérations inutiles pour minimiser la charge de travail. L'utilisation de tqdm
présente plusieurs avantages, notamment
- Retour d'information visuel : Les barres de progression permettent aux utilisateurs de voir la partie d'une tâche qui est terminée et d'estimer le temps que prendra la partie restante.
- Fonctionne partout : La bibliothèque
tqdm
fonctionne sur toutes les plates-formes (Linux, Windows, Mac, FreeBSD, NetBSD, SunOS), dans n'importe quelle console ou dans une interface graphique. - Intégration facile :
Tqdm
s'intègre de manière transparente avec les notebooks Jupyter, les bibliothèques communes comme Pandaset les constructions Python courantes comme les boucles. - Personnalisation : Il offre plusieurs options permettant d'adapter l'apparence et le comportement des barres de progression, que nous aborderons plus loin.
- Performance : Alors que des logiciels similaires comme ProgressBar ont un surcoût de 800ns/itération, le surcoût de 60ns/itération de tdqm est beaucoup plus rapide.
Devenez ingénieur en données
Comment installer Tqdm
Comme pour la plupart des bibliothèques Python, la manière la plus simple d'installer tqdm
est d'utiliser le gestionnaire de paquets pip
.
pip install tqdm
Tqdm : Exemple simple
Pour créer une barre de progression, nous enveloppons notre itérable avec la fonction tqdm()
(que nous importons du module tqdm
). Prenons un exemple simple. La fonction time.sleep(0.01)
sert d'espace réservé au code qui est censé être exécuté à chaque itération.
from tqdm import tqdm
for i in tqdm(range(1000)):
time.sleep(0.01)
# …
En guise de raccourci pour tdqm(range(n))
, vous pouvez également utiliser trange(n)
. Le code suivant renvoie exactement le même résultat que le code précédent :
from tqdm import tqdm
for i in trange(1000):
time.sleep(0.01)
# …
Les deux exemples renvoient une barre de progression qui ressemble à celle ci-dessus.
Examinez de plus près la barre de progression pour voir quelles informations elle fournit. Décortiquons les détails présentés par tqdm
:
- Indicateurs de progrès :
- Pourcentage d'itérations
- Remplissage du bar
- Fraction du nombre total d'itérations
- Mesures :
- Temps écoulé
- Estimation du temps restant
- Performance (itérations par seconde)
Tqdm Personnalisation : Faire progresser les barreaux par soi-même
Tqdm
offre diverses options de personnalisation pour adapter l'apparence et le comportement des barres de progression. Nous examinerons les paramètres de personnalisation les plus importants avant de nous pencher sur des cas d'utilisation plus avancés de tqdm
.
Ajout d'une description de la barre de progression
Une personnalisation courante consiste à ajouter une étiquette descriptive à l'aide du paramètre desc
, ce qui rend la barre de progression plus informative et permet de garder une vue d'ensemble des différents itérables.
Par exemple, si vous ajoutez le paramètre desc=”Processing large range”
, le titre "Processing large range" s'affichera à gauche de la barre de progression.
for _ in tqdm(range(20000000), desc="Processing large range"):
continue
Je vous encourage à exécuter le code ci-dessus dans votre environnement avec et sans le paramètre desc
et à remarquer les différences.
Spécification du nombre total d'itérations
Le paramètre total
spécifie le nombre total d'itérations dans la boucle, ce qui permet à tqdm
de fournir des estimations plus précises du temps restant et du pourcentage d'achèvement.
Dans un exemple de base utilisant tqdm(range())
ou trange()
, cela n'est pas nécessaire, puisque le nombre d'itérations est déjà inclus dans les parenthèses. Cependant, il existe deux scénarios principaux dans lesquels l'ajout du paramètre total=n
(n étant le nombre total) peut s'avérer utile :
1. Itérables sans méthode len()
: Pour les itérables sans méthode len()
, tels que les générateurs dont le nombre d'éléments est inconnu, vous devez fournir manuellement la valeur total
. Sans ce paramètre, tqdm()
n'affichera que le nombre d'itérations terminées. Veuillez noter que la barre de progression redémarre si le nombre réel d'éléments dépasse le nombre spécifié sur total
.
from tqdm import tqdm
import time
import random
# Function generating random number between 1 and 100
def generate_random_numbers():
while True:
yield random.randint(1, 100)
# Without total: tqdm() only shows number of iterations, does not know total
for num in tqdm(generate_random_numbers(), desc=’Random Iteration’):
time.sleep(0.01)
# …
Voici à quoi cela ressemble si le nombre d'articles est inconnu et que nous ne spécifions pas le total.
# With total (assuming you know the desired number of iterations): tqdm() shows progress
num_iterations = 1000
for num in tqdm(generate_random_numbers(), total=num_iterations, desc="Random Iteration"):
time.sleep(0.01)
# …
C'est beaucoup mieux, maintenant la barre de progression s'affiche !
2. Mises à jour manuelles : Si nous mettons à jour la barre de progression manuellement dans une fonction à l'aide de la méthode update()
, la valeur totale doit être spécifiée pour garantir un cursus correct. La méthode update()
permet, par exemple, de répondre à des processus en évolution dynamique ou de mettre en place un cursus personnalisé. Nous y reviendrons plus tard.
Amélioration de l'apparence visuelle
Si vous souhaitez modifier l'ordre d'apparition des éléments de la barre de progression, vous pouvez définir le paramètre bar_format
en fonction de la chaîne de format préférée. De cette façon, nous pouvons contrôler l'emplacement de divers éléments tels que le pourcentage, le temps écoulé et le caractère de remplissage de la barre. Pour plus de détails, vous pouvez consulter la documentation.
Un autre réglage de l'aspect visuel peut être effectué à l'aide du paramètre colour
. Il est possible d'utiliser des chaînes de mots comme "vert" ou des chaînes de codes hexadécimaux comme "#00ff00".
Le paramètre leave
concerne la disparition plutôt que l'apparition : il détermine si la barre de progression reste visible ou non après son achèvement. Si la valeur est True
, la barre persistera après la fin de la boucle ; si la valeur est False
, elle disparaîtra.
Examinons les différences visuelles entre les résultats dans un autre exemple. Le code suivant crée trois barres de progression : une avec les paramètres par défaut, une dans laquelle l'ordre et la couleur des éléments sont modifiés et une qui disparaît une fois terminée. Les résultats sont visibles dans le GIF ci-dessous.
from tqdm import tqdm
import time
# Progress bar 1: Default settings
for i in tqdm(range(300)):
time.sleep(0.01)
# Progress bar 2: Customized bar format and color
for i in tqdm(range(300), bar_format='[{elapsed}<{remaining}] {n_fmt}/{total_fmt} | {l_bar}{bar} {rate_fmt}{postfix}', colour='yellow'):
time.sleep(0.01)
# Progress bar 3: Customized bar format and color, leave=False
for i in tqdm(range(300), bar_format='[{elapsed}<{remaining}] {n_fmt}/{total_fmt} | {l_bar}{bar} {rate_fmt}{postfix}', colour='red', leave=False):
time.sleep(0.01)
Utilisation avancée : Traiter des scénarios plus complexes
Maintenant que nous savons comment construire une barre de progression simple et comment la personnaliser, nous pouvons passer à quelques cas plus avancés.
Barres de progression imbriquées
Les boucles imbriquées sont des boucles contenues dans d'autres boucles. En conséquence, les barres de progression imbriquées sont une série de barres de progression pour chaque itération de boucles contenues dans d'autres boucles. Pour les créer, entourez chaque boucle d'une fonction tqdm()
et ajoutez des étiquettes descriptives pour chaque itérable.
Le code suivant comporte trois boucles imbriquées et permet de donner un exemple de la manière dont les barres de progression imbriquées apparaîtront :
from tqdm import trange
import time
for i in trange(3, desc='outer loop'):
for j in trange(2, desc='middle loop'):
for k in trange(6, desc='inner loop'):
time.sleep(0.01)
Dans le résultat final ci-dessus, nous pouvons reconnaître un schéma dans lequel les différentes barres de progression sont mises à jour. Tqdm commencera toujours par la boucle la plus externe jusqu'à ce qu'il atteigne la boucle la plus interne, dont les itérations seront traitées et la barre de progression mise à jour en conséquence.
Supposons maintenant que nous ayons trois boucles imbriquées, comme dans l'exemple. Après l'itération interne initiale, il passe à la boucle centrale, la met à jour en indiquant qu'une itération est terminée, avant de revenir à l'itérable interne. Ce processus est répété jusqu'à ce que la boucle centrale soit considérée comme terminée, ce qui déclenche l'apparition de la barre extérieure avec une itération terminée.
Il en va de même entre la boucle extérieure et la boucle centrale. En fin de compte, la dernière exécution interne complète l'itérable du milieu, qui à son tour complète la dernière itération externe.
Mises à jour manuelles
La mise à jour manuelle des barres de progression à l'aide du site tqdm
peut s'avérer utile dans plusieurs cas de figure :
- Itérables de longueur inconnue : Lorsque nous travaillons avec des itérables qui n'ont pas de longueur définie (par exemple, des générateurs, des flux de réseau), nous pouvons mettre à jour manuellement la barre de progression en fonction de la quantité de données traitées ou du nombre d'opérations terminées.
- Des processus qui évoluent de manière dynamique : Si le nombre d'itérations ou le temps de traitement par itération peut changer au cours de l'exécution, les mises à jour manuelles nous permettent d'ajuster la barre de progression en conséquence.
- Un cursus personnalisé : Pour un contrôle plus précis de la barre de progression, nous pouvons la mettre à jour manuellement en fonction de critères ou d'événements spécifiques. Par exemple, nous pourrions vouloir mettre à jour la barre de progression en fonction de l'achèvement de certaines étapes ou de l'avancement de tâches individuelles dans le cadre d'un processus plus large.
- Intégration avec des systèmes externes : Si nous intégrons
tqdm
avec des systèmes ou des bibliothèques externes qui ne fournissent pas un moyen naturel de suivre la progression, des mises à jour manuelles peuvent être utilisées pour synchroniser la barre de progression avec le processus externe.
Pour mettre à jour manuellement une barre de progression tqdm
, il est important que le paramètre total
soit spécifié comme l'estimation du nombre maximum d'itérations attendu. Ensuite, lorsque le code traite chaque nouvel élément, la barre de progression doit être mise à jour à l'aide de la méthode update()
. La valeur de mise à jour doit représenter le nombre d'itérations traitées depuis la dernière mise à jour.
Supposons que notre itérable doive contenir jusqu'à 750 éléments. Dans cet exemple, la longueur réelle est un nombre aléatoire compris entre 100 et 1000, qui nous est inconnu. Nous lançons l'opération progress_bar
, en fixant la valeur de estimated_total
à 750. Nous parcourons ensuite les données, en mettant à jour la barre de progression après le traitement de chaque point.
from tqdm import tqdm
def process_data(data):
time.sleep(0.01) # simulate processing data
processed_data = data
return processed_data
# Generate an iterable with random length between 100 and 1,000
random_length = random.randint(100, 1000)
data_list = [i for i in range(random_length)]
# Define estimated maximum number of iterations
estimated_total = 750
# Define the progress bar using the estimated_total
progress_bar = tqdm(total=estimated_total)
# Iterating through data list of unknown length
for data in data_list:
processed_data = process_data(data)
progress_bar.update(1)
Nous avons sous-estimé la longueur de l'itérable, ce qui fait que la sortie continue à compter les itérations après avoir atteint un taux de progression de 100 %.
Multiprocessus
Le multiprocessing et le threading sont des techniques utilisées pour exécuter des tâches simultanément, ce qui améliore les performances et la réactivité. Dans ces scénarios, il peut être difficile de suivre la progression des tâches individuelles ou la progression globale de l'exécution parallèle. Tqdm
peut être un outil précieux pour fournir un retour d'information visuel et suivre la progression de ces opérations simultanées.
Le module tqdm.contrib.concurrent
fournit des fonctions spécialisées pour créer des barres de progression dans des contextes de multiprocessus ou de threading. Ces fonctions gèrent la synchronisation et la communication entre le processus principal et les processus travailleurs ou threads, garantissant ainsi la mise à jour correcte de la barre de progression. Ils sont conçus pour fonctionner de manière transparente avec l'API concurrent.futures
, en utilisant la fonction ProcessPoolExecutor()
ou ThreadPoolExecutor()
.
Voici un exemple utilisant le module tqdm.contrib.concurrent.futures :
import concurrent.futures
from tqdm.contrib.concurrent import process_map
def process_data(data):
for i in tqdm(range(100), desc=f"Processing {data['name']}"):
# Process data
time.sleep(0.01)
if __name__ == '__main__':
with concurrent.futures.ProcessPoolExecutor() as executor:
results = process_map(process_data, [
{'name': 'dataset1'},
{'name': 'dataset2'},
# …
])
Dans cet exemple, la fonction process_data()
comprend une barre de progression tqdm
pour suivre son évolution. La fonction process_data()
sera exécutée simultanément pour chaque donnée de la liste. Cela signifie que plusieurs barres de progression seront affichées simultanément, chacune représentant la progression d'un processus distinct. Le paramètre desc
est défini de manière à créer dynamiquement une description pour chaque barre de progression sur la base du nom de l'ensemble de données correspondant, ce qui nous permet de faire la distinction entre les différentes barres de progression.
Intégration avec pandas
Le module tqdm.pandas
offre un moyen pratique d'ajouter des barres de progression aux opérations pandas
. Ceci est particulièrement utile pour les opérations qui prennent du temps sur les grands DataFramecar elle fournit un retour visuel sur la progression de la tâche. Nous pouvons appliquer le décorateur tqdm.pandas()
à toute fonction pandas
qui opère sur des lignes ou des colonnes.
Pour commencer, nous définissons un DataFrame aléatoire de 100 000 lignes et appelons le décorateur tqdm.pandas()
. Si vous souhaitez personnaliser la barre de progression, c'est le moment de le faire, car les fonctions progress_apply()
et progress_map()
ne prennent pas les paramètres tqdm()
. Ici, nous voulons donner un nom aux barres de progression suivantes, c'est pourquoi nous spécifions également le paramètre desc
.
import pandas as pd
import numpy as np
from tqdm import tqdm
df = pd.DataFrame(np.random.randint(0, 10, (100000, 6)))
tqdm.pandas(desc='DataFrame Operation')
Nous pouvons maintenant appliquer des fonctions aux lignes, aux colonnes ou à l'ensemble du DataFrame. Au lieu d'utiliser l'une des fonctions apply()
ou map()
, appelez progress_apply()
ou progress_map()
, et la barre de progression s'affichera. N'oubliez pas que apply()
et progress_apply()
peuvent être appliqués aux DataFrame, aux lignes ou aux colonnes, tandis que map()
et progress_map()
ne peuvent être appliqués qu'aux séries ou aux colonnes. Par exemple :
# Halving each value in the DataFrame using progress_apply()
Result_apply = df.progress_apply(lambda x: x / 2)
# Doubling each element of the first column using progress_map()
result_map = df[0].progress_map(lambda x: x * 2)
Tqdm : Problèmes courants et solutions
Examinons les problèmes et les erreurs les plus courants de Tqdm et apprenons à les résoudre.
La barre de progression ne se met pas à jour
L'un des problèmes les plus fréquents rencontrés lors de l'utilisation de tqdm
est l'absence de mise à jour de la barre de progression. Cela est souvent dû à des problèmes de mise en mémoire tampon, en particulier dans des environnements tels que les Jupyter Notebooks. Lorsque la sortie est mise en mémoire tampon, la barre de progression peut ne pas être affichée ou mise à jour immédiatement, ce qui donne l'impression que le processus est gelé ou ne répond pas.
L'utilisation du module tqdm.notebook
permet de résoudre les problèmes de mise en mémoire tampon et de garantir la mise à jour correcte de la barre de progression dans les blocs-notes Jupyter. Ce module fournit une barre de progression basée sur une interface graphique spécialement conçue pour les environnements Jupyter.
En outre, il offre des indications de couleur conviviales (bleu : normal, vert : terminé, rouge : erreur/interruption).
Si nous interrompons le code de notre exemple de barre de progression imbriquée, il ressemble à ceci :
Barres de progression imbriquées en Python à l'aide de tqdm.notebook
, illustrant le schéma de couleurs des barres terminées par rapport aux barres interrompues.
Un autre moyen efficace de résoudre le problème des barres de progression qui ne s'actualisent pas consiste à vider explicitement le flux de sortie. Lorsque des données sont écrites sur le flux de sortie standard (par exemple, à l'aide de print()
), elles sont généralement mises en mémoire tampon avant d'être envoyées au périphérique de sortie réel. Le fait de vider le flux de sortie oblige l'interprète Python à envoyer immédiatement toutes les données mises en mémoire tampon vers le périphérique de sortie, ce qui garantit que les données sont affichées ou écrites sans délai.
Pour purger la sortie, utilisez la méthode flush()
du flux de sortie standard. Pour une sortie plus réactive, envisagez de vider le flux de sortie plus fréquemment, par exemple après quelques itérations ou après un certain laps de temps. Gardez à l'esprit qu'il y a un compromis à faire, car le fait de vider le flux de sortie peut entraîner un surcoût supplémentaire. Voici un exemple d'intégration de la méthode dans un processus simple tqdm
:
import sys
import time
from tqdm import tqdm
for i in tqdm(range(100)):
time.sleep(0.1)
sys.stdout.flush() # Flush the output stream after each iteration
Problèmes de compatibilité
Bien que tqdm
soit généralement compatible avec la plupart des environnements et des bibliothèques Python, il peut y avoir des problèmes de compatibilité occasionnels ou des comportements inattendus. Parmi les scénarios les plus courants, on peut citer
- Flux de sortie personnalisés : Lorsque vous utilisez des flux de sortie personnalisés ou que vous redirigez la sortie vers des fichiers,
tqdm
peut ne pas fonctionner comme prévu. Nous devons nous assurer que le flux de sortie que nous utilisons prend en charge les opérations nécessaires à l'affichage de la barre de progression. - Bibliothèques tierces : Dans certains cas,
tqdm
peut interagir de manière inattendue avec des bibliothèques tierces, en particulier celles qui gèrent elles-mêmes la sortie ou le cursus. Nous pouvons essayer de désactiver ou de modifier les fonctionnalités de la bibliothèque tierce concernée pour voir si cela résout le problème. - Compatibilité des versions : Il est toujours bon d'utiliser des versions compatibles de
tqdm
et d'autres bibliothèques. Consultez la documentation de la bibliothèque pour tout problème de compatibilité connu avec des versions spécifiques de Python ou d'autres dépendances.
Lorsque vous rencontrez des problèmes de compatibilité, vous pouvez envisager les solutions suivantes :
- Rétrogradation ou mise à niveau : Nous pouvons essayer une version différente de
tqdm
. - Modifier le code : Si nécessaire, nous pouvons adapter notre code pour résoudre les éventuels conflits de compatibilité.
- Recherchez l'aide de la communauté : Si cela ne suffit pas, nous pouvons nous adresser à la communauté
tqdm
ou aux forums en ligne pour obtenir de l'aide et des solutions potentielles.
En gardant à l'esprit ces problèmes de compatibilité potentiels et leurs solutions de contournement, nous pouvons efficacement dépanner et résoudre tous les problèmes rencontrés lors de l'utilisation de tqdm
dans nos projets Python.
Conclusion
En conclusion, Tqdm est une bibliothèque Python qui nous fournit des barres de progression et d'autres statistiques utiles, ce qui facilite la surveillance et la gestion de l'exécution du code.
Qu'il s'agisse d'itérer sur de vastes ensembles de données, d'entraîner des modèles d'apprentissage automatique, ou d'utiliser des outils d'analyse de données. modèles d'apprentissage automatique, ou effectuez toute autre opération chronophage, tqdm offre un moyen simple mais puissant de suivre la progression et de rester informé de l'état de votre code.
Pour aller plus loin, n'hésitez pas à consulter les autres tutoriels Python de tutoriels DataCamp Pythonet la documentation Tqdmou son code source et Readme sur GitHub.
FAQ
Comment créer une barre de progression simple avec tqdm ?
Installez et importez la bibliothèque tqdm
, puis enveloppez votre itérable avec la fonction tqdm()
.
Puis-je utiliser tqdm avec pandas DataFrame ou d'autres bibliothèques ?
Oui, vous pouvez utiliser tqdm
avec pandas DataFrame et d'autres bibliothèques. Le module tqdm.pandas
fournit des fonctions spécifiques pour intégrer tqdm
avec pandas.
Puis-je personnaliser l'apparence de la barre de progression de Tqdm ?
Oui, vous pouvez personnaliser le format de la barre, la couleur, le nombre total d'itérations, etc. en utilisant les paramètres de Tqdm.
La barre de progression de Tqdm ne se met pas à jour correctement, que dois-je faire ?
Vérifiez les problèmes de mise en mémoire tampon, en particulier dans les blocs-notes Jupyter. Essayez d'utiliser tqdm.notebook
ou de vider explicitement la sortie. Veillez également à ce que les paramètres de total
soient correctement utilisés.

Après avoir acquis une solide base en économie, en droit et en comptabilité dans le cadre de mes doubles études à l'administration financière régionale, j'ai eu un premier contact avec les statistiques dans le cadre de mes études en sciences sociales et de mon travail en tant que tutrice. En réalisant des analyses empiriques quantitatives, j'ai découvert une passion qui m'a conduit à poursuivre mon voyage dans le magnifique domaine de la science des données et à apprendre des outils d'analyse tels que R, SQL et Python. Actuellement, j'améliore mes compétences pratiques chez Deutsche Telekom, où je peux acquérir beaucoup d'expérience pratique dans le codage de chemins de données pour importer, traiter et analyser des données à l'aide de Python.
Les meilleurs cours de Python !
cours
Python Toolbox
cours
Introduction to Testing in Python
blog
Q2 2023 DataCamp Donates Digest
blog
Les 32 meilleures questions d'entretien sur AWS et leurs réponses pour 2024
blog
2022-2023 Rapport annuel DataCamp Classrooms
blog
Célébration de Saghar Hazinyar : Une boursière de DataCamp Donates et une diplômée de Code to Inspire

Fereshteh Forough
4 min
blog
Nous avons fait don de bourses DataCamp Premium à un million de personnes, et ce n'est pas fini.
blog
Les 20 meilleures questions d'entretien pour les flocons de neige, à tous les niveaux

Nisha Arya Ahmed
20 min