Визуализация

Мы используем стандартную конвенцию для ссылки на API matplotlib:

In [1]: import matplotlib.pyplot as plt

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

import matplotlib
matplotlib.style.use('ggplot')

Мы предоставляем основы в pandas для лёгкого создания привлекательных диаграмм. См. раздел экосистемы для библиотек визуализации, которые выходят за рамки основных представленных здесь.

Основные диаграммы: plot

См. кулинарную книгу для некоторых продвинутых стратегий

Метод plot в Series и DataFrame — это просто обертка вокруг plt.plot():

In [2]: ts = pd.Series(np.random.randn(1000), index=pd.date_range('1/1/2000', periods=1000))

In [3]: ts = ts.cumsum()

In [4]: ts.plot()
Out[4]: <matplotlib.axes._subplots.AxesSubplot at 0x7ff26d422750>

Если индекс состоит из дат, он вызывает gcf().autofmt_xdate(), чтобы красиво отформатировать ось x, как описано выше.

В DataFrame, plot() — это удобная функция для построения всех столбцов с метками:

In [5]: df = pd.DataFrame(np.random.randn(1000, 4), index=ts.index, columns=list('ABCD'))

In [6]: df = df.cumsum()

In [7]: plt.figure(); df.plot();

Вы можете построить один столбец против другого, используя ключевые слова x и y в plot():

In [8]: df3 = pd.DataFrame(np.random.randn(1000, 2), columns=['B', 'C']).cumsum()

In [9]: df3['A'] = pd.Series(list(range(len(df))))

In [10]: df3.plot(x='A', y='B')
Out[10]: <matplotlib.axes._subplots.AxesSubplot at 0x7ff2667845d0>

Другие диаграммы

Методы построения диаграмм поддерживают несколько стилей диаграмм, помимо стандартной линейной диаграммы. Эти методы могут быть предоставлены в качестве ключевого аргумента kind для plot(). К ним относятся:

• ‘bar’ или ‘barh’ для столбчатых диаграмм
• ‘hist’ для гистограмм
• ‘box’ для ящиковых диаграмм
• ‘kde’ или 'density' для диаграмм плотности
• ‘area’ для диаграмм областей
• ‘scatter’ для диаграмм рассеяния
• ‘hexbin’ для диаграмм гексагонального разбиения
• ‘pie’ для круговых диаграмм

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

In [11]: plt.figure();

In [12]: df.ix[5].plot(kind='bar'); plt.axhline(0, color='k')
Out[12]: <matplotlib.lines.Line2D at 0x7ff266b33890>

Вы также можете создать эти другие диаграммы, используя методы DataFrame.plot.<kind> вместо предоставления ключевого аргумента kind. Это облегчает поиск методов построения диаграмм и используемых ими аргументов:

In [13]: df = pd.DataFrame()

In [14]: df.plot.<TAB>
df.plot.area     df.plot.barh     df.plot.density  df.plot.hist     df.plot.line     df.plot.scatter
df.plot.bar      df.plot.box      df.plot.hexbin   df.plot.kde      df.plot.pie

Помимо этих kind есть методы DataFrame.hist() и DataFrame.boxplot(), которые используют отдельный интерфейс.

Наконец, есть несколько функций построения диаграмм в pandas.tools.plotting, которые принимают Series или DataFrame в качестве аргумента. К ним относятся

• Матрица рассеяния
• Кривые Эндрюса
• Параллельные координаты
• Диаграмма запаздывания
• Диаграмма автокорреляции
• Диаграмма бутстрепа
• RadViz

Диаграммы также могут быть дополнены ошибками или таблицами.

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

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

In [15]: plt.figure();

In [16]: df.ix[5].plot.bar(); plt.axhline(0, color='k')
Out[16]: <matplotlib.lines.Line2D at 0x7ff2673d3510>

Вызов метода DataFrame plot.bar() создаёт диаграмму с несколькими столбцами:

In [17]: df2 = pd.DataFrame(np.random.rand(10, 4), columns=['a', 'b', 'c', 'd'])

In [18]: df2.plot.bar();

Для создания столбчатой диаграммы с накоплением передайте stacked=True:

In [19]: df2.plot.bar(stacked=True);

Для получения горизонтальных столбчатых диаграмм используйте метод barh:

In [20]: df2.plot.barh(stacked=True);

Гистограммы

Гистограмму можно построить, используя методы DataFrame.plot.hist() и Series.plot.hist().

In [21]: df4 = pd.DataFrame({'a': np.random.randn(1000) + 1, 'b': np.random.randn(1000),
   ....:                     'c': np.random.randn(1000) - 1}, columns=['a', 'b', 'c'])
   ....: 

In [22]: plt.figure();

In [23]: df4.plot.hist(alpha=0.5)
Out[23]: <matplotlib.axes._subplots.AxesSubplot at 0x7ff26779c3d0>

Гистограмму можно сделать ступенчатой, используя stacked=True. Размер ячейки можно изменить с помощью ключевого слова bins.

In [24]: plt.figure();

