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

Мы используем стандартную конвенцию для ссылки на 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 0x1120939d0>

Если индекс состоит из дат, он вызывает 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 0x11684fb10>

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

Методы построения диаграмм позволяют использовать несколько стилей диаграмм помимо стандартной диаграммы линий. Эти методы могут быть предоставлены в качестве ключевого аргумента 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 0x116b9f610>

Вы также можете создать эти другие диаграммы, используя методы 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 0x116e8a410>

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

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 0x1179938d0>

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

In [24]: plt.figure();

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

Вы можете передать другие ключевые слова, поддерживаемые 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 0x117ad40d0>

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

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

In [28]: plt.figure();

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

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

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

In [31]: df.diff().hist(color='k', alpha=0.5, bins=50)
Out[31]: 
array([[<matplotlib.axes._subplots.AxesSubplot object at 0x115775790>,
        <matplotlib.axes._subplots.AxesSubplot object at 0x11689aa10>],
       [<matplotlib.axes._subplots.AxesSubplot object at 0x1168893d0>,
        <matplotlib.axes._subplots.AxesSubplot object at 0x116194050>]], 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 0x118d2ea90>,
        <matplotlib.axes._subplots.AxesSubplot object at 0x11930db90>],
       [<matplotlib.axes._subplots.AxesSubplot object at 0x119396150>,
        <matplotlib.axes._subplots.AxesSubplot object at 0x1193be610>]], 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 0x1196dd910>

Диаграмму размаха можно окрасить, передав ключевое слово 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 0x119666d90>

Также вы можете передать другие ключевые слова, поддерживаемые 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 0x119d39e10>

См. метод 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'])

В основном, функции построения возвращают matplotlib Axes в качестве возвращаемого значения. В boxplot, тип возврата можно изменить с помощью аргумента return_type, а также включить/выключить поддиаграммы (subplots=True в plot или by указывается в boxplot).

Когда subplots=False / by равно None:

• if return_type is 'dict', a dictionary containing the matplotlib Lines is returned. The keys are “boxes”, “caps”, “fliers”, “medians”, and “whiskers”.

  Это значение по умолчанию для boxplot по историческим причинам. Обратите внимание, что plot.box() возвращает Axes по умолчанию, как и другие графики.

• если return_type равно 'axes', возвращается matplotlib Axes, содержащий диаграмму размаха.

• if return_type is 'both' a namedtuple containing the matplotlib Axes

  и возвращается matplotlib Lines.

Когда subplots=True / by — это некоторая колонка DataFrame:

• Возвращается словарь return_type, где ключами являются столбцы DataFrame. График имеет фрагмент для каждого столбца DataFrame, с отдельным ящиком для каждого значения by.

Наконец, при вызове boxplot для объекта Groupby, возвращается словарь return_type, где ключи совпадают с ключами объекта Groupby. График имеет фрагмент для каждого ключа, каждый фрагмент содержит ящик для каждого столбца DataFrame.

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 0x11d669b90>

Полезным ключевым аргументом является 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 0x119f58750>

См. метод 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 0x11d415b50>

Для круговых диаграмм лучше использовать квадратные фигуры с равными соотношениями сторон. Вы можете создать фигуру с равной шириной и высотой или заставить соотношение сторон быть равным после построения графика, вызвав 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 0x11cfe0450>,
       <matplotlib.axes._subplots.AxesSubplot object at 0x11cc789d0>], 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 0x11c901790>

Если вы передаете значения, сумма которых меньше 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 0x11c979f10>

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

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

