Kurs
Tqdm Python: Ein Leitfaden mit praktischen Beispielen
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.
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
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)
# …
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)
# …
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)
# …
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)
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)
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)
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:
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.

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.
Top Python-Kurse!
Kurs
Python Toolbox
Kurs