In [25]: df4.plot.hist(stacked=True, bins=20)
Out[25]: <matplotlib.axes._subplots.AxesSubplot at 0x7ff26caf76d0>

Вы можете передать другие ключевые слова, поддерживаемые matplotlib hist. Например, горизонтальную и кумулятивную гистограмму можно построить, используя orientation='horizontal' и cumulative='True'.

In [26]: plt.figure();

In [27]: df4['a'].plot.hist(orientation='horizontal', cumulative=True)
Out[27]: <matplotlib.axes._subplots.AxesSubplot at 0x7ff26c2c89d0>

См. метод hist и документацию matplotlib по гистограммам matplotlib hist documentation для получения более подробной информации.

Существующий интерфейс DataFrame.hist для построения гистограмм по-прежнему поддерживается.

In [28]: plt.figure();

In [29]: df['A'].diff().hist()
Out[29]: <matplotlib.axes._subplots.AxesSubplot at 0x7ff2770919d0>

DataFrame.hist() строит гистограммы столбцов на нескольких поддиаграммах:

In [30]: plt.figure()
Out[30]: <matplotlib.figure.Figure at 0x7ff26d67c090>

In [31]: df.diff().hist(color='k', alpha=0.5, bins=50)
Out[31]: 
array([[<matplotlib.axes._subplots.AxesSubplot object at 0x7ff2726264d0>,
        <matplotlib.axes._subplots.AxesSubplot object at 0x7ff2667c8390>],
       [<matplotlib.axes._subplots.AxesSubplot object at 0x7ff266667a50>,
        <matplotlib.axes._subplots.AxesSubplot object at 0x7ff2671545d0>]], dtype=object)

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

In [32]: data = pd.Series(np.random.randn(1000))

In [33]: data.hist(by=np.random.randint(0, 4, 1000), figsize=(6, 4))
Out[33]: 
array([[<matplotlib.axes._subplots.AxesSubplot object at 0x7ff266750690>,
        <matplotlib.axes._subplots.AxesSubplot object at 0x7ff26c71e110>],
       [<matplotlib.axes._subplots.AxesSubplot object at 0x7ff26735f750>,
        <matplotlib.axes._subplots.AxesSubplot object at 0x7ff26c2fe650>]], dtype=object)

Диаграммы размаха

Диаграммы размаха можно построить, вызвав Series.plot.box() и DataFrame.plot.box(), или DataFrame.boxplot() для визуализации распределения значений в каждом столбце.

Например, вот диаграмма размаха, представляющая пять испытаний по 10 наблюдениям случайной равномерной величины на [0,1).

In [34]: df = pd.DataFrame(np.random.rand(10, 5), columns=['A', 'B', 'C', 'D', 'E'])

In [35]: df.plot.box()
Out[35]: <matplotlib.axes._subplots.AxesSubplot at 0x7ff27132a050>

Диаграмму размаха можно окрасить, передав ключевое слово color . Вы можете передать dict, ключами которого являются boxes, whiskers, medians и caps. Если некоторые ключи отсутствуют в dict, для соответствующих элементов используются значения по умолчанию. Также в диаграмме размаха есть ключевое слово sym для указания стиля выбросов.

При передаче других типов аргументов через ключевое слово color, они будут напрямую переданы в matplotlib для всех boxes, whiskers, medians и caps раскраски.

Цвета применяются ко всем блокам. Если вам нужна более сложная раскраска, вы можете получить каждый нарисованный элемент, передав return_type.

In [36]: color = dict(boxes='DarkGreen', whiskers='DarkOrange',
   ....:              medians='DarkBlue', caps='Gray')
   ....: 

In [37]: df.plot.box(color=color, sym='r+')
Out[37]: <matplotlib.axes._subplots.AxesSubplot at 0x7ff26c76b890>

Также вы можете передать другие ключевые слова, поддерживаемые matplotlib boxplot. Например, горизонтальную и пользовательскую диаграмму размаха можно построить, используя ключевые слова vert=False и positions.

In [38]: df.plot.box(vert=False, positions=[1, 4, 5, 6, 8])
Out[38]: <matplotlib.axes._subplots.AxesSubplot at 0x7ff26c1f2dd0>

См. метод boxplot и документацию matplotlib по диаграммам размаха matplotlib boxplot documentation для получения более подробной информации.

Существующий интерфейс DataFrame.boxplot для построения диаграмм размаха по-прежнему поддерживается.

In [39]: df = pd.DataFrame(np.random.rand(10,5))

In [40]: plt.figure();

In [41]: bp = df.boxplot()

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

In [42]: df = pd.DataFrame(np.random.rand(10,2), columns=['Col1', 'Col2'] )

In [43]: df['X'] = pd.Series(['A','A','A','A','A','B','B','B','B','B'])

In [44]: plt.figure();

In [45]: bp = df.boxplot(by='X')

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

In [46]: df = pd.DataFrame(np.random.rand(10,3), columns=['Col1', 'Col2', 'Col3'])