Pandas старается быть практичным при построении графиков DataFrame или 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 0x11a194350>,
        <matplotlib.axes._subplots.AxesSubplot object at 0x11a58b810>,
        <matplotlib.axes._subplots.AxesSubplot object at 0x1197fa710>,
        <matplotlib.axes._subplots.AxesSubplot object at 0x11acca850>],
       [<matplotlib.axes._subplots.AxesSubplot object at 0x11a5b1f90>,
        <matplotlib.axes._subplots.AxesSubplot object at 0x11db27c90>,
        <matplotlib.axes._subplots.AxesSubplot object at 0x11a570c10>,
        <matplotlib.axes._subplots.AxesSubplot object at 0x11ac04d10>],
       [<matplotlib.axes._subplots.AxesSubplot object at 0x11c109c90>,
        <matplotlib.axes._subplots.AxesSubplot object at 0x11ab82a90>,
        <matplotlib.axes._subplots.AxesSubplot object at 0x11ab6fc90>,
        <matplotlib.axes._subplots.AxesSubplot object at 0x11c1a84d0>],
       [<matplotlib.axes._subplots.AxesSubplot object at 0x11db52790>,
        <matplotlib.axes._subplots.AxesSubplot object at 0x11cf6f710>,
        <matplotlib.axes._subplots.AxesSubplot object at 0x11abe4850>,
        <matplotlib.axes._subplots.AxesSubplot object at 0x1154bb8d0>]], 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 0x11fca2910>

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

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

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

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 0x11fdb7950>

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

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

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

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 0x11fb7fa50>

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

График лага

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

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

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

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 0x121a34ed0>

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

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

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

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

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 0x121a346d0>

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

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

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 0x121c3e750>

RadViz

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

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

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 0x122706c10>

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

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

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

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 0x1227b4190>

Масштабы

Вы можете передать 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 0x1213f4ed0>

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

Построение на вторичной оси Y

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

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

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

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

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

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

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

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

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

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

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

Отключение корректировки разрешения тиков

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

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

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

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

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

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

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

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

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

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

Подграфики

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

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

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

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

Количество осей, которые могут быть размещены в строках х столбцах, заданное 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 или dict ошибок со именами столбцов, соответствующих атрибуту columns построения DataFrame или соответствующим атрибуту name Series
• В виде str , указывающего, какие из столбцов построения DataFrame содержат значения ошибок
• В виде значений (list, tuple, или np.ndarray). Должны быть такой же длины, как построение DataFrame/Series

Также поддерживаются асимметричные погрешности, однако в этом случае необходимо указать значения погрешностей напрямую. Для M длины Series, должен быть предоставлен массив Mx2, указывающий нижние и верхние (или левые и правые) погрешности. Для 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 0x1271da9d0>

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

Построение с таблицей 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 0x127228f90>

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

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 0x12716a210>

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

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 0x126ce7d10>

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

Примечание: Вы можете получить экземпляры таблиц на осях с помощью свойства 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 0x1295f2a10>

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

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

In [167]: from matplotlib import cm

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

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

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

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 0x1278a2050>

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

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

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

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

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

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

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

Построение графиков напрямую с помощью 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 0x12c8d98d0>

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

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

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

Интерфейс построения графиков Trellis

tips_data = pd.read_csv('tips.csv')

Импортируем API rplot:

In [185]: import pandas.tools.rplot as rplot

Примеры

RPlot был API для создания графиков Trellis. Эти графики позволяют организовать данные в прямоугольную сетку по значениям определённых атрибутов. В примере ниже данные из набора данных tips организованы по атрибутам ‘sex’ и ‘smoker’. Поскольку оба этих атрибута могут принимать одно из двух значений, полученная сетка имеет два столбца и две строки. Для каждой ячейки сетки отображается гистограмма.

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

In [187]: plot = rplot.RPlot(tips_data, x='total_bill', y='tip')

In [188]: plot.add(rplot.TrellisGrid(['sex', 'smoker']))

In [189]: plot.add(rplot.GeomHistogram())

In [190]: plot.render(plt.gcf())
Out[190]: <matplotlib.figure.Figure at 0x12c8d9ad0>

Аналогичный график можно создать с seaborn с использованием объекта FacetGrid, что приводит к следующему изображению:

import seaborn as sns
g = sns.FacetGrid(tips_data, row="sex", col="smoker")
g.map(plt.hist, "total_bill")

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

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

