Direkt zum Inhalt

Tqdm Python: Ein Leitfaden mit praktischen Beispielen

tqdm ist eine Python-Bibliothek, die einen schnellen, erweiterbaren Fortschrittsbalken für Schleifen und Iterables bereitstellt, mit dem du den Fortschritt deines Codes einfach visualisieren kannst.
Aktualisierte 15. Jan. 2025  · 11 Min. Lesezeit

Hast du dich schon einmal in einer Situation befunden, in der du dich bei einem lang laufenden Python-Skript gefragt hast, ob hinter dem Bildschirm etwas passiert ist?

Die Ungewissheit über den Fortschritt könnte dazu führen, dass du einen fast vollständigen Lauf abbrichst oder endlos auf einen bereits unterbrochenen Skriptlauf wartest.

Die tqdm Python Bibliothek löst dieses Problem, indem sie Fortschrittsanzeigen für deine Skripte bereitstellt.

tqdm Fortschrittsbalken Beispiel

Was ist tqdm?

Tqdm ist eine Python-Bibliothek, die schnelle, erweiterbare Fortschrittsbalken für Schleifen und Iterables bietet. Mit diesem Lernpfad kannst du auf einfache Weise den Fortschritt zeitintensiver Aufgaben verfolgen.

Der Name der Bibliothek bedeutet auf Arabisch "Fortschritt" (taqadum, تقدّم), und ist eine Abkürzung für "Ich liebe dich so sehr" auf Spanisch (te quiero demasiado).

Tdqm verfolgt den Lernpfad und aktualisiert die Anzeige des Fortschrittsbalkens, indem es die Iterationen zählt, die verstrichene und die verbleibende Zeit berechnet und den Gesamtfortschritt in der Balkenfüllung anzeigt.

Sie nutzt intelligente Algorithmen, um die verbleibende Zeit vorherzusagen und überspringt unnötige Iterationsanzeigen, um den Overhead zu minimieren. Die Nutzung von tqdm bietet mehrere Vorteile, darunter:

  • Visuelles Feedback: Anhand von Fortschrittsbalken kannst du sehen, wie viel von einer Aufgabe bereits erledigt ist und wie lange der verbleibende Teil noch dauern könnte.
  • Funktioniert überall: Die tqdm Bibliothek funktioniert auf jeder Plattform (Linux, Windows, Mac, FreeBSD, NetBSD, SunOS), in jeder Konsole oder in einer GUI.
  • Einfache Integration: Tqdm integriert sich nahtlos in Jupyter-Notebooks, gängige Bibliotheken wie Pandasund gängigen Python-Konstrukten wie Schleifen.
  • Anpassungen: Sie bietet verschiedene Optionen, um das Aussehen und das Verhalten der Fortschrittsbalken anzupassen, auf die wir später noch eingehen werden.
  • Leistung: Während ähnliche Pakete wie ProgressBar einen Overhead von 800ns/Initeration haben, arbeitet tdqm mit einem Overhead von 60ns/Initeration viel schneller.

Werde Dateningenieur

Baue Python-Kenntnisse auf, um ein professioneller Dateningenieur zu werden.
Jetzt kostenlos loslegen

Wie man Tqdm installiert 

Wie bei den meisten Python-Bibliotheken ist es am einfachsten, tqdm mit dem pip Paketmanager zu installieren.

pip install tqdm

Tqdm: Einfaches Beispiel

Um einen Fortschrittsbalken zu erstellen, umhüllen wir unsere iterable mit der Funktion tqdm() (die wir aus dem Modul tqdm importieren). Schauen wir uns ein einfaches Beispiel an. Die Funktion time.sleep(0.01) dient als Platzhalter für den Code, der in jeder Iteration ausgeführt werden soll.

from tqdm import tqdm
    for i in tqdm(range(1000)):
    time.sleep(0.01)
    # …

gif, das die Fertigstellung des Fortschrittsbalkens aus dem Beispielcode innerhalb von 10 Sekunden zeigt.

Als Abkürzung für tdqm(range(n)) kannst du auch trange(n) verwenden. Der folgende Code liefert genau die gleiche Ausgabe wie der vorherige:

from tqdm import tqdm
    for i in trange(1000):
	time.sleep(0.01)
	# …

Beide Beispiele geben einen Fortschrittsbalken zurück, der wie der oben abgebildete aussieht.

