Как расположить несколько графиков рядом python

Использование библиотеки Matplotlib. Как нарисовать несколько графиков в одном окне

Часто бывает удобно отобразить несколько независимых графиков в одном окне. Для этого предназначена функция subplot() из пакета matplotlib.pyplot.

У этой функции есть несколько вариантов ее использования. В этой статье мы рассмотрим два из них.

Функция subplot() ожидает три параметра:

• количество строк в графике;
• количество столбцов в графике;
• номер ячейки, куда будут выводиться графики, после вызова этой функции. Ячейки нумеруются построчно, начиная с 1.

Проще всего сразу рассмотреть пример. В этом примере для простоты будут выводиться одинаковые графики в разные ячейки. Чтобы было более наглядно, в заголовок каждого графика будет добавлена цифра, обозначающая порядковый номер ячейки.

import matplotlib. pyplot as plt

import numpy as np

if __name__ == ‘__main__’ :
# Интервал изменения переменной по оси X
xmin = — 20.0
xmax = 20.0
count = 200

# Создадим список координат по оиси X на отрезке [xmin; xmax]
x = np. linspace ( xmin , xmax , count )

# Вычислим значение функции в заданных точках
y = np. sinc ( x / np. pi )

plt. figure ( figsize = ( 8 , 8 ) )

# . Две строки, три столбца.
# . Текущая ячейка — 1
plt. subplot ( 2 , 3 , 1 )
plt. plot ( x , y )
plt. title ( «1» )

# . Текущая ячейка — 2
plt. subplot ( 2 , 3 , 2 )
plt. plot ( x , y )
plt. title ( «2» )

# . Текущая ячейка — 3
plt. subplot ( 2 , 3 , 3 )
plt. plot ( x , y )
plt. title ( «3» )

# . Текущая ячейка — 4
plt. subplot ( 2 , 3 , 4 )
plt. plot ( x , y )
plt. title ( «4» )

# . Текущая ячейка — 5
plt. subplot ( 2 , 3 , 5 )
plt. plot ( x , y )
plt. title ( «5» )

# . Текущая ячейка — 6
plt. subplot ( 2 , 3 , 6 )
plt. plot ( x , y )
plt. title ( «6» )

# Покажем окно с нарисованным графиком
plt. show ( )

Все эти ячейки чисто условные, поэтому для каждого вызова subplot() разбиение главного окна может быть свое, что позволяет сделать, например, следующее расположение графиков (обратите внимание на нумерацию ячеек):

import matplotlib. pyplot as plt

import numpy as np

if __name__ == ‘__main__’ :
# Интервал изменения переменной по оси X
xmin = — 20.0
xmax = 20.0
count = 200

# Создадим список координат по оиси X на отрезке [xmin; xmax]
x = np. linspace ( xmin , xmax , count )

# Вычислим значение функции в заданных точках
y = np. sinc ( x / np. pi )

plt. figure ( figsize = ( 8 , 8 ) )

# . Две строки, три столбца.
# . Текущая ячейка — 1
plt. subplot ( 2 , 3 , 1 )
plt. plot ( x , y )
plt. title ( «1» )

# . Две строки, три столбца.
# . Текущая ячейка — 2
plt. subplot ( 2 , 3 , 2 )
plt. plot ( x , y )
plt. title ( «2» )

# . Две строки, три столбца.
# . Текущая ячейка — 4
plt. subplot ( 2 , 3 , 4 )
plt. plot ( x , y )
plt. title ( «4» )

# . Две строки, три столбца.
# . Текущая ячейка — 5
plt. subplot ( 2 , 3 , 5 )
plt. plot ( x , y )
plt. title ( «5» )

# . Одна строка, три столбца.
# . Текущая ячейка — 3
plt. subplot ( 1 , 3 , 3 )
plt. plot ( x , y )
plt. title ( «3» )

# Покажем окно с нарисованным графиком
plt. show ( )

У функции есть еще несколько необычный способ задания разбиения окна. В случае, если количество графиков не превышает 9, вместо перечисления трех чисел мы можем писать одно трехзначное целое число. То есть, вместо plt.subplot(1, 3, 3) мы можем написать plt.subplot(133). Поэтому предыдущий пример мы можем переписать в следующем виде, при этом внешний вид графика не изменится:

import matplotlib. pyplot as plt

import numpy as np

if __name__ == ‘__main__’ :
# Интервал изменения переменной по оси X
xmin = — 20.0
xmax = 20.0
count = 200

# Создадим список координат по оиси X на отрезке [xmin; xmax]
x = np. linspace ( xmin , xmax , count )

# Вычислим значение функции в заданных точках
y = np. sinc ( x / np. pi )

plt. figure ( figsize = ( 8 , 8 ) )

# . Две строки, три столбца.
# . Текущая ячейка — 1
plt. subplot ( 231 )
plt. plot ( x , y )
plt. title ( «1» )

# . Две строки, три столбца.
# . Текущая ячейка — 2
plt. subplot ( 232 )
plt. plot ( x , y )
plt. title ( «2» )

# . Две строки, три столбца.
# . Текущая ячейка — 4
plt. subplot ( 234 )
plt. plot ( x , y )
plt. title ( «4» )

