Плт автоцентр купчино: ПЛТ Автоцентр Купчино официальный сайт автосалона

Ex-MATLAB (которые все хорошие люди, я обещаю!) Понравилась эта функциональность, потому что с from pylab import * они могли просто вызвать plot () или array () напрямую, как в MATLAB.

Проблема здесь может быть очевидна для некоторых пользователей Python: использование из pylab import * в сеансе или скрипте обычно является плохой практикой.Matplotlib теперь прямо предупреждает об этом в своих собственных руководствах:

«[pylab] все еще существует по историческим причинам, но настоятельно не рекомендуется использовать его. Он загрязняет пространства имен функциями, которые затеняют встроенные функции Python и могут привести к трудно отслеживаемым ошибкам. Чтобы получить интеграцию с IPython без импорта, предпочтительно использовать магию % matplotlib ». [Источник]

Внутренне существует множество потенциально конфликтующих импортов, замаскированных в пределах короткого источника pylab.Фактически, использование ipython --pylab (из терминала / командной строки) или % pylab (из инструментов IPython / Jupyter) просто вызывает из pylab import * под капотом.

Суть в том, что matplotlib отказался от этого удобного модуля и теперь явно рекомендует не использовать pylab, приводит вещи в большее соответствие с одним из ключевых понятий Python: явное лучше, чем неявное.

Без pylab мы обычно можем обойтись только одним каноническим импортом:

  >>> import matplotlib.pyplot как plt
  

Пока мы занимаемся этим, давайте также импортируем NumPy, который мы будем использовать для генерации данных позже, и вызовем np.random.seed () , чтобы сделать примеры с воспроизводимыми (псевдо) случайными данными:

  >>> импортировать numpy как np
>>> np.random.seed (444)
  

Иерархия объектов Matplotlib

Одна из важных концепций библиотеки matplotlib в целом — это иерархия объектов.

Если вы прошли какое-либо вводное руководство по matplotlib, вы, вероятно, назвали что-то вроде plt.участок ([1, 2, 3]) . Этот однострочный текст скрывает тот факт, что сюжет на самом деле представляет собой иерархию вложенных объектов Python. «Иерархия» здесь означает, что существует древовидная структура объектов matplotlib, лежащих в основе каждого графика.

A Figure объект — это самый внешний контейнер для графики matplotlib, который может содержать несколько объектов Axes . Одним из источников путаницы является название: Axes фактически переводится в то, что мы думаем как отдельный график или график (а не во множественное число от «оси», как мы могли бы ожидать).

Вы можете представить себе объект Figure как коробчатый контейнер, содержащий одну или несколько осей (реальные графики). Ниже осей Axes в иерархии расположены более мелкие объекты, такие как отметки, отдельные строки, легенды и текстовые поля. Почти каждый «элемент» диаграммы — это собственный управляемый объект Python, вплоть до отметок и меток:

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

  >>> fig, _ = plt. подсюжеты ()
>>> тип (рис)
<класс 'matplotlib.figure.Figure'>
  

Выше мы создали две переменные с plt.subplots () . Первый — это объект верхнего уровня Figure . Вторая — это «одноразовая» переменная, которая нам пока не нужна, она обозначена знаком подчеркивания. Используя обозначение атрибутов, легко пройти вниз по иерархии фигур и увидеть первую отметку оси y первого объекта Axes:

  >>> one_tick = рис.оси [0] .yaxis.get_major_ticks () [0]
>>> тип (one_tick)
<класс 'matplotlib.axis.YTick'>
  

Выше, fig (экземпляр класса Figure ) имеет несколько осей (список, для которого мы берем первый элемент). Каждая ось Axes имеет yaxis и xaxis , каждая из которых имеет набор «основных тиков», и мы берем первый.

Matplotlib представляет это как анатомию фигуры, а не явную иерархию:

(В истинном стиле matplotlib рисунок выше создан здесь в документации matplotlib. )

Подходы с отслеживанием состояния и подходы без сохранения состояния