In [192]: plot = rplot.RPlot(tips_data, x='total_bill', y='tip')

In [193]: plot.add(rplot.TrellisGrid(['sex', 'smoker']))

In [194]: plot.add(rplot.GeomDensity())

In [195]: plot.render(plt.gcf())
Out[195]: <matplotlib.figure.Figure at 0x12d96ab90>

g = sns.FacetGrid(tips_data, row="sex", col="smoker")
g.map(sns.kdeplot, "total_bill")

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

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

In [197]: plot = rplot.RPlot(tips_data, x='total_bill', y='tip')

In [198]: plot.add(rplot.TrellisGrid(['sex', 'smoker']))

In [199]: plot.add(rplot.GeomScatter())

In [200]: plot.add(rplot.GeomPolyFit(degree=2))

In [201]: plot.render(plt.gcf())
Out[201]: <matplotlib.figure.Figure at 0x12e9ffd50>

Аналог графика рассеяния в seaborn:

g = sns.FacetGrid(tips_data, row="sex", col="smoker")
g.map(plt.scatter, "total_bill", "tip")

и с линией регрессии, используя специализированную функцию seaborn regplot.

g = sns.FacetGrid(tips_data, row="sex", col="smoker", margin_titles=True)
g.map(sns.regplot, "total_bill", "tip", order=2)

Ниже представлен аналогичный график, но с наложенным графиком оценки двумерной плотности ядра, за которым следует эквивалент seaborn.

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

In [203]: plot = rplot.RPlot(tips_data, x='total_bill', y='tip')

In [204]: plot.add(rplot.TrellisGrid(['sex', 'smoker']))

In [205]: plot.add(rplot.GeomScatter())

In [206]: plot.add(rplot.GeomDensity2D())

In [207]: plot.render(plt.gcf())
Out[207]: <matplotlib.figure.Figure at 0x12daa1ad0>

g = sns.FacetGrid(tips_data, row="sex", col="smoker")
g.map(plt.scatter, "total_bill", "tip")
g.map(sns.kdeplot, "total_bill", "tip")

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

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

In [209]: plot = rplot.RPlot(tips_data, x='total_bill', y='tip')

In [210]: plot.add(rplot.TrellisGrid(['sex', '.']))

In [211]: plot.add(rplot.GeomHistogram())

In [212]: plot.render(plt.gcf())
Out[212]: <matplotlib.figure.Figure at 0x12f59eb90>

Если первый группирующий атрибут не указан, графики будут расположены в строке.

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

In [214]: plot = rplot.RPlot(tips_data, x='total_bill', y='tip')

In [215]: plot.add(rplot.TrellisGrid(['.', 'smoker']))

In [216]: plot.add(rplot.GeomHistogram())

In [217]: plot.render(plt.gcf())
Out[217]: <matplotlib.figure.Figure at 0x130addd10>

В seaborn, это также можно сделать, указав только один из аргументов row и col.

В примере ниже цвет и форма графических объектов графика рассеяния сопоставляются с атрибутами ‘day’ и ‘size’ соответственно. Для задания этих сопоставлений используются объекты масштаба. Список классов масштаба с аргументами инициализации приведен ниже для удобства ссылки.

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

In [219]: plot = rplot.RPlot(tips_data, x='tip', y='total_bill')

In [220]: plot.add(rplot.TrellisGrid(['sex', 'smoker']))

In [221]: plot.add(rplot.GeomPoint(size=80.0, colour=rplot.ScaleRandomColour('day'), shape=rplot.ScaleShape('size'), alpha=1.0))

In [222]: plot.render(plt.gcf())
Out[222]: <matplotlib.figure.Figure at 0x130addd90>

Это также можно сделать в seaborn, по крайней мере, для 3 переменных:

g = sns.FacetGrid(tips_data, row="sex", col="smoker", hue="day")
g.map(plt.scatter, "tip", "total_bill")
g.add_legend()