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

PythonPythonBeginner
Практиковаться сейчас

This tutorial is from open-source community. Access the source code

💡 Этот учебник переведен с английского с помощью ИИ. Чтобы просмотреть оригинал, вы можете перейти на английский оригинал

Введение

В этом практическом занятии вы научитесь использовать библиотеку 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), который затем строит данные в режиме реального времени.