Хорошо, нам нужен еще один кусок теории, прежде чем мы сможем перейти к блестящим визуализациям: разница между интерфейсами с отслеживанием состояния (на основе состояния, машина состояний) и без состояния (объектно-ориентированный, объектно-ориентированный).

Выше мы использовали import matplotlib.pyplot как plt для импорта модуля pyplot из matplotlib и назвали его plt .

Почти все функции из pyplot, такие как plt.plot () , неявно либо ссылаются на существующий текущий рисунок и текущие оси, либо создают их заново, если их не существует.В документации matplotlib скрыт этот полезный фрагмент:

«[С помощью pyplot] простые функции используются для добавления элементов графика (линий, изображений, текста и т. Д.) к текущим осям на текущем рисунке .» [курсив мой]

Hardcore ex-MATLAB пользователи могут выразить это словами примерно так: « plt. plot () — это интерфейс конечного автомата, который неявно отслеживает текущее число!» На английском это означает, что:

• Интерфейс с отслеживанием состояния выполняет вызовы с использованием plt.plot () и другие функции pyplot верхнего уровня. Есть только одна фигура или ось, которыми вы манипулируете в данный момент времени, и вам не нужно явно ссылаться на нее.
• Непосредственное изменение базовых объектов — это объектно-ориентированный подход. Обычно мы делаем это путем вызова методов объекта Axes , который представляет собой сам график.

Поток этого процесса на высоком уровне выглядит так:

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

Это легче увидеть, заглянув под капот. plt.plot () можно сократить до пяти или около того строк кода:

  # matplotlib / pyplot.py
>>> def plot (* args, ** kwargs):
. .. "" "Сокращенная версия plt.plot ()." ""
... ax = plt.gca ()
... вернуть ax.plot (* args, ** kwargs)

>>> def gca (** kwargs):
... "" "Получить текущие оси текущего рисунка." ""
... вернуть plt.gcf (). gca (** kwargs)
  

Звонок plt.plot () — это просто удобный способ получить текущие оси текущего рисунка и затем вызвать его метод plot () . Это то, что подразумевается под утверждением, что интерфейс с отслеживанием состояния всегда «неявно отслеживает» сюжет, на который он хочет ссылаться.

pyplot является домом для набора функций, которые на самом деле являются просто оболочками вокруг объектно-ориентированного интерфейса matplotlib. Например, для plt.title () существуют соответствующие методы установки и получения в рамках объектно-ориентированного подхода, ax.set_title () и ax.get_title () . (Использование геттеров и сеттеров обычно более популярно в таких языках, как Java, но это ключевая особенность объектно-ориентированного подхода matplotlib. )

Вызов plt.title () преобразуется в одну строку: gca (). Set_title (s, * args, ** kwargs) . Вот что он делает:

• gca () захватывает текущую ось и возвращает ее.
• set_title () — это метод установки, который устанавливает заголовок для этого объекта Axes.«Удобство» здесь в том, что нам не нужно было явно указывать какой-либо объект Axes с помощью plt.title () .

Точно так же, если вы потратите несколько минут, чтобы взглянуть на исходный код функций верхнего уровня, таких как plt.grid () , plt.legend () и plt.ylabels () , вы заметите что все они следуют одной и той же структуре делегирования текущим Axes с помощью gca () и последующего вызова некоторого метода текущей Axes. (Это основной объектно-ориентированный подход!)

Понимание

Хорошо, хватит теории. Теперь мы готовы связать все воедино и поработать над планом. С этого момента мы в основном будем полагаться на объектно-ориентированный подход без сохранения состояния, который более гибок и удобен по мере усложнения графиков.

Предписанный способ создания фигуры с единственной осью в рамках объектно-ориентированного подхода (не слишком интуитивно) — это plt.subplots () . Это действительно единственный раз, когда объектно-ориентированный подход использует pyplot для создания фигуры и осей:

  >>> fig, ax = plt.подсюжеты ()
  