In [47]: df['X'] = pd.Series(['A','A','A','A','A','B','B','B','B','B'])

In [48]: df['Y'] = pd.Series(['A','B','A','B','A','B','A','B','A','B'])

In [49]: plt.figure();

In [50]: bp = df.boxplot(column=['Col1','Col2'], by=['X','Y'])

В boxplot, тип возвращаемого значения можно контролировать с помощью ключевого аргумента return_type. Допустимые значения — {"axes", "dict", "both", None}. Факеттирование, создаваемое с помощью DataFrame.boxplot с ключевым аргументом by, также повлияет на тип возвращаемого значения:

Groupby.boxplot всегда возвращает ряд return_type.

In [51]: np.random.seed(1234)

In [52]: df_box = pd.DataFrame(np.random.randn(50, 2))

In [53]: df_box['g'] = np.random.choice(['A', 'B'], size=50)

In [54]: df_box.loc[df_box['g'] == 'B', 1] += 3

In [55]: bp = df_box.boxplot(by='g')

Сравните с:

In [56]: bp = df_box.groupby('g').boxplot()

График областей

Вы можете создать графики областей с помощью Series.plot.area() и DataFrame.plot.area(). Графики областей по умолчанию являются накопительными. Для создания накопительного графика областей каждый столбец должен содержать либо только положительные, либо только отрицательные значения.

Если входные данные содержат NaN, они автоматически заполняются 0. Если вы хотите удалить или заполнить их другими значениями, используйте dataframe.dropna() или dataframe.fillna() перед вызовом plot.

In [57]: df = pd.DataFrame(np.random.rand(10, 4), columns=['a', 'b', 'c', 'd'])

In [58]: df.plot.area();

Чтобы создать не накопительный график, передайте stacked=False. Значение альфы устанавливается в 0.5, если не указано иное:

In [59]: df.plot.area(stacked=False);

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

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

In [60]: df = pd.DataFrame(np.random.rand(50, 4), columns=['a', 'b', 'c', 'd'])

In [61]: df.plot.scatter(x='a', y='b');

Чтобы построить несколько групп столбцов на одной оси, повторите метод plot, указав целевые ax. Рекомендуется указать ключевые аргументы color и label, чтобы различать группы.

In [62]: ax = df.plot.scatter(x='a', y='b', color='DarkBlue', label='Group 1');

In [63]: df.plot.scatter(x='c', y='d', color='DarkGreen', label='Group 2', ax=ax);

Ключевой аргумент c может быть задан как имя столбца для задания цвета каждой точки:

In [64]: df.plot.scatter(x='a', y='b', c='c', s=50);

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

In [65]: df.plot.scatter(x='a', y='b', s=df['c']*200);

См. метод scatter и документацию matplotlib scatter для получения дополнительной информации.

Диаграмма гексагональных ячеек

Вы можете создать диаграмму гексагональных ячеек с помощью DataFrame.plot.hexbin(). Диаграммы гексагональных ячеек могут быть полезной альтернативой диаграммам рассеяния, если данные слишком плотные, чтобы отобразить каждую точку индивидуально.

In [66]: df = pd.DataFrame(np.random.randn(1000, 2), columns=['a', 'b'])

In [67]: df['b'] = df['b'] + np.arange(1000)

In [68]: df.plot.hexbin(x='a', y='b', gridsize=25)
Out[68]: <matplotlib.axes._subplots.AxesSubplot at 0x7ff2713ce350>

Полезным ключевым аргументом является gridsize; он контролирует количество гексагонов по оси x и по умолчанию равен 100. Более большое значение gridsize означает больше, более мелких ячеек.

По умолчанию вычисляется гистограмма подсчетов вокруг каждой (x, y) точки. Вы можете указать альтернативные агрегации, передав значения в аргументы C и reduce_C_function. C задает значение в каждой (x, y) точке, а reduce_C_function — это функция от одного аргумента, которая сводит все значения в ячейке к одному числу (например, mean, max, sum, std). В этом примере координаты задаются столбцами a и b, а значение — столбцом z. Ячейки агрегируются с помощью функции numpy max.

In [69]: df = pd.DataFrame(np.random.randn(1000, 2), columns=['a', 'b'])

In [70]: df['b'] = df['b'] = df['b'] + np.arange(1000)

In [71]: df['z'] = np.random.uniform(0, 3, 1000)

In [72]: df.plot.hexbin(x='a', y='b', C='z', reduce_C_function=np.max,
   ....:         gridsize=25)
   ....: 
Out[72]: <matplotlib.axes._subplots.AxesSubplot at 0x7ff2669b58d0>

См. метод hexbin и документацию matplotlib hexbin для получения дополнительной информации.

Круговая диаграмма

Вы можете создать круговую диаграмму с помощью DataFrame.plot.pie() или Series.plot.pie(). Если в данных есть NaN, они автоматически заполняются 0. Будет выброшено исключение ValueError, если в данных есть отрицательные значения.

In [73]: series = pd.Series(3 * np.random.rand(4), index=['a', 'b', 'c', 'd'], name='series')