# . Две строки, три столбца.
# . Текущая ячейка — 5
plt. subplot ( 235 )
plt. plot ( x , y )
plt. title ( «5» )

# . Одна строка, три столбца.
# . Текущая ячейка — 3
plt. subplot ( 133 )
plt. plot ( x , y )
plt. title ( «3» )

# Покажем окно с нарисованным графиком
plt. show ( )

У функции subplot() есть еще другие способы использования, которые описаны в статье Использование класса GridSpec для расположения графиков.

Вы можете подписаться на новости сайта через RSS, Группу Вконтакте или Канал в Telegram.

Как вывести несколько графиков одновременно?

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

import random import matplotlib.pyplot as plt import numpy as np import pandas as pd plt.style.use('ggplot') mn, mx, N = -10000, 10000, 1000 dataset = pd.Series(data=[random.randint(mn, mx) for _ in range(1000)], name='X') print("Характеристики полученных целочисленных данных :\n") print(f"Минимальное значение : ") print(f"Количество повторяющихся значений : ") print(f"Максимальное значение : ") print(f"Сумма чисел : ") plt.plot(list(range(1000)), dataset, alpha=0.8) plt.title("Линейный график\n(по заданным целочисленным данным)") plt.show() plt.hist(dataset, alpha=0.8) plt.title('Гистограмма значений \n(по заданным целочисленным данным)') plt.show() dataframe = pd.DataFrame(dataset) dataframe['X_по_возрастанию'] = dataframe.X.sort_values().values dataframe['X_по_убыванию'] = dataframe.X.sort_values(ascending=False).values dataframe.head() plt.plot(dataframe['X_по_возрастанию'], label="X по возрастанию") plt.plot(dataframe['X_по_убыванию'], label="X по убыванию") plt.title('Два линейных графика отсортированных значений\n(по заданным целочисленным данным)') plt.legend() plt.show() 

Отслеживать
73.1k 107 107 золотых знаков 38 38 серебряных знаков 55 55 бронзовых знаков
задан 2 мая 2021 в 10:26
11 1 1 золотой знак 1 1 серебряный знак 4 4 бронзовых знака
удалите все вызовы plt.show() кроме последнего
2 мая 2021 в 10:30

Может что-то не так делаю, но в таком случае график едет и все в куче. Надо в идеале чтобы три окна одновременно появлялись. Или три полноценных графика в одном окне.

2 мая 2021 в 10:33

это уже следующий вопрос 😉 Для того чтобы графики не «съезжали» значения различных графиков должны лежать приблизительно в одинаковых диапазонах. В противном случае графики будут «ехать»

2 мая 2021 в 10:40
А вывод нескольких окон одновременно возможен? В моем случае 3
2 мая 2021 в 10:48

2 ответа 2

Сортировка: Сброс на вариант по умолчанию

Для того чтобы отобразить несколько независимых графиков в одном окне — предназначена функция subplot() из пакета pylab .

import random import matplotlib.pyplot as plt import numpy as np import pandas as pd # Импортируем один из пакетов Matplotlib import pylab plt.style.use('ggplot') mn, mx, N = -10000, 10000, 1000 dataset = pd.Series(data=[random.randint(mn, mx) for _ in range(1000)], name='X') print("Характеристики полученных целочисленных данных :\n") print(f"Минимальное значение : ") print(f"Количество повторяющихся значений : ") print(f"Максимальное значение : ") print(f"Сумма чисел : ") # Две строки, два столбца. Текущая ячейка - 1 pylab.subplot (2, 2, 1) pylab.plot(list(range(1000)), dataset, alpha=0.8) pylab.title ("Линейный график") # Две строки, два столбца. Текущая ячейка - 3 pylab.subplot (2, 2, 3) pylab.hist(dataset, alpha=0.8) #plot (xlist, ylist) pylab.title ("Гистограмма значений") dataframe = pd.DataFrame(dataset) dataframe['X_по_возрастанию'] = dataframe.X.sort_values().values dataframe['X_по_убыванию'] = dataframe.X.sort_values(ascending=False).values dataframe.head() # Две строки, два столбца. Текущая ячейка - 2 pylab.subplot (1, 2, 2) pylab.plot (dataframe['X_по_возрастанию'], label="X по возрастанию") pylab.plot (dataframe['X_по_убыванию'], label="X по убыванию") pylab.title ("Два линейных графика") # Покажем окно с нарисованным графиком pylab.show() 

Отслеживать
ответ дан 2 мая 2021 в 11:38
73.1k 107 107 золотых знаков 38 38 серебряных знаков 55 55 бронзовых знаков

Ответ @S.Nick в целом верен, но у него есть один большой недостаток: в нём используется matplotlib.pylab . Разработчики matplotlib рекомендуют пользоваться pyplot .

pylab был разработан для упрощения жизни тем людям, кто переходит в Python из MATLAB. Этот пакет импортирует в глобальное пространство имён все рисовальные функции pyplot И вычислительные функции numpy , благодаря чему пайтоновский скрипт становится похожим на матлабовский. Типа такого:

from pylab import * x = linspace(-3, 3, 30) y = x**2 plot(x, y) show() 

Вызовы pylab.subplot работают, но несколько бессмысленны, так как это прямые синонимы функций из pyplot . В ответе S.Nick вы можете заменить все обращения к pylab.subplot на вызов оригинала pyplot.subplot :