Выше мы воспользовались возможностью итеративной распаковки, чтобы назначить отдельную переменную каждому из двух результатов plt.subplots () . Обратите внимание, что здесь мы не передали аргументы в подзаголовок () . Вызов по умолчанию — subplots (nrows = 1, ncols = 1) . Следовательно, ax является единственным объектом AxesSubplot :

  >>> тип (топор)
<класс 'matplotlib. axes._subplots.AxesSubplot'>
  

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

  >>> rng = np.arange (50)
>>> rnd = np.random.randint (0, 10, размер = (3, rng.size))
>>> лет = 1950 + номер

>>> fig, ax = plt.subplots (figsize = (5, 3))
>>> ax.stackplot (yrs, rng + rnd, labels = ['Eastasia', 'Eurasia', 'Oceania'])
>>> ax.set_title ('Совокупный рост долга с течением времени')
>>> ax.legend (loc = 'верхний левый')
>>> ax.set_ylabel ('Общий долг')
>>> топор.set_xlim (xmin = yrs [0], xmax = yrs [-1])
>>> fig.tight_layout ()
  

Вот что происходит выше:

• После создания трех случайных временных рядов мы определили одну фигуру ( fig ), содержащую одну ось (график, ax ).

• Мы вызываем методы ax напрямую, чтобы создать диаграмму с областями с накоплением и добавить легенду, заголовок и метку оси Y. При объектно-ориентированном подходе ясно, что все это атрибуты ax .

• tight_layout () применяется к объекту Figure в целом, чтобы убрать заполнение пробелов.

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

  >>> x = np.random.randint (низкий = 1, высокий = 11, размер = 50)
>>> y = x + np.random.randint (1, 5, размер = x.size)
>>> data = np.column_stack ((x, y))

>>> fig, (ax1, ax2) = plt.подзаголовки (nrows = 1, ncols = 2,
... figsize = (8, 4))

>>> ax1.scatter (x = x, y = y, marker = 'o', c = 'r', edgecolor = 'b')
>>> ax1.set_title ('Scatter: $ x $ против $ y $')
>>> ax1.set_xlabel ('$ x $')
>>> ax1.set_ylabel ('$ y $')

>>> ax2.hist (данные, бункеры = np.arange (data.min (), data.max ()),
... метка = ('x', 'y'))
>>> ax2.legend (loc = (0,65, 0,8))
>>> ax2.set_title ('Частоты $ x $ и $ y $')
>>> ax2. yaxis.tick_right ()
  

В этом примере происходит кое-что еще:

• Поскольку мы создаем фигуру «1×2», возвращенный результат plt.subplots (1, 2) теперь является объектом Figure и массивом NumPy объектов Axes. (Вы можете проверить это с помощью fig, axs = plt.subplots (1, 2) и взглянув на axs .)

• Мы работаем с ax1 и ax2 по отдельности, что было бы трудно сделать при использовании подхода с отслеживанием состояния. Последняя строка является хорошей иллюстрацией иерархии объектов, где мы модифицируем yaxis , принадлежащую вторым Axes, помещая его метки и метки справа.

• Текст внутри знаков доллара использует разметку TeX для выделения переменных курсивом.

Помните, что несколько осей могут быть заключены в данную фигуру или «принадлежать» ей. В приведенном выше случае fig.axes получает список всех объектов Axes:

  >>> (fig. axes [0] - это ax1, fig.axes [1] - это ax2)
(Правда правда)
  

( fig.axes — это строчные, а не прописные буквы. Нельзя отрицать, что терминология немного сбивает с толку.)

Сделав еще один шаг вперед, мы могли бы в качестве альтернативы создать фигуру, которая содержит сетку 2×2 из объектов Axes :

  >>> fig, ax = plt.subplots (nrows = 2, ncols = 2, figsize = (7, 7))
  

Итак, что такое ax ? Это уже не одна Axes , а их двумерный массив NumPy:

  >>> тип (топор)
numpy.ndarray

>>> топор
массив ([[,
        <объект matplotlib.axes._subplots.AxesSubplot в 0x113045c88>],
       [<объект matplotlib.axes._subplots.AxesSubplot в 0x11d573cf8>,
        <объект matplotlib.axes._subplots.AxesSubplot в 0x1130117f0>]],
      dtype = объект)