Sieh dir den Fortschrittsbalken genauer an, um zu sehen, welche Informationen er liefert. Schauen wir uns die Details von tqdm an:

  • Fortschrittsindikatoren:
    • Prozentsatz der Wiederholungen
    • Bar Fill
    • Anteil der gesamten Iterationen
  • Metriken:
    • Verstrichene Zeit
    • Geschätzte verbleibende Zeit
    • Leistung (Iterationen pro Sekunde)

Tqdm-Anpassung: Fortschritt machen Bars deine eigenen

Tqdm bietet verschiedene Anpassungsmöglichkeiten, um das Aussehen und Verhalten von Fortschrittsbalken anzupassen. Wir werden einen Blick auf die wichtigsten Anpassungsparameter werfen, bevor wir fortgeschrittenere Anwendungsfälle von tqdm untersuchen.

Hinzufügen einer Beschreibung des Fortschrittsbalkens

Eine gängige Anpassung ist das Hinzufügen eines beschreibenden Etiketts mit dem Parameter desc, das den Fortschrittsbalken informativer macht und dabei hilft, den Überblick über verschiedene Iterables zu behalten.

Wenn du zum Beispiel den Parameter desc=”Processing large range” hinzufügst, wird links vom Fortschrittsbalken der Titel "Processing large range" angezeigt.

for _ in tqdm(range(20000000), desc="Processing large range"):
	continue

Ich ermutige dich, den obigen Code in deiner Umgebung mit und ohne den Parameter desc auszuführen und die Unterschiede zu bemerken.

Festlegen der Gesamtzahl der Iterationen

Der Parameter total gibt die Gesamtzahl der Iterationen in der Schleife an, so dass tqdm genauere Schätzungen der verbleibenden Zeit und der prozentualen Fertigstellung liefern kann.

In einem einfachen Beispiel mit tqdm(range()) oder trange() ist dies nicht notwendig, da die Anzahl der Iterationen bereits in den Klammern enthalten ist. Es gibt jedoch zwei Hauptszenarien, in denen das Hinzufügen des Parameters total=n (wobei n die Gesamtzahl ist) hilfreich sein kann: 

1. Iterables ohne eine len() Methode: Für Iterables ohne eine len() Methode, wie z.B. Generatoren mit einer unbekannten Anzahl von Elementen, musst du den total Wert manuell eingeben. Ohne diesen Parameter zeigt tqdm() nur die Anzahl der abgeschlossenen Iterationen an. Bitte beachte, dass der Fortschrittsbalken erneut startet, wenn die tatsächliche Anzahl der Artikel die angegebene total Anzahl übersteigt.

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)
	# …

Dieses Gif zeigt die Anzahl der Iterationen ohne einen Fortschrittsbalken an.

So sieht es aus, wenn die Anzahl der Artikel unbekannt ist und wir die Gesamtzahl nicht angeben.

# 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)
	# …

In diesem gif ist der Fortschrittsbalken wieder sichtbar, nachdem der Gesamtparameter festgelegt wurde.

Viel besser, jetzt wird der Fortschrittsbalken angezeigt!

2. Manuelle Updates: Wenn wir den Lernpfad innerhalb einer Funktion mit der Methode update() manuell aktualisieren, muss der Gesamtwert angegeben werden, damit der Lernpfad korrekt verfolgt werden kann. Die Methode update() ermöglicht es zum Beispiel, auf sich dynamisch verändernde Prozesse zu reagieren oder eine individuelle Fortschrittsverfolgung zu implementieren. Darauf kommen wir später noch zu sprechen.

Optisches Erscheinungsbild optimieren

Wenn wir die Reihenfolge, in der die Elemente des Fortschrittsbalkens angezeigt werden, ändern wollen, können wir den Parameter bar_format auf die bevorzugte Formatzeichenfolge setzen. Auf diese Weise können wir die Platzierung verschiedener Elemente wie den Prozentsatz, die verstrichene Zeit und das Füllzeichen des Balkens steuern. Weitere Einzelheiten findest du in der Dokumentation.

Eine weitere Anpassung des Erscheinungsbildes kann mit dem Parameter colour vorgenommen werden. Es ist möglich, entweder Wortzeichenfolgen wie "grün" oder hexadezimale Codezeichenfolgen wie "#00ff00" zu verwenden.

Beim Parameter leave geht es eher um das Verschwinden als um das Erscheinen: Er bestimmt, ob der Fortschrittsbalken nach seiner Fertigstellung sichtbar bleibt oder nicht. Bei True bleibt der Balken nach Beendigung der Schleife bestehen, bei False verschwindet er.