In [74]: series.plot.pie(figsize=(6, 6))
Out[74]: <matplotlib.axes._subplots.AxesSubplot at 0x7ff26c8ac210>

Для круговых диаграмм лучше использовать квадратные фигуры с равным соотношением сторон. Вы можете создать фигуру с равной шириной и высотой или принудительно установить равное соотношение сторон после построения графика, вызвав ax.set_aspect('equal') на возвращенном объекте axes.

Обратите внимание, что круговая диаграмма с DataFrame требует, чтобы вы либо указали целевой столбец с помощью аргумента y или subplots=True. Когда указан y, строится круговая диаграмма для выбранного столбца. Если указан subplots=True, для каждого столбца строятся круговые диаграммы как подграфики. По умолчанию в каждой круговой диаграмме будет отображаться легенда; укажите legend=False, чтобы ее скрыть.

In [75]: df = pd.DataFrame(3 * np.random.rand(4, 2), index=['a', 'b', 'c', 'd'], columns=['x', 'y'])

In [76]: df.plot.pie(subplots=True, figsize=(8, 4))
Out[76]: 
array([<matplotlib.axes._subplots.AxesSubplot object at 0x7ff26c896f50>,
       <matplotlib.axes._subplots.AxesSubplot object at 0x7ff26ceb2750>], dtype=object)

Вы можете использовать ключевые аргументы labels и colors для указания меток и цветов каждого сегмента.

Если вы хотите скрыть метки сегментов, укажите labels=None. Если указано fontsize, это значение будет применено к меткам сегментов. Также можно использовать другие ключевые аргументы, поддерживаемые matplotlib.pyplot.pie().

In [77]: series.plot.pie(labels=['AA', 'BB', 'CC', 'DD'], colors=['r', 'g', 'b', 'c'],
   ....:                 autopct='%.2f', fontsize=20, figsize=(6, 6))
   ....: 
Out[77]: <matplotlib.axes._subplots.AxesSubplot at 0x7ff270fede50>

Если вы передаете значения, сумма которых меньше 1.0, matplotlib рисует полукруг.

In [78]: series = pd.Series([0.1] * 4, index=['a', 'b', 'c', 'd'], name='series2')

In [79]: series.plot.pie(figsize=(6, 6))
Out[79]: <matplotlib.axes._subplots.AxesSubplot at 0x7ff26c39e9d0>

См. документацию matplotlib pie для получения дополнительной информации.

Построение графиков с пропущенными данными

Pandas пытается быть прагматичным при построении графиков DataFrames или Series, содержащих пропущенные данные. Пропущенные значения удаляются, пропускаются или заполняются в зависимости от типа графика.

Если какое-либо из этих значений по умолчанию не соответствует вашим требованиям или вы хотите явно указать, как обрабатывать пропущенные значения, рассмотрите использование fillna() или dropna() перед построением графика.

Инструменты для построения графиков

Эти функции можно импортировать из pandas.tools.plotting и принять Series или DataFrame в качестве аргумента.

Матрица диаграмм рассеяния

Вы можете создать матрицу диаграмм рассеяния, используя метод scatter_matrix в pandas.tools.plotting:

In [80]: from pandas.tools.plotting import scatter_matrix

In [81]: df = pd.DataFrame(np.random.randn(1000, 4), columns=['a', 'b', 'c', 'd'])

In [82]: scatter_matrix(df, alpha=0.2, figsize=(6, 6), diagonal='kde')
Out[82]: 
array([[<matplotlib.axes._subplots.AxesSubplot object at 0x7ff26def9410>,
        <matplotlib.axes._subplots.AxesSubplot object at 0x7ff2705099d0>,
        <matplotlib.axes._subplots.AxesSubplot object at 0x7ff26cff4050>,
        <matplotlib.axes._subplots.AxesSubplot object at 0x7ff26e422990>],
       [<matplotlib.axes._subplots.AxesSubplot object at 0x7ff26e1ffe10>,
        <matplotlib.axes._subplots.AxesSubplot object at 0x7ff26d005250>,
        <matplotlib.axes._subplots.AxesSubplot object at 0x7ff2701eb2d0>,
        <matplotlib.axes._subplots.AxesSubplot object at 0x7ff26d058090>],
       [<matplotlib.axes._subplots.AxesSubplot object at 0x7ff267867110>,
        <matplotlib.axes._subplots.AxesSubplot object at 0x7ff2679232d0>,
        <matplotlib.axes._subplots.AxesSubplot object at 0x7ff271ddb290>,
        <matplotlib.axes._subplots.AxesSubplot object at 0x7ff26ee92210>],
       [<matplotlib.axes._subplots.AxesSubplot object at 0x7ff26ddd2350>,
        <matplotlib.axes._subplots.AxesSubplot object at 0x7ff26e2142d0>,
        <matplotlib.axes._subplots.AxesSubplot object at 0x7ff26df3d0d0>,
        <matplotlib.axes._subplots.AxesSubplot object at 0x7ff26d59c2d0>]], dtype=object)

График плотности