>>> ax.shape
(2, 2)
  

Это подтверждается строкой документации:

« ax может быть либо одним объектом matplotlib. axes.Axes , либо массивом из объектов Axes , если было создано более одного подзаголовка.”

Теперь нам нужно вызвать методы построения графика для каждой из этих Axes (но не для массива NumPy, который в данном случае является просто контейнером). Распространенный способ решить эту проблему — использовать итеративную распаковку после преобразования массива в одномерный:

  >>> fig, ax = plt.subplots (nrows = 2, ncols = 2, figsize = (7, 7))
>>> ax1, ax2, ax3, ax4 = ax.flatten () # сглаживаем 2d массив NumPy до 1d
  

Мы также могли бы сделать это с помощью ((ax1, ax2), (ax3, ax4)) = ax , но первый подход имеет тенденцию быть более гибким.

Чтобы проиллюстрировать некоторые более продвинутые функции подзаголовка, давайте возьмем некоторые макроэкономические данные о жилье в Калифорнии, извлеченные из сжатого tar-архива, используя io , tarfile и urllib из стандартной библиотеки Python.

  >>> из io import BytesIO
>>> импортировать tarfile
>>> из urllib.request import urlopen

>>> url = 'http://www.dcc.fc.up.pt/~ltorgo/Regression/cal_housing.tgz'
>>> b = BytesIO (urlopen (url).читать())
>>> fpath = 'CaliforniaHousing / cal_housing.data'

>>> с tarfile.open (mode = 'r', fileobj = b) в качестве архива:
... корпус = np.loadtxt (archive.extractfile (fpath), delimiter = ',')
  

Переменная «ответ» и ниже, если использовать статистический термин, представляет собой среднюю стоимость жилья в районе. население и возраст — это население района и средний возраст дома соответственно:

  >>> y = жилье [:, -1]
>>> поп, возраст = жилье [:, [4, 7]].Т
  

Затем давайте определим «вспомогательную функцию», которая помещает текстовое поле внутри графика и действует как «заголовок внутри графика»:

  >>> def add_titlebox (топор, текст):
... ax.text (.55, . 8, текст,
... horizontalalignment = 'центр',
... преобразовать = ax.transAxes,
... bbox = dict (цвет лица = 'белый', альфа = 0,6),
... fontsize = 12,5)
... вернуть топор
  

Мы готовы поработать над заговором. Модуль gridspec в Matplotlib позволяет больше настраивать подзаголовок.pyplot subplot2grid () прекрасно взаимодействует с этим модулем. Допустим, мы хотим создать такой макет:

На самом деле, у нас есть сетка 3×2. ax1 в два раза больше высоты и ширины ax2 / ax3 , что означает, что он занимает два столбца и две строки.

Второй аргумент функции subplot2grid () — это (строка, столбец) расположение осей в сетке:

  >>> размер сетки = (3, 2)
>>> фиг = плт.рисунок (figsize = (12, 8))
>>> ax1 = plt.subplot2grid (размер сетки, (0, 0), colspan = 2, rowspan = 2)
>>> ax2 = plt.subplot2grid (размер сетки, (2, 0))
>>> ax3 = plt.subplot2grid (размер сетки, (2, 1))
  

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

  >>> ax1. set_title ('Стоимость дома как функция возраста и населения района',
... fontsize = 14)
>>> sctr = ax1.scatter (x = возраст, y = pop, c = y, cmap = 'RdYlGn')
>>> плт.цветная полоса (sctr, ax = ax1, format = '$% d')
>>> ax1.set_yscale ('журнал')
>>> ax2.hist (возраст, бункеры = 'авто')
>>> ax3.hist (pop, bins = 'auto', log = True)

>>> add_titlebox (ax2, 'Гистограмма: домашний возраст')
>>> add_titlebox (ax3, 'Гистограмма: население области (log scl.)')
  

Выше, colorbar () (отличается от ColorMap ранее) вызывается непосредственно на рисунке, а не на осях. Его первый аргумент использует .scatter () Matplotlib и является результатом ax1.scatter () , который функционирует как отображение значений y в ColorMap.