import random import matplotlib.pyplot as plt import numpy as np import pandas as pd plt.style.use('ggplot') mn, mx, N = -10000, 10000, 1000 dataset = pd.Series(data=[random.randint(mn, mx) for _ in range(1000)], name='X') print("Характеристики полученных целочисленных данных :\n") print(f"Минимальное значение : ") print(f"Количество повторяющихся значений : ") print(f"Максимальное значение : ") print(f"Сумма чисел : ") # Две строки, два столбца. Текущая ячейка - 1 plt.subplot (2, 2, 1) plt.plot(list(range(1000)), dataset, alpha=0.8) plt.title ("Линейный график") # Две строки, два столбца. Текущая ячейка - 3 plt.subplot (2, 2, 3) plt.hist(dataset, alpha=0.8) #plot (xlist, ylist) plt.title ("Гистограмма значений") dataframe = pd.DataFrame(dataset) dataframe['X_по_возрастанию'] = dataframe.X.sort_values().values dataframe['X_по_убыванию'] = dataframe.X.sort_values(ascending=False).values dataframe.head() # Две строки, два столбца. Текущая ячейка - 2 plt.subplot (1, 2, 2) plt.plot (dataframe['X_по_возрастанию'], label="X по возрастанию") plt.plot (dataframe['X_по_убыванию'], label="X по убыванию") plt.title ("Два линейных графика") plt.show() 

Визуализация данных с matplotlib

Библиотека matplotlib содержит большой набор инструментов для двумерной графики. Она проста в использовании и позволяет получать графики высокого качества. В этом разделе мы рассмотрим наиболее распространенные типы диаграмм и различные настройки их отображения.

Модуль matplotlib.pyplot предоставляет процедурный интерфейс к (объектно-ориентированной) библиотеке matplotlib, который во многом копирует инструменты пакета MATLAB. Инструменты модуля pyplot де-факто являются стандартным способом работы с библиотекой matplotlib , поэтому мы органичимся рассмотрением этого пакета.

Двумерные графики

pyplot.plot

Нарисовать графики функций sin и cos с matplotlib.pyplot можно следующим образом:

import numpy as np import matplotlib.pyplot as plt phi = np.linspace(0, 2.*np.pi, 100) plt.plot(phi, np.sin(phi)) plt.plot(phi, np.cos(phi)) plt.show() 

В результате получаем

Мы использовали функцию plot, которой передали два параметра — списки значений по горизонтальной и вертикальной осям. При последовательных вызовах функции plot графики строятся в одних осях, при этом происходит автоматическое переключение цвета.

fmt = '[marker][line][color]' 

функции plot позволяет задавать тип маркера, тип линии и цвет. Приведем несколько примеров:

x = np.linspace(0, 1, 100) f1 = 0.25 - (x - 0.5)**2 f2 = x**3 plt.plot(x, f1, ':b') # пунктирная синяя линия plt.plot(x, f2, '--r') # штрихованная красная линия plt.plot(x, f1+f2, 'k') # черная непрерывная линия plt.show() 

rg = np.random.Generator(np.random.PCG64()) plt.plot(rg.binomial(10, 0.3, 6), 'ob') # синие круги plt.plot(rg.poisson(7, 6), 'vr') # красные треугольники plt.plot(rg.integers(0, 10, 6), 'Dk') # черные ромбы plt.show() 

Из последнего примера видно, что если в функцию plot передать только один список y , то он будет использован для значений по вертикальной оси. В качестве значений по горизонтальной оси будет использован range(len(y)) .

Более тонкую настройку параметров можно выполнить, передавая различные именованные аргументы, например:

• marker : str — тип маркера
• markersize : float — размер маркера
• linestyle : str — тип линии
• linewidth : float — толщина линии
• color : str — цвет

Полный список доступных параметров можно найти в документации.

pyplot.errorbar

Результаты измерений в физике чаще всего представлены в виде величин с ошибками. Функция plt.errorbar позволяет отображать такие данные:

rg = np.random.Generator(np.random.PCG64(5)) x = np.arange(6) y = rg.poisson(149, x.size) plt.errorbar(x, y, yerr=np.sqrt(y), marker='o', linestyle='none') plt.show() 

Ошибки можно задавать и для значений по горизонтальной оси:

rg = np.random.Generator(np.random.PCG64(5)) N = 6 x = rg.poisson(169, N) y = rg.poisson(149, N) plt.errorbar(x, y, xerr=np.sqrt(x), yerr=np.sqrt(y), marker='o', linestyle='none') plt.show() 

Ошибки измерений могут быть асимметричными. Для их отображения в качестве параметра yerr (или xerr ) необходимо передать кортеж из двух списков:

rg = np.random.Generator(np.random.PCG64(11)) N = 6 x = np.arange(N) y = rg.poisson(149, N) yerr = [ 0.7*np.sqrt(y), 1.2*np.sqrt(y) ] plt.errorbar(x, y, yerr=yerr, marker='o', linestyle='none') plt.show() 

Функция pyplot.errorbar поддерживает настройку отображения графика с помощью параметра fmt и всех именованных параметров, которые доступны в функции pyplot . Кроме того, здесь появляются параметры для настройки отображения линий ошибок (“усов”):

