Начало работы
Установка и первый график
Matplotlib — основа графиков в Python. pyplot — интерфейс на основе состояния (как MATLAB). В скрипте всегда вызывайте plt.show(), чтобы отрисовать фигуру; в Jupyter фигура отрисовыва ется автоматически при завершении ячейки.
# install
pip install matplotlib
import matplotlib.pyplot as plt
import numpy as np
# a simple line plot
x = np.linspace(0, 10, 100)
y = np.sin(x)
plt.plot(x, y)
plt.title("Sine Wave")
plt.xlabel("x")
plt.ylabel("sin(x)")
plt.show()Интерфейс pyplot
Интерфейс pyplot повторяет MATLAB: каждый вызов работает с «текущей» фигурой и осями, которые отслеживаются внутри. Он краток для быстрых графиков, но путается при множестве subplot. Используйте plt.gcf()/plt.gca(), чтобы получить текущие объекты фигуры и осей.
import matplotlib.pyplot as plt
# pyplot tracks the "current" figure and axes
plt.figure() # create a new figure
plt.plot([1, 2, 3], [4, 5, 2])
plt.title("State-based") # applies to the current axes
plt.xlim(0, 4)
plt.ylim(0, 6)
plt.show()
# plt.gcf() -> current figure, plt.gca() -> current axes
print(plt.gca())Figure и Axes (ОО-интерфейс)
Объектно-ориентированный (ОО) интерфейс рекомендуется для всего сложнее одного графика. Вы создаёте Figure (весь холст) и один или несколько Axes (отдельные графики) и вызываете их методы. Он чисто масштабируется на subplot, сдвоенные оси и сложные раскладки.
import matplotlib.pyplot as plt
import numpy as np
# object-oriented interface: explicit Figure and Axes objects
fig, ax = plt.subplots() # fig is the canvas, ax is a single Axes
x = np.linspace(0, 5, 50)
ax.plot(x, x**2, label="x^2")
ax.plot(x, x**3, label="x^3")
ax.set_title("OO Interface")
ax.set_xlabel("x")
ax.set_ylabel("y")
ax.legend()
plt.show()Частые импорты и соглашения
plt — почти универсальный псевдоним pyplot, np — NumPy: почти каждый учебник и библиотека этого ждут. rcParams — глобальный словарь конфигурации: задайте его один раз в начале скрипта, чтобы зафиксировать DPI, размер шрифта, размер фигуры и другие умолчания.
# the universal alias
import matplotlib.pyplot as plt
import numpy as np
# for the OO interface you often see
from matplotlib.figure import Figure
from matplotlib.axes import Axes
# set a global style once
plt.rcParams["figure.dpi"] = 100
plt.rcParams["font.size"] = 11
# inline backend in Jupyter (not needed in scripts)
# %matplotlib inlineБэкенды и plt.show()
Бэкенд отрисовывает фигуру: интерактивные (TkAgg, Qt5Agg) открывают окно, неинтерактивные (Agg) только пишут файлы. Вызывайте matplotlib.use() до импорта pyplot. plt.show() в скрипте блокирует до закрытия окон; в Jupyter %matplotlib inline встраивает фигуры в ноутбук.
import matplotlib
# list available backends
print(matplotlib.rcsetup.all_backends)
# force a backend (do this BEFORE importing pyplot)
# matplotlib.use("Agg") # non-interactive, for saving files
# matplotlib.use("TkAgg") # interactive Tk window
import matplotlib.pyplot as plt
plt.plot([1, 2, 3])
# plt.show() blocks until the window is closed
plt.savefig("out.png") # saving works without any GUI backendЛинейные графики (plot)
Базовый линейный график
plt.plot(x, y) рисует линию, соединяющую точки (x, y) по порядку. Если передать один массив, он используется как y, а x по умолчанию 0..N-1. plt.grid(True) включает сетку. Точки соединяются в порядке массива, поэтому для плавной кривой сначала отсортируйте x.
import matplotlib.pyplot as plt
import numpy as np
x = np.arange(0, 10, 0.5)
y = x * 2
plt.plot(x, y)
plt.title("y = 2x")
plt.xlabel("x")
plt.ylabel("y")
plt.grid(True)
plt.show()Несколько линий
Каждый вызов plt.plot() добавляет новую линию на текущие оси и автоматически переходит к следующему цвету цикла. Передавайте label= каждой, чтобы plt.legend() мог их опознать. Matplotlib сам управляет пределами осей, расширяя их под наибольший диапазон.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 2 * np.pi, 100)
plt.plot(x, np.sin(x), label="sin")
plt.plot(x, np.cos(x), label="cos")
plt.plot(x, np.sin(x) + np.cos(x), label="sin+cos")
plt.legend()
plt.title("Trig Functions")
plt.show()Стили линий и маркеры
Строка формата 'цвет+маркер+стиль' (например, 'ro--') компактна, но загадочна. Для читаемости предпочитайте явные аргументы color=, marker=, linestyle=. Частые стили: '-' '--' ':' '-.'. Частые маркеры: 'o' 's' '^' 'D' 'v' '+' 'x'.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 5, 20)
# format string: [color][marker][linestyle]
plt.plot(x, x, "r-") # red solid line
plt.plot(x, x*2, "go--") # green circles, dashed
plt.plot(x, x*3, "bs:") # blue squares, dotted
plt.plot(x, x*4, "k^-.") # black triangles, dash-dot
# explicit kwargs (clearer, recommended)
plt.plot(x, x*5, color="purple", marker="D",
linestyle="-.", linewidth=2, markersize=6)Цвета
Matplotlib принимает много форматов цвета: имена ('red'), hex-строки ('#FF8800'), кортежи RGB(A), имена Tableau ('tab:blue'), ссылки на цикл ('C0'..'C9') и строки градаций серого ('0.5'). 'C0' берёт первый цвет текущего стиля, сохраняя согласованность с циклом.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 1, 30)
plt.plot(x, x, color="red") # named color
plt.plot(x, x+0.2, color="#FF8800") # hex RGB
plt.plot(x, x+0.4, color=(0.1, 0.8, 0.2))# RGB tuple 0-1
plt.plot(x, x+0.6, color="C0") # cycle color 0
plt.plot(x, x+0.8, color="tab:purple") # Tableau palette
# gray shorthand: a string of float in [0,1]
plt.plot(x, x+1.0, color="0.5") # mid gray
plt.show()Толщина линии, alpha и zorder
linewidth задаёт толщину штриха (по умолчанию 1.5). alpha задаё т прозрачность и необходима при перекрытии кривых, чтобы видеть, что под ними. zorder управляет наложением: большие значения рисуются позже (сверху). По умолчанию zorder 2 у линий и 1 у патчей.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 10, 100)
# alpha = transparency (0 invisible, 1 opaque)
# zorder = draw order; higher draws on top
plt.fill_between(x, np.sin(x), alpha=0.3, zorder=1)
plt.plot(x, np.sin(x), linewidth=2, zorder=2)
plt.plot(x, np.cos(x), linewidth=4, alpha=0.7, zorder=3)
plt.show()Ступенчатые графики
plt.step() рисует ступенчатые функции для цифровых сигналов и дискретных данных; where задаёт место подъёма ступени ('pre', 'post', 'mid'). plt.stairs() (3.4+) — современный эквивалент, принимающий значения y и отдельные границы бинов; хорошо сочетается с гистограммными данными.
import matplotlib.pyplot as plt
import numpy as np
x = np.arange(5)
y = [1, 3, 2, 4, 3]
# step: like plot but with horizontal/vertical steps
plt.step(x, y, where="post", label="post")
plt.step(x, y + 1, where="mid", label="mid")
plt.step(x, y + 2, where="pre", label="pre")
plt.legend(title="where=")
# stairs (matplotlib 3.4+): step from explicit bin edges
plt.stairs([1, 2, 1], baseline=0)
plt.show()Точечные графики
Базовый scatter
plt.scatter(x, y) рисует точки без соединяющих линий. Он медленнее plt.plot(x, y, 'o') на десятках тысяч точек, потому что позволяет задавать размер и цвет каждой точке. Для максимальной скорости при одинаковом стиле используйте plt.plot с маркером.
import matplotlib.pyplot as plt
import numpy as np
rng = np.random.default_rng(0)
x = rng.random(50)
y = rng.random(50)
plt.scatter(x, y)
plt.title("Basic Scatter")
plt.xlabel("x")
plt.ylabel("y")
plt.axis("equal") # equal aspect ratio
plt.show()Размер и цвет маркера
Аргумент s — ПЛОЩАДЬ маркера в пунктах в квадрате (не радиус), поэтому s в 4 раза больше даёт лишь вдвое больший радиус. Аргумент c (цвет) вместе с cmap отображает числовой массив на цветовую карту. При перекрытии точек ставьте alpha < 1, чтобы видеть плотность.
import matplotlib.pyplot as plt
import numpy as np
rng = np.random.default_rng(1)
n = 50
x = rng.random(n)
y = rng.random(n)
sizes = rng.random(n) * 500 # area in points^2
colors = rng.random(n) # mapped to colormap
plt.scatter(x, y, s=sizes, c=colors, cmap="viridis", alpha=0.6)
plt.colorbar(label="value")
plt.title("Bubble Chart")
plt.show()Scatter с цветовой картой
Передача одномерного массива в c отображает каждую точку на цветовую карту; plt.colorbar(sc) добавляет шкалу (передавайте возвращённый объект scatter, чтобы шкала знала о сопоставлении). vmin/vmax фиксируют диапазон карты; без них matplotlib масштабирует по min/max данных.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 10, 200)
y = np.sin(x)
c = x # color by x value
sc = plt.scatter(x, y, c=c, cmap="plasma", vmin=0, vmax=10)
cb = plt.colorbar(sc)
cb.set_label("x position")
plt.title("Colored by x")
plt.show()Прозрачность и перерисовка
При множестве перекрывающихся точек сплошной scatter скрывает плотность. Опустите alpha до ~0.05 и уменьшите маркер, чтобы раскрыть структуру. Для очень больших данных (100k+ точек) plt.hexbin или plt.hist2d агрегируют в бины и работают быстрее и нагляднее сырого scatter.
import matplotlib.pyplot as plt
import numpy as np
rng = np.random.default_rng(2)
n = 5000
x = rng.normal(0, 1, n)
y = rng.normal(0, 1, n)
# dense scatter: low alpha reveals density
plt.scatter(x, y, s=5, alpha=0.05, c="navy")
plt.title("Density via alpha")
# alternative: hexbin for very large datasets
plt.figure()
plt.hexbin(x, y, gridsize=40, cmap="Blues")
plt.colorbar(label="count")
plt.show()Категориальный scatter
В Matplotlib нет встроенного strip plot, поэтому scatter с ручным джиттером по оси x — стандартный DIY-подход. Для публикационного качества категориальных графиков (box, violin, swarm) предпочитайте Seaborn: он построен на Matplotlib и интегрируется со стилями plt.
import matplotlib.pyplot as plt
import numpy as np
rng = np.random.default_rng(3)
groups = ["A", "B", "C"]
data = [rng.normal(0, 1, 30),
rng.normal(2, 1, 30),
rng.normal(1, 1.5, 30)]
for i, d in enumerate(data):
# add jitter on x so points do not stack on one line
jitter = rng.uniform(-0.1, 0.1, len(d))
plt.scatter(np.full(len(d), i) + jitter, d, label=groups[i])
plt.xticks(range(len(groups)), groups)
plt.legend()
plt.show()Столбчатые диаграммы
Вертикальные столбцы
plt.bar(x, height) рисует вертикальные столбцы; x может быть строками (категории). Возвращённый BarContainer позволяет аннотировать или перекрашивать отдельные столбцы. Цикл с plt.text() подписывает каждый столбец: настройте ha/va ('center'/'bottom') и смещение по y, чтобы подписи стояли чуть выше столбца.
import matplotlib.pyplot as plt
categories = ["Apple", "Banana", "Cherry", "Date"]
values = [25, 40, 30, 15]
bars = plt.bar(categories, values, color="tab:blue", edgecolor="black")
# annotate each bar with its value
for bar, v in zip(bars, values):
plt.text(bar.get_x() + bar.get_width()/2, v + 1,
str(v), ha="center", va="bottom")
plt.title("Fruit Sales")
plt.ylabel("units sold")
plt.ylim(0, 50)
plt.show()Горизонтальные столбцы
plt.barh(y, width) рисует горизонтальные столбцы — идеально для длинных названий категорий, которые перекрывались бы на вертикальной диаграмме. Вызовите ax.invert_yaxis(), чтобы первый элемент был сверху, как люди читают списки. Ширина по умолчанию 0.8.
import matplotlib.pyplot as plt
items = ["Reading", "Coding", "Sleep", "Exercise"]
hours = [2, 6, 8, 1]
plt.barh(items, hours, color="tab:green")
plt.xlabel("hours per day")
plt.title("Daily Activities")
# invert so the first item appears at the top
plt.gca().invert_yaxis()
plt.show()Сгруппированные столбцы
Сгруппированные столбцы ставят две (или более) серии рядом, смещая позиции x на половину ширины. Паттерн x +/- w/2 при ширине w ставит их вплотную. Используйте np.arange для числовых позиций x, чтобы математика работала, затем переподпишите через plt.xticks.
import matplotlib.pyplot as plt
import numpy as np
labels = ["Q1", "Q2", "Q3", "Q4"]
a = [20, 35, 30, 35]
b = [25, 32, 34, 20]
x = np.arange(len(labels))
w = 0.35
plt.bar(x - w/2, a, w, label="2023")
plt.bar(x + w/2, b, w, label="2024")
plt.xticks(x, labels)
plt.ylabel("revenue")
plt.legend()
plt.show()Стековые столбцы
Стековые столбцы используют аргумент bottom=: каждая серия начинается там, где закончилась предыдущая. Для более двух серий аккумулируйте: bottom = [m+w for m, w in zip(men, women)]. Стеки показывают суммы и состав, но верхние серии труднее сравнивать между категориями.
import matplotlib.pyplot as plt
import numpy as np
labels = ["A", "B", "C"]
men = [20, 35, 30]
women = [25, 32, 34]
plt.bar(labels, men, label="Men")
plt.bar(labels, women, bottom=men, label="Women")
plt.legend()
plt.title("Stacked Bars")
plt.show()Столбцы с планками ошибок
Аргумент yerr добавляет вертикальные планки ошибок; capsize задаёт длину усов на концах. Передайте error_kw для стилизации планок. Для асимметричных ошибок передавайте yerr=[lower_errors, upper_errors]. Это работает и на barh (xerr), и на plt.errorbar.
import matplotlib.pyplot as plt
import numpy as np
labels = ["A", "B", "C"]
means = [20, 35, 30]
errors = [2, 4, 3]
plt.bar(labels, means, yerr=errors, capsize=6,
color="tab:orange", edgecolor="black",
error_kw={"ecolor": "black", "linewidth": 1.5})
plt.title("Bar with Error Bars")
plt.ylabel("mean value")
plt.show()Гистограммы
Базовая гистограмма
plt.hist(x) раскладывает данные по бинам и рисует столбцы. bins может быть числом (количество бинов) или последовательностью явных границ. По умолчанию возвращаются счётчики, поэтому ось Y — частота. Возвращается (counts, bin_edges, patches), что можно использовать для дальнейшей настройки.
import matplotlib.pyplot as plt
import numpy as np
rng = np.random.default_rng(0)
data = rng.normal(0, 1, 1000)
plt.hist(data, bins=30)
plt.title("Histogram")
plt.xlabel("value")
plt.ylabel("frequency")
plt.show()Выбор бинов
Выбор бинов радикально меняет вид гистограммы. 'auto' берёт максимум правил Стёрджеса и Фридмана-Диакониса — разумное умолчание. Передавайте явный массив границ для полного контроля и сопоставимых бинов между наборами. Мало бинов скрывает структуру, много — добавляет шум.
import matplotlib.pyplot as plt
import numpy as np
rng = np.random.default_rng(1)
data = rng.normal(0, 1, 1000)
# auto bin selection (Freedman-Diaconis, Sturges, etc.)
plt.hist(data, bins="auto", alpha=0.5, label="auto")
plt.hist(data, bins=10, alpha=0.5, label="10 bins")
plt.hist(data, bins=np.arange(-4, 4, 0.25),
alpha=0.5, label="0.25 width")
plt.legend()
plt.show()Несколько гистограмм
Перекрывающимся гистограммам нужен alpha < 1, чтобы видеть оба распределения; используйте разные цвета. Для более двух групп stacked=True избегает беспорядка, но усложняет сравнение. Рассмотрите kdeplot (Seaborn) для гладких кривых плотности, которые накладываются чище гистограмм.
import matplotlib.pyplot as plt
import numpy as np
rng = np.random.default_rng(2)
a = rng.normal(0, 1, 1000)
b = rng.normal(1, 1.2, 1000)
plt.hist(a, bins=30, alpha=0.6, label="A", color="tab:blue")
plt.hist(b, bins=30, alpha=0.6, label="B", color="tab:orange")
plt.legend()
plt.show()
# stacked alternative
plt.figure()
plt.hist([a, b], bins=30, stacked=True, label=["A", "B"])
plt.legend()
plt.show()Плотность и нормализация
density=True делит счётчики на (всего * ширина бина), так что площади столбцов суммируются в 1, давая плотность вероятности. Это делает гистограммы сопоставимыми при разных объёмах выборки и позволяет накладывать теоретическую плотность. weights= задаёт веса отдельных наблюдений.
import matplotlib.pyplot as plt
import numpy as np
rng = np.random.default_rng(3)
data = rng.normal(0, 1, 1000)
# density=True normalizes the area to 1 (PDF)
plt.hist(data, bins=30, density=True, alpha=0.6)
# overlay the theoretical PDF
from scipy.stats import norm
xs = np.linspace(-4, 4, 200)
plt.plot(xs, norm.pdf(xs), "r-", lw=2)
plt.title("Normalized Histogram + PDF")
plt.show()Двумерная гистограмма
plt.hist2d раскладывает две переменные в 2D-сетку и красит каждую ячейку по счётчику — дискретный родственник scatter для плотных данных. Для более гладкого результата используйте plt.hexbin (гексагональные бины). Оба принимают cmap и возвращают значения для colorbar.
import matplotlib.pyplot as plt
import numpy as np
rng = np.random.default_rng(4)
x = rng.normal(0, 1, 10000)
y = x + rng.normal(0, 1, 10000)
plt.hist2d(x, y, bins=40, cmap="Blues")
plt.colorbar(label="count")
plt.title("2D Histogram")
plt.xlabel("x")
plt.ylabel("y")
plt.show()Круговые диаграммы
Базовая круговая диаграмма
plt.pie(x, labels) рисует круг по значениям x. autopct форматирует проценты (строка в стиле printf или функция). startangle поворачивает начало первого сектора. Всегда вызывайте plt.axis('equal'), чтобы круг был настоящим кругом, а не эллипсом.
import matplotlib.pyplot as plt
labels = ["Rent", "Food", "Transport", "Fun"]
sizes = [1200, 600, 300, 400]
plt.pie(sizes, labels=labels, autopct="%1.1f%%", startangle=90)
plt.title("Monthly Budget")
plt.axis("equal") # circle, not ellipse
plt.show()Explode и тени
explode — кортеж той же длины, что sizes; каждое значение сдвигает сектор от центра (0 = без сдвига). shadow=True добавляет тень для глубины. Используйте explode редко, чтобы выделить один сектор: сдвиг каждого сектора выглядит загромождённо.
import matplotlib.pyplot as plt
labels = ["A", "B", "C", "D"]
sizes = [30, 25, 25, 20]
explode = (0, 0.1, 0, 0) # pull the 2nd wedge out
plt.pie(sizes, labels=labels, explode=explode,
shadow=True, autopct="%1.0f%%",
startangle=140)
plt.title("Exploded Pie")
plt.show()Кольцевая диаграмма
Коль цо — это круг с дырой: задайте wedgeprops={'width': 0.4}, чтобы рисовать кольца вместо полных секторов. В центре можно разместить сводную подпись через plt.text(0, 0, ...). Кольца обычно читаются легче кругов: длина кольца кодирует значение лучше угла сектора.
import matplotlib.pyplot as plt
labels = ["A", "B", "C"]
sizes = [40, 35, 25]
wedges, texts = plt.pie(sizes, labels=labels,
wedgeprops=dict(width=0.4, edgecolor="w"))
plt.title("Donut Chart")
# add center text
plt.text(0, 0, "Total\n100", ha="center", va="center", fontsize=14)
plt.show()Проценты и начальный угол
autopct может быть функцией, получающей процент и возвращающей строку, — так можно показать и процент, и абсолютное значение. startangle + counterclock=False управляют направлением (старт сверху, по часовой — обычный порядок чтения). pctdistance позиционирует подписи процентов.
import matplotlib.pyplot as plt
labels = ["North", "South", "East", "West"]
sizes = [32, 24, 28, 16]
colors = ["#4C72B0", "#DD8452", "#55A868", "#C44E52"]
plt.pie(sizes, labels=labels, colors=colors,
autopct=lambda p: f"{p:.1f}%\n({p*sum(sizes)/100:.0f})",
startangle=90, counterclock=False,
pctdistance=0.75)
plt.show()Вложенные круги (концентрические)
Два вызова plt.pie с разными radius и width создают концентрические кольца — простой sunburst. Внешнее кольцо обычно показывает категории верхнего уровня, внутреннее — их разбивку. Держите внутренний радиус меньше и добавляйте edgecolor='w', чтобы визуально разделить секторы.
import matplotlib.pyplot as plt
# outer ring: regions, inner ring: sub-categories
outer = [40, 30, 30]
inner = [20, 20, 15, 15, 25, 5]
outer_labels = ["A", "B", "C"]
inner_labels = ["A1", "A2", "B1", "B2", "C1", "C2"]
plt.pie(outer, labels=outer_labels, radius=1.0,
wedgeprops=dict(width=0.3, edgecolor="w"))
plt.pie(inner, labels=inner_labels, radius=0.7,
wedgeprops=dict(width=0.3, edgecolor="w"))
plt.title("Nested Pie")
plt.show()Subplot и раскладки
plt.subplot
plt.subplot(rows, cols, index) выбирает оси в сетке (индексация с 1) — устаревший MATLAB-стиль. Индекс идёт слева направо и сверху вниз. Он меняет «текущие оси», поэтому последующие вызовы plt рисуют там. Для нового кода предпочитайте plt.subplots(): чище и возвращает настоящие объекты Axes.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 5, 50)
# subplot(nrows, ncols, index) -- 1-indexed!
plt.subplot(2, 2, 1)
plt.plot(x, x)
plt.subplot(2, 2, 2)
plt.plot(x, x**2)
plt.subplot(2, 2, 3)
plt.plot(x, x**3)
plt.subplot(2, 2, 4)
plt.plot(x, np.sin(x))
plt.tight_layout()
plt.show()plt.subplots
plt.subplots(nrows, ncols) возвращает (fig, axes), где axes — массив NumPy объектов Axes: индексируйте как axes[row, col]. sharex/sharey выравнивают деления и экономят место. fig.suptitle() задаёт заголовок над всеми subplot. Всегда вызывайте plt.tight_layout(), чтобы подписи не перекрывались.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 2*np.pi, 100)
# one figure, 2x2 grid of Axes, shared x and y
fig, axes = plt.subplots(2, 2, figsize=(8, 6),
sharex=True, sharey=True)
axes[0, 0].plot(x, np.sin(x)); axes[0, 0].set_title("sin")
axes[0, 1].plot(x, np.cos(x)); axes[0, 1].set_title("cos")
axes[1, 0].plot(x, np.tan(x)); axes[1, 0].set_title("tan")
axes[1, 1].plot(x, -np.sin(x)); axes[1, 1].set_title("-sin")
fig.suptitle("Trig Family")
plt.tight_layout()
plt.show()GridSpec
GridSpec даёт полный контроль над размерами subplot: можно объединять ячейки срезами (gs[0, :] = вся строка, gs[1:, 2] = высокий правый столбец). width_ratios/height_ratios делают столбцы и строки неравными. Это стандартный инструмент для сложных дашбордов.
import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec
fig = plt.figure(figsize=(8, 6))
gs = gridspec.GridSpec(3, 3, figure=fig)
ax1 = fig.add_subplot(gs[0, :]) # full top row
ax2 = fig.add_subplot(gs[1, :2]) # middle, left 2 cols
ax3 = fig.add_subplot(gs[1:, 2]) # right, spans 2 rows
ax4 = fig.add_subplot(gs[2, 0:2]) # bottom-left
ax1.set_title("wide top")
ax3.set_title("tall right")
plt.tight_layout()
plt.show()Общие оси
sharex=True (или sharey=True) связывает оси: панорамирование и зум одной обновляют другие — отлично для стековых временных рядов. Ещё это скрывает дублирующиеся подписи делений у внутренних осей. Общие группы доступны через ax.get_shared_x_axes(); оси можно убрать из группы, чтобы разъединить.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 10, 100)
fig, (ax1, ax2) = plt.subplots(2, 1, sharex=True)
ax1.plot(x, np.sin(x))
ax2.plot(x, np.cos(x))
# zooming on one now zooms both
ax1.set_xlim(0, 5)
# decouple later if needed
# ax2.get_shared_x_axes().remove(ax2)
fig.suptitle("Shared x-axis")
plt.show()Tight layout и constrained
tight_layout() один раз подправляет отступы, чтобы подписи не перекрывались, но не знает о fig.suptitle — передайте rect, чтобы зарезервировать место. layout='constrained' (или fig=Figure(layout='constrained')) — современная альтернатива, пересчитывающая при каждой отрисовке, корректно обрабатывает suptitle и colorbar; рекомендуется для нового кода.
import matplotlib.pyplot as plt
# tight_layout: simple, adjusts subplot spacing
fig, axes = plt.subplots(2, 2)
for ax in axes.flat:
ax.set_xlabel("x label")
ax.set_ylabel("y label")
ax.set_title("a title")
fig.suptitle("tight_layout")
plt.tight_layout()
# leave room for suptitle
plt.tight_layout(rect=[0, 0, 1, 0.95])
plt.show()
# constrained_layout: recomputes on every draw (more robust)
fig, axes = plt.subplots(2, 2, layout="constrained")
fig.suptitle("constrained_layout")
plt.show()Легенды и аннотации
Базовая легенда
plt.legend() собирает подписи со всех отрисованных объектов. loc задаёт позицию внутри осей ('upper right', 'lower left', 'best', ...). Для внешней легенды сочетайте bbox_to_anchor=(x, y) (в долях осей) с loc, чтобы привязать этот угол рамки легенды к точке.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 1, 30)
plt.plot(x, x, label="linear")
plt.plot(x, x**2, label="quadratic")
plt.plot(x, x**3, label="cubic")
plt.legend()
plt.show()
# legend outside the axes
plt.figure()
plt.plot(x, x, label="linear")
plt.plot(x, x**2, label="quadratic")
plt.legend(loc="upper left", bbox_to_anchor=(1, 1))
plt.tight_layout()
plt.show()Позиция легенды и колонки
ncol раскладывает элементы легенды в несколько колонок — полезно при множестве коротких подписей. frameon/framealpha/fancybox управляют видом рамки легенды. title добавляет заголовок. Для вида без рамки задайте frameon=False: в публикациях часто выглядит чище.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 1, 30)
for i in range(1, 6):
plt.plot(x, x**i, label=f"x^{i}")
plt.legend(loc="upper center", ncol=3, fontsize=9,
frameon=True, framealpha=0.9,
title="Powers", title_fontsize=10)
plt.title("Custom Legend")
plt.show()Аннотирование точек
ax.annotate(text, xy, xytext) помещает текст в xytext и (при желании) рисует стрелку к xy. xy по умолчанию в координатах данных. arrowprops — словарь стилей стрелки; arrowstyle='->' самый частый. Для выносок annotate гораздо гибче plt.text.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 2*np.pi, 100)
y = np.sin(x)
plt.plot(x, y)
# mark and label the maximum
idx = np.argmax(y)
plt.annotate(f"max = {y[idx]:.2f}",
xy=(x[idx], y[idx]), # point to annotate
xytext=(x[idx]-1, 0.5), # text position
arrowprops=dict(arrowstyle="->"))
plt.show()Аннотации со стрелками
arrowprops стилизует соединитель: arrowstyle ('->', '-|>', '<->'), color, lw. connectionstyle изгибает стрелку: 'arc3,rad=0.3' изгибает, 'angle3' даёт прямой угол, 'bar' добавляет T-образную планку. Это позволяет строить понятные выноски в обход данных, не перекрывая кривые.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-3, 3, 100)
plt.plot(x, x**3 - 3*x)
plt.annotate("local min", xy=(1, -2), xytext=(2, -10),
arrowprops=dict(arrowstyle="->", color="red",
lw=2, connectionstyle="arc3,rad=0.3"))
plt.annotate("local max", xy=(-1, 2), xytext=(-3, 8),
arrowprops=dict(arrowstyle="-|>", color="blue",
connectionstyle="angle3"))
plt.show()Свои элементы легенды
Когда стандартная легенда (из отрисованных объектов) не устраивает, создайте свои элементы через Line2D, Patch или Line2D без данных и передайте handles= в legend(). Это необходимо для легенд, объединяющих линии, патчи и маркеры в одном ключе.
import matplotlib.pyplot as plt
from matplotlib.lines import Line2D
from matplotlib.patches import Patch
plt.plot([1, 2, 3], [1, 4, 9], "o-", color="tab:blue")
plt.plot([1, 2, 3], [1, 8, 27], "s--", color="tab:orange")
custom = [
Line2D([0], [0], color="tab:blue", marker="o", label="squared"),
Line2D([0], [0], color="tab:orange", marker="s", ls="--", label="cubed"),
Patch(facecolor="gray", label="reference band"),
]
plt.legend(handles=custom)
plt.show()Стили, цвета и rcParams
Встроенные стили
plt.style.use(name) применяет готовый вид глобально; plt.style.context(name) применяет временно внутри блока with. Популярные стили: 'ggplot', 'seaborn-v0_8-*', 'bmh', 'fivethirtyeight'. Учтите: стили Seaborn в Matplotlib 3.6+ переименованы с суффиксом '-v0_8'.
import matplotlib.pyplot as plt
# list all available styles
print(plt.style.available)
# use a style globally
plt.style.use("seaborn-v0_8-whitegrid")
# or as a context manager (temporary)
with plt.style.context("dark_background"):
plt.figure()
plt.plot([1, 2, 3], [1, 4, 9])
plt.title("dark")
plt.show()
plt.plot([1, 2, 3], [9, 4, 1])
plt.title("default again")
plt.show()Цветовые карты
Цветовые карты делятся на три семейства: последовательные (viridis, plasma) для упорядоченных данных 0..N, дивергентные (coolwarm, RdBu) для данных со значимой серединой (с vmin/vmax, центрированными на 0) и качественные (Set2, tab10) для различных категорий. Предпочитайте перцептивно равномерные вроде viridis: они безопасны для дальтоников и хорошо печатаются.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 10, 100)
y = np.sin(x)
# sequential, diverging, qualitative
for cmap in ["viridis", "plasma", "coolwarm", "RdBu", "Set2"]:
plt.scatter(x, y, c=x, cmap=cmap, label=cmap)
plt.colorbar(label=cmap)
plt.title(cmap)
plt.show()Свой цветовой цикл
axes.prop_cycle (объект cycler) задаёт последовательность свойств, перебираемых при добавлении линий. Можно циклически менять цвет, стиль, маркер и другое: сочетайте cycler(color=[...]) + cycler(linestyle=[...]), чтобы оба менялись одновременно. Так каждый график получает согласованную фирменную палитру.
import matplotlib.pyplot as plt
from cycler import cycler
# set the default color cycle for new axes
plt.rcParams["axes.prop_cycle"] = cycler(
color=["#e41a1c", "#377eb8", "#4daf4a", "#984ea3", "#ff7f00"])
for i in range(1, 6):
plt.plot([0, 1, 2], [i]*3, label=f"line {i}", lw=4)
plt.legend()
plt.title("Custom Cycle")
plt.show()rcParams
rcParams — главный словарь конфигурации, управляющий каждым умолчанием: размер фигуры, DPI, шрифты, толщины линий, сетка, опции savefig. Задайте значения один раз в начале скрипта для согласованного вывода. plt.rcParams.update({...}) задаёт несколько сразу. Для постоянных умолчаний используйте mpl.rcParamsFile или файл matplotlibrc.
import matplotlib.pyplot as plt
import matplotlib as mpl
# read / set individual parameters
mpl.rcParams["figure.figsize"] = (8, 4)
mpl.rcParams["figure.dpi"] = 100
mpl.rcParams["font.size"] = 12
mpl.rcParams["axes.grid"] = True
mpl.rcParams["axes.grid.which"] = "both"
mpl.rcParams["savefig.bbox"] = "tight"
# update many at once
plt.rcParams.update({
"axes.titlesize": "large",
"axes.labelsize": "medium",
"lines.linewidth": 2,
})
plt.plot([1, 2, 3])
plt.title("Configured Defaults")
plt.show()Форматы цветов
matplotlib.colors даёт преобразования (to_hex, to_rgb), списки именованных цветов и построение цветовых карт. LinearSegmentedColormap.from_list строит непрерывную карту из нескольких опорных цветов. Для своих категориальных карт используйте ListedColormap(['#aaa', '#bbb', ...]). Это позволяет точно попасть в фирменную палитру.
import matplotlib.pyplot as plt
import matplotlib.colors as mcolors
# all named colors
print(list(mcolors.CSS4_COLORS)[:5])
# convert between formats
print(mcolors.to_hex((0.1, 0.2, 0.5))) # #1a3380
print(mcolors.to_rgb("#ff8800")) # (1.0, 0.533, 0.0)
# make a custom colormap from a list of colors
cmap = mcolors.LinearSegmentedColormap.from_list(
"rg", ["red", "yellow", "green"])
import numpy as np
plt.imshow(np.linspace(0, 1, 256).reshape(1, -1),
cmap=cmap, aspect="auto")
plt.title("Custom Colormap")
plt.show()Настройки осей
Пределы (xlim / ylim)
plt.xlim/plt.ylim (или ax.set_xlim/ax.set_ylim) задают видимый диапазон данных. Передача None оставляет предел на авто-масштабирование, например set_ylim(None, 5) фиксирует только верх. plt.margins() добавляет отступ как долю диапазона данных вместо жёстких пределов.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 10, 100)
plt.plot(x, np.sin(x))
# set explicit limits
plt.xlim(2, 8)
plt.ylim(-1.5, 1.5)
# or autoscale with margin
# plt.margins(x=0.05, y=0.1)
# query current limits
print(plt.xlim()) # (2.0, 8.0)
plt.show()Деления
plt.xticks(positions) задаёт позиции делений; plt.xticks(positions, labels) ещё и их текст. Пустой список полностью скрывает деления. Для числовых осей обычно дайте MaxNLocator выбирать деления автоматически и переопределяйте только для категориальных или символических осей (например, кратных pi).
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 2*np.pi, 100)
plt.plot(x, np.sin(x))
# set tick positions
plt.xticks([0, np.pi/2, np.pi, 3*np.pi/2, 2*np.pi])
# set positions AND labels
plt.xticks([0, np.pi/2, np.pi, 3*np.pi/2, 2*np.pi],
["0", "pi/2", "pi", "3pi/2", "2pi"])
# turn off ticks
# plt.xticks([])
plt.show()Форматирование делений
Модуль ticker даёт точный контроль: Locators решают, ГДЕ стоят деления (MultipleLocator каждые N единиц, MaxNLocator до N делений, LogLocator для лог-осей); Formatters решают ТЕКСТ подписи (FormatStrFormatter в стиле printf, FuncFormatter — произвольная функция). Для мелкой сетки используйте minor locators.
import matplotlib.pyplot as plt
import numpy as np
from matplotlib.ticker import MultipleLocator, FormatStrFormatter, FuncFormatter
x = np.linspace(0, 5, 100)
plt.plot(x, x**2)
ax = plt.gca()
ax.xaxis.set_major_locator(MultipleLocator(1))
ax.xaxis.set_minor_locator(MultipleLocator(0.25))
ax.yaxis.set_major_formatter(FormatStrFormatter("%.0f"))
# format with a function
ax.yaxis.set_major_formatter(
FuncFormatter(lambda v, p: f"{v/1000:.1f}k"))
plt.show()Логарифмическая шкала
plt.xscale('log') / plt.yscale('log') переводят ось в логарифмическую — необходимо для данных, охватывающих порядки величин. 'symlog' — лог-шкала с линейной областью около нуля, поэтому показывает и отрицательные значения. plt.grid(True, which='both') показывает основные и мелкие (лог-равномерные) линии сетки.
import matplotlib.pyplot as plt
import numpy as np
x = np.logspace(0, 4, 50) # 10^0 .. 10^4
plt.plot(x, x**2)
# log both axes
plt.xscale("log")
plt.yscale("log")
# symlog: log scale that handles negative/zero values
# plt.yscale("symlog", linthresh=1)
plt.title("Log-Log Plot")
plt.grid(True, which="both", ls="--", alpha=0.5)
plt.show()Пропорции и рамки
ax.set_aspect('equal') обеспечивает одинаковый масштаб, чтобы круги оставались кругами, — критично для геометрии и карт. Spines — линии рамки осей; скрытие верхней и правой («despining») даёт чистый современный вид, популяризованный Seaborn. Рамки можно переносить в произвольные позиции данных для осей-перекрестий.
import matplotlib.pyplot as plt
import numpy as np
fig, ax = plt.subplots()
theta = np.linspace(0, 2*np.pi, 100)
ax.plot(np.cos(theta), np.sin(theta))
# equal data units on x and y (a true circle)
ax.set_aspect("equal")
# hide the top and right spines
ax.spines["top"].set_visible(False)
ax.spines["right"].set_visible(False)
# move the remaining spines to the center for a cross-hair
# ax.spines["left"].set_position(("data", 0))
# ax.spines["bottom"].set_position(("data", 0))
plt.show()Текст и математические выражения
Текст на осях
ax.text(x, y, s) по умолчанию размещает текст в координатах данных. Передайте transform=ax.transAxes для координат в долях осей (0,0 = левый низ, 1,1 = правый верх) — так подписи крепятся к углу независимо от диапазона данных. ha/va управляют выравниванием по горизонтали и вертикали.
import matplotlib.pyplot as plt
plt.plot([0, 1], [0, 1])
# ax.text(x, y, s) -- x, y in data coords
plt.text(0.5, 0.5, "center of plot", ha="center", va="center",
fontsize=14, color="red", rotation=30)
# align to axes fraction instead of data coords
plt.text(0.02, 0.98, "top-left", transform=plt.gca().transAxes,
ha="left", va="top", bbox=dict(boxstyle="round", fc="yellow"))
plt.show()suptitle и figtext
fig.suptitle() добавляет заголовок на всю фигуру (над всеми subplot): зарезервируйте место через tight_layout(rect=[...]) или используйте layout='constrained'. fig.text(x, y, s) размещает текст в долях фигуры (0,0 = левый низ фигуры), полезно для нижних колонтитулов и заметок об источнике.
import matplotlib.pyplot as plt
fig, axes = plt.subplots(1, 2)
axes[0].plot([1, 2, 3])
axes[1].plot([3, 2, 1])
# figure-level title (above all axes)
fig.suptitle("Main Title", fontsize=16, fontweight="bold")
# arbitrary figure-coordinate text
fig.text(0.5, 0.01, "figure footer text", ha="center", fontsize=9)
plt.tight_layout(rect=[0, 0.03, 1, 0.95])
plt.show()Математика LaTeX (mathtext)
В Matplotlib встроенный движок mathtext: оборачивайте LaTeX-подобную математику в знаки доллара ($...$) и используйте сырые строки (r"..."). Работают частые команды: \frac, \sum, \int, греческие буквы \alpha..\omega, верхние индексы x^2, нижние x_i. Внешний LaTeX не нужен. Берите r-строки, чтобы обратные косые выжили в Python.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 2*np.pi, 100)
plt.plot(x, np.sin(x))
# mathtext: enclose LaTeX in dollar signs
plt.title(r"$\sin(x)$ vs $x$")
plt.xlabel(r"$x$ (radians)")
plt.ylabel(r"$\sin(x)$")
# fractions, sums, greek letters
plt.text(2, 0.5, r"$\frac{a}{b} + \sum_{i=1}^{n} x_i^2$")
plt.text(2, -0.5, r"$\alpha, \beta, \gamma, \pi, \infty$")
plt.show()Свойства текста
Любой текстовый объект принимает богатый набор свойств: fontsize, fontweight ('bold'), fontstyle ('italic'), family ('serif'/'sans-serif'/'monospace'), color и dict bbox для фона. Текстовые объекты возвращаются, чтобы их можно было менять позже (полезно в анимациях и интерактивных обновлениях).
import matplotlib.pyplot as plt
t = plt.text(0.5, 0.5, "Styled Text",
fontsize=18, fontweight="bold",
fontstyle="italic", family="serif",
color="darkblue",
bbox=dict(boxstyle="round,pad=0.5",
facecolor="lightyellow", edgecolor="black"))
# animate or update properties later
t.set_fontsize(24)
t.set_color("crimson")
plt.show()Аннотации (textcoords)
textcoords в annotate определяет, как понимать xytext: 'data' (по умолчанию, единицы данных), 'offset points' (пункты относительно xy — отлично, чтобы сдвинуть подпись от точки), 'axes fraction' (0-1 по осям) или 'figure fraction'. Смешение систем координат позволяет выноскам оставаться читаемыми при зуме.
import matplotlib.pyplot as plt
plt.plot([1, 2, 3, 4], [1, 4, 2, 3])
# xy in data coords, xytext in points OFFSET from xy
plt.annotate("offset text", xy=(2, 4),
xytext=(15, 15), textcoords="offset points",
arrowprops=dict(arrowstyle="->"))
# xytext in axes fraction
plt.annotate("axes corner", xy=(2, 4),
xytext=(0.8, 0.8), textcoords="axes fraction",
arrowprops=dict(arrowstyle="-|>"))
plt.show()Сохранение фигур
Основы savefig
plt.savefig(path) записывает текущую фигуру в файл. Важно: вызывайте его ДО plt.show() — show() завершает и может очистить фигуру, поэтому сохранение после даст пустой файл. Расширение файла автоматически задаёт формат (.png, .pdf, .svg, .jpg).
import matplotlib.pyplot as plt
plt.plot([1, 2, 3], [4, 5, 2])
# save BEFORE plt.show() -- show() clears the figure
plt.savefig("plot.png")
plt.savefig("plot.pdf")
plt.show()Форматы
Выбирайте формат по цели: PNG для экрана и веба, PDF или SVG (векторные) для печати и правки, так как они масштабируются без пикселизации; JPG только для фотоизображений (он теряет резкость линий и текста). Векторные форматы также дают куда меньшие файлы для графиков с малым числом элементов. format= переопределяет расширение.
import matplotlib.pyplot as plt
plt.plot([1, 2, 3], [1, 4, 9])
# raster formats (pixels)
plt.savefig("plot.png") # lossless, default
plt.savefig("plot.jpg", quality=95)
plt.savefig("plot.tiff", dpi=200)
# vector formats (scale without pixelation)
plt.savefig("plot.pdf") # best for publications
plt.savefig("plot.svg") # editable in Inkscape/Illustrator
# explicit format override
plt.savefig("plot.dat", format="png")DPI и разрешение
DPI (точек на дюйм) задаёт разрешение растрового вывода: размеры в пикселях = figsize * dpi. 72-100 DPI достаточно для экрана; для печати нужно 300+. Сохраняйте в векторном формате (PDF/SVG), чтобы вообще избежать вопросов разрешения. Задайте savefig.dpi в rcParams для согласованного вывода высокого разрешения во всём скрипте.
import matplotlib.pyplot as plt
fig, ax = plt.subplots(figsize=(6, 4))
ax.plot([1, 2, 3], [1, 4, 9])
# dpi controls pixel density: width_px = figsize[0] * dpi
plt.savefig("low.png", dpi=72) # 432 x 288 px
plt.savefig("high.png", dpi=300) # 1800 x 1200 px
# set a global default DPI
plt.rcParams["savefig.dpi"] = 300
plt.savefig("global.png")bbox_inches и pad
По умолчанию savefig обрезает по прямоугольнику фигуры, что может отрезать подписи и заголовки у края. bbox_inches='tight' расширяет сохраняемую область, включая все объекты, а pad_inches добавл яет небольшой отступ вокруг. Это почти всегда то, что нужно: задайте умолчание через rcParams['savefig.bbox']='tight'.
import matplotlib.pyplot as plt
plt.plot([1, 2, 3], [1, 4, 9])
plt.title("With Long Title That Might Be Cut Off")
# tight bbox trims whitespace and keeps labels inside
plt.savefig("tight.png", bbox_inches="tight", pad_inches=0.1)
# trim even more aggressively
plt.savefig("tighter.png", bbox_inches="tight", pad_inches=0)
# preview the tight bounding box
# bbox = plt.savefig("x.png", bbox_inches="tight") # returns a BboxПрозрачность и цвет фона
transparent=True делает фон фигуры прозрачным (альфа-канал PNG) — идеально для наложения графиков на слайды и веб-страницы. facecolor задаёт цвет сохраняемого фона (переопределяет экранный). Фон осей управляется отдельно через ax.set_facecolor(). Сочетайте оба для многослойного дизайна.
import matplotlib.pyplot as plt
fig, ax = plt.subplots()
ax.plot([1, 2, 3], [1, 4, 9])
ax.set_facecolor("#f0f0f0")
# transparent background (alpha channel)
plt.savefig("transparent.png", transparent=True)
# explicit figure face color
plt.savefig("colored.png", facecolor="lightblue", edgecolor="none")
# control which elements are saved
plt.savefig("full.png", facecolor=fig.get_facecolor())3D-графики (mplot3d)
Настройка 3D-осей
Создайте 3D-оси с projection='3d' (через add_subplot или subplot_kw в subplots). Работают все 2D-методы плюс z-специфичные (set_zlabel, plot_surface, scatter и др.). Поддержка 3D идёт через набор mplot3d, входящий в Matplotlib и не требующий отдельной установки.
import matplotlib.pyplot as plt
import numpy as np
fig = plt.figure()
# add a 3D axes via projection
ax = fig.add_subplot(projection="3d")
# or from subplots
# fig, ax = plt.subplots(subplot_kw={"projection": "3d"})
ax.set_xlabel("X")
ax.set_ylabel("Y")
ax.set_zlabel("Z")
ax.set_title("3D Axes")
plt.show()3D-точечный график
ax.scatter(x, y, z) на 3D-осях рисует точки в пространстве; аргументы s и c работают как в 2D-scatter. Добавьте fig.colorbar(sc), чтобы показать сопоставление цветов. 3D-scatter хорош для изучения кластеров, но статичные 3D-графики могут скрывать глубину: вращайте интерактивно или кодируйте одно измерение цветом.
import matplotlib.pyplot as plt
import numpy as np
rng = np.random.default_rng(0)
n = 200
x = rng.normal(0, 1, n)
y = rng.normal(0, 1, n)
z = rng.normal(0, 1, n)
c = np.sqrt(x**2 + y**2 + z**2)
fig = plt.figure()
ax = fig.add_subplot(projection="3d")
sc = ax.scatter(x, y, z, c=c, cmap="viridis")
fig.colorbar(sc, label="distance from origin")
ax.set_title("3D Scatter")
plt.show()3D-поверхность
plot_surface(X, Y, Z) рисует цветную поверхность; X, Y, Z должны быть двумерными массивами одинаковой формы из np.meshgrid. rstride/cstride задают, сколько точек сетки пропускать (меньше — глаже, но медленнее). cmap красит по Z; добавьте colorbar (с shrink, чтобы влез в 3D-фигуру).
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-5, 5, 80)
y = np.linspace(-5, 5, 80)
X, Y = np.meshgrid(x, y)
R = np.sqrt(X**2 + Y**2)
Z = np.sin(R)
fig = plt.figure()
ax = fig.add_subplot(projection="3d")
surf = ax.plot_surface(X, Y, Z, cmap="coolwarm",
rstride=1, cstride=1,
linewidth=0, antialiased=True)
fig.colorbar(surf, shrink=0.5, aspect=10)
ax.set_title("3D Surface")
plt.show()3D-каркас и контуры
plot_wireframe рисует только линии сетки (легче полной поверхности, хорошо для структуры). ax.contourf с zdir='z' и offset проецирует залитые контуры на плоскость под поверхностью — частая визуализация «2D под 3D». Сочетайте поверхность с проецированными контурами для богатых карт рельефа.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-3, 3, 30)
y = np.linspace(-3, 3, 30)
X, Y = np.meshgrid(x, y)
Z = X * np.exp(-X**2 - Y**2)
fig = plt.figure()
ax = fig.add_subplot(projection="3d")
ax.plot_wireframe(X, Y, Z, color="black", rstride=1, cstride=1)
ax.set_title("Wireframe")
# 3D contour (filled) projected at the bottom
fig = plt.figure()
ax = fig.add_subplot(projection="3d")
ax.contourf(X, Y, Z, zdir="z", offset=-0.5, cmap="viridis")
ax.set_title("3D Contour")
plt.show()3D-столбцы
ax.bar3d(x, y, z, dx, dy, dz) рисует прямоугольные столбцы в позициях (x, y) от основания z с шириной dx, dy и высотой dz. shade=True добавляет освещение для 3D-эффекта. Уплощайте массивы координат через .ravel(), если начинаете с meshgrid. 3D-столбцы читаются тяжело — по возможности предпочитайте сгруппированные 2D-столбцы.
import matplotlib.pyplot as plt
import numpy as np
fig = plt.figure()
ax = fig.add_subplot(projection="3d")
x = np.arange(3)
y = np.arange(3)
X, Y = np.meshgrid(x, y)
X, Y = X.ravel(), Y.ravel()
Z = np.zeros_like(X)
dz = np.array([1, 2, 3, 2, 3, 1, 3, 1, 2])
ax.bar3d(X, Y, Z, dx=0.6, dy=0.6, dz=dz,
shade=True, color="tab:orange")
ax.set_title("3D Bar Chart")
plt.show()Контурные графики
Контурные линии
plt.contour(X, Y, Z) рисует изолинии, где Z постоянно. X, Y берутся из meshgrid. levels задаёт число (или точные значения) контуров. plt.clabel(cs) подписывает каждую линию значением. Линейные контуры точны, но разреженны; сочетайте с contourf для залитых областей.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-3, 3, 100)
y = np.linspace(-3, 3, 100)
X, Y = np.meshgrid(x, y)
Z = np.sin(X) * np.cos(Y)
# line contours
cs = plt.contour(X, Y, Z, levels=15, colors="black", linewidths=0.8)
plt.clabel(cs, inline=True, fontsize=8)
plt.title("Contour Lines")
plt.colorbar(cs)
plt.show()Залитые контуры
plt.contourf (обратите внимание на 'f') заливает области между уровнями цветом, давая вид гладкой тепловой карты. Как и contour, требует сеточных X, Y, Z. levels управляет детализацией. contourf — стандартный способ визуализировать двумерные скалярные поля: температуру, рельеф, плотность вероятности.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-2, 2, 100)
y = np.linspace(-2, 2, 100)
X, Y = np.meshgrid(x, y)
Z = X**2 + Y**2
cf = plt.contourf(X, Y, Z, levels=20, cmap="viridis")
plt.colorbar(cf, label="Z")
plt.title("Filled Contour")
plt.xlabel("X")
plt.ylabel("Y")
plt.show()Подписи контуров (clabel)
plt.clabel(cs) подписывает контурные линии их значением Z; inline=True разрывает линию под подпись. fmt форматирует число ('%.2f' или функция). Передайте levels=[...], чтобы подписать только конкретные изолинии. Подписанные контуры передают точные значения без цветовой шкалы.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-3, 3, 100)
y = np.linspace(-3, 3, 100)
X, Y = np.meshgrid(x, y)
Z = X * np.exp(-X**2 - Y**2)
cs = plt.contour(X, Y, Z, 10, colors="black")
plt.clabel(cs, inline=True, fontsize=9, fmt="%.2f")
# label only specific levels
# plt.clabel(cs, levels=[-0.1, 0, 0.1])
plt.title("Labeled Contours")
plt.show()Цветовая шкала
plt.colorbar(mappable) добавляет ключ цветов — всегда передавайте объект, возвращённый contour/imshow/scatter, чтобы шкала знала о сопоставлении. set_label/set_ticks настраивают её. В subplot шкалы могут отнимать место у оси: используйте аргумент ax= или fig.colorbar(mappable, ax=axes), чтобы управлять размещением между несколькими осями.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 5, 100)
y = np.linspace(0, 5, 100)
X, Y = np.meshgrid(x, y)
Z = np.sin(X) + np.cos(Y)
cf = plt.contourf(X, Y, Z, cmap="RdBu")
# basic colorbar
cb = plt.colorbar(cf)
cb.set_label("Z value")
cb.set_ticks([-2, -1, 0, 1, 2])
# place colorbar with specific size and padding
# cb = plt.colorbar(cf, fraction=0.046, pad=0.04)
plt.title("Colorbar Example")
plt.show()meshgrid и griddata
Contour/contourf нужны данные на регулярной сетке. Для разрозненных образцов используйте scipy.interpolate.griddata для интерполяции на meshgrid (методы: 'linear', 'nearest', 'cubic'). np.mgrid[...] — удобное сокращение для meshgrid по диапазону. Отрисовка исходных точек поверх показывает, где данные разрежены.
import matplotlib.pyplot as plt
import numpy as np
from scipy.interpolate import griddata
# scattered (x, y, z) samples
rng = np.random.default_rng(0)
pts = rng.uniform(-2, 2, (200, 2))
z = np.sin(pts[:,0]) * np.cos(pts[:,1])
# build a regular grid
grid_x, grid_y = np.mgrid[-2:2:100j, -2:2:100j]
# interpolate scattered data onto the grid
grid_z = griddata(pts, z, (grid_x, grid_y), method="cubic")
plt.contourf(grid_x, grid_y, grid_z, levels=20, cmap="plasma")
plt.scatter(pts[:,0], pts[:,1], c="white", s=5, alpha=0.5)
plt.colorbar(label="z")
plt.title("Scattered -> Grid -> Contour")
plt.show()Показ изображений (imshow)
Основы imshow
plt.imshow(arr) показывает двумерный массив как тепловую карту или трёхмерный (H, W, 3) как RGB-изображение. По умолчанию origin='upper' (верх слева), как принято для изображений; задайте origin='lower' для математических осей. plt.axis('off') скрывает деления для чистого показа.
import matplotlib.pyplot as plt
import numpy as np
# a 2D array is shown as a heatmap (color = value)
rng = np.random.default_rng(0)
img = rng.random((10, 10))
plt.imshow(img, cmap="viridis")
plt.colorbar(label="value")
plt.title("imshow of a 2D array")
plt.show()
# a 3D array (H, W, 3 or 4) is shown as an RGB(A) image
rgb = rng.integers(0, 256, (50, 50, 3), dtype=np.uint8)
plt.imshow(rgb)
plt.axis("off")
plt.title("RGB image")
plt.show()Цветовая карта и шкала
extent=[xmin, xmax, ymin, max] сопоставляет пиксели массива с координатами данных; без него imshow использует индексы пикселей. origin='lower' ставит строку 0 вниз (математическое соглашение). aspect='auto' растягивает изображение на оси; по умолчанию 'equal' сохраняет квадратные пиксели. Передавайте объект изображения в colorbar.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-3, 3, 200)
y = np.linspace(-3, 3, 200)
X, Y = np.meshgrid(x, y)
Z = np.sin(X**2 + Y**2) / (X**2 + Y**2 + 1)
im = plt.imshow(Z, extent=[-3, 3, -3, 3], origin="lower",
cmap="RdBu", aspect="auto")
cb = plt.colorbar(im)
cb.set_label("intensity")
plt.title("imshow with extent")
plt.show()Интерполяция
interpolation управляет смешением пикселей при увеличении: 'none'/'nearest' показывает чёткие блоки (хорошо для сырых пикселей), 'bilinear'/'bicubic' сглаживает (хорошо для тепловых карт). Интерполяция меняет только вид, не данные. Для небольших массивов часто НУЖЕН 'nearest', чтобы отдельные ячейки были видны.
import matplotlib.pyplot as plt
import numpy as np
rng = np.random.default_rng(1)
small = rng.random((5, 5))
methods = ["none", "bilinear", "bicubic", "nearest"]
fig, axes = plt.subplots(1, 4, figsize=(12, 3))
for ax, m in zip(axes, methods):
ax.imshow(small, interpolation=m, cmap="magma")
ax.set_title(m)
ax.axis("off")
plt.tight_layout()
plt.show()vmin / vmax и norm
vmin/vmax фиксируют диапазон данных, отображаемый на карту (обрезая выбросы). Для нелинейных сопоставлений используйте norm=: LogNorm для данных с порядками величин, TwoSlopeNorm, чтобы центрировать дивергентную карту на значимой середине (например, 0 для аномалий). norm и vmin/vmax взаимоисключающи — передавайте только одно.
import matplotlib.pyplot as plt
import numpy as np
from matplotlib.colors import LogNorm, TwoSlopeNorm
rng = np.random.default_rng(2)
Z = rng.random((50, 50)) * 1000 + 1
# clamp the colormap range
plt.imshow(Z, vmin=100, vmax=500, cmap="viridis")
plt.colorbar()
plt.title("clipped range")
plt.show()
# log-scaled colors
plt.imshow(Z, norm=LogNorm(vmin=1, vmax=1001), cmap="plasma")
plt.colorbar()
plt.title("log scale")
plt.show()
# diverging norm centered on a midpoint
# norm = TwoSlopeNorm(vmin=-1, vcenter=0, vmax=1)Показ изображения из файла
mpimg.imread загружает изображение в массив NumPy (float 0-1 для PNG, 0-255 uint8 для JPEG). plt.imshow показывает его; plt.imsave записывает массив обратно на диск. RGB-изображения сохраняют цвета; для одноканальных задавайте cmap='gray'. Учтите: PIL/pillow мощнее для нетривиальной обработки изображений.
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
# read an image file into a numpy array
img = mpimg.imread("photo.png") # shape (H, W, 3) or (H, W, 4)
print(img.shape, img.dtype)
plt.imshow(img)
plt.axis("off")
plt.show()
# save the (possibly modified) array back to a file
# plt.imsave("out.png", img)
# drop the alpha channel if present
if img.shape[-1] == 4:
img = img[..., :3]Полярные графики
Полярные оси
projection='polar' превращает оси в полярные координаты: x — угол (theta, радианы), y — радиус (r). Все стандартные методы работают, но оперируют в (theta, r). Полярные графики идеальны для направленных данных, периодических функций и круговых симметрий. Задавайте деления через ax.set_thetagrids и ax.set_rgrids.
import matplotlib.pyplot as plt
import numpy as np
# create a polar axes via projection
fig = plt.figure()
ax = fig.add_subplot(projection="polar")
# or from subplots
# fig, ax = plt.subplots(subplot_kw={"projection": "polar"})
theta = np.linspace(0, 2*np.pi, 100)
ax.plot(theta, np.sin(2*theta))
plt.show()Полярный линейный график
На полярных осях plot(theta, r) рисует кривые, где theta — угол, r — радиус. set_rmax ограничивает радиальный диапазон; set_rticks и set_thetagrids настраивают радиальные и угловые деления. Полярные линейные графики наглядно показывают периодические функции: синусоида замыкается в петлю.
import matplotlib.pyplot as plt
import numpy as np
theta = np.linspace(0, 2*np.pi, 200)
fig, ax = plt.subplots(subplot_kw={"projection": "polar"})
ax.plot(theta, 1 + np.cos(theta), label="cardioid")
ax.plot(theta, np.abs(np.sin(2*theta)), label="rose")
ax.set_rmax(2.0)
ax.set_rticks([0.5, 1.0, 1.5])
ax.set_thetagrids([0, 90, 180, 270])
ax.legend(loc="upper right")
plt.show()Радарная диаграмма
Радар — полярный линейный график с осью на категорию. Приём: добавьте первое значение и угол в конец, чтобы кривая за мкнулась, и залейте внутренность с alpha. Задайте xticks по углам категорий и подпишите. Радары сравнивают многомерные профили, но могут вводить в заблуждение — используйте редко.
import matplotlib.pyplot as plt
import numpy as np
labels = ["Speed", "Power", "Range", "Comfort", "Price"]
values = [8, 7, 6, 5, 9]
N = len(labels)
# close the loop
angles = np.linspace(0, 2*np.pi, N, endpoint=False).tolist()
values += values[:1]
angles += angles[:1]
fig, ax = plt.subplots(subplot_kw={"projection": "polar"})
ax.plot(angles, values, "o-")
ax.fill(angles, values, alpha=0.25)
ax.set_xticks(angles[:-1])
ax.set_xticklabels(labels)
ax.set_title("Radar Chart")
plt.show()Полярные столбцы (роза)
Роза (полярные столбцы) использует ax.bar на полярных осях: каждый столбец занимает угловой сектор. Полезно для направленных гистограмм: направление ветра, распределение периода волн. Красьте столбцы по радиусу (как здесь) для дополнительного измерения. bottom= позволяет стековать или смещать столбцы от центра.
import matplotlib.pyplot as plt
import numpy as np
rng = np.random.default_rng(0)
N = 12
theta = np.linspace(0, 2*np.pi, N, endpoint=False)
widths = 2*np.pi / N
radii = rng.uniform(1, 5, N)
fig, ax = plt.subplots(subplot_kw={"projection": "polar"})
bars = ax.bar(theta, radii, width=widths, bottom=0,
edgecolor="black")
# color bars by radius
for r, bar in zip(radii, bars):
bar.set_facecolor(plt.cm.viridis(r / radii.max()))
ax.set_title("Rose Diagram")
plt.show()Полярные настройки
set_theta_zero_location('N') переносит 0 радиан наверх, а set_theta_direction(-1) делает углы возрастающими по часовой — компасное соглашение. set_rlabel_position(angle) переносит радиальные подписи на любой угол, чтобы не перекрывать данные. Эти правки превращают математический полярный график в направленный/компасный.
import matplotlib.pyplot as plt
import numpy as np
fig, ax = plt.subplots(subplot_kw={"projection": "polar"})
ax.plot(np.linspace(0, 2*np.pi, 100), np.linspace(0, 1, 100))
# rotate 0 degrees to the top, go clockwise
ax.set_theta_zero_location("N")
ax.set_theta_direction(-1)
# radial limits and ticks
ax.set_rlim(0, 1.2)
ax.set_rticks([0.25, 0.5, 0.75, 1.0])
ax.set_rlabel_position(135) # move radial labels out of the way
# label directions in degrees
ax.set_thetagrids([0, 90, 180, 270], labels=["E","N","W","S"])
plt.show()Сдвоенные оси
twinx (вторая ось Y)
ax.twinx() создаёт новые оси, делящие ось X, но со своей осью Y справа, — стандартный способ строить две величины с разными единицами (например, температура и влажность). Подкрасьте каждую ось и её деления в цвет своей кривой, чтобы читатель понимал, какая шкала к какой серии относится.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 10, 100)
fig, ax1 = plt.subplots()
ax1.plot(x, np.sin(x), "b-")
ax1.set_xlabel("x")
ax1.set_ylabel("sin(x)", color="b")
ax1.tick_params(axis="y", labelcolor="b")
# a second axes sharing the same x, with an independent y
ax2 = ax1.twinx()
ax2.plot(x, x*10, "r-")
ax2.set_ylabel("10*x", color="r")
ax2.tick_params(axis="y", labelcolor="r")
plt.title("twinx: two y-scales")
plt.show()twiny (вторая ось X)
ax.twiny() — горизонтальный аналог: новые оси делят ось Y, но имеют свою ось X сверху. Используйте, чтобы показать те же данные в двух масштабах X (метры и футы, время в секундах и минутах). Тот же совет по цвету: цвет оси должен совпадать с кривой.
import matplotlib.pyplot as plt
import numpy as np
y = np.linspace(0, 10, 50)
fig, ax1 = plt.subplots()
ax1.plot(np.exp(y), y, "g-")
ax1.set_ylabel("y")
ax1.set_xlabel("exp(y)", color="g")
# second axes sharing y, independent x on top
ax2 = ax1.twiny()
ax2.plot(y**2, y, "m-")
ax2.set_xlabel("y^2", color="m")
plt.title("twiny: two x-scales")
plt.show()Комбинированный график с двумя осями
При сдвоенных осях у каждой свои легенды. Чтобы показать одну общую, соберите объекты линий с обеих осей в список и вызовите ax1.legend(lines, labels). Это идиоматичный способ держать один ключ для двухосевого графика, чтобы читатель сразу опознал обе серии.
import matplotlib.pyplot as plt
import numpy as np
t = np.linspace(0, 5, 100)
temp_c = 20 + 5*np.sin(t) # Celsius
humidity = 60 - 5*t # percent
fig, ax1 = plt.subplots(figsize=(8, 4))
l1, = ax1.plot(t, temp_c, "r-o", label="Temperature (C)")
ax1.set_xlabel("time (s)")
ax1.set_ylabel("Temperature (C)", color="r")
ax1.tick_params(axis="y", labelcolor="r")
ax2 = ax1.twinx()
l2, = ax2.plot(t, humidity, "b-s", label="Humidity (%)")
ax2.set_ylabel("Humidity (%)", color="b")
ax2.tick_params(axis="y", labelcolor="b")
# combine legends from both axes
lines = [l1, l2]
ax1.legend(lines, [l.get_label() for l in lines], loc="upper right")
plt.title("Temperature & Humidity")
plt.show()Рамки сдвоенных осей
Сдвоенные оси естественно дают удвоенную верхнюю рамку. Скрывайте верхние рамки на обеих осях для чистоты и красьте левую и правую рамки в цвет соответствующих осей Y. Вместе с цветными подписями делений это ясно показывает, какая шкала к какой кривой относится, не загромождая график.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 10, 100)
fig, ax1 = plt.subplots()
ax2 = ax1.twinx()
ax1.plot(x, np.sin(x), color="tab:blue")
ax2.plot(x, np.cos(x), color="tab:orange")
# remove the top spine so the two axes don't double-border
ax1.spines["top"].set_visible(False)
ax2.spines["top"].set_visible(False)
# color the spines to match their axes
ax1.spines["left"].set_color("tab:blue")
ax2.spines["right"].set_color("tab:orange")
plt.title("Clean Twin Axes")
plt.show()Вторая ось с другими единицами
Иногда вторая серия не нужна — нужна вторая ось с пересчитанными единицами (км/мили, C/F). Создайте twiny(), выровняйте пределы через set_xlim, затем вручную задайте xticks/xticklabels в пересчитанных значениях. Так одна серия данных аннотируется двумя системами единиц.
import matplotlib.pyplot as plt
import numpy as np
km = np.linspace(0, 100, 50)
mile = km * 0.621371
fig, ax1 = plt.subplots()
ax1.plot(km, np.sin(km/10), "tab:purple")
ax1.set_xlabel("distance")
ax1.set_ylabel("signal", color="tab:purple")
ax2 = ax1.twiny()
ax2.set_xlim(ax1.get_xlim()) # align x limits
# relabel the top ticks in miles
new_ticks = np.array([0, 25, 50, 75, 100])
ax2.set_xticks(new_ticks)
ax2.set_xticklabels([f"{m:.0f}" for m in new_ticks*0.621371])
ax2.set_xlabel("miles")
plt.show()Планки ошибок и заливки
errorbar
plt.errorbar(x, y, yerr) рисует точки с вертикальными планками ошибок — стандарт для экспериментальных данных с неопределённостью. fmt — строка формата графика ('o-' = маркеры + линия). ecolor, elinewidth и capsize стилизуют планки. xerr= задаёт горизонтальные ошибки, оба — для двумерных неопределённостей.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 5, 10)
y = np.exp(-x)
yerr = 0.1 + 0.1*x # error grows with x
plt.errorbar(x, y, yerr=yerr, fmt="o-", color="tab:blue",
ecolor="gray", elinewidth=1.5, capsize=4,
markersize=6, label="exp(-x) +/- err")
plt.legend()
plt.title("Error Bar Plot")
plt.show()Асимметричные ошибки
Для асимметричных неопределённостей передавайте yerr массивом 2 x N: строка 0 — нижние (вниз) ошибки, строка 1 — верхние (вверх). Это обычно при смещённых ошибках (например, пуассоновские счётчики). Тот же паттерн применим к xerr для асимметричных горизонтальных ошибок.
import matplotlib.pyplot as plt
import numpy as np
x = np.arange(5)
y = np.array([2, 3, 5, 4, 6])
# separate lower and upper errors (each a 1-D array)
yerr = [[0.5, 1, 0.8, 0.6, 1.2], # lower
[1.0, 0.8, 1.5, 1.0, 0.7]] # upper
plt.errorbar(x, y, yerr=yerr, fmt="s", color="tab:green",
capsize=5)
plt.title("Asymmetric Error Bars")
plt.show()
# horizontal asymmetric errors work the same way
# xerr = [[...lower...], [...upper...]]fill_between
fill_between(x, y1, y2) закрашивает область между двумя кривыми y — идеально для доверительных интервалов, полос ошибок и диапазонов. where= ограничивает заливку местами, где булев массив True (используйте interpolate=True, если кривые пересекаются). alpha < 1 оставляет кривую видимой сквозь полосу.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 10, 100)
y = np.sin(x)
std = 0.2
plt.plot(x, y, "b-", label="mean")
# shade +/- one standard deviation
plt.fill_between(x, y - std, y + std, color="blue", alpha=0.2,
label="+/- 1 std")
# shade only where a condition holds
plt.fill_between(x, y, 0, where=(y > 0), color="green", alpha=0.2,
label="y > 0")
plt.legend()
plt.show()stackplot
plt.stackplot(x, y1, y2, ...) укладывает несколько серий друг на друга, показывая суммы и состав по непрерывному x (обычно время). В отличие от стековых столбцов это для непрерывных данных. Общая высота — сумма всех серий. Используйте разные цвета с alpha, чтобы границы слоёв были видны.
import matplotlib.pyplot as plt
import numpy as np
years = np.arange(2010, 2021)
a = np.array([10, 12, 14, 15, 17, 18, 20, 22, 23, 25, 27])
b = np.array([ 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])
c = np.array([ 3, 4, 4, 5, 6, 6, 7, 8, 8, 9, 10])
plt.stackplot(years, a, b, c, labels=["A", "B", "C"],
colors=["#4C72B0", "#55A868", "#C44E52"], alpha=0.8)
plt.legend(loc="upper left")
plt.title("Stacked Area Chart")
plt.xlabel("year")
plt.ylabel("value")
plt.show()fill (полигон)
plt.fill(x, y) замыкает и закрашивает произвольный полигон — полезно для выделения областей и заливки под кривой. Чтобы залить под кривой, соедините x с его обратным порядком, а y — с нулями. Для нескольких несвязных областей передавайте двумерные массивы или вызывайте fill повторно.
import matplotlib.pyplot as plt
import numpy as np
# fill a closed polygon defined by its vertices
x = [0, 1, 1, 0, 0]
y = [0, 0, 1, 1, 0]
plt.fill(x, y, color="tab:cyan", alpha=0.5)
# shade under a curve
xs = np.linspace(0, 2*np.pi, 100)
ys = np.sin(xs)
plt.fill(np.r_[xs, xs[::-1]],
np.r_[ys, np.zeros_like(ys)],
color="tab:orange", alpha=0.3)
plt.title("Filled Polygons")
plt.show()Интеграция с Seaborn
Введение в Seaborn
Seaborn — высокоуровневая библиотека статистических графиков на основе Matplotlib: принимает DataFrame pandas, выполняет группировку и агрегацию и использует более приятные умолчания. Каждая функция Seaborn возвращает Axes (или Figure) Matplotlib, поэтому вы продолжаете настраивать через plt/ax. Вызовите sns.set_theme() один раз, чтобы перейти на стиль Seaborn.
# install seaborn
pip install seaborn
import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
# Seaborn is built ON matplotlib: any sns plot returns an Axes
# and accepts an ax= argument, so you can mix freely.
sns.set_theme() # apply seaborn's default style
tips = sns.load_dataset("tips")
ax = sns.scatterplot(data=tips, x="total_bill", y="tip", hue="time")
ax.set_title("Tips dataset")
plt.show()Стили Seaborn
sns.set_style задаёт вид осей (сетка, фон), set_context масштабирует шрифты и линии под носитель вывода ('paper', 'talk', 'poster'), а set_palette задаёт цветовой цикл. sns.despine() убирае т верхнюю и правую рамки. Из этого одной-двумя строками складывается отточенный вид по умолчанию.
import seaborn as sns
import matplotlib.pyplot as plt
# five built-in themes: darkgrid, whitegrid, dark, white, ticks
sns.set_style("whitegrid")
sns.set_context("notebook") # paper, notebook, talk, poster
# set the color palette
sns.set_palette("Set2")
import numpy as np
for i in range(4):
plt.plot(np.arange(10), np.arange(10)+i)
plt.title("Seaborn-styled")
plt.show()
# remove the top/right spines (despine) for a clean look
# sns.despine()relplot (реляционный)
sns.relplot — интерфейс уровня фигуры для реляционных графиков: kind='scatter' (по умолчанию) или 'line'. col/row автоматически разбивают данные на subplot (faceting) — гораздо проще ручных subplot. Возвращает FacetGrid, чьи .fig и .axes позволяют спуститься к Matplotlib для тонкой настройки заголовков и раскладки.
import seaborn as sns
import matplotlib.pyplot as plt
tips = sns.load_dataset("tips")
# scatter or line, faceted by a categorical variable
g = sns.relplot(data=tips, x="total_bill", y="tip",
hue="smoker", style="time", col="day",
kind="scatter", height=3, aspect=1.2)
g.fig.suptitle("Tips by day", y=1.03)
plt.show()histplot и kdeplot
sns.histplot — современная замена устаревшего distplot: рисует гистограммы и может наложить ядерную оценку плотности (kde=True). stat='density' нормализует, а common_norm=False нормирует группы независимо. sns.kdeplot рисует только гладкую кривую плотности — удобно для сравнения распределений.
import seaborn as sns
import matplotlib.pyplot as plt
tips = sns.load_dataset("tips")
# histogram with an overlaid KDE (density curve)
sns.histplot(data=tips, x="total_bill", bins=20, kde=True,
hue="time", stat="density", common_norm=False)
plt.title("Histogram + KDE")
plt.show()
# standalone KDE
plt.figure()
sns.kdeplot(data=tips, x="total_bill", hue="time", fill=True)
plt.show()heatmap
sns.heatmap рисует цветную матрицу с необязательными подписями ячеек (annot=True). center=0 с дивергентной картой (coolwarm) делает положительные и отрицательные корреляции визуально различимыми. Он оборачивает plt.imshow + plt.text + colorbar, экономя много шаблонного кода для матриц корреляций и ошибок.
import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
# correlation matrix
tips = sns.load_dataset("tips")
num = tips.select_dtypes("number").drop(columns=["size"])
corr = num.corr()
sns.heatmap(corr, annot=True, cmap="coolwarm", center=0,
vmin=-1, vmax=1, square=True,
linewidths=0.5, fmt=".2f")
plt.title("Correlation Heatmap")
plt.show()pairplot и violinplot
sns.pairplot строит сетку точечных графиков для каждой пары числовых колонок, окрашивая по категориальному признаку, — быстрейший способ изучить связи в новом наборе данных. sns.violinplot сочетает box plot с оценкой плотности, показывая форму распределения по группам. Оба под капотом — Matplotlib, и их можно донастроить.
import seaborn as sns
import matplotlib.pyplot as plt
iris = sns.load_dataset("iris")
# scatter matrix: every numeric column vs every other
g = sns.pairplot(iris, hue="species", height=2.5)
g.fig.suptitle("Iris pairplot", y=1.01)
plt.show()
# violin plot: box + kernel density on each side
plt.figure()
sns.violinplot(data=iris, x="species", y="sepal_length",
inner="quartile")
plt.show()Интерактив и анимация
Виджет Slider
matplotlib.widgets.Slider добавляет интерактивный ползунок. Создайте для него оси (часто внизу фигуры через plt.axes([left, bottom, width, height] в долях фигуры), привяжите колбэк к on_changed и обновляйте данные графика внутри него. Вызывайте fig.canvas.draw_idle() для перерисовки. Нужен интерактивный бэкенд (не Agg).
import matplotlib.pyplot as plt
from matplotlib.widgets import Slider
import numpy as np
fig, ax = plt.subplots()
plt.subplots_adjust(bottom=0.25)
x = np.linspace(0, 10, 500)
line, = ax.plot(x, np.sin(x))
# axes for the slider
ax_freq = plt.axes([0.2, 0.1, 0.6, 0.03])
slider = Slider(ax_freq, "freq", 0.1, 5.0, valinit=1.0)
def update(val):
line.set_ydata(np.sin(slider.val * x))
fig.canvas.draw_idle()
slider.on_changed(update)
plt.show()Кнопки
matplotlib.widgets.Button добавляет кликабельную кнопку. Как и ползунку, ей нужны свои оси (в долях фигуры). Колбэк получает объект события, который обычно игнорируется. Сочетайте несколько виджетов (ползунки, кнопки, флажки), чтобы строить простые дашборды исследования данных прямо в Matplotlib.
import matplotlib.pyplot as plt
from matplotlib.widgets import Button
import numpy as np
fig, ax = plt.subplots()
plt.subplots_adjust(bottom=0.2)
(ln,) = ax.plot(np.random.rand(10))
ax_btn = plt.axes([0.7, 0.05, 0.2, 0.075])
btn = Button(ax_btn, "Resample")
def reshuffle(event):
ln.set_ydata(np.random.rand(10))
fig.canvas.draw_idle()
btn.on_clicked(reshuffle)
plt.show()CheckButtons
CheckButtons рисует список флажков. Колбэк получает текст переключённой метки, по нему вы переключаете видимость нужного объекта. Позволяет зрителям включать и выключать серии. Как и с любыми виджетами, нужен интерактивный бэкенд, и окно должно оставаться открытым.
import matplotlib.pyplot as plt
from matplotlib.widgets import CheckButtons
import numpy as np
x = np.linspace(0, 5, 200)
l1, = plt.plot(x, np.sin(x), label="sin")
l2, = plt.plot(x, np.cos(x), label="cos")
plt.subplots_adjust(right=0.8)
rax = plt.axes([0.82, 0.4, 0.15, 0.2])
check = CheckButtons(rax, ["sin", "cos"], [True, True])
def toggle(label):
if label == "sin": l1.set_visible(not l1.get_visible())
if label == "cos": l2.set_visible(not l2.get_visible())
plt.draw()
check.on_clicked(toggle)
plt.show()Курсор и события мыши
mpl_connect связывает события (button_press_event, motion_notify_event, key_press_event, scroll_event) с колбэками. Объект события несёт event.xdata/event.ydata (координаты данных) и event.inaxes (какие оси или None). Это основа своих взаимодействий: перекрестий, клика с аннотацией, своих инструментов зума.
import matplotlib.pyplot as plt
fig, ax = plt.subplots()
ax.plot([1, 2, 3, 4], [1, 4, 2, 3])
def on_click(event):
if event.inaxes != ax:
return
print(f"clicked at x={event.xdata:.2f} y={event.ydata:.2f}")
def on_move(event):
if event.inaxes == ax:
ax.set_title(f"x={event.xdata:.2f}, y={event.ydata:.2f}")
fig.canvas.draw_idle()
fig.canvas.mpl_connect("button_press_event", on_click)
fig.canvas.mpl_connect("motion_notify_event", on_move)
plt.show()Анимация (FuncAnimation)
FuncAnimation ведёт анимацию, многократно вызывая update(frame). update должен вернуть изменённые объекты (кортежем), чтобы blit=True перерисовывал только их для скорости. interval — задержка между кадрами в мс. Для сохранения нужен writer ('ffmpeg' для mp4, 'pillow' для gif). Держите ссылку на объект анимации (ani), иначе его соберёт сборщик мусора и она остановится.
import matplotlib.pyplot as plt
import matplotlib.animation as animation
import numpy as np
fig, ax = plt.subplots()
x = np.linspace(0, 2*np.pi, 200)
line, = ax.plot(x, np.sin(x))
def update(frame):
line.set_ydata(np.sin(x + frame / 10.0))
return line,
ani = animation.FuncAnimation(fig, update, frames=100,
interval=50, blit=True, repeat=True)
# save to a file (requires ffmpeg or pillow installed)
# ani.save("wave.mp4", writer="ffmpeg")
# ani.save("wave.gif", writer="pillow")
plt.show()Связанные сниппеты Matplotlib
Copy-paste ready code for common tasks.
Line Plot
Plot lines with markers, colors, and styles.
Bar Chart
Draw vertical, horizontal, and grouped bars.
Scatter Plot
Visualize relationships with size and color encodings.
Subplots
Arrange multiple axes with subplots and GridSpec.
Labels and Legend
Annotate plots with text, arrows, and legend options.
Styles and Themes
Apply built-in styles and customize rcParams.
Save Figure
Export figures to PNG, PDF, and SVG with DPI control.
3D Plot
Render surfaces and scatter in 3D.
Was this helpful?