Визуально разница в цвете (переменная y) не так велика, когда мы перемещаемся вверх и вниз по оси y, что указывает на то, что возраст дома является более сильным фактором, определяющим стоимость дома.

«Фигурки» за кадром

Каждый раз, когда вы вызываете plt. subplots () или менее часто используемую plt.figure () (которая создает Figure без осей), вы создаете новый объект Figure, который matplotlib тайком хранит в памяти.Ранее мы ссылались на концепцию текущего рисунка и текущих осей. По умолчанию это последние созданные Figure и Axes, которые мы можем показать с помощью встроенной функции id () для отображения адреса объекта в памяти:

  >>> fig1, ax1 = plt.subplots ()

>>> id (рис1)
4525567840

>>> id (plt.gcf ()) # `fig1` - текущая цифра.
4525567840

>>> fig2, ax2 = plt.subplots ()
>>> id (fig2) == id (plt.gcf ()) # Текущая цифра изменилась на `fig2`.
Истинный
  

(Здесь также можно использовать встроенный оператор is .)

После описанной выше процедуры текущая фигура — fig2 , последняя созданная фигура. Однако обе цифры все еще находятся в памяти, каждая с соответствующим идентификационным номером (с индексом 1, в стиле MATLAB):

  >>> plt. get_fignums ()
[1, 2]
  

Полезный способ получить все сами фигуры — это сопоставление plt.figure () для каждого из этих целых чисел:

  >>> def get_all_figures ():
... return [plt.figure (i) for i в plt.get_fignums ()]

>>> get_all_figures ()
[,
 ]
  

Помните об этом при запуске сценария, в котором вы создаете группу фигур. Вам нужно будет явно закрыть каждый из них после использования, чтобы избежать MemoryError . Сама по себе пт.close () закрывает текущую фигуру, plt.close (num) закрывает номер фигуры num , а plt.close ('all') закрывает все окна фигур:

  >>> plt.close ('все')
>>> get_all_figures ()
[]
  

Цветная вспышка:

Хотя ax.plot () — один из наиболее распространенных методов построения графиков на осях, существует множество других. (Мы использовали ax.stackplot () выше. Вы можете найти полный список здесь.)

Наиболее часто используются методы imshow () и matshow () , причем последний является оболочкой для первого. Они полезны в любое время, когда необработанный числовой массив можно визуализировать в виде цветной сетки.

Во-первых, давайте создадим две отдельные сетки с какой-нибудь причудливой индексацией NumPy:

  >>> x = np.diag (np.arange (2, 12)) [:: - 1]
>>> x [np.diag_indices_from (x [:: - 1])] = np.arange (2, 12)
>>> x2 = np.arange (x.size) .reshape (x.shape)
  

Затем мы можем сопоставить их с их изображениями. В этом конкретном случае мы отключаем все метки и отметки осей, используя понимание словаря и передавая результат в ax.tick_params () :

  >>> side = ('слева', 'справа', 'сверху', 'снизу')
>>> nolabels = {s: False for s in side}
>>> nolabels.update ({'label% s'% s: false для s в сторонах})
>>> печать (без меток)
{'left': Ложь, 'right': Ложь, 'top': Ложь, 'bottom': Ложь, 'labelleft': Ложь,
 labelright: False, labeltop: False, labelbottom: False}
  

Затем мы можем использовать диспетчер контекста, чтобы отключить сетку, и вызвать matshow () для каждой оси. Наконец, нам нужно поместить цветовую панель в то, что технически является новой осью в пределах рис. . Для этого мы можем использовать немного эзотерической функции из глубины matplotlib:

  >>> from mpl_toolkits.axes_grid1.axes_divider import make_axes_locatable

