Einführung
In diesem Lab lernst du, wie du die multiprocessing-Bibliothek und Matplotlib verwendest, um Daten zu visualisieren, die von einem separaten Prozess generiert werden. Wir werden zwei Klassen erstellen - ProcessPlotter und NBPlot - um die Visualisierung und die Datengenerierung zu verarbeiten. Die NBPlot-Klasse wird zufällige Daten generieren und diese über eine Pipe an die ProcessPlotter-Klasse senden, die dann die Daten in Echtzeit visualisieren wird.
Tipps für die VM
Nachdem der Start der VM abgeschlossen ist, klicke in der oberen linken Ecke, um zur Registerkarte Notebook zu wechseln und Jupyter Notebook für die Übung zu nutzen.
Manchmal musst du einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Die Validierung von Vorgängen kann aufgrund der Einschränkungen von Jupyter Notebook nicht automatisiert werden.
Wenn du während des Lernens Probleme stellst, kannst du Labby gerne fragen. Gib nach der Sitzung Feedback, und wir werden das Problem für dich prompt beheben.
Bibliotheken importieren
Wir beginnen mit dem Import der erforderlichen Bibliotheken. Wir werden multiprocessing verwenden, um die separaten Prozesse zu verarbeiten, time für die Zeitverzögerung, numpy um zufällige Daten zu generieren und matplotlib für die Visualisierung.
import multiprocessing as mp
import time
import numpy as np
import matplotlib.pyplot as plt
Definiere die Klasse ProcessPlotter
Die Klasse ProcessPlotter wird die Visualisierung der über die Pipe gesendeten Daten verarbeiten. Sie wird ständig die Pipe auf neue Daten überprüfen und diese in Echtzeit visualisieren.
class ProcessPlotter:
def __init__(self):
self.x = []
self.y = []
def terminate(self):
plt.close('all')
def call_back(self):
while self.pipe.poll():
command = self.pipe.recv()
if command is None:
self.terminate()
return False
else:
self.x.append(command[0])
self.y.append(command[1])
self.ax.plot(self.x, self.y, 'ro')
self.fig.canvas.draw()
return True
def __call__(self, pipe):
print('starting plotter...')
self.pipe = pipe
self.fig, self.ax = plt.subplots()
timer = self.fig.canvas.new_timer(interval=1000)
timer.add_callback(self.call_back)
timer.start()
print('...done')
plt.show()
Definiere die Klasse NBPlot
Die Klasse NBPlot wird zufällige Daten generieren und diese über eine Pipe an die Klasse ProcessPlotter senden.
class NBPlot:
def __init__(self):
self.plot_pipe, plotter_pipe = mp.Pipe()
self.plotter = ProcessPlotter()
self.plot_process = mp.Process(
target=self.plotter, args=(plotter_pipe,), daemon=True)
self.plot_process.start()
def plot(self, finished=False):
send = self.plot_pipe.send
if finished:
send(None)
else:
data = np.random.random(2)
send(data)
Erstelle eine Instanz von NBPlot und sende Daten an ProcessPlotter
Erstelle eine Instanz der Klasse NBPlot und sende zufällige Daten an die Klasse ProcessPlotter. Wir werden 10 Datensätze senden, mit einer Verzögerung von 0,5 Sekunden zwischen jedem Satz.
def main():
pl = NBPlot()
for _ in range(10):
pl.plot()
time.sleep(0.5)
pl.plot(finished=True)
if __name__ == '__main__':
if plt.get_backend() == "MacOSX":
mp.set_start_method("forkserver")
main()
Zusammenfassung
In diesem Lab haben wir gelernt, wie man die Bibliothek multiprocessing und Matplotlib verwendet, um Daten zu visualisieren, die aus einem separaten Prozess generiert wurden. Wir haben zwei Klassen - ProcessPlotter und NBPlot - erstellt, um die Visualisierung und die Datengenerierung zu verarbeiten. Die Klasse NBPlot generiert zufällige Daten und sendet sie an die Klasse ProcessPlotter über eine Pipe, die dann die Daten in Echtzeit visualisiert.