Skip to content

Matplotlib Шпаргалка

Комплексная библиотека Python для визуализации данных.

01

Начало работы

Установка и первый график

Matplotlib — основа графиков в Python. pyplot — интерфейс на основе состояния (как MATLAB). В скрипте всегда вызывайте plt.show(), чтобы отрисовать фигуру; в Jupyter фигура отрисовывается автоматически при завершении ячейки.

matplotlib
# 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(), чтобы получить текущие объекты фигуры и осей.

matplotlib
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, сдвоенные оси и сложные раскладки.

matplotlib
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, размер шрифта, размер фигуры и другие умолчания.

matplotlib
# 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 встраивает фигуры в ноутбук.

matplotlib
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
02

Линейные графики (plot)

Базовый линейный график

plt.plot(x, y) рисует линию, соединяющую точки (x, y) по порядку. Если передать один массив, он используется как y, а x по умолчанию 0..N-1. plt.grid(True) включает сетку. Точки соединяются в порядке массива, поэтому для плавной кривой сначала отсортируйте x.

matplotlib
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 сам управляет пределами осей, расширяя их под наибольший диапазон.

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'.

matplotlib
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' берёт первый цвет текущего стиля, сохраняя согласованность с циклом.

matplotlib
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 у патчей.

matplotlib
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 и отдельные границы бинов; хорошо сочетается с гистограммными данными.

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

Точечные графики

Базовый scatter

plt.scatter(x, y) рисует точки без соединяющих линий. Он медленнее plt.plot(x, y, 'o') на десятках тысяч точек, потому что позволяет задавать размер и цвет каждой точке. Для максимальной скорости при одинаковом стиле используйте plt.plot с маркером.

matplotlib
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, чтобы видеть плотность.

matplotlib
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 данных.

matplotlib
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.

matplotlib
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.

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

Столбчатые диаграммы

Вертикальные столбцы

plt.bar(x, height) рисует вертикальные столбцы; x может быть строками (категории). Возвращённый BarContainer позволяет аннотировать или перекрашивать отдельные столбцы. Цикл с plt.text() подписывает каждый столбец: настройте ha/va ('center'/'bottom') и смещение по y, чтобы подписи стояли чуть выше столбца.

matplotlib
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.

matplotlib
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.

matplotlib
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)]. Стеки показывают суммы и состав, но верхние серии труднее сравнивать между категориями.

matplotlib
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.

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

Гистограммы

Базовая гистограмма

plt.hist(x) раскладывает данные по бинам и рисует столбцы. bins может быть числом (количество бинов) или последовательностью явных границ. По умолчанию возвращаются счётчики, поэтому ось Y — частота. Возвращается (counts, bin_edges, patches), что можно использовать для дальнейшей настройки.

matplotlib
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' берёт максимум правил Стёрджеса и Фридмана-Диакониса — разумное умолчание. Передавайте явный массив границ для полного контроля и сопоставимых бинов между наборами. Мало бинов скрывает структуру, много — добавляет шум.

matplotlib
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) для гладких кривых плотности, которые накладываются чище гистограмм.

matplotlib
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= задаёт веса отдельных наблюдений.

matplotlib
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.

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

Круговые диаграммы

Базовая круговая диаграмма

plt.pie(x, labels) рисует круг по значениям x. autopct форматирует проценты (строка в стиле printf или функция). startangle поворачивает начало первого сектора. Всегда вызывайте plt.axis('equal'), чтобы круг был настоящим кругом, а не эллипсом.

matplotlib
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 редко, чтобы выделить один сектор: сдвиг каждого сектора выглядит загромождённо.

matplotlib
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, ...). Кольца обычно читаются легче кругов: длина кольца кодирует значение лучше угла сектора.

matplotlib
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 позиционирует подписи процентов.

matplotlib
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', чтобы визуально разделить секторы.

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

Subplot и раскладки

plt.subplot

plt.subplot(rows, cols, index) выбирает оси в сетке (индексация с 1) — устаревший MATLAB-стиль. Индекс идёт слева направо и сверху вниз. Он меняет «текущие оси», поэтому последующие вызовы plt рисуют там. Для нового кода предпочитайте plt.subplots(): чище и возвращает настоящие объекты Axes.

matplotlib
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(), чтобы подписи не перекрывались.

matplotlib
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 делают столбцы и строки неравными. Это стандартный инструмент для сложных дашбордов.

matplotlib
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(); оси можно убрать из группы, чтобы разъединить.