>>> с plt.rc_context (rc = {'axes.grid': False}):
... fig, (ax1, ax2) = plt.subplots (1, 2, figsize = (8, 4))
... ax1.matshow (x)
... img2 = ax2.matshow (x2, cmap = 'RdYlGn_r')
... для ax in (ax1, ax2):
... ax.tick_params (axis = 'both', which = 'both', ** nolabels)
... для i, j в zip (* x.nonzero ()):
... ax1.text (j, i, x [i, j], color = 'white', ha = 'center', va = 'center')
...
... делитель = make_axes_locatable (ax2)
... cax = diverr.append_axes ("right", size = '5%', pad = 0)
... plt.colorbar (img2, cax = cax, ax = [ax1, ax2])
... fig.suptitle ('Тепловые карты с Axes.matshow', fontsize = 16)
  

График в пандах

Библиотека pandas стала популярной не только из-за возможности мощного анализа данных, но и из-за удобных заранее подготовленных методов построения графиков. Интересно, однако, что методы построения pandas на самом деле просто удобные оболочки для существующих вызовов matplotlib.

То есть метод plot (), в серии pandas и DataFrame является оболочкой вокруг plt.plot () . Например, одно удобство заключается в том, что если индекс DataFrame состоит из дат, pandas внутренне вызывает gcf (). Autofmt_xdate () для получения текущего рисунка и удобного автоматического форматирования оси x.

В свою очередь, помните, что plt.plot () (подход, основанный на состоянии) неявно осведомлен о текущей фигуре и текущих осях, поэтому pandas следует за подходом на основе состояний путем расширения.

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

  >>> импортировать панд как pd

>>> s = pd.Series (np.arange (5), index = list ('abcde'))
>>> топор = с. участок()

>>> тип (топор)


>>> id (plt.gca ()) == id (топор)
Истинный
  

Эту внутреннюю архитектуру полезно знать, когда вы смешиваете методы построения графиков pandas с традиционными вызовами matplotlib, что делается ниже при построении скользящего среднего широко наблюдаемого финансового временного ряда. ma — это серия pandas, для которой мы можем вызвать ma.plot () (метод pandas), а затем настроить, получив оси, созданные этим вызовом ( plt.gca () ), для ссылки на matplotlib:

  >>> импортировать панд как pd
>>> импортировать matplotlib.transforms как mtransforms

>>> url = 'https://fred.stlouisfed.org/graph/fredgraph.csv?id=VIXCLS'
>>> vix = pd.read_csv (url, index_col = 0, parse_dates = True, na_values ​​= '.',
... infer_datetime_format = Верно,
... squeeze = True) .dropna ()
>>> ma = vix.rolling ('90d'). mean ()
>>> state = pd.cut (ma, bins = [- np. инф, 14, 18, 24, np.inf],
... метки = диапазон (4))

>>> cmap = plt.get_cmap ('RdYlGn_r')
>>> ma.plot (color = 'black', linewidth = 1.5, marker = '', figsize = (8, 4),
... label = 'VIX 90d MA')
>>> ax = plt.gca () # Получить текущие оси, на которые ссылается ma.plot ()
>>> ax.set_xlabel ('')
>>> ax.set_ylabel ('90-дневная скользящая средняя: CBOE VIX')
>>> ax.set_title ('Состояние режима волатильности')
>>> ax.grid (Ложь)
>>> ax.legend (loc = 'верхний центр')
>>> топор.set_xlim (xmin = ma.index [0], xmax = ma.index [-1])

>>> trans = mtransforms.bleded_transform_factory (ax.transData, ax.transAxes)
>>> для i, цвет в enumerate (cmap ([0.2, 0.4, 0.6, 0.8])):
... ax.fill_between (ma.index, 0, 1, где = состояние == i,
... цвет лица = цвет, преобразование = транс)
>>> ax.axhline (vix.mean (), linestyle = 'dashed', color = 'xkcd: темно-серый',
... альфа = 0,6, метка = 'Среднее за весь период', маркер = '')
  

Выше много чего происходит:

• ma — 90-дневная скользящая средняя индекса VIX, мера рыночных ожиданий в отношении краткосрочной волатильности акций. Состояние — это объединение скользящего среднего в различные режимные состояния. Высокий показатель VIX считается сигналом повышенного уровня страха на рынке.