Schauen wir uns die visuellen Unterschiede in den Ergebnissen in einem anderen Beispiel an. Der folgende Code erstellt drei Fortschrittsbalken: einen mit den Standardeinstellungen, einen, bei dem die Reihenfolge der Elemente und die Farbe geändert werden, und einen, der so eingestellt ist, dass er nach Fertigstellung verschwindet. Die Ergebnisse sind in dem GIF unten zu sehen.

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)

Ein Gif, das drei verschiedene Fortschrittsbalken zeigt: 1) Einfacher Fortschrittsbalken mit Standardeinstellungen, 2) gelber Fortschrittsbalken mit verstrichener Zeit und Zeitschätzungen links vom Fertigstellungsprozentsatz und dem Fortschrittsbalken, 3) rote Version des zweiten Balkens, die nach der Fertigstellung verschwindet.

Erweiterte Verwendung: Umgang mit komplexeren Szenarien

Da wir nun wissen, wie man einen einfachen Fortschrittsbalken erstellt und ihn anpasst, können wir uns ein paar fortgeschritteneren Fällen zuwenden.

Verschachtelte Fortschrittsbalken

Verschachtelte Schleifen sind Schleifen, die in anderen Schleifen enthalten sind. Verschachtelte Fortschrittsbalken sind also eine Reihe von Fortschrittsbalken für jede Iteration von Schleifen, die in anderen Schleifen enthalten sind. Um sie zu erstellen, umhüllst du jede Schleife mit einer tqdm() Funktion und fügst beschreibende Bezeichnungen für jede Iterable hinzu. 

Der folgende Code hat drei verschachtelte Schleifen und kann ein Beispiel dafür geben, wie die verschachtelten Fortschrittsbalken aussehen werden:

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)

Ein Screenshot, der drei verschachtelte Fortschrittsbalken in einem Jupyter Notebook zeigt. Der äußerste Lernpfad verfolgt die äußere Schleife, der mittlere Lernpfad verfolgt die mittlere Schleife und der innerste Lernpfad verfolgt die innere Schleife. Jeder Fortschrittsbalken zeigt die aktuelle Iteration, die Gesamtzahl der Iterationen, die geschätzte verbleibende Zeit und einen Prozentwert für die Fertigstellung an. Die Reihenfolge der Balken ist wie im Text beschrieben.

In der endgültigen Ausgabe oben können wir ein Muster erkennen, in dem die verschiedenen Fortschrittsbalken aktualisiert werden. Tqdm beginnt immer mit der äußersten Schleife, bis es die innerste Schleife erreicht, deren Iterationen verarbeitet werden und der Fortschrittsbalken entsprechend aktualisiert wird.

Nehmen wir an, wir haben drei verschachtelte Schleifen, genau wie im Beispiel. Nach der anfänglichen inneren Iteration geht es zur mittleren Schleife, aktualisiert diese als eine abgeschlossene Iteration und kehrt dann zur inneren Iteration zurück. Dieser Vorgang wird so lange wiederholt, bis die mittlere Schleife als abgeschlossen markiert wird, was dazu führt, dass der äußere Balken mit einer abgeschlossenen Iteration erscheint.

Das Gleiche passiert auch zwischen der äußeren und der mittleren Schleife. Am Ende vervollständigt der letzte innere Durchlauf die mittlere Iteration, die wiederum die letzte äußere Iteration abschließt.

Manuelle Updates

Das manuelle Aktualisieren von Fortschrittsbalken mit tqdm kann in verschiedenen Szenarien nützlich sein:

  • Iterables mit unbekannter Länge: Wenn wir mit Iterables arbeiten, die keine definierte Länge haben (z. B. Generatoren, Netzwerkströme), können wir den Fortschrittsbalken manuell anhand der verarbeiteten Datenmenge oder der Anzahl der abgeschlossenen Operationen aktualisieren.
  • Sich dynamisch verändernde Prozesse: Wenn sich die Anzahl der Iterationen oder die Bearbeitungszeit pro Iteration während der Ausführung ändern kann, können wir durch manuelle Aktualisierungen den Fortschrittsbalken entsprechend anpassen.
  • Individueller Lernpfad: Um eine genauere Kontrolle über den Fortschrittsbalken zu erhalten, können wir ihn manuell auf der Grundlage bestimmter Kriterien oder Ereignisse aktualisieren. Zum Beispiel könnten wir den Fortschrittsbalken auf der Grundlage des Abschlusses bestimmter Meilensteine oder des Fortschritts einzelner Aufgaben innerhalb eines größeren Prozesses aktualisieren wollen.
  • Integration mit externen Systemen: Wenn wir tqdm in externe Systeme oder Bibliotheken integrieren, die keine natürliche Möglichkeit zur Verfolgung des Lernpfads bieten, können wir den Lernpfad manuell mit dem externen Prozess synchronisieren.