• ecolor : str — цвет линий ошибок
• elinewidth : float — ширина линий ошибок
• capsize : float — длина “колпачков” на концах линий ошибок
• capthick : float — толщина “колпачков” на концах линий ошибок

и некоторые другие. Изменим параметры отрисовки данных из предыдущего примера:

# . plt.errorbar(x, y, yerr=yerr, marker='o', linestyle='none', ecolor='k', elinewidth=0.8, capsize=4, capthick=1) plt.show() 

Настройки отображения

Наши графики все еще выглядят довольно наивно. В этой части мы рассмотрим различные настройки, которые позволят достичь качества оформления диаграмм, соответствующего, например, публикациям в рецензируемых журналах.

Диапазон значений осей

Задавать диапазон значений осей в matplotlib можно несколькими способами. Например, так:

pyplot.xlim([0, 200]) # диапазон горизонтальной оси от 0 до 200 pyplot.xlim([0, 1]) # диапазон вертикальной оси от 0 до 1 

Размер шрифта

Размер и другие свойства шрифта, который используется в matplotlib по умолчанию, можно изменить с помощью объекта matplotlib.rcParams :

matplotlib.rcParams.update('font.size': 14>) 

Объект matplotlib.rcParams хранит множество настроек, изменяя которые, можно управлять поведением по умолчанию. Смотрите подробнее в документации.

Подписи осей

Подписи к осям задаются следующим образом:

plt.xlabel('run number', fontsize=16) plt.ylabel(r'average current ($\mu A$)', fontsize=16) 

В подписях к осям (и вообще в любом тексте в matplotlib) можно использовать инструменты текстовой разметки TeX, позволяющие отрисовывать различные математические выражения. TeX-выражения должны быть внутри пары символов $ , кроме того, их следует помещать в r-строки, чтобы избежать неправильной обработки.

Заголовок

Функция pyplot.title задает заголовок диаграммы. Применим наши новые знания:

import numpy as np import matplotlib.pyplot as plt import matplotlib # задаем размер шрифта matplotlib.rcParams.update('font.size': 12>) rg = np.random.Generator(np.random.PCG64(11)) x = np.arange(6) y = rg.poisson(149, x.size) yerr = [ 0.7*np.sqrt(y), 1.2*np.sqrt(y) ] plt.errorbar(x, y, yerr=yerr, marker='o', linestyle='none', ecolor='k', elinewidth=0.8, capsize=4, capthick=1) # добавляем подписи к осям и заголовок диаграммы plt.xlabel('run number', fontsize=16) plt.ylabel(r'average current ($\mu A$)', fontsize=16) plt.title(r'The $\alpha^\prime$ experiment. Season 2020-2021') # задаем диапазон значений оси y plt.ylim([0, 200]) # оптимизируем поля и расположение объектов plt.tight_layout() plt.show() 

В этом примере мы использовали функцию pyplot.tight_layout, которая автоматически подбирает параметры отображения так, чтобы различные элементы не пересекались.

Легенда

При построении нескольких графиков в одних осях полезно добавлять легенду — пояснения к каждой линии. Следующий пример показывает, как это делается с помощью аргументов label и функции pyplot.legend :

import numpy as np import matplotlib.pyplot as plt import matplotlib matplotlib.rcParams.update('font.size': 12>) x = np.linspace(0, 1, 100) f1 = 0.25 - (x - 0.5)**2 f2 = x**3 # указываем в аргументе label содержание легенды plt.plot(x, f1, ':b', label='1st component') plt.plot(x, f2, '--r', label='2nd component') plt.plot(x, f1+f2, 'k', label='total') plt.xlabel(r'$x$', fontsize=16) plt.ylabel(r'$f(x)$', fontsize=16) plt.xlim([0, 1]) plt.ylim([0, 1]) # выводим легенду plt.legend(fontsize=14) plt.tight_layout() plt.show() 

Функция pyplot.legend старается расположить легенду так, чтобы она не пересекала графики. Аргумент loc позволяет задать расположение легенды вручную. В большинстве случаев расположение по умолчанию получается удачным. Детали и описание других аргументов смотрите в документации.

Сетка

Сетка во многих случаях облегчает анализ графиков. Включить отображение сетки можно с помощью функции pyplot.grid . Аргумент axis этой функции имеет три возможных значения: x , y и both и определяет оси, вдоль которых будут проведены линии сетки. Управлять свойствами линии сетки можно с помощью именованных аргументов, которые мы рассматривали выше при обсуждении функции pyplot.plot .

В matplotlib поддерживается два типа сеток: основная и дополнительная. Выбор типа сетки выполняется с помощью аргумента which , который может принимать три значения: major , minor и both . По умолчанию используется основная сетка.

Линии сетки привязаны к отметкам на осях. Чтобы работать с дополнительной сеткой необходимо сначала включить вспомогательные отметки на осях (которые по умолчанию отключены и к которым привязаны линии дополнительной сетки) с помощью функции pyplot.minorticks_on . Приведем пример:

import numpy as np import matplotlib.pyplot as plt import matplotlib matplotlib.rcParams.update('font.size': 12>) x = np.linspace(-1, 1, 250) plt.plot(x, x, label=r'$x$') plt.plot(x, x**2, label=r'$x^2$') plt.plot(x, x**3, label=r'$x^3$') plt.plot(x, np.cbrt(x), label=r'$x^$') plt.legend(fontsize=16) # включаем дополнительные отметки на осях plt.minorticks_on() plt.xlabel(r'$x$', fontsize=16) plt.xlim([-1., 1.]) plt.ylim([-1., 1.]) # включаем основную сетку plt.grid(which='major') # включаем дополнительную сетку plt.grid(which='minor', linestyle=':') plt.tight_layout() plt.show() 

Логарифмический масштаб

Функции pyplot.semilogy и pyplot.semilogx выполняют переключение между линейным и логарифмическим масштабами осей. В некоторых случаях логарифмический масштаб позволяет отобразить особенности зависимостей, которые не видны в линейном масштабе. Вот так выглядят графики экспоненциальных функций в линейном масштабе:

plt.semilogy() 

делает график гораздо более информативным:

Теперь мы видим поведение функций во всем динамическом диапазоне, занимающем 12 порядков.

Произвольные отметки на осях

Вернемся к первому примеру, в котором мы строили графики синуса и косинуса. Сделаем так, чтобы на горизонтальной оси отметки соответствовали различным долям числа pi и имели соответствующие подписи:

Метки на горизонтальной оси были заданы с помощью функции pyplot.xticks :

plt.xticks( np.linspace(-np.pi, np.pi, 9), [r'$-\pi$', r'$-3\pi/4$', r'$-\pi/2$', r'$-\pi/4$', r'$0$', r'$\pi/4$', r'$+\pi/2$', r'$3\pi/4$', r'$+\pi$']) 

Модуль pyplot.ticker содержит более продвинутые инструменты для управления отметками на осях. Подробности смотрите в документации.

Размер изображения

До сих пор мы строили графики в одном окне, размер которого был задан по умолчанию. За кадром matplotlib создавал объект типа Figure, который определяет размер окна и содержит все остальные элементы. Кроме того, автоматически создавался объект типа Axis. Подробнее работа с этими объектами будет рассмотрена ниже. Сейчас же мы рассмотрим функцию pyplot.figure , которая позволяет создавать новые объекты типа Figure и переключаться между уже созданными объектами.

Функция pyplot.figure может принимать множество аргументов. Вот основные:

• num : int или str — уникальный идентификатор объекта типа. Если задан новый идентификатор, то создается новый объект и он становится активным. В случае, если передан идентификатор уже существующего объекта, то этот объект возвращается и становится активным
• figsize : (float, float) — размер изображения в дюймах
• dpi : float — разрешение в количестве точек на дюйм

Описание других параметров функции pyplot.figure можно найти в документации. Используем эту функцию и функцию pyplot.axis чтобы улучшить наш пример с построением степенных функций:

Мы добавили две строки по сравнению с прошлой версией:

fig = plt.figure(figsize=(6, 6)) # . plt.axis('equal') 

Функция pyplot.axis позволяет задавать некоторые свойства осей. Ее вызов с параметром ‘equal’ делает одинаковыми масштабы вертикальной и горизонтальной осей, что кажется хорошей идеей в этом примере. Функция pyplot.axis возвращает кортеж из четырех значений xmin, xmax, ymin, ymax , соответствующих границам диапазонов значений осей.

Некоторые другие способы использования функции pyplot.axis :

• Кортеж из четырех float задаст новые границы диапазонов значений осей
• Строка ‘off’ выключит отображение линий и меток осей

Гистограммы

Обратимся теперь к другим типам диаграмм. Функция pyplot.hist строит гистограмму по набору значений:

import numpy as np import matplotlib.pyplot as plt rg = np.random.Generator(np.random.PCG64(5)) data = rg.poisson(145, 10000) plt.hist(data, bins=40) # для краткости мы опускаем код для настройки осей, сетки и т.д. 

Аргумент bins задает количество бинов гистограммы. По умолчанию используется значение 10. Если вместо целого числа в аргумент bins передать кортеж значений, то они будут использованы для задания границ бинов. Таким образом можно построить гистограмму с произвольным разбиением.

Некоторые другие аргументы функции pyplot.hist :

• range : (float, float) — диапазон значений, в котором строится гистограмма. Значения за пределами заданного диапазона игнорируются.
• density : bool . При значении True будет построена гистограмма, соответствующая плотности вероятности, так что площадь гистограммы будет равна единице.
• weights : список float значений того же размера, что и набор данных. Определяет вес каждого значения при построении гистограммы.
• histtype : str . может принимать значения . Определяет тип отрисовки гистограммы.

В качестве первого аргумента можно передать кортеж наборов значений. Для каждого из них будет построена гистограмма. Аргумент stacked со значением True позволяет строить сумму гистограмм для кортежа наборов. Покажем несколько примеров:

rg = np.random.Generator(np.random.PCG64(5)) data1 = rg.poisson(145, 10000) data2 = rg.poisson(140, 2000) # левая гистограмма plt.hist([data1, data2], bins=40) # центральная гистограмма plt.hist([data1, data2], bins=40, histtype='step') # правая гистограмма plt.hist([data1, data2], bins=40, stacked=True) 