• cmap — это ColorMap — объект matplotlib, который, по сути, является отображением поплавков в цвета RGBA. Любую цветовую карту можно перевернуть, добавив '_r' , поэтому 'RdYlGn_r' — это перевернутая цветовая карта: красный-желтый-зеленый. В документации Matplotlib есть удобный визуальный справочник по ColorMaps.

• Единственный реальный вызов панд, который мы делаем здесь, — это ma.plot () . Это вызывает внутри plt.plot () , поэтому для интеграции объектно-ориентированного подхода нам нужно получить явную ссылку на текущие оси с ax = plt.gca () .

• Второй фрагмент кода создает блоки с цветовой заливкой, которые соответствуют каждому бину состояния . cmap ([0,2, 0,4, 0,6, 0,8]). говорит: «Получите последовательность RGBA для цветов в 20-м, 40-м, 60-м и 80-м« процентилях »по спектру ColorMaps.” enumerate () используется, потому что мы хотим отобразить каждый цвет RGBA обратно в состояние.

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

Завершение

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

Однако понимание того, как взаимодействуют интерфейсы matplotlib, — это вложение, которое может окупиться в будущем. Как советовал Дэн Бейдер из Real Python, потратить время на анализ кода, а не прибегать к решению Stack Overflow «копировать макароны», как правило, является более разумным долгосрочным решением. Придерживаясь объектно-ориентированного подхода, вы можете сэкономить часы разочарования, когда вы захотите превратить сюжет из простого в произведение искусства.

Дополнительные ресурсы

Из документации matplotlib:

• Индекс примеров matplotlib
• FAQ по использованию
• Страница руководств, разделенная на разделы для начинающих, среднего и продвинутого уровней
• Жизненный цикл сюжета, который затрагивает объектно-ориентированный подход и подход с отслеживанием состояния

Сторонние ресурсы:

Другие графические библиотеки:

• Библиотека seaborn, построенная на основе matplotlib и разработанная для расширенной статистической графики, которая сама по себе может занять весь учебник
• Datashader, графическая библиотека, специально предназначенная для больших наборов данных
• Список других сторонних пакетов из документации matplotlib

Приложение A: Конфигурация и стиль

Если вы следовали этому руководству, вполне вероятно, что графики, появляющиеся на вашем экране, выглядят стилистически иначе, чем показанные здесь.

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

1. Путем настройки файла matplotlibrc
2. Путем изменения параметров конфигурации в интерактивном режиме или из сценария .py .

Файл matplotlibrc (вариант № 1 выше) — это, по сути, текстовый файл, определяющий пользовательские настройки, которые запоминаются между сеансами Python. В Mac OS X он обычно находится по адресу ~ / .matplotlib / matplotlibrc .

Подсказка: GitHub — отличное место для хранения файлов конфигурации. Я держу здесь свой. Просто убедитесь, что они не содержат личную или конфиденциальную информацию, такую ​​как пароли или закрытые ключи SSH!

В качестве альтернативы вы можете изменить параметры конфигурации в интерактивном режиме (вариант № 2 выше). Когда вы импортируете matplotlib.pyplot как plt , вы получаете доступ к объекту rcParams , который напоминает словарь настроек Python. Все объекты модуля, начинающиеся с «rc», являются средством взаимодействия с вашими стилями и настройками графика:

  >>> [attr для attr в каталоге (plt), если attr.начинается с ('rc')]
['rc', 'rcParams', 'rcParamsDefault', 'rc_context', 'rcdefaults']
  

из них:

• plt.rcdefaults () восстанавливает параметры rc из внутренних значений по умолчанию matplotlib, которые перечислены в plt.rcParamsDefault . Это вернет (перезапишет) все, что вы уже настроили в файле matplotlibrc.
• plt.rc () используется для интерактивной настройки параметров.
• plt.rcParams — это (изменяемый) объект, подобный словарю, который позволяет напрямую управлять настройками.Если вы настроили индивидуальные настройки в файле matplotlibrc, они будут отражены в этом словаре.