Вы можете создавать графики плотности, используя методы Series.plot.kde() и DataFrame.plot.kde().

In [83]: ser = pd.Series(np.random.randn(1000))

In [84]: ser.plot.kde()
Out[84]: <matplotlib.axes._subplots.AxesSubplot at 0x7ff266c28d10>

Кривые Эндрюса

Кривые Эндрюса позволяют отображать многомерные данные в виде множества кривых, созданных с помощью атрибутов выборок в качестве коэффициентов для рядов Фурье. Различная цветовая маркировка кривых для каждого класса позволяет визуализировать кластеризацию данных. Кривые, относящиеся к выборкам одного класса, обычно будут располагаться ближе друг к другу и образовывать более крупные структуры.

Примечание: Набор данных «Ирис» доступен здесь.

In [85]: from pandas.tools.plotting import andrews_curves

In [86]: data = pd.read_csv('data/iris.data')

In [87]: plt.figure()
Out[87]: <matplotlib.figure.Figure at 0x7ff26c276bd0>

In [88]: andrews_curves(data, 'Name')
Out[88]: <matplotlib.axes._subplots.AxesSubplot at 0x7ff270a8a9d0>

Параллельные координаты

Параллельные координаты — это метод построения графиков для многомерных данных. Он позволяет визуально увидеть кластеры в данных и оценить другие статистические показатели. Используя параллельные координаты, точки представлены соединёнными отрезками прямых. Каждая вертикальная линия представляет один атрибут. Один набор соединённых отрезков прямых представляет одну точку данных. Точки, которые имеют тенденцию к кластеризации, будут казаться расположенными ближе друг к другу.

In [89]: from pandas.tools.plotting import parallel_coordinates

In [90]: data = pd.read_csv('data/iris.data')

In [91]: plt.figure()
Out[91]: <matplotlib.figure.Figure at 0x7ff26798f850>

In [92]: parallel_coordinates(data, 'Name')
Out[92]: <matplotlib.axes._subplots.AxesSubplot at 0x7ff267994810>

График запаздывания

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

In [93]: from pandas.tools.plotting import lag_plot

In [94]: plt.figure()
Out[94]: <matplotlib.figure.Figure at 0x7ff26dd75d10>

In [95]: data = pd.Series(0.1 * np.random.rand(1000) +
   ....:     0.9 * np.sin(np.linspace(-99 * np.pi, 99 * np.pi, num=1000)))
   ....: 

In [96]: lag_plot(data)
Out[96]: <matplotlib.axes._subplots.AxesSubplot at 0x7ff26dd75910>

График автокорреляции

Графики автокорреляции часто используются для проверки случайности временных рядов. Это делается путём вычисления автокорреляций для значений данных при различных временных лагах. Если временной ряд является случайным, такие автокорреляции должны быть близки к нулю для любого и всех временных отставаний. Если временной ряд не является случайным, то одна или несколько автокорреляций будут существенно отличаться от нуля. Горизонтальные линии на графике соответствуют доверительным интервалам 95% и 99%. Пунктирная линия соответствует доверительному интервалу 99%.

In [97]: from pandas.tools.plotting import autocorrelation_plot

In [98]: plt.figure()
Out[98]: <matplotlib.figure.Figure at 0x7ff267d7a350>

In [99]: data = pd.Series(0.7 * np.random.rand(1000) +
   ....:    0.3 * np.sin(np.linspace(-9 * np.pi, 9 * np.pi, num=1000)))
   ....: 

In [100]: autocorrelation_plot(data)
Out[100]: <matplotlib.axes._subplots.AxesSubplot at 0x7ff26dd79ad0>

График бутстрапа

Графики бутстрапа используются для визуальной оценки неопределённости статистической величины, такой как среднее значение, медиана, среднее арифметическое и т.д. Случайная подвыборка указанного размера выбирается из набора данных, вычисляется интересующая статистика для этой подвыборки, и этот процесс повторяется определённое число раз. Результирующие графики и гистограммы составляют график бутстрапа.

In [101]: from pandas.tools.plotting import bootstrap_plot

In [102]: data = pd.Series(np.random.rand(1000))

In [103]: bootstrap_plot(data, size=50, samples=500, color='grey')
Out[103]: <matplotlib.figure.Figure at 0x7ff2677380d0>

RadViz

RadViz — способ визуализации многомерных данных. Он основан на простом алгоритме минимизации натяжения пружин. В основном, вы создаёте набор точек на плоскости. В нашем случае они равномерно распределены по единичной окружности. Каждая точка представляет один атрибут. Затем вы представляете, что каждая выборка в наборе данных присоединена к каждой из этих точек пружиной, жёсткость которой пропорциональна численному значению этого атрибута (они нормализованы к единичному интервалу). Точка на плоскости, к которой наша выборка стремится (где действующие на нашу выборку силы находятся в равновесии), является местом, где будет нарисован кружок, представляющий нашу выборку. В зависимости от того, к какому классу принадлежит эта выборка, она будет окрашена по-разному.

