Откройте мощь многопроцессорности и Matplotlib

Введение

В этом практическом занятии вы научитесь использовать библиотеку multiprocessing и Matplotlib для построения графиков с данными, сгенерированными в отдельном процессе. Мы создадим два класса - ProcessPlotter и NBPlot - для обработки построения графиков и генерации данных соответственно. Класс NBPlot будет генерировать случайные данные и отправлять их в класс ProcessPlotter через трубу (pipe), который затем будет построать данные в режиме реального времени.

Советы по работе с ВМ

После запуска ВМ нажмите в левом верхнем углу, чтобы переключиться на вкладку Notebook и получить доступ к Jupyter Notebook для практики.

Иногда может потребоваться подождать несколько секунд, пока Jupyter Notebook полностью загрузится. Валидация операций не может быть автоматизирована из-за ограничений Jupyter Notebook.

Если вы сталкиваетесь с проблемами во время обучения, не стесняйтесь обращаться к Labby. Оставьте отзыв после занятия, и мы оперативно решим проблему для вас.

Импорт библиотек

Начнем с импорта необходимых библиотек. Мы будем использовать multiprocessing для обработки отдельных процессов, time для задержки времени, numpy для генерации случайных данных и matplotlib для построения графиков.

import multiprocessing as mp
import time
import numpy as np
import matplotlib.pyplot as plt

Определение класса `ProcessPlotter`

Класс ProcessPlotter будет обрабатывать построение графиков для данных, отправленных через трубу (pipe). Он будет постоянно проверять трубу на наличие новых данных и строить их в режиме реального времени.

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

Определение класса `NBPlot`

Класс NBPlot будет генерировать случайные данные и отправлять их в класс ProcessPlotter через трубу (pipe).

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)

Создайте экземпляр `NBPlot` и отправьте данные в `ProcessPlotter`

Создайте экземпляр класса NBPlot и отправьте случайные данные в класс ProcessPlotter. Мы отправим 10 наборов данных с задержкой в 0,5 секунды между каждым набором.

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

Резюме

В этом практическом занятии мы узнали, как использовать библиотеку multiprocessing и Matplotlib для построения графиков для данных, генерируемых в отдельном процессе. Мы создали два класса - ProcessPlotter и NBPlot - для обработки построения графиков и генерации данных соответственно. Класс NBPlot генерирует случайные данные и отправляет их в класс ProcessPlotter через трубу (pipe), который затем строит данные в режиме реального времени.

Многопроцессорность с Matplotlib