В физике гистограммы часто представляют в виде набора значений с ошибками, предполагая при этом, что количество событий в каждом бине является случайной величиной, подчиняющейся биномиальному распределению. В пределе больших значений флуктуации количества событий в бине могут быть описаны распределением Пуассона, так что характерная величина флуктуации определяется корнем из числа событий. Библиотека matplotlib не имеет инструмента для такого представления данных, однако его легко получить с помощью комбинации numpy.histogram и pyplot.errorbar :

def poisson_hist(data, bins=60, lims=None): """ Гистограмма в виде набора значений с ошибками """ hist, bins = np.histogram(data, bins=bins, range=lims) bins = 0.5 * (bins[1:] + bins[:-1]) return (bins, hist, np.sqrt(hist)) rg = np.random.Generator(np.random.PCG64(5)) data = rg.poisson(145, 10000) x, y, yerr = poisson_hist(data, bins=40, lims=(100, 190)) plt.errorbar(x, y, yerr=yerr, marker='o', markersize=4, linestyle='none', ecolor='k', elinewidth=0.8, capsize=3, capthick=1) 

Диаграммы рассеяния

Распределение событий по двум измерениям удобно визуализировать с помощью диаграммы рассеяния:

rg = np.random.Generator(np.random.PCG64(5)) means = (0.5, 0.9) covar = [ [1., 0.6], [0.6, 1.] ] data = rg.multivariate_normal(means, covar, 5000) plt.scatter(data[:,0], data[:,1], marker='o', s=1) 

Каждой паре значений в наборе данных соответствует одна точка на диаграмме. Несмотря на свою простоту, диаграмма рассеяния позволяет во многих случаях наглядно представлять двумерные данные. Функция pyplot.scatter позволяет визуализировать и данные более высокой размерности: размер и цвет маркера могут быть заданы для каждой точки отдельно:

rg = np.random.Generator(np.random.PCG64(4)) data = rg.uniform(-1, 1, (50, 2)) col = np.arctan2(data[:, 1], data[:, 0]) size = 100*np.sum(data**2, axis=1) plt.scatter(data[:,0], data[:,1], marker='o', s=size, c=col) 

Цветовую палитру можно задать с помощью аргумента cmap . Подробности и описание других аргументов функции pyplot.scatter можно найти в документации.

Контурные диаграммы

Контурные диаграммы позволяют визуализировать функции двух переменных:

from scipy import stats means = (0.5, 0.9) covar = [ [1., 0.6], [0.6, 1.] ] mvn = stats.multivariate_normal(means, covar) x, y = np.meshgrid( np.linspace(-3, 3, 80), np.linspace(-2, 4, 80) ) data = np.dstack((x, y)) # левая диаграмма — без заливки цветом plt.contour(x, y, mvn.pdf(data), levels=10) # правая диаграмма — с заливкой цветом plt.contourf(x, y, mvn.pdf(data), levels=10) 

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

Обратите внимание на использование функций numpy.meshgrid и numpy.dstack в этом примере.

Контурную диаграмму можно дополнить цветовой полосой colorbar , вызвав функцию pyplot.colorbar :

cs = plt.contourf(x, y, mvn.pdf(data), levels=15, cmap=matplotlib.cm.magma_r) cbar = plt.colorbar(cs) 

Более подробное описание функций plt.contour и plt.contourf смотрите в документации.

Расположение нескольких осей в одном окне

В одном окне (объекте Figure ) можно разместить несколько осей (объектов axis.Axis ). Функция pyplot.subplots создает объект Figure , содержащий регулярную сетку объектов axis.Axis :

import numpy as np from scipy import stats import matplotlib.pyplot as plt fig, axes = plt.subplots(ncols=3, nrows=2, figsize=(12, 8)) x = np.linspace(0.01, 25, 250) for idx, row in enumerate(axes): for jdx, ax in enumerate(row): ndf = idx * 3 + jdx + 1 y = stats.chi2.pdf(x, ndf) ax.plot(x, y, label=fr'$\chi^2_ndf>>>(x)$') ax.set_xlabel(r'$x$', fontsize=16) ax.set_ylim([0, 1.05*y.max()]) ax.minorticks_on() ax.legend(fontsize=16) ax.grid(which='major') ax.grid(which='minor', linestyle=':') fig.tight_layout() plt.show() 

Количество строк и столбцов, по которым располагаются различные оси, задаются с помощью параметров nrows и ncols , соответственно. Функция pyplot.subplots возвращает объект Figure и двумерный список осей axis.Axis . Обратите внимание на то, что вместо вызовов функций модуля pyplot в этом примере использовались вызовы методов классов Figure и axis.Axis .

В последнем примере горизонтальная ось во всех графиках имеет один и тот же диапазон. Аргумент sharex функции pyplot.subplots позволяет убрать дублирование отрисовки осей в таких случаях:

fig, axes = plt.subplots(ncols=3, nrows=2, figsize=(12, 8), sharex=True) # . for idx, row in enumerate(axes): for jdx, ax in enumerate(row): # . if idx: ax.set_xlabel(r'$x$', fontsize=16) 

Существует аналогичный параметр sharey для вертикальной оси.