Um einen tqdm Fortschrittsbalken manuell zu aktualisieren, ist es wichtig, dass der total Parameter als Schätzung der maximalen erwarteten Anzahl von Iterationen angegeben wird. Wenn der Code dann jedes neue Element verarbeitet, muss der Fortschrittsbalken mit der Methode update() aktualisiert werden. Der Aktualisierungswert sollte die Anzahl der Iterationen angeben, die seit der letzten Aktualisierung durchgeführt wurden.

Nehmen wir an, wir erwarten, dass unsere Iterable bis zu 750 Elemente enthält. In diesem Beispiel ist die tatsächliche Länge eine zufällige Zahl zwischen 100 und 1000, die uns unbekannt ist. Wir starten die progress_bar und setzen estimated_total auf 750. Dann gehen wir die Daten durch und aktualisieren den Fortschrittsbalken, nachdem jeder Punkt verarbeitet wurde.

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)

In diesem Gif schließt der Fortschrittsbalken bei 100% (750/750) ab und zählt dann die verbleibenden Iterationen weiter (950 am Ende).

Wir haben die Länge der Iterabilien unterschätzt, was dazu führte, dass die Ausgabe auch nach Erreichen von 100% Fortschritt noch Iterationen zählte.

Multiprocessing

Multiprocessing und Threading sind Techniken zur gleichzeitigen Ausführung von Aufgaben, die die Leistung und Reaktionsfähigkeit verbessern. In diesen Szenarien kann es schwierig sein, den Fortschritt einzelner Aufgaben oder den Gesamtfortschritt der parallelen Ausführung zu verfolgen. Tqdm kann ein wertvolles Werkzeug sein, um visuelles Feedback zu geben und den Fortschritt dieser gleichzeitigen Vorgänge zu überwachen.

Das Modul tqdm.contrib.concurrent bietet spezielle Funktionen zur Erstellung von Fortschrittsbalken im Multiprozessing- oder Threading-Kontext. Diese Funktionen sorgen für die Synchronisierung und Kommunikation zwischen dem Hauptprozess und den Arbeitsprozessen oder Threads und stellen sicher, dass der Fortschrittsbalken korrekt aktualisiert wird. Sie sind so konzipiert, dass sie nahtlos mit der concurrent.futures API zusammenarbeiten, indem sie die Funktion ProcessPoolExecutor() oder ThreadPoolExecutor() verwenden.

Hier ist ein Beispiel, das das Modul tqdm.contrib.concurrent.futures verwendet:

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'},
	# …
	])

In diesem Beispiel enthält die Funktion process_data() einen tqdm Lernpfad, um den Fortschritt zu verfolgen. Die Funktion process_data() wird gleichzeitig für jedes Datenelement in der Liste ausgeführt. Das bedeutet, dass mehrere Fortschrittsbalken gleichzeitig angezeigt werden, die jeweils den Fortschritt eines separaten Prozesses darstellen. Der Parameter desc ist so eingestellt, dass er dynamisch eine Beschreibung für jeden Fortschrittsbalken erstellt, die auf dem Namen des entsprechenden Datensatzes basiert und uns dabei hilft, zwischen verschiedenen Fortschrittsbalken zu unterscheiden.

Integration mit Pandas

Das Modul tqdm.pandas bietet eine bequeme Möglichkeit, Fortschrittsbalken zu pandas Operationen hinzuzufügen. Dies ist besonders nützlich für zeitaufwändige Operationen auf großen DataFramesnützlich, da es eine visuelle Rückmeldung über den Fortschritt der Aufgabe gibt. Wir können den tqdm.pandas() Dekorator auf jede pandas Funktion anwenden, die mit Zeilen oder Spalten arbeitet.

Um loszulegen, definieren wir einen zufälligen DataFrame mit 100.000 Zeilen und rufen den tqdm.pandas() Dekorator auf. Wenn wir den Fortschrittsbalken anpassen wollen, ist jetzt der richtige Zeitpunkt dafür, denn die Funktionen progress_apply() und progress_map() nehmen die Parameter tqdm() nicht an. Hier wollen wir den folgenden Fortschrittsbalken einen Namen geben, also geben wir auch den Parameter desc an.

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

