Ich möchte den Fortschritt in Python anzeigen!

Überblick

Wenn Sie einen Prozess ausführen, der lange dauert und keine Antwort erfolgt, sind Sie besorgt darüber, "wie weit der Prozess fortgeschritten ist" oder "funktioniert er?" Es gibt, richtig? Ja, es gibt (3-Stufen-Nutzung). Daher werde ich feststellen, wie der Fortschritt der Schleifenverarbeitung angezeigt wird.

↓ ↓ ↓ Übrigens sieht es so aus ↓ ↓ ↓ Wenn Sie es nützlich finden, wäre ich Ihnen dankbar, wenn Sie die LGTM-Aktie kommentieren könnten.

Inhaltsverzeichnis

• [Verwenden Sie das Paket tqdm](#Verwenden Sie das Paket tqdm)
• [Versuche es selbst zu machen](# Versuche es selbst zu machen)
• [Escape-Sequenz](# Escape-Sequenz)
• [Versuchen Sie, einen Fortschrittsbalken zu erstellen](# Versuchen Sie, einen Fortschrittsbalken zu erstellen)
• [Entwicklung: ANSI-Escape-Code](#Development Ansi-Escape-Code)

Verwendung des Pakets tqdm

Zunächst möchte ich "tqdm" vorstellen, die königliche Straße des Fortschritts (ich halte sie für egoistisch). Es ist sehr einfach zu bedienen, importieren Sie es einfach und binden Sie es wie folgt in Ihre Schleife ein:

tqdm_test.py

%!pip install tqdm
import tqdm
import numpy as np


for i in tqdm.tqdm(range(int(1e7))):
    np.pi*np.pi

Jetzt sollten Sie so etwas sehen: Es ist bequem ~ Da Sie ein iterierbares (schleifenfähiges) Objekt an tqdm.tqdm () übergeben, können Sie auch Listen, Wörterbücher, Zeichenfolgen usw. übergeben. Als Einschränkung wäre es jedoch schrecklich, wenn es eine Standardausgabe wie die Druckfunktion in der Schleifenverarbeitung gibt.

tqdm_test.py

%!pip install tqdm
import tqdm
import numpy as np


for i in tqdm.tqdm(range(int(1e7))):
    np.pi*np.pi
    if i % 1e6 == 0:
        print(i)

Die gleiche Überlegung ist, dass es schrecklich wäre, Fortschritte mit der Funktion tqdm.tqdm zum Verschachteln von Schleifen zu zeigen.

tqdm_test.py

import tqdm
for t in tqdm.tqdm(range(10)):
    for i in tqdm.tqdm(range(int(1e6))):
        np.pi*np.pi

So etwas ist sehr selten unpraktisch, oder? Haben Sie alle eine solche Erfahrung? Es gibt, richtig? Ja, es gibt (3-Stufen-Nutzung). Also lasst uns selbst etwas dagegen tun.

Versuche es selbst zu machen

Zumindest in Python scheint es, dass ** die Standardausgabezeichenfolge zum Zeitpunkt des Zeilenumbruchs die Kontrolle über das Programm verlässt **. Umgekehrt bedeutet dies, dass es auch nach Standardausgabe programmgesteuert betrieben werden kann, solange kein Zeilenumbruch vorliegt **.

progress.py

for i in range(int(1e7)):
    if i % 1e4 == 0:
        print("\r", i, end="")
    np.pi*np.pi

Diese \ r und end =" " ermöglichen es dem Programm, nach der Standardausgabe weiterhin die Kontrolle darüber zu übernehmen. end =" " ist eine Option zum Festlegen der Zeichenfolge, die am Ende der von der Funktion print ausgegebenen Zeichenfolge hinzugefügt werden soll, und \ n (Zeilenvorschub) ist standardmäßig angegeben. Wenn Sie es ändern, um ein leeres Zeichen hinzuzufügen, indem Sie "end =" "" setzen (obwohl es seltsam zu sagen ist), gibt es keine Zeilenumbrüche, sodass Sie programmgesteuert mit der Standardausgabe spielen können. Wie hier zu sehen ist, werden \ r und \ n, beginnend mit einem Backslash, als ** Escape-Sequenzen ** bezeichnet und sind eine Gruppe von Zeichenfolgen, die eine spezielle Steuerung ermöglichen, die Sie in die Zeichenfolge aufnehmen möchten. Ich werde.

Fluchtabfolge

Wie oben erwähnt, ist die Escape-Sequenz eine Gruppe von Zeichenfolgen, die verwendet werden, wenn Sie einer Zeichenfolge eine spezielle Steuerung geben möchten. Die typischen sind in der folgenden Tabelle aufgeführt.

In Bezug auf die Verarbeitung gibt der Schrägstrich den Beginn der Escape-Sequenzbeschreibung an und wird in die Steueranweisung oder den Zeichencode konvertiert, der der folgenden Zeichenfolge entspricht. Daher wird es auch verwendet, wenn die in der Steueranweisung der Zeichenfolge selbst verwendete Zeichenfolge ausgegeben wird, z. B. doppeltes Anführungszeichen "".

test_esc.py

print("\"")
print("\'")
print("\\")

Mit dieser Funktion können Sie eine Zeichenfolge in Unicode lesen, dies ist jedoch wahrscheinlich nicht der Fall.

test_esc.py

# Hello world!
print("\x48\x65\x6c\x6c\x6f\x20\x77\x6f\x72\x6c\x64\x21")

Versuchen Sie, einen Fortschrittsbalken zu erstellen

Lassen Sie uns Ihren eigenen Fortschrittsbalken mit der Escape-Sequenz \ r erstellen.

progress.py

import time
for i in range(50):
    print("\r[" + "#"*i + "]", end="")
    time.sleep(0.1)

Vorerst haben wir etwas geschaffen, das man als Fortschrittsbalken bezeichnen kann! Ich weiß übrigens nicht warum, aber die Escape-Sequenz funktioniert nicht, wenn ich die Funktion format verwende. Es schmeckt nicht so gut wie es ist, also lasst uns mehr entwickeln.

progress.py

import time
epoch = 50
for i in range(epoch):
    bar = "="*i + (">" if i < epoch-1 else "=") + " "*(epoch-i-1)
    print("\r[" + bar + "]", "{}/{}".format(i+1, epoch), end="")
    time.sleep(0.1)

Schreiben Sie zur Erklärung zuerst die Hauptteilzeichenfolge des Fortschrittsbalkens in die Variable bar. Im Code werden Leerzeichen ausgefüllt, um die Länge des Fortschrittsbalkens festzulegen, und der Anfang ist ein Pfeil.

Außerdem können Sie alles tun, weil Sie nur die Verschachtelung definieren müssen, die Sie mit tqdm nicht machen konnten.

progress.py

import time


t_epoch = 10
i_epoch = 50
lap_time = -1
start_time = time.time()
for t in range(t_epoch):
    t_per = int((t+1)/t_epoch*i_epoch)
    for i in range(i_epoch):
        i_per = int((i+1)/i_epoch*i_epoch)
        if i_per <= t_per:
            bar = ("progress:[" + "X"*i_per
                                + "\\"*(t_per-i_per)
                                + " "*(i_epoch-t_per) + "]")
        else:
            bar = ("progress:[" + "X"*t_per
                                + "/"*(i_per-t_per)
                                + " "*(i_epoch-i_per) + "]")
        time.sleep(1e-2)
        elapsed_time = time.time() - start_time
        print("\r" + bar, "{}s/{}s".format(
                int(elapsed_time),
                int(lap_time*t_epoch) if lap_time > 0 
           else int(elapsed_time*(i_epoch/(i+1))*t_epoch)),
              end="")
    lap_time = (time.time() - start_time)/(t+1)

Es wurde plötzlich kompliziert ... Ich werde es erklären. t_per und i_per berechnen und halten die Anzahl der Zeichen, die erforderlich sind, um den Fortschritt in der t-Schleife und i-Schleife als Zeichenfolge anzuzeigen. bar ist der Fortschrittsbalken selbst

• Die t-Schleife verwendet den String \, um den Fortschritt anzuzeigen.
• Die i-Schleife verwendet den String /, um den Fortschritt anzuzeigen.
• Der überlappende Teil zeigt den Fortschritt mit der Zeichenkette "X" an

Es ist so programmiert. Der Backslash ist das Startzeichen der Escape-Sequenz, daher müssen Sie "\" verwenden. lap_time enthält die Zeit, die für eine Schleife von i benötigt wird. Ich versuche, den Durchschnitt zu nehmen, um einen genaueren Wert zu erhalten. elapsed_time ist die verstrichene Zeit bis zur Gegenwart.

progress.py

                int(lap_time*t_epoch) if lap_time > 0 
           else int(elapsed_time*(i_epoch/(i+1))*t_epoch))

Wenn jedoch "lap_time" berechnet wird, wird es angezeigt, und wenn dies nicht der Fall ist (dh wenn Sie zum ersten Mal in die Schleife von "i" eintreten), wird die Rundenzeit aus der verstrichenen Zeit geschätzt und angezeigt.

Dies ist nur ein Beispiel. Denken Sie also bitte darüber nach.

Evolution: ANSI-Escape-Code

In der bisherigen Geschichte heißt es, dass "die Standardausgabe bei einem Zeilenumbruch nicht überschrieben werden kann", aber tatsächlich auch bei einem Zeilenumbruch betrieben werden kann. Die Methode ist ** ANSI-Escape-Code **.

progress.py

import time
epoch = 25

print("　"*(epoch-10) + "I ノ ノ ノ Hami ⌒ Mi.")
print("　"*(epoch-11) + " (´ ・ ω ・ ｀)ω ・ ｀)jetzt! Schieß mit Ora!")
print("　"*(epoch-13) + "⊂∩∩tsu)")
print("　"*(epoch-10) + "/　　　〈　　 〈")
print("　"*(epoch-11) + " ( /⌒ ｀ J ⌒'")
print("\n\n")
print("　"*(epoch-1)  + "Nein")
print("　"*(epoch-4)  + "彡 ノ")
print("　"*(epoch-6)  + "Nein")
print("　"*(epoch-8)  + "Nono Minono")
print()
print("　"*(epoch-11) + "(´；ω；｀)ω^｀)Scheiße ah ah ah! !! !!")
print("　"*(epoch-13) + "⊂∩∩tsu)")
print("　"*(epoch-10) + "/　　　〈　　 〈")
print("　"*(epoch-11) + " ( /⌒ ｀ J ⌒'")
print("\033[6A")
for i in range(epoch):
    bar = "弌"*i + "⊃" + "　"*(epoch-i-1)
    print("\zu r" + bar + "]", "{}/{}".format(i+1, epoch), end="")
    time.sleep(0.1)
print()
print("\033[5B")

Bitte gehen Sie durch, wenn der Weg zum Verbergen persönlicher Informationen kompliziert ist lol Wissen Sie Es ist eine Parodie AA der berühmten Szene von Dragon Ball gegen Radits. (Ich habe etwas gefunden, also habe ich es benutzt) Der Code zum Anzeigen des AA-Teils ist wie Sie sehen können. Beachten Sie jedoch, dass alle AAs im Voraus ausgegeben wurden. Und

progress.py

print("\033[6A")

Vorgeöffnet von

progress.py

print("　"*(epoch-8)  + "Nono Minono")
print()
print("　"*(epoch-11) + "(´；ω；｀)ω^｀)Scheiße ah ah ah! !! !!")

Ich ging zum leeren Zeilenteil von und zeigte die Manuki Kosatsu-Methode auf die gleiche Weise wie zuvor an. Schließlich

progress.py

print()
print("\033[5B")

Die Manuki Kosatsu-Methode ist fehlerhaft und wird in die letzte Zeile der Standardausgabe verschoben.

Nun kommt der mysteriöse Code heraus, dies ist der ** ANSI-Escape-Code **. In Python finden Sie in der folgenden Tabelle ANSI-Escape-Codes.

Wenn Sie Fragen haben, stellen wir nur die ersten vier zur Verfügung. Mit diesem ANSI-Code können Sie wie bisher mit einem hohen Freiheitsgrad arbeiten.

Übrigens scheint dieser ANSI-Code nur bei Verwendung einer Konsole wie eines Terminals verwendbar zu sein. Lassen Sie uns also den einzeiligen Fortschrittsbalken bei \ r im Jupiter-Notizbuch usw. in Kauf nehmen.

abschließend

Also habe ich mir die unerwartet komplizierte Standardausgabe notiert. Nun, es scheint unwahrscheinlich, dass Menschen, die ihre eigenen Fortschrittsbalken machen müssen ... Nun, ich bin sicher, es ist gut, dass Sie mit diesen Funktionen verschiedene Dinge spielen können.

Referenz

• Escape Sequence
• Unicode-Liste
• Aa von Manuki Kotobuki wurde abgeschlossen
• Süße AA von 2ch / Zusammenfassung der Gesichtszeichen