matplotlib
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; рекомендуется для нового кода.

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

Легенды и аннотации

Базовая легенда

plt.legend() собирает подписи со всех отрисованных объектов. loc задаёт позицию внутри осей ('upper right', 'lower left', 'best', ...). Для внешней легенды сочетайте bbox_to_anchor=(x, y) (в долях осей) с loc, чтобы привязать этот угол рамки легенды к точке.

matplotlib
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: в публикациях часто выглядит чище.

matplotlib
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.

matplotlib
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-образную планку. Это позволяет строить понятные выноски в обход данных, не перекрывая кривые.

matplotlib
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(). Это необходимо для легенд, объединяющих линии, патчи и маркеры в одном ключе.

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

Стили, цвета и rcParams

Встроенные стили

plt.style.use(name) применяет готовый вид глобально; plt.style.context(name) применяет временно внутри блока with. Популярные стили: 'ggplot', 'seaborn-v0_8-*', 'bmh', 'fivethirtyeight'. Учтите: стили Seaborn в Matplotlib 3.6+ переименованы с суффиксом '-v0_8'.

matplotlib
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: они безопасны для дальтоников и хорошо печатаются.

matplotlib
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=[...]), чтобы оба менялись одновременно. Так каждый график получает согласованную фирменную палитру.

matplotlib
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.

matplotlib
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', ...]). Это позволяет точно попасть в фирменную палитру.

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

Настройки осей

Пределы (xlim / ylim)

plt.xlim/plt.ylim (или ax.set_xlim/ax.set_ylim) задают видимый диапазон данных. Передача None оставляет предел на авто-масштабирование, например set_ylim(None, 5) фиксирует только верх. plt.margins() добавляет отступ как долю диапазона данных вместо жёстких пределов.

matplotlib
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).

matplotlib
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.

matplotlib
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') показывает основные и мелкие (лог-равномерные) линии сетки.

matplotlib
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. Рамки можно переносить в произвольные позиции данных для осей-перекрестий.

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

Текст и математические выражения

Текст на осях

ax.text(x, y, s) по умолчанию размещает текст в координатах данных. Передайте transform=ax.transAxes для координат в долях осей (0,0 = левый низ, 1,1 = правый верх) — так подписи крепятся к углу независимо от диапазона данных. ha/va управляют выравниванием по горизонтали и вертикали.

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

matplotlib
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.

matplotlib
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 для фона. Текстовые объекты возвращаются, чтобы их можно было менять позже (полезно в анимациях и интерактивных обновлениях).

matplotlib
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'. Смешение систем координат позволяет выноскам оставаться читаемыми при зуме.

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

Сохранение фигур

Основы savefig

plt.savefig(path) записывает текущую фигуру в файл. Важно: вызывайте его ДО plt.show() — show() завершает и может очистить фигуру, поэтому сохранение после даст пустой файл. Расширение файла автоматически задаёт формат (.png, .pdf, .svg, .jpg).

matplotlib
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= переопределяет расширение.

matplotlib
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 для согласованного вывода высокого разрешения во всём скрипте.

matplotlib
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'.

matplotlib
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(). Сочетайте оба для многослойного дизайна.

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

3D-графики (mplot3d)

Настройка 3D-осей

Создайте 3D-оси с projection='3d' (через add_subplot или subplot_kw в subplots). Работают все 2D-методы плюс z-специфичные (set_zlabel, plot_surface, scatter и др.). Поддержка 3D идёт через набор mplot3d, входящий в Matplotlib и не требующий отдельной установки.

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-графики могут скрывать глубину: вращайте интерактивно или кодируйте одно измерение цветом.

matplotlib
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-фигуру).

matplotlib
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». Сочетайте поверхность с проецированными контурами для богатых карт рельефа.

matplotlib
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-столбцы.

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

Контурные графики

Контурные линии

plt.contour(X, Y, Z) рисует изолинии, где Z постоянно. X, Y берутся из meshgrid. levels задаёт число (или точные значения) контуров. plt.clabel(cs) подписывает каждую линию значением. Линейные контуры точны, но разреженны; сочетайте с contourf для залитых областей.

matplotlib
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 — стандартный способ визуализировать двумерные скалярные поля: температуру, рельеф, плотность вероятности.

matplotlib
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=[...], чтобы подписать только конкретные изолинии. Подписанные контуры передают точные значения без цветовой шкалы.

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