Jetzt können wir Funktionen auf Zeilen, Spalten oder den gesamten DataFrame anwenden. Anstatt eine der Funktionen apply() oder map() zu verwenden, rufe progress_apply() oder progress_map() auf, und der Fortschrittsbalken wird angezeigt. Denke daran, dass apply() und progress_apply() auf DataFrames, Zeilen oder Spalten angewendet werden können, während map() und progress_map() nur auf Serien oder Spalten angewendet werden können. Zum Beispiel:

# 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: Häufige Probleme und deren Behebung

Lass uns einige häufige Tqdm-Probleme und -Fehler besprechen und lernen, wie du sie beheben kannst.

Fortschrittsbalken wird nicht aktualisiert

Eines der häufigsten Probleme, die bei der Verwendung von tqdm auftreten, ist ein sich nicht aktualisierender Fortschrittsbalken. Dies geschieht häufig aufgrund von Pufferungsproblemen, insbesondere in Umgebungen wie Jupyter-Notebooks. Wenn die Ausgabe gepuffert wird, kann es sein, dass der Fortschrittsbalken nicht sofort angezeigt oder aktualisiert wird, was den Eindruck eines eingefrorenen oder nicht reagierenden Prozesses erweckt.

Mit dem Modul tqdm.notebook kannst du Pufferungsprobleme beheben und sicherstellen, dass der Fortschrittsbalken in Jupyter Notebooks korrekt aktualisiert wird. Dieses Modul bietet eine GUI-basierte Fortschrittsanzeige, die speziell für Jupyter-Umgebungen entwickelt wurde.

Außerdem bietet er benutzerfreundliche Farbhinweise (blau: normal, grün: abgeschlossen, rot: Fehler/Unterbrechung).

Wenn wir den Code aus unserem verschachtelten Fortschrittsbalken-Beispiel unterbrechen, sieht er wie folgt aus:

Ein Screenshot, der den unterbrochenen Lauf von drei verschachtelten Fortschrittsbalken in einem Jupyter Notebook zeigt. Alle abgeschlossenen Balken sind grün gefärbt, während alle unterbrochenen Balken rot gefärbt sind.

Verschachtelte Fortschrittsbalken in Python mit tqdm.notebook, die das Farbschema von abgeschlossenen und unterbrochenen Balken veranschaulichen.

Eine weitere effektive Methode zur Behebung von Problemen mit nicht aktualisierten Fortschrittsbalken ist das explizite Flushen des Ausgabestroms. Wenn Daten in den Standardausgabestrom geschrieben werden (z. B. mit print()), werden die Daten normalerweise gepuffert, bevor sie an das eigentliche Ausgabegerät gesendet werden. Das Flushen des Ausgabestroms zwingt den Python-Interpreter, alle zwischengespeicherten Daten sofort an das Ausgabegerät zu senden, damit die Daten ohne Verzögerung angezeigt oder geschrieben werden. 

Um die Ausgabe zu spülen, verwende die Methode flush() des Standardausgabestroms. Für eine reaktionsschnellere Ausgabe solltest du überlegen, den Ausgabestrom häufiger zu spülen, vielleicht nach ein paar Iterationen oder nach einer bestimmten Zeitspanne. Bedenke, dass es einen Kompromiss gibt, da das Spülen des Ausgabestroms zusätzlichen Overhead verursachen kann. Hier ist ein Beispiel, wie du die Methode in einen einfachen tqdm Prozess einbauen kannst:

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

Kompatibilitätsprobleme

Obwohl tqdm im Allgemeinen mit den meisten Python-Umgebungen und -Bibliotheken kompatibel ist, kann es gelegentlich zu Kompatibilitätsproblemen oder unerwarteten Verhaltensweisen kommen. Einige häufige Szenarien, auf die du achten solltest, sind:

  • Benutzerdefinierte Ausgabeströme: Wenn du benutzerdefinierte Ausgabeströme verwendest oder die Ausgabe in Dateien umleitest, funktioniert tqdm möglicherweise nicht wie erwartet. Wir müssen sicherstellen, dass der Ausgabestrom, den wir verwenden, die notwendigen Operationen für die Anzeige des Fortschrittsbalkens unterstützt.
  • Bibliotheken von Drittanbietern: In einigen Fällen kann tqdm unerwartet mit Bibliotheken von Drittanbietern interagieren, insbesondere mit solchen, die die Ausgabe oder die Fortschrittsverfolgung selbst übernehmen. Wir können versuchen, die entsprechenden Bibliotheksfunktionen von Drittanbietern zu deaktivieren oder zu ändern, um zu sehen, ob das Problem dadurch gelöst wird.
  • Versionskompatibilität: Es ist immer eine gute Praxis, kompatible Versionen von tqdm und anderen Bibliotheken zu verwenden. Prüfen Sie die Bibliotheksdokumentation für alle bekannten Kompatibilitätsprobleme mit bestimmten Versionen von Python oder anderen Abhängigkeiten.