С plt.rc () и plt.rcParams эти два синтаксиса эквивалентны для настройки параметров:

  >>> plt. rc ('lines', linewidth = 2, color = 'r') # Синтаксис 1

>>> plt.rcParams ['lines.linewidth'] = 2 # Синтаксис 2
>>> plt.rcParams ['lines.color'] = 'r'
  

Примечательно, что класс Figure затем использует некоторые из них в качестве аргументов по умолчанию.

Соответственно, стиль — это просто заранее определенный набор пользовательских настроек. Для просмотра доступных стилей используйте:

  >>> plt.style.available
['seaborn-dark', 'seaborn-darkgrid', 'seaborn-ticks', 'пятьдесят восемь',
 'seaborn-whitegrid', 'classic', '_classic_test', 'быстрый', 'seaborn-talk',
 "морская-темная-палитра", "морская-яркая", "морская-пастельная", "оттенки серого",
 'seaborn-notebook', 'ggplot', 'seaborn-colorblind', 'seaborn-приглушенный',
 'seaborn', 'Solarize_Light2', 'seaborn-paper', 'bmh', 'морской-белый',
 'dark_background', 'seaborn-poster', 'seaborn-deep']
  

Чтобы задать стиль, позвоните по номеру:

  >>> plt.style.use ('пятьдесят восемь')
  

Ваши участки приобретут новый вид:

Этот полный пример доступен здесь.

Для вдохновения в matplotlib также есть несколько дисплеев таблиц стилей для справки.

Приложение B: Интерактивный режим

За кулисами matplotlib также взаимодействует с различными бэкэндами. Бэкэнд — это рабочая лошадка, стоящая за отрисовкой диаграммы. (Например, в популярном дистрибутиве Anaconda бэкэнд по умолчанию — Qt5Agg.) Некоторые бэкэнды интерактивны, то есть они динамически обновляются и «всплывают» для пользователя при изменении.

Хотя интерактивный режим по умолчанию отключен, вы можете проверить его статус с помощью plt.rcParams ['interactive'] или plt.isinteractive () , а также включать и выключать его с помощью plt.ion () и plt.ioff () , соответственно:

  >>> plt.rcParams ['interactive'] # или: plt.isinteractive ()
Истинный
  

  >>> plt.ioff ()
>>> plt.rcParams ['интерактивный']
Ложь
  

В некоторых примерах кода вы можете заметить присутствие plt. show () в конце фрагмента кода. Основная цель plt.show () , как следует из названия, состоит в том, чтобы фактически «показать» (открыть) рисунок, когда вы работаете с выключенным интерактивным режимом. Другими словами:

• Если включен интерактивный режим, plt.show () не требуется, и изображения будут автоматически всплывать и обновляться по мере обращения к ним.
• Если интерактивный режим выключен, вам понадобится plt.show () для отображения фигуры и plt.draw () для обновления графика.

Ниже мы убеждаемся, что интерактивный режим отключен, что требует вызова plt.show () после построения самого графика:

  >>> plt.ioff ()
>>> x = np.arange (-4, 5)
>>> у1 = х ** 2
>>> у2 = 10 / (х ** 2 + 1)
>>> fig, ax = plt.subplots ()
>>> топор.plot (x, y1, 'rx', x, y2, 'b +', linestyle = 'solid')
>>> ax.fill_between (x, y1, y2, где = y2> y1, interpolate = True,
...  цвет = 'зеленый', альфа = 0,3)
>>> lgnd = ax.legend (['y1', 'y2'], loc = 'верхний центр', тень = True)
>>> lgnd.get_frame (). set_facecolor ('# ffb19a')
>>> plt.show ()
  

Примечательно, что интерактивный режим не имеет никакого отношения к используемой вами среде IDE или к тому, включили ли вы встроенное построение с помощью чего-то вроде jupyter notebook --matplotlib inline или % matplotlib .

Смотреть сейчас В этом руководстве есть связанный видеокурс, созданный командой Real Python. Посмотрите его вместе с письменным руководством, чтобы углубить свое понимание: Python Plotting With Matplotlib

.