matplotlib
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 по диапазону. Отрисовка исходных точек поверх показывает, где данные разрежены.

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

Показ изображений (imshow)

Основы imshow

plt.imshow(arr) показывает двумерный массив как тепловую карту или трёхмерный (H, W, 3) как RGB-изображение. По умолчанию origin='upper' (верх слева), как принято для изображений; задайте origin='lower' для математических осей. plt.axis('off') скрывает деления для чистого показа.

matplotlib
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.

matplotlib
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', чтобы отдельные ячейки были видны.

matplotlib
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 взаимоисключающи — передавайте только одно.

matplotlib
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 мощнее для нетривиальной обработки изображений.

matplotlib
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]
16

Полярные графики

Полярные оси

projection='polar' превращает оси в полярные координаты: x — угол (theta, радианы), y — радиус (r). Все стандартные методы работают, но оперируют в (theta, r). Полярные графики идеальны для направленных данных, периодических функций и круговых симметрий. Задавайте деления через ax.set_thetagrids и ax.set_rgrids.

matplotlib
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 настраивают радиальные и угловые деления. Полярные линейные графики наглядно показывают периодические функции: синусоида замыкается в петлю.

matplotlib
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 по углам категорий и подпишите. Радары сравнивают многомерные профили, но могут вводить в заблуждение — используйте редко.

matplotlib
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= позволяет стековать или смещать столбцы от центра.

matplotlib
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) переносит радиальные подписи на любой угол, чтобы не перекрывать данные. Эти правки превращают математический полярный график в направленный/компасный.

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

Сдвоенные оси

twinx (вторая ось Y)

ax.twinx() создаёт новые оси, делящие ось X, но со своей осью Y справа, — стандартный способ строить две величины с разными единицами (например, температура и влажность). Подкрасьте каждую ось и её деления в цвет своей кривой, чтобы читатель понимал, какая шкала к какой серии относится.

matplotlib
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 (метры и футы, время в секундах и минутах). Тот же совет по цвету: цвет оси должен совпадать с кривой.

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

matplotlib
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. Вместе с цветными подписями делений это ясно показывает, какая шкала к какой кривой относится, не загромождая график.

matplotlib
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 в пересчитанных значениях. Так одна серия данных аннотируется двумя системами единиц.

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

Планки ошибок и заливки

errorbar

plt.errorbar(x, y, yerr) рисует точки с вертикальными планками ошибок — стандарт для экспериментальных данных с неопределённостью. fmt — строка формата графика ('o-' = маркеры + линия). ecolor, elinewidth и capsize стилизуют планки. xerr= задаёт горизонтальные ошибки, оба — для двумерных неопределённостей.

matplotlib
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 для асимметричных горизонтальных ошибок.

matplotlib
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 оставляет кривую видимой сквозь полосу.

matplotlib
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, чтобы границы слоёв были видны.

matplotlib
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 повторно.

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

Интеграция с Seaborn

Введение в Seaborn

Seaborn — высокоуровневая библиотека статистических графиков на основе Matplotlib: принимает DataFrame pandas, выполняет группировку и агрегацию и использует более приятные умолчания. Каждая функция Seaborn возвращает Axes (или Figure) Matplotlib, поэтому вы продолжаете настраивать через plt/ax. Вызовите sns.set_theme() один раз, чтобы перейти на стиль Seaborn.

matplotlib
# 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() убирает верхнюю и правую рамки. Из этого одной-двумя строками складывается отточенный вид по умолчанию.

matplotlib
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 для тонкой настройки заголовков и раскладки.

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 рисует только гладкую кривую плотности — удобно для сравнения распределений.

matplotlib
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, экономя много шаблонного кода для матриц корреляций и ошибок.

matplotlib
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, и их можно донастроить.

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

Интерактив и анимация

Виджет Slider

matplotlib.widgets.Slider добавляет интерактивный ползунок. Создайте для него оси (часто внизу фигуры через plt.axes([left, bottom, width, height] в долях фигуры), привяжите колбэк к on_changed и обновляйте данные графика внутри него. Вызывайте fig.canvas.draw_idle() для перерисовки. Нужен интерактивный бэкенд (не Agg).

matplotlib
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.

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

matplotlib
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). Это основа своих взаимодействий: перекрестий, клика с аннотацией, своих инструментов зума.

matplotlib
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), иначе его соберёт сборщик мусора и она остановится.

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

Was this helpful?

Learning path

Learn from scratch

Learn this language from the ground up with structured lessons.