Bei Kompatibilitätsproblemen können wir die folgenden Abhilfemaßnahmen in Betracht ziehen:

  • Downgrade oder Upgrade: Wir können eine andere Version von tqdm ausprobieren.
  • Ändere den Code: Falls nötig, können wir unseren Code anpassen, um Kompatibilitätskonflikte zu umgehen.
  • Suche dir Hilfe in der Gemeinde: Wenn das alles nicht hilft, können wir uns an die tqdm Community oder Online-Foren wenden, um Hilfe und mögliche Lösungen zu erhalten.

Wenn wir diese potenziellen Kompatibilitätsprobleme und ihre Umgehungsmöglichkeiten kennen, können wir alle Probleme, die bei der Verwendung von tqdm in unseren Python-Projekten auftreten, effektiv beheben. Python-Projekten.

Fazit

Zusammenfassend lässt sich sagen, dass Tqdm eine Python-Bibliothek ist, die uns mit Fortschrittsbalken und anderen hilfreichen Statistiken versorgt und so die Überwachung und Verwaltung der Codeausführung erleichtert.

Ob du nun große Datensätze iterierst, Modelle für Machine-Learning-Modelleoder andere zeitaufwändige Operationen durchführst, tqdm bietet dir eine einfache, aber leistungsstarke Möglichkeit, den Lernpfad zu verfolgen und über den Status deines Codes informiert zu bleiben.

Für weitere Erkundungen kannst du dir die anderen DataCamp Python-Tutorials, die Tqdm-Dokumentationoder den Quellcode und Readme auf GitHub.

FAQs

Wie erstelle ich einen einfachen Fortschrittsbalken mit tqdm?

Installiere und importiere die Bibliothek tqdm und wickle dann deine Iterable mit der Funktion tqdm() ein.

Kann ich tqdm mit DataFrames von Pandas oder anderen Bibliotheken verwenden?

Ja, du kannst tqdm mit Pandas DataFrames und anderen Bibliotheken verwenden. Das Modul tqdm.pandas bietet spezielle Funktionen für die Integration von tqdm mit Pandas.

Kann ich das Aussehen des Tqdm-Fortschrittsbalkens anpassen?

Ja, du kannst das Format des Balkens, die Farbe, die Gesamtzahl der Iterationen und mehr mit den Parametern von Tqdm anpassen.

Der Tqdm-Fortschrittsbalken wird nicht richtig aktualisiert, was soll ich tun?

Prüfe auf Pufferungsprobleme, besonders in Jupyter Notebooks. Versuche, tqdm.notebook zu verwenden oder die Ausgabe explizit zu spülen. Achte außerdem auf die korrekte Verwendung der total Parameter.


Tom Farnschläder's photo
Author
Tom Farnschläder
LinkedIn

Nachdem ich mir in meinem dualen Studium in der regionalen Finanzverwaltung eine solide Basis in Wirtschaft, Recht und Rechnungswesen erarbeitet hatte, kam ich in meinem Studium der Sozialwissenschaften und meiner Arbeit als Tutorin erstmals mit Statistik in Berührung. Bei der Durchführung quantitativer empirischer Analysen entdeckte ich eine Leidenschaft, die mich dazu brachte, meine Reise in das wunderbare Feld der Datenwissenschaft fortzusetzen und Analysetools wie R, SQL und Python zu erlernen. Zurzeit vertiefe ich meine praktischen Fähigkeiten bei der Deutschen Telekom, wo ich viele praktische Erfahrungen beim Programmieren von Datenpfaden zum Importieren, Verarbeiten und Analysieren von Daten mit Python sammeln kann.

Themen

Top Python-Kurse!

Zertifizierung verfügbar

Kurs

Einführung in Python für Entwickler

3 hr
40.1K
Beherrsche die Grundlagen der Programmierung in Python. Keine Vorkenntnisse erforderlich!
Siehe DetailsRight Arrow
Kurs starten
Mehr anzeigenRight Arrow