Примечание: Набор данных «Ирис» доступен здесь.

In [104]: from pandas.tools.plotting import radviz

In [105]: data = pd.read_csv('data/iris.data')

In [106]: plt.figure()
Out[106]: <matplotlib.figure.Figure at 0x7ff26e5d5190>

In [107]: radviz(data, 'Name')
Out[107]: <matplotlib.axes._subplots.AxesSubplot at 0x7ff26ebc86d0>

Форматирование графиков

Большинство методов построения графиков имеют набор ключевых аргументов, которые контролируют макет и форматирование возвращаемого графика:

In [108]: plt.figure(); ts.plot(style='k--', label='Series');

Для каждого типа графика (например, line, bar, scatter) все дополнительные ключевые аргументы передаются соответствующей функции matplotlib (ax.plot(), ax.bar(), ax.scatter()). Эти аргументы могут использоваться для дополнительной стилизации, выходящей за рамки возможностей pandas.

Управление легендой

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

In [109]: df = pd.DataFrame(np.random.randn(1000, 4), index=ts.index, columns=list('ABCD'))

In [110]: df = df.cumsum()

In [111]: df.plot(legend=False)
Out[111]: <matplotlib.axes._subplots.AxesSubplot at 0x7ff26e65d590>

Масштабы

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

In [112]: ts = pd.Series(np.random.randn(1000), index=pd.date_range('1/1/2000', periods=1000))

In [113]: ts = np.exp(ts.cumsum())

In [114]: ts.plot(logy=True)
Out[114]: <matplotlib.axes._subplots.AxesSubplot at 0x7ff2704da990>

См. также ключевые аргументы logx и loglog.

Построение на дополнительной оси Y

Для построения данных на дополнительной оси Y используйте ключевой аргумент secondary_y:

In [115]: df.A.plot()
Out[115]: <matplotlib.axes._subplots.AxesSubplot at 0x7ff26e663290>

In [116]: df.B.plot(secondary_y=True, style='g')
Out[116]: <matplotlib.axes._subplots.AxesSubplot at 0x7ff26e10e1d0>

Для построения некоторых столбцов в DataFrame передайте имена столбцов ключевому аргументу secondary_y:

In [117]: plt.figure()
Out[117]: <matplotlib.figure.Figure at 0x7ff26cd69450>

In [118]: ax = df.plot(secondary_y=['A', 'B'])

In [119]: ax.set_ylabel('CD scale')
Out[119]: <matplotlib.text.Text at 0x7ff26c8112d0>

In [120]: ax.right_ax.set_ylabel('AB scale')
Out[120]: <matplotlib.text.Text at 0x7ff266f57710>

Обратите внимание, что столбцы, построенные на дополнительной оси Y, автоматически помечаются «(справа)» в легенде. Чтобы отключить автоматическую маркировку, используйте ключевой аргумент mark_right=False:

In [121]: plt.figure()
Out[121]: <matplotlib.figure.Figure at 0x7ff26752ced0>

In [122]: df.plot(secondary_y=['A', 'B'], mark_right=False)
Out[122]: <matplotlib.axes._subplots.AxesSubplot at 0x7ff267a133d0>

Отключение автоматической подстройки разрешения делений

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

Вот поведение по умолчанию, обратите внимание, как выполняется маркировка делений оси X:

In [123]: plt.figure()
Out[123]: <matplotlib.figure.Figure at 0x7ff267a3bc10>

In [124]: df.A.plot()
Out[124]: <matplotlib.axes._subplots.AxesSubplot at 0x7ff26e538f90>

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

In [125]: plt.figure()
Out[125]: <matplotlib.figure.Figure at 0x7ff26e51add0>

In [126]: df.A.plot(x_compat=True)
Out[126]: <matplotlib.axes._subplots.AxesSubplot at 0x7ff26eae0b10>

Если у вас есть несколько графиков, которые нужно отключить, метод use в pandas.plot_params может быть использован в with statement:

In [127]: plt.figure()
Out[127]: <matplotlib.figure.Figure at 0x7ff26dea43d0>

In [128]: with pd.plot_params.use('x_compat', True):
   .....:     df.A.plot(color='r')
   .....:     df.B.plot(color='g')
   .....:     df.C.plot(color='b')
   .....: 

Подграфики

Каждый Series в DataFrame может быть построен на другой оси с использованием ключевого аргумента subplots:

In [129]: df.plot(subplots=True, figsize=(6, 6));

Использование макета и нацеливание на несколько осей

Макет подграфиков можно задать с помощью ключевого аргумента layout. Он может принимать (rows, columns). Ключевой аргумент layout также может быть использован в hist и boxplot. Если вход некорректен, будет выброшено исключение ValueError.

Количество осей, которое может содержать макет, заданное строками x столбцами с помощью layout, должно быть больше количества необходимых подграфиков. Если макет может содержать больше осей, чем требуется, пустые оси не отрисовываются. Аналогично методу reshape массива numpy, вы можете использовать -1 для одной размерности, чтобы автоматически рассчитать количество строк или столбцов, учитывая другую.