Более гибкие возможности регулярного расположения осей предоставляет функция pyplot.subplot. Мы не будем рассматривать эту функцию и ограничимся лишь ее упоминанием.

Функция pyplot.axes позволяет добавлять новые оси в текущем окне в произвольном месте:

import numpy as np import matplotlib.pyplot as plt exno = 26 rg = np.random.Generator(np.random.PCG64(5)) x1 = rg.exponential(10, 5000) x2 = rg.normal(10, 0.1, 100) # Строим основную гистограмму plt.hist([x1, x2], bins=150, range=(0, 60), stacked=True) plt.minorticks_on() plt.xlim((0, 60)) plt.grid(which='major') plt.grid(which='minor', linestyle=':') # Строим вторую гистограмму в отдельных осях plt.axes([.5, .5, .4, .4]) plt.hist([x1, x2], bins=100, stacked=True, range=(9, 11)) plt.grid(which='major') plt.tight_layout() # сохраняем диаграмму в файл plt.savefig('histograms.png') plt.show() 

В этом примере была использована функция pyplot.savefig , сохраняющая содержимое текущего окна в файл в векторном или растровом формате. Формат задается с помощью аргумента format или автоматически определяется из имени файла (как в примере выше). Набор доступных форматов зависит от окружения, однако в большинстве случаев можно использовать такие форматы как png , jpeg , pdf , svg и eps .

Резюме

Предметом изучения в этом разделе был модуль pyplot библиотеки matplotlib , содержащий инструменты для построения различных диаграмм. Были рассмотрены:

• функции для построения диаграмм pyplot.plot , pyplot.errorbar . pyplot.hist , pyplot.scatter , pyplot.contour и pyplot.contourf ;
• средства настройки свойств линий и маркеров;
• средства настройки координатных осей: подписи, размер шрифта, координатная сетка, произвольные метки др.;
• инструмены для расположения нескольких координатных осей в одном окне.

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

Источники

• matplotlib.pyplot
• Pyplot tutorial
• Colormaps
• Scipy Lecture Notes

Отображение нескольких координатных осей в одном окне

Частой задачей является отображение нескольких координатных осей (Axes) в одном окне (Figure). В самом простом варианте это можно сделать с помощью функции subplot, которая имеет следующий синтаксис:

subplot(nrows, ncols, index)

где nrows, ncols – число строк и столбцов; index – индекс текущих координатных осей. Например, мы можем разбить все пространство окна на одну строку и три столбца, получим 1 x 3 = 3 поля для отображения графиков:

import numpy as np import matplotlib.pyplot as plt plt.subplot(1, 3, 1) plt.plot(np.random.random(10)) plt.subplot(1, 3, 2) plt.plot(np.random.random(10)) plt.subplot(1, 3, 3) plt.plot(np.random.random(10)) plt.grid() plt.show()

Обратите внимание, что сетка отобразилась только для последнего графика. Почему так произошло? Дело в том, что функция grid() сработала для активного объекта Axes. А это был, как раз, третий график. Соответственно, если мы хотим установить сетку для всех осей, то, конечно, можно прописать grid() после каждого вызова функции subplot():

plt.subplot(1, 3, 1) plt.grid() plt.plot(np.random.random(10)) plt.subplot(1, 3, 2) plt.grid() plt.plot(np.random.random(10)) plt.subplot(1, 3, 3) plt.plot(np.random.random(10)) plt.grid() plt.show()

Но можно применить более гибкий способ, сохраняя ссылки на каждую из осей в отдельной переменной:

ax1 = plt.subplot(1, 3, 1) plt.plot(np.random.random(10)) ax2 = plt.subplot(1, 3, 2) plt.plot(np.random.random(10)) ax3 = plt.subplot(1, 3, 3) plt.plot(np.random.random(10))

А уже потом, через эти переменные настраивать вид осей:

ax1.grid() ax2.grid() ax3.grid()

То есть, каждый вызов функции subplot() возвращает ссылку на создаваемый объект Axes. Причем, он создается именно в этот момент и не раньше. Например, если не создавать оси с индексом 2, то в окне будут только два графика:

Или, можно сделать так. Разбить все окно на сетку 2 x 3 и во второй строке разместить один общий график:

Работает это так. Разбиение subplot(2, 3, x) дает две строки и три столбца. Соответственно, в первой строке мы размещаем три графика. Далее, выбираем разбиение тоже в две строки, но один столбец – subplot(2, 1, x). Это позволяет нам сформировать единый график во второй строке, указывая индекс 2:

ax1 = plt.subplot(2, 3, 1) plt.plot(np.random.random(10)) ax2 = plt.subplot(2, 3, 2) plt.plot(np.random.random(10)) ax3 = plt.subplot(2, 3, 3) plt.plot(np.random.random(10)) ax4 = plt.subplot(2, 1, 2) plt.plot(np.random.random(10))

Вот так гибко можно оперировать расположениями полей для графиков. Причем, если число:

то вместо трех чисел можно указывать одно трехзначное число:

ax1 = plt.subplot(131) plt.plot(np.random.random(10)) ax2 = plt.subplot(132) plt.plot(np.random.random(10)) ax3 = plt.subplot(133) plt.plot(np.random.random(10))

Функция subplots()