In [130]: df.plot(subplots=True, layout=(2, 3), figsize=(6, 6), sharex=False);

Приведённый выше пример идентичен использованию

In [131]: df.plot(subplots=True, layout=(2, -1), figsize=(6, 6), sharex=False);

Необходимое количество столбцов (3) определяется из количества рядов для построения и заданного количества строк (2).

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

Когда несколько осей передаются через ключевой аргумент ax, ключевые аргументы layout, sharex и sharey не влияют на вывод. Вам следует явно передать sharex=False и sharey=False, иначе вы увидите предупреждение.

In [132]: fig, axes = plt.subplots(4, 4, figsize=(6, 6));

In [133]: plt.subplots_adjust(wspace=0.5, hspace=0.5);

In [134]: target1 = [axes[0][0], axes[1][1], axes[2][2], axes[3][3]]

In [135]: target2 = [axes[3][0], axes[2][1], axes[1][2], axes[0][3]]

In [136]: df.plot(subplots=True, ax=target1, legend=False, sharex=False, sharey=False);

In [137]: (-df).plot(subplots=True, ax=target2, legend=False, sharex=False, sharey=False);

Другой вариант — передача аргумента ax в метод Series.plot() для построения на определённой оси:

In [138]: fig, axes = plt.subplots(nrows=2, ncols=2)

In [139]: df['A'].plot(ax=axes[0,0]); axes[0,0].set_title('A');

In [140]: df['B'].plot(ax=axes[0,1]); axes[0,1].set_title('B');

In [141]: df['C'].plot(ax=axes[1,0]); axes[1,0].set_title('C');

In [142]: df['D'].plot(ax=axes[1,1]); axes[1,1].set_title('D');

Построение с ошибками

Построение с ошибками теперь поддерживается в методах DataFrame.plot() и Series.plot()

Горизонтальные и вертикальные ошибки могут быть переданы в ключевые аргументы xerr и yerr метода plot(). Значения ошибок могут быть заданы различными способами.

• В виде DataFrame или Series ошибок с именами столбцов, соответствующими атрибуту columns построения DataFrame или соответствующим атрибуту name объекта Series
• В виде строки, указывающей, какие столбцы DataFrame содержат значения ошибок.
• В виде исходных значений (list, tuple, или np.ndarray). Должны быть такой же длины, как и данные для построения DataFrame/Series

Также поддерживаются асимметричные погрешности, однако в этом случае необходимо предоставить исходные значения погрешностей. Для M длины Series должен быть предоставлен массив, указывающий нижние и верхние (или левые и правые) погрешности. Для MxN DataFrame асимметричные погрешности должны быть в массиве Mx2xN.

Вот пример того, как легко построить средние значения групп со стандартными отклонениями по исходным данным.

# Generate the data
In [143]: ix3 = pd.MultiIndex.from_arrays([['a', 'a', 'a', 'a', 'b', 'b', 'b', 'b'], ['foo', 'foo', 'bar', 'bar', 'foo', 'foo', 'bar', 'bar']], names=['letter', 'word'])

In [144]: df3 = pd.DataFrame({'data1': [3, 2, 4, 3, 2, 4, 3, 2], 'data2': [6, 5, 7, 5, 4, 5, 6, 5]}, index=ix3)

# Group by index labels and take the means and standard deviations for each group
In [145]: gp3 = df3.groupby(level=('letter', 'word'))

In [146]: means = gp3.mean()

In [147]: errors = gp3.std()

In [148]: means
Out[148]: 
             data1  data2
letter word              
a      bar     3.5    6.0
       foo     2.5    5.5
b      bar     2.5    5.5
       foo     3.0    4.5

In [149]: errors
Out[149]: 
                data1     data2
letter word                    
a      bar   0.707107  1.414214
       foo   0.707107  0.707107
b      bar   0.707107  0.707107
       foo   1.414214  0.707107

# Plot
In [150]: fig, ax = plt.subplots()

In [151]: means.plot.bar(yerr=errors, ax=ax)
Out[151]: <matplotlib.axes._subplots.AxesSubplot at 0x7ff26cc76f90>

Построение таблиц

Построение с таблицей matplotlib теперь поддерживается в DataFrame.plot() и Series.plot() с ключевым словом table. Ключевое слово table может принимать bool, DataFrame или Series. Простой способ построения таблицы — указать table=True. Данные будут транспонированы, чтобы соответствовать стандартному макету matplotlib.

In [152]: fig, ax = plt.subplots(1, 1)

In [153]: df = pd.DataFrame(np.random.rand(5, 3), columns=['a', 'b', 'c'])

In [154]: ax.get_xaxis().set_visible(False)   # Hide Ticks

In [155]: df.plot(table=True, ax=ax)
Out[155]: <matplotlib.axes._subplots.AxesSubplot at 0x7ff26c4cc5d0>

Также вы можете передать различные DataFrame или Series для ключевого слова table. Данные будут построены так, как отображается в методе печати (без автоматической транспонирования). При необходимости транспонирование должно быть выполнено вручную, как показано в примере ниже.