Однако, с помощью функции subplot() не очень удобно оперировать большим числом координатных осей в пределах одной формы. Для этого лучше подходит другая похожая функция:

которая на выходе дает ссылку на фигуру и список координатных осей:

f, ax = plt.subplots(2, 2) plt.show()

Причем, оси здесь создаются сразу в отличие от функции subplot(). Далее, мы можем взять любой объект Axes, чтобы работать с нужным нам полем, например, так:

ax[0, 0].plot(np.arange(0, 5, 0.2)) ax[0, 0].grid() ax[0, 1].plot(np.arange(5, 0, -0.2)) ax[0, 1].grid()

Здесь мы отображаем два линейных графика и показываем сетку в первых двух координатных осях.

Объект Figure

Мало того, используя ссылку на объект Figure, можно устанавливать те или иные свойства для всего окна:

f.set_size_inches(7, 4) # размер 7 x 4 дюймов f.set_facecolor('#eee') # цвет фона (светло-серый)

Полный список методов для работы с окном можно посмотреть на странице официальной документации:

Объект Figure можно создавать и независимо с помощью класса Figure, например, так:

fig = plt.figure(figsize=(7, 4))

В результате, у нас появятся два окна для отображения графиков. Это произошло по той причине, что функция subplots() автоматически создает новое окно. Если нам нужно на ранее созданной фигуре отображать графики, то мы должны сразу после создания записать функцию plot():

fig = plt.figure(figsize=(7, 4)) plt.plot(np.arange(0, 5, 0.2))

Либо, отдельно создать координатную ось и, затем, в ней отображать графики:

ax1 = fig.add_axes([0.0, 0, 1.0, 1.0]) ax1.plot(np.arange(0, 5, 0.2))

Здесь список параметров в методе add_axes() следует интерпретировать как:

[pos_x, pos_y, width, height]

Причем, все значения определяются в интервале [0; 1] и, фактически определяют долю от ширины или высоты окна. В данном случае оси занимают все пространство окна. То есть, с помощью метода add_axes() можно располагать координатные оси совершенно произвольным образом.

Другой способ добавления осей в фигуру – метод add_subplot():

fig = plt.figure(figsize=(7, 4)) ax1 = fig.add_subplot(1, 3, 1) ax1.plot(np.arange(0, 5, 0.2))

Здесь все работает также как и с функцией subplot(), о которой мы только что говорили.

Если же нам нужно просто создать окно с одной или несколькими осями, то обычно, для этого используют уже рассмотренный нами метод:

f, ax = plt.subplots()

не указывая параметры. Тогда будет создана фигура с одной координатной осью.

Компоновка графиков с помощью GridSpec

Рассмотренные ранее подходы к компоновке графиков хороши при размещении графиков в ячейках регулярной сетки. Для более сложных элементов компоновки хорошо подходит класс GridSpec из ветки:

То есть, вначале его нужно импортировать, например, так:

from matplotlib.gridspec import GridSpec

Далее, с его помощью мы также разбиваем все пространство фигуры на строки и столбцы:

fig = plt.figure(figsize=(7, 4)) gs = GridSpec(ncols=3, nrows=2, figure=fig)

И, затем, используя синтаксис срезов пакета numpy, можно формировать координатные оси, охватывающие произвольное число ячеек:

Как видите, все предельно просто. На уровне программы все выглядит так:

ax1 = plt.subplot(gs[0, 0]) ax1.plot(np.arange(0, 5, 0.2)) ax2 = fig.add_subplot(gs[1, 0:2]) ax2.plot(np.random.random(10)) ax3 = fig.add_subplot(gs[:, 2]) ax3.plot(np.random.random(10))

Причем, обратите внимание, первую ось я специально сформировал с помощью функции subplot(), а остальные две – с помощью метода add_subplot(). То есть, можно использовать любой способ формирования полей для вывода графиков.

Также можно задавать размеры каждого графика (относительно суммарной длины всех ячеек) в виде списков:

ws = [1, 2, 5] hs = [2, 0.5] gs = GridSpec(ncols=3, nrows=2, figure=fig, width_ratios=ws, height_ratios=hs)

Получим следующий результат:

Вот так, достаточно просто можно выполнять компоновку осей для отображения графиков в области окна.

Видео по теме

#1. Установка пакета и основные возможности

#2. Функция plot для построения и оформления двумерных графиков

#3. Отображение нескольких координатных осей в одном окне

#4. Граничные значения осей и локаторы для расположения меток на них

#5. Настраиваем формат отображения меток у координатных осей

#6. Делаем логарифмический масштаб у координатных осей

#7. Размещаем стандартные текстовые элементы на графике

#8. Добавляем легенду и рисуем геометрические фигуры на графиках

#9. Рисуем ступенчатые, стековые, stem и точечные графики

#10. Рисуем гистограммы, столбчатые и круговые диаграммы

#11. Показ изображений и цветовых сеток

#12. Как строить трехмерные графики

#13. Рисуем линии уровня функциями contour, contourf и tricontour, tricontourf

#14. Создаем анимацию графиков Классы FuncAnimation и ArtistAnimation

© 2023 Частичное или полное копирование информации с данного сайта для распространения на других ресурсах, в том числе и бумажных, строго запрещено. Все тексты и изображения являются собственностью сайта