In [156]: fig, ax = plt.subplots(1, 1)

In [157]: ax.get_xaxis().set_visible(False)   # Hide Ticks

In [158]: df.plot(table=np.round(df.T, 2), ax=ax)
Out[158]: <matplotlib.axes._subplots.AxesSubplot at 0x7ff26ea2e690>

Наконец, существует вспомогательная функция pandas.tools.plotting.table для создания таблицы из DataFrame и Series и добавления её в matplotlib.Axes. Эта функция может принимать ключевые слова, которыми обладает таблица matplotlib.

In [159]: from pandas.tools.plotting import table

In [160]: fig, ax = plt.subplots(1, 1)

In [161]: table(ax, np.round(df.describe(), 2),
   .....:       loc='upper right', colWidths=[0.2, 0.2, 0.2])
   .....: 
Out[161]: <matplotlib.table.Table at 0x7ff270843f10>

In [162]: df.plot(ax=ax, ylim=(0, 2), legend=None)
Out[162]: <matplotlib.axes._subplots.AxesSubplot at 0x7ff267fce190>

Примечание: Вы можете получить экземпляры таблицы на осях, используя свойство axes.tables для дальнейших декораций. Дополнительную информацию см. в документации по таблицам matplotlib здесь.

Цветовые карты

Возможная проблема при построении большого числа столбцов заключается в том, что некоторые ряды могут быть трудно различить из-за повторения стандартных цветов. Для решения этой проблемы построение DataFrame поддерживает использование аргумента colormap=, который принимает либо Matplotlib цветовой карту, либо строку, являющуюся именем цветовой карты, зарегистрированной в Matplotlib. Визуализация стандартных цветовых карт matplotlib доступна здесь.

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

Чтобы использовать цветовую карту cubehelix, мы можем просто передать 'cubehelix' в colormap=

In [163]: df = pd.DataFrame(np.random.randn(1000, 10), index=ts.index)

In [164]: df = df.cumsum()

In [165]: plt.figure()
Out[165]: <matplotlib.figure.Figure at 0x7ff266ee9650>

In [166]: df.plot(colormap='cubehelix')
Out[166]: <matplotlib.axes._subplots.AxesSubplot at 0x7ff267037910>

или мы можем передать саму цветовую карту

In [167]: from matplotlib import cm

In [168]: plt.figure()
Out[168]: <matplotlib.figure.Figure at 0x7ff26c8efb10>

In [169]: df.plot(colormap=cm.cubehelix)
Out[169]: <matplotlib.axes._subplots.AxesSubplot at 0x7ff270ee6c90>

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

In [170]: dd = pd.DataFrame(np.random.randn(10, 10)).applymap(abs)

In [171]: dd = dd.cumsum()

In [172]: plt.figure()
Out[172]: <matplotlib.figure.Figure at 0x7ff272475250>

In [173]: dd.plot.bar(colormap='Greens')
Out[173]: <matplotlib.axes._subplots.AxesSubplot at 0x7ff26efff1d0>

Графики параллельных координат:

In [174]: plt.figure()
Out[174]: <matplotlib.figure.Figure at 0x7ff2717f4250>

In [175]: parallel_coordinates(data, 'Name', colormap='gist_rainbow')
Out[175]: <matplotlib.axes._subplots.AxesSubplot at 0x7ff2717d2810>

Графики кривых Эндрюса:

In [176]: plt.figure()
Out[176]: <matplotlib.figure.Figure at 0x7ff25dd3af50>

In [177]: andrews_curves(data, 'Name', colormap='winter')
Out[177]: <matplotlib.axes._subplots.AxesSubplot at 0x7ff25dcc9b90>

Построение непосредственно с помощью matplotlib

В некоторых ситуациях может быть предпочтительнее или необходимо готовить графики непосредственно с помощью matplotlib, например, когда определенный тип графика или настройка еще не поддерживается pandas. Объекты Series и DataFrame ведут себя как массивы и, следовательно, могут быть переданы непосредственно в функции matplotlib без явного преобразования.

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

In [178]: price = pd.Series(np.random.randn(150).cumsum(),
   .....:                   index=pd.date_range('2000-1-1', periods=150, freq='B'))
   .....: 

In [179]: ma = price.rolling(20).mean()

In [180]: mstd = price.rolling(20).std()

In [181]: plt.figure()
Out[181]: <matplotlib.figure.Figure at 0x7ff25d8ca350>

In [182]: plt.plot(price.index, price, 'k')
Out[182]: [<matplotlib.lines.Line2D at 0x7ff25d88a910>]

In [183]: plt.plot(ma.index, ma, 'b')
Out[183]: [<matplotlib.lines.Line2D at 0x7ff25d8cadd0>]

In [184]: plt.fill_between(mstd.index, ma-2*mstd, ma+2*mstd, color='b', alpha=0.2)
Out[184]: <matplotlib.collections.PolyCollection at 0x7ff25d853fd0>

Интерфейс построения сетки