Введение в структуры данных

Начнём с быстрого, но неполного обзора основных структур данных в pandas, чтобы вы могли начать работу. Основное поведение, касающееся типов данных, индексов и маркировки/выравнивания осей, применяется ко всем объектам. Для начала импортируйте numpy и загрузите pandas в пространство имён:

In [1]: import numpy as np

In [2]: import pandas as pd

Вот основное правило, которое следует помнить: выравнивание данных является внутренним. Связь между метками и данными не будет нарушена, если вы этого явно не сделаете.

Мы дадим краткое введение в структуры данных, а затем рассмотрим все широкие категории функциональности и методов в отдельных разделах.

Ряды

Series — это одномерный маркированный массив, способный хранить любые типы данных (целые числа, строки, числа с плавающей точкой, объекты Python и т. д.). Метки осей вместе называются индексом. Основной метод создания ряда — вызов:

>>> s = pd.Series(data, index=index)

Здесь data может быть многими разными вещами:

• словарь Python
• ndarray
• скалярное значение (например, 5)

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

Из ndarray

Если data — это ndarray, индекс должен иметь такую же длину, как и данные. Если индекс не передан, он будет создан со значениями [0, ..., len(data) - 1].

In [3]: s = pd.Series(np.random.randn(5), index=['a', 'b', 'c', 'd', 'e'])

In [4]: s
Out[4]: 
a   -2.7828
b    0.4264
c   -0.6505
d    1.1465
e   -0.6631
dtype: float64

In [5]: s.index
Out[5]: Index([u'a', u'b', u'c', u'd', u'e'], dtype='object')

In [6]: pd.Series(np.random.randn(5))
Out[6]: 
0    0.2939
1   -0.4049
2    1.1665
3    0.8420
4    0.5398
dtype: float64

Из словаря

Если data — это словарь, если передан индекс, будут извлечены значения в данных, соответствующие меткам в индексе. В противном случае индекс будет построен из отсортированных ключей словаря, если это возможно.

In [7]: d = {'a' : 0., 'b' : 1., 'c' : 2.}

In [8]: pd.Series(d)
Out[8]: 
a    0.0
b    1.0
c    2.0
dtype: float64

In [9]: pd.Series(d, index=['b', 'c', 'd', 'a'])
Out[9]: 
b    1.0
c    2.0
d    NaN
a    0.0
dtype: float64

Из скалярного значения Если data — это скалярное значение, должен быть передан индекс. Значение будет повторяться для соответствия длине индекса

In [10]: pd.Series(5., index=['a', 'b', 'c', 'd', 'e'])
Out[10]: 
a    5.0
b    5.0
c    5.0
d    5.0
e    5.0
dtype: float64

Ряд похож на ndarray

Series ведет себя очень похоже на ndarray, и является допустимым аргументом для большинства функций NumPy. Однако такие операции, как срезы, также производят срез индекса.

In [11]: s[0]
Out[11]: -2.7827595933769937

In [12]: s[:3]
Out[12]: 
a   -2.7828
b    0.4264
c   -0.6505
dtype: float64

In [13]: s[s > s.median()]
Out[13]: 
b    0.4264
d    1.1465
dtype: float64

In [14]: s[[4, 3, 1]]
Out[14]: 
e   -0.6631
d    1.1465
b    0.4264
dtype: float64

In [15]: np.exp(s)
Out[15]: 
a    0.0619
b    1.5318
c    0.5218
d    3.1472
e    0.5153
dtype: float64

Мы рассмотрим индексацию на основе массивов в отдельном разделе.

Ряд похож на словарь

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

In [16]: s['a']
Out[16]: -2.7827595933769937

In [17]: s['e'] = 12.

In [18]: s
Out[18]: 
a    -2.7828
b     0.4264
c    -0.6505
d     1.1465
e    12.0000
dtype: float64

In [19]: 'e' in s
Out[19]: True

In [20]: 'f' in s
Out[20]: False

Если метка не содержится, возникает исключение:

>>> s['f']
KeyError: 'f'

Используя метод get, отсутствующая метка вернёт None или указанное значение по умолчанию:

In [21]: s.get('f')

In [22]: s.get('f', np.nan)
Out[22]: nan

См. также раздел об обращении к атрибутам.

Векторные операции и выравнивание меток с рядами

При анализе данных, как и в случае с обычными массивами NumPy, обычно нет необходимости циклически перебирать значения рядов. Ряды также могут быть переданы в большинство методов NumPy, ожидающих ndarray.

In [23]: s + s
Out[23]: 
a    -5.5655
b     0.8529
c    -1.3010
d     2.2930
e    24.0000
dtype: float64

In [24]: s * 2
Out[24]: 
a    -5.5655
b     0.8529
c    -1.3010
d     2.2930
e    24.0000
dtype: float64

In [25]: np.exp(s)
Out[25]: 
a         0.0619
b         1.5318
c         0.5218
d         3.1472
e    162754.7914
dtype: float64

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

In [26]: s[1:] + s[:-1]
Out[26]: 
a       NaN
b    0.8529
c   -1.3010
d    2.2930
e       NaN
dtype: float64

Результат операции между невыровненными рядами будет иметь объединение участвующих индексов. Если метка не найдена в одном ряду или другом, результат будет помечен как отсутствующий NaN. Возможность записи кода без явного выравнивания данных даёт огромную свободу и гибкость в интерактивном анализе и исследовании данных. Встроенные функции выравнивания данных в структурах данных pandas отличают pandas от большинства аналогичных инструментов для работы с маркированными данными.

Атрибут имени

Ряды также могут иметь атрибут name:

In [27]: s = pd.Series(np.random.randn(5), name='something')

In [28]: s
Out[28]: 
0    0.5410
1   -1.1747
2    0.1287
3    0.0430
4   -0.4287
Name: something, dtype: float64

In [29]: s.name
Out[29]: 'something'

Ряд name будет присвоен автоматически во многих случаях, особенно при взятии 1D срезов DataFrame, как вы увидите ниже.

Вы можете переименовать ряд с помощью метода pandas.Series.rename().

In [30]: s2 = s.rename("different")

In [31]: s2.name
Out[31]: 'different'

Обратите внимание, что s и s2 ссылаются на разные объекты.

DataFrame

DataFrame — это двумерная маркированная структура данных со столбцами потенциально различных типов. Можно представить её как электронную таблицу или таблицу SQL, или как словарь объектов Series. Это, как правило, наиболее часто используемый объект pandas. Как и ряды, DataFrame принимает множество различных видов входных данных:

• Словарь 1D ndarray, списков, словарей или рядов
• 2-мерный numpy.ndarray
• Структурированный или записывающий ndarray
• Список Series
• Другой DataFrame

Вместе с данными вы можете необязательно передать индекс (метки строк) и столбцы (метки столбцов). Если вы передадите индекс и/или столбцы, вы гарантируете индекс и/или столбцы результирующего DataFrame. Таким образом, словарь рядов плюс определённый индекс отбросит все данные, не соответствующие переданному индексу.

Если метки осей не переданы, они будут построены из входных данных на основе правил здравого смысла.

Из словаря рядов или словарей

Результирующий индекс будет объединением индексов различных рядов. Если есть вложенные словари, они будут сначала преобразованы в ряды. Если столбцы не переданы, столбцы будут отсортированным списком ключей словаря.

In [32]: d = {'one' : pd.Series([1., 2., 3.], index=['a', 'b', 'c']),
   ....:      'two' : pd.Series([1., 2., 3., 4.], index=['a', 'b', 'c', 'd'])}
   ....: 

In [33]: df = pd.DataFrame(d)

In [34]: df
Out[34]: 
   one  two
a  1.0  1.0
b  2.0  2.0
c  3.0  3.0
d  NaN  4.0

In [35]: pd.DataFrame(d, index=['d', 'b', 'a'])
Out[35]: 
   one  two
d  NaN  4.0
b  2.0  2.0
a  1.0  1.0

In [36]: pd.DataFrame(d, index=['d', 'b', 'a'], columns=['two', 'three'])
Out[36]: 
   two three
d  4.0   NaN
b  2.0   NaN
a  1.0   NaN

Метки строк и столбцов соответственно можно получить, обратившись к атрибутам index и columns:

In [37]: df.index
Out[37]: Index([u'a', u'b', u'c', u'd'], dtype='object')

In [38]: df.columns
Out[38]: Index([u'one', u'two'], dtype='object')

Из словаря ndarray/списков

Все ndarray должны иметь одинаковую длину. Если передан индекс, он также должен иметь такую же длину, как и массивы. Если индекс не передан, результат будет range(n), где n — длина массива.

In [39]: d = {'one' : [1., 2., 3., 4.],
   ....:      'two' : [4., 3., 2., 1.]}
   ....: 

In [40]: pd.DataFrame(d)
Out[40]: 
   one  two
0  1.0  4.0
1  2.0  3.0
2  3.0  2.0
3  4.0  1.0

In [41]: pd.DataFrame(d, index=['a', 'b', 'c', 'd'])
Out[41]: 
   one  two
a  1.0  4.0
b  2.0  3.0
c  3.0  2.0
d  4.0  1.0

Из структурированного или записывающего массива

Этот случай обрабатывается аналогично словарю массивов.

In [42]: data = np.zeros((2,), dtype=[('A', 'i4'),('B', 'f4'),('C', 'a10')])

In [43]: data[:] = [(1,2.,'Hello'), (2,3.,"World")]

In [44]: pd.DataFrame(data)
Out[44]: 
   A    B      C
0  1  2.0  Hello
1  2  3.0  World

In [45]: pd.DataFrame(data, index=['first', 'second'])
Out[45]: 
        A    B      C
first   1  2.0  Hello
second  2  3.0  World

In [46]: pd.DataFrame(data, columns=['C', 'A', 'B'])
Out[46]: 
       C  A    B
0  Hello  1  2.0
1  World  2  3.0

Из списка словарей

In [47]: data2 = [{'a': 1, 'b': 2}, {'a': 5, 'b': 10, 'c': 20}]

In [48]: pd.DataFrame(data2)
Out[48]: 
   a   b     c
0  1   2   NaN
1  5  10  20.0

In [49]: pd.DataFrame(data2, index=['first', 'second'])
Out[49]: 
        a   b     c
first   1   2   NaN
second  5  10  20.0

In [50]: pd.DataFrame(data2, columns=['a', 'b'])
Out[50]: 
   a   b
0  1   2
1  5  10

Из словаря кортежей

Вы можете автоматически создать фрейм с многоуровневым индексом, передав словарь кортежей

In [51]: pd.DataFrame({('a', 'b'): {('A', 'B'): 1, ('A', 'C'): 2},
   ....:               ('a', 'a'): {('A', 'C'): 3, ('A', 'B'): 4},
   ....:               ('a', 'c'): {('A', 'B'): 5, ('A', 'C'): 6},
   ....:               ('b', 'a'): {('A', 'C'): 7, ('A', 'B'): 8},
   ....:               ('b', 'b'): {('A', 'D'): 9, ('A', 'B'): 10}})
   ....: 
Out[51]: 
       a              b      
       a    b    c    a     b
A B  4.0  1.0  5.0  8.0  10.0
  C  3.0  2.0  6.0  7.0   NaN
  D  NaN  NaN  NaN  NaN   9.0

Из ряда

Результат будет DataFrame с тем же индексом, что и входной ряд, и с одним столбцом, имя которого — исходное имя ряда (только если другое имя столбца не указано).

Отсутствующие данные

Подробно об этом будет сказано в разделе Отсутствующие данные. Чтобы создать DataFrame с отсутствующими данными, используйте np.nan для этих значений. В качестве альтернативы вы можете передать numpy.MaskedArray в качестве аргумента данных конструктору DataFrame, а его замаскированные записи будут считаться отсутствующими.

Альтернативные конструкторы

DataFrame.from_dict

DataFrame.from_dict принимает словарь словарей или словарь последовательностей массивов и возвращает DataFrame. Он работает подобно конструктору DataFrame за исключением параметра orient, который по умолчанию равен 'columns', но может быть установлен на 'index', чтобы использовать ключи словаря в качестве меток строк.

DataFrame.from_records

DataFrame.from_records принимает список кортежей или ndarray со структурированным типом. Работает аналогично обычному конструктору DataFrame, за исключением того, что индекс может быть определённым полем структурированного типа, используемым в качестве индекса. Например:

In [52]: data
Out[52]: 
array([(1, 2.0, 'Hello'), (2, 3.0, 'World')], 
      dtype=[('A', '<i4'), ('B', '<f4'), ('C', 'S10')])

In [53]: pd.DataFrame.from_records(data, index='C')
Out[53]: 
       A    B
C            
Hello  1  2.0
World  2  3.0

DataFrame.from_items

DataFrame.from_items работает аналогично форме конструктора dict, который принимает последовательность пар (key, value), где ключи — имена столбцов (или строк в случае orient='index'), а значения — значения столбцов (или строк). Это может быть полезно для построения DataFrame со столбцами в определённом порядке без необходимости явного указания списка столбцов:

In [54]: pd.DataFrame.from_items([('A', [1, 2, 3]), ('B', [4, 5, 6])])
Out[54]: 
   A  B
0  1  4
1  2  5
2  3  6

Если вы передадите orient='index', ключи будут метками строк. Но в этом случае вы также должны передать желаемые имена столбцов:

In [55]: pd.DataFrame.from_items([('A', [1, 2, 3]), ('B', [4, 5, 6])],
   ....:                         orient='index', columns=['one', 'two', 'three'])
   ....: 
Out[55]: 
   one  two  three
A    1    2      3
B    4    5      6

Выбор, добавление и удаление столбцов

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

In [56]: df['one']
Out[56]: 
a    1.0
b    2.0
c    3.0
d    NaN
Name: one, dtype: float64

In [57]: df['three'] = df['one'] * df['two']

In [58]: df['flag'] = df['one'] > 2

In [59]: df
Out[59]: 
   one  two  three   flag
a  1.0  1.0    1.0  False
b  2.0  2.0    4.0  False
c  3.0  3.0    9.0   True
d  NaN  4.0    NaN  False

Столбцы могут быть удалены или удалены, как и в случае со словарем:

In [60]: del df['two']

In [61]: three = df.pop('three')

In [62]: df
Out[62]: 
   one   flag
a  1.0  False
b  2.0  False
c  3.0   True
d  NaN  False

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

In [63]: df['foo'] = 'bar'

In [64]: df
Out[64]: 
   one   flag  foo
a  1.0  False  bar
b  2.0  False  bar
c  3.0   True  bar
d  NaN  False  bar

При вставке Series, у которой нет такого же индекса, как у DataFrame, она будет преобразована к индексу DataFrame:

In [65]: df['one_trunc'] = df['one'][:2]

In [66]: df
Out[66]: 
   one   flag  foo  one_trunc
a  1.0  False  bar        1.0
b  2.0  False  bar        2.0
c  3.0   True  bar        NaN
d  NaN  False  bar        NaN

Можно вставлять необработанные массивы NumPy, но их длина должна совпадать с длиной индекса DataFrame.

По умолчанию столбцы вставляются в конец. Функция insert доступна для вставки в определённом месте столбцов:

In [67]: df.insert(1, 'bar', df['one'])

In [68]: df
Out[68]: 
   one  bar   flag  foo  one_trunc
a  1.0  1.0  False  bar        1.0
b  2.0  2.0  False  bar        2.0
c  3.0  3.0   True  bar        NaN
d  NaN  NaN  False  bar        NaN

Присваивание новых столбцов в цепочках методов

На основе глагола dplyr’s mutate метод DataFrame имеет метод assign(), который позволяет легко создавать новые столбцы, потенциально производные от существующих столбцов.

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

In [70]: iris.head()
Out[70]: 
   SepalLength  SepalWidth  PetalLength  PetalWidth         Name
0          5.1         3.5          1.4         0.2  Iris-setosa
1          4.9         3.0          1.4         0.2  Iris-setosa
2          4.7         3.2          1.3         0.2  Iris-setosa
3          4.6         3.1          1.5         0.2  Iris-setosa
4          5.0         3.6          1.4         0.2  Iris-setosa

In [71]: (iris.assign(sepal_ratio = iris['SepalWidth'] / iris['SepalLength'])
   ....:      .head())
   ....: 
Out[71]: 
   SepalLength  SepalWidth  PetalLength  PetalWidth         Name  sepal_ratio
0          5.1         3.5          1.4         0.2  Iris-setosa       0.6863
1          4.9         3.0          1.4         0.2  Iris-setosa       0.6122
2          4.7         3.2          1.3         0.2  Iris-setosa       0.6809
3          4.6         3.1          1.5         0.2  Iris-setosa       0.6739
4          5.0         3.6          1.4         0.2  Iris-setosa       0.7200

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

In [72]: iris.assign(sepal_ratio = lambda x: (x['SepalWidth'] /
   ....:                                      x['SepalLength'])).head()
   ....: 
Out[72]: 
   SepalLength  SepalWidth  PetalLength  PetalWidth         Name  sepal_ratio
0          5.1         3.5          1.4         0.2  Iris-setosa       0.6863
1          4.9         3.0          1.4         0.2  Iris-setosa       0.6122
2          4.7         3.2          1.3         0.2  Iris-setosa       0.6809
3          4.6         3.1          1.5         0.2  Iris-setosa       0.6739
4          5.0         3.6          1.4         0.2  Iris-setosa       0.7200

assign всегда возвращает копию данных, оставляя исходный DataFrame без изменений.

Передача вызываемого объекта, а не фактического значения для вставки, полезна, когда у вас нет ссылки на DataFrame под рукой. Это часто используется при использовании assign в цепочках операций. Например, мы можем ограничить DataFrame только теми наблюдениями, у которых длина чашелистика больше 5, вычислить отношение и построить график:

In [73]: (iris.query('SepalLength > 5')
   ....:      .assign(SepalRatio = lambda x: x.SepalWidth / x.SepalLength,
   ....:              PetalRatio = lambda x: x.PetalWidth / x.PetalLength)
   ....:      .plot(kind='scatter', x='SepalRatio', y='PetalRatio'))
   ....: 
Out[73]: <matplotlib.axes._subplots.AxesSubplot at 0x11cee0c90>

Поскольку передаётся функция, функция вычисляется для присваиваемого DataFrame. Важно, что это DataFrame, отфильтрованный для строк с длиной чашелистика больше 5. Фильтрация происходит первой, а затем вычисления отношений. Это пример, где у нас не было ссылки на отфильтрованный DataFrame.

Подпись функции для assign просто **kwargs. Ключи — имена столбцов для новых полей, а значения — либо значение для вставки (например, Series или массив NumPy), либо функция от одного аргумента, вызываемая для DataFrame. Возвращается копия исходного DataFrame со вставленными новыми значениями.

In [74]: # Don't do this, bad reference to `C`
        df.assign(C = lambda x: x['A'] + x['B'],
                  D = lambda x: x['A'] + x['C'])
In [2]: # Instead, break it into two assigns
        (df.assign(C = lambda x: x['A'] + x['B'])
           .assign(D = lambda x: x['A'] + x['C']))

Индексирование/Выбор

Основы индексирования таковы:

Выбор строки, например, возвращает Series, индекс которой — столбцы DataFrame:

In [75]: df.loc['b']
Out[75]: 
one              2
bar              2
flag         False
foo            bar
one_trunc        2
Name: b, dtype: object

In [76]: df.iloc[2]
Out[76]: 
one             3
bar             3
flag         True
foo           bar
one_trunc     NaN
Name: c, dtype: object

Более исчерпывающее описание более сложных индексирования и срезов с использованием меток см. в разделе по индексированию. Мы рассмотрим основы повторного индексирования/соответствия новым наборам меток в разделе по повторному индексированию.

Выравнивание данных и арифметика

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

In [77]: df = pd.DataFrame(np.random.randn(10, 4), columns=['A', 'B', 'C', 'D'])

In [78]: df2 = pd.DataFrame(np.random.randn(7, 3), columns=['A', 'B', 'C'])

In [79]: df + df2
Out[79]: 
        A       B       C   D
0 -1.9160 -0.9862 -2.4213 NaN
1  0.9651  1.6767  0.3298 NaN
2 -1.6622  2.1966 -1.9169 NaN
3 -0.1887  0.7653 -0.0010 NaN
4 -1.0760  0.3969 -1.1774 NaN
5  2.8104 -0.1792 -0.5705 NaN
6 -1.2272  0.1963  0.5312 NaN
7     NaN     NaN     NaN NaN
8     NaN     NaN     NaN NaN
9     NaN     NaN     NaN NaN

При выполнении операции между DataFrame и Series, по умолчанию Series выравнивается по индексу DataFrame, а столбцы – по строкам, выполняется векторное произведение по строкам. Например:

In [80]: df - df.iloc[0]
Out[80]: 
        A       B       C       D
0  0.0000  0.0000  0.0000  0.0000
1  2.3859  1.3585  1.2234 -2.1065
2  2.1047  1.7004  1.3268 -0.6895
3  1.8741  2.7181  2.3819 -0.7597
4  2.1988  0.9662  0.8265  0.0932
5  4.9966  1.1967  1.3303 -0.2855
6  1.2632  0.5778  1.0712 -0.5254
7  3.4625  0.6322  1.0626 -0.4427
8  2.6802  3.1629  1.2977 -1.8177
9  1.3038  0.1957  3.5899 -0.8671

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

In [81]: index = pd.date_range('1/1/2000', periods=8)

In [82]: df = pd.DataFrame(np.random.randn(8, 3), index=index, columns=list('ABC'))

In [83]: df
Out[83]: 
                 A       B       C
2000-01-01  0.0627 -0.0284  0.4436
2000-01-02 -0.2688 -1.5776  1.8502
2000-01-03  0.6381 -0.5566 -0.0712
2000-01-04 -0.5114  0.1563 -1.0756
2000-01-05  1.6636 -0.4377 -0.0773
2000-01-06  0.0292  0.1790  1.7401
2000-01-07 -0.7290 -0.8980 -0.3142
2000-01-08 -0.0481 -0.8756  0.1691

In [84]: type(df['A'])
Out[84]: pandas.core.series.Series

In [85]: df - df['A']
Out[85]: 
            2000-01-01 00:00:00  2000-01-02 00:00:00  2000-01-03 00:00:00  \
2000-01-01                  NaN                  NaN                  NaN   
2000-01-02                  NaN                  NaN                  NaN   
2000-01-03                  NaN                  NaN                  NaN   
2000-01-04                  NaN                  NaN                  NaN   
2000-01-05                  NaN                  NaN                  NaN   
2000-01-06                  NaN                  NaN                  NaN   
2000-01-07                  NaN                  NaN                  NaN   
2000-01-08                  NaN                  NaN                  NaN   

            2000-01-04 00:00:00 ...  2000-01-08 00:00:00   A   B   C  
2000-01-01                  NaN ...                  NaN NaN NaN NaN  
2000-01-02                  NaN ...                  NaN NaN NaN NaN  
2000-01-03                  NaN ...                  NaN NaN NaN NaN  
2000-01-04                  NaN ...                  NaN NaN NaN NaN  
2000-01-05                  NaN ...                  NaN NaN NaN NaN  
2000-01-06                  NaN ...                  NaN NaN NaN NaN  
2000-01-07                  NaN ...                  NaN NaN NaN NaN  
2000-01-08                  NaN ...                  NaN NaN NaN NaN  

[8 rows x 11 columns]

df - df['A']

df.sub(df['A'], axis=0)

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

Операции со скалярами выполняются так же, как и ожидается:

In [86]: df * 5 + 2
Out[86]: 
                  A       B        C
2000-01-01   2.3135  1.8579   4.2178
2000-01-02   0.6561 -5.8882  11.2510
2000-01-03   5.1903 -0.7830   1.6438
2000-01-04  -0.5571  2.7814  -3.3781
2000-01-05  10.3180 -0.1886   1.6135
2000-01-06   2.1460  2.8950  10.7003
2000-01-07  -1.6451 -2.4900   0.4289
2000-01-08   1.7596 -2.3780   2.8455

In [87]: 1 / df
Out[87]: 
                  A        B        C
2000-01-01  15.9483 -35.1931   2.2545
2000-01-02  -3.7205  -0.6339   0.5405
2000-01-03   1.5672  -1.7966 -14.0388
2000-01-04  -1.9553   6.3984  -0.9297
2000-01-05   0.6011  -2.2845 -12.9363
2000-01-06  34.2568   5.5863   0.5747
2000-01-07  -1.3717  -1.1136  -3.1826
2000-01-08 -20.8019  -1.1421   5.9134

In [88]: df ** 4
Out[88]: 
                     A           B           C
2000-01-01  1.5457e-05  6.5188e-07  3.8707e-02
2000-01-02  5.2191e-03  6.1948e+00  1.1718e+01
2000-01-03  1.6575e-01  9.5982e-02  2.5745e-05
2000-01-04  6.8412e-02  5.9663e-04  1.3386e+00
2000-01-05  7.6595e+00  3.6712e-02  3.5708e-05
2000-01-06  7.2612e-07  1.0268e-03  9.1678e+00
2000-01-07  2.8246e-01  6.5029e-01  9.7473e-03
2000-01-08  5.3406e-06  5.8781e-01  8.1783e-04

Булевы операторы также работают:

In [89]: df1 = pd.DataFrame({'a' : [1, 0, 1], 'b' : [0, 1, 1] }, dtype=bool)

In [90]: df2 = pd.DataFrame({'a' : [0, 1, 1], 'b' : [1, 1, 0] }, dtype=bool)

In [91]: df1 & df2
Out[91]: 
       a      b
0  False  False
1  False   True
2   True  False

In [92]: df1 | df2
Out[92]: 
      a     b
0  True  True
1  True  True
2  True  True

In [93]: df1 ^ df2
Out[93]: 
       a      b
0   True   True
1   True  False
2  False   True

In [94]: -df1
Out[94]: 
       a      b
0  False   True
1   True  False
2  False  False

Транспонирование

Для транспонирования используйте атрибут T (также функция transpose), аналогично ndarray:

# only show the first 5 rows
In [95]: df[:5].T
Out[95]: 
   2000-01-01  2000-01-02  2000-01-03  2000-01-04  2000-01-05
A      0.0627     -0.2688      0.6381     -0.5114      1.6636
B     -0.0284     -1.5776     -0.5566      0.1563     -0.4377
C      0.4436      1.8502     -0.0712     -1.0756     -0.0773

Взаимодействие DataFrame с функциями NumPy

Элементные NumPy ufuncs (log, exp, sqrt, ...) и различные другие функции NumPy могут использоваться без проблем с DataFrame, при условии, что данные в нём являются числовыми:

In [96]: np.exp(df)
Out[96]: 
                 A       B       C
2000-01-01  1.0647  0.9720  1.5582
2000-01-02  0.7643  0.2065  6.3611
2000-01-03  1.8928  0.5732  0.9312
2000-01-04  0.5996  1.1692  0.3411
2000-01-05  5.2783  0.6455  0.9256
2000-01-06  1.0296  1.1960  5.6977
2000-01-07  0.4824  0.4074  0.7304
2000-01-08  0.9531  0.4166  1.1842

In [97]: np.asarray(df)
Out[97]: 
array([[ 0.0627, -0.0284,  0.4436],
       [-0.2688, -1.5776,  1.8502],
       [ 0.6381, -0.5566, -0.0712],
       [-0.5114,  0.1563, -1.0756],
       [ 1.6636, -0.4377, -0.0773],
       [ 0.0292,  0.179 ,  1.7401],
       [-0.729 , -0.898 , -0.3142],
       [-0.0481, -0.8756,  0.1691]])

Метод dot для DataFrame реализует матричное умножение:

In [98]: df.T.dot(df)
Out[98]: 
        A       B       C
A  4.0471 -0.0390  0.1783
B -0.0390  4.6207 -2.5806
C  0.1783 -2.5806  7.9431

Аналогично, метод dot для Series реализует скалярное произведение:

In [99]: s1 = pd.Series(np.arange(5,10))

In [100]: s1.dot(s1)
Out[100]: 255

DataFrame не предназначен для прямого использования вместо ndarray, поскольку его семантика индексирования в некоторых местах существенно отличается от матрицы.

Вывод в консоль

Очень большие DataFrame будут обрезаны для вывода в консоли. Вы также можете получить сводку, используя info(). (Здесь я считываю версию CSV набора данных baseball из пакета plyr R):

In [101]: baseball = pd.read_csv('data/baseball.csv')

In [102]: print(baseball)
       id     player  year  stint  ...   hbp   sh   sf  gidp
0   88641  womacto01  2006      2  ...   0.0  3.0  0.0   0.0
1   88643  schilcu01  2006      1  ...   0.0  0.0  0.0   0.0
..    ...        ...   ...    ...  ...   ...  ...  ...   ...
98  89533   aloumo01  2007      1  ...   2.0  0.0  3.0  13.0
99  89534  alomasa02  2007      1  ...   0.0  0.0  0.0   0.0

[100 rows x 23 columns]

In [103]: baseball.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 100 entries, 0 to 99
Data columns (total 23 columns):
id        100 non-null int64
player    100 non-null object
year      100 non-null int64
stint     100 non-null int64
team      100 non-null object
lg        100 non-null object
g         100 non-null int64
ab        100 non-null int64
r         100 non-null int64
h         100 non-null int64
X2b       100 non-null int64
X3b       100 non-null int64
hr        100 non-null int64
rbi       100 non-null float64
sb        100 non-null float64
cs        100 non-null float64
bb        100 non-null int64
so        100 non-null float64
ibb       100 non-null float64
hbp       100 non-null float64
sh        100 non-null float64
sf        100 non-null float64
gidp      100 non-null float64
dtypes: float64(9), int64(11), object(3)
memory usage: 18.0+ KB

Однако, использование to_string вернёт строковое представление DataFrame в табличной форме, хотя оно не всегда поместится в ширину консоли:

In [104]: print(baseball.iloc[-20:, :12].to_string())
       id     player  year  stint team  lg    g   ab   r    h  X2b  X3b
80  89474  finlest01  2007      1  COL  NL   43   94   9   17    3    0
81  89480  embreal01  2007      1  OAK  AL    4    0   0    0    0    0
82  89481  edmonji01  2007      1  SLN  NL  117  365  39   92   15    2
83  89482  easleda01  2007      1  NYN  NL   76  193  24   54    6    0
84  89489  delgaca01  2007      1  NYN  NL  139  538  71  139   30    0
85  89493  cormirh01  2007      1  CIN  NL    6    0   0    0    0    0
86  89494  coninje01  2007      2  NYN  NL   21   41   2    8    2    0
87  89495  coninje01  2007      1  CIN  NL   80  215  23   57   11    1
88  89497  clemero02  2007      1  NYA  AL    2    2   0    1    0    0
89  89498  claytro01  2007      2  BOS  AL    8    6   1    0    0    0
90  89499  claytro01  2007      1  TOR  AL   69  189  23   48   14    0
91  89501  cirilje01  2007      2  ARI  NL   28   40   6    8    4    0
92  89502  cirilje01  2007      1  MIN  AL   50  153  18   40    9    2
93  89521  bondsba01  2007      1  SFN  NL  126  340  75   94   14    0
94  89523  biggicr01  2007      1  HOU  NL  141  517  68  130   31    3
95  89525  benitar01  2007      2  FLO  NL   34    0   0    0    0    0
96  89526  benitar01  2007      1  SFN  NL   19    0   0    0    0    0
97  89530  ausmubr01  2007      1  HOU  NL  117  349  38   82   16    3
98  89533   aloumo01  2007      1  NYN  NL   87  328  51  112   19    1
99  89534  alomasa02  2007      1  NYN  NL    8   22   1    3    1    0

Начиная с версии 0.10.0, широкие DataFrame по умолчанию будут отображаться на нескольких строках:

In [105]: pd.DataFrame(np.random.randn(3, 12))
Out[105]: 
         0         1         2         3         4         5         6   \
0  1.225021 -0.528620  0.448676  0.619107 -1.199110 -0.949097  2.169523   
1 -1.753617  0.992384 -0.505601 -0.599848  0.133585  0.008836 -1.767710   
2 -0.461585 -1.321106  1.745476  1.445100  0.991037 -0.860733 -0.870661   

         7         8         9         10        11  
0  0.302230  0.919516  0.657436  0.262574 -0.804798  
1  0.700112 -0.020773 -0.302481  0.347869  0.179123  
2 -0.117845 -0.046266  2.095649 -0.524324 -0.610555  

Вы можете изменить количество отображаемых данных в одной строке, задав опцию display.width.

In [106]: pd.set_option('display.width', 40) # default is 80

In [107]: pd.DataFrame(np.random.randn(3, 12))
Out[107]: 
         0         1         2   \
0 -1.280951  1.472585 -1.001914   
1  0.130529 -1.603771 -0.128830   
2 -1.084566 -0.515272  1.367586   

         3         4         5   \
0  1.044770 -0.050668 -0.013289   
1 -1.869301 -0.232977 -0.139801   
2  0.963500  0.224105 -0.020051   

         6         7         8   \
0 -0.291893  2.029038 -1.117195   
1 -1.083341 -0.357234 -0.818199   
2  0.524663  0.351081 -1.574209   

         9         10        11  
0  1.598577 -0.397325  0.151653  
1 -0.886885  1.238885 -1.639274  
2 -0.486856 -0.545888 -0.927076  

Вы можете настроить максимальную ширину отдельных столбцов, задав display.max_colwidth.

In [108]: datafile={'filename': ['filename_01','filename_02'],
   .....:           'path': ["media/user_name/storage/folder_01/filename_01",
   .....:                    "media/user_name/storage/folder_02/filename_02"]}
   .....: 

In [109]: pd.set_option('display.max_colwidth',30)

In [110]: pd.DataFrame(datafile)
Out[110]: 
      filename  \
0  filename_01   
1  filename_02   

                            path  
0  media/user_name/storage/fo...  
1  media/user_name/storage/fo...  

In [111]: pd.set_option('display.max_colwidth',100)

In [112]: pd.DataFrame(datafile)
Out[112]: 
      filename  \
0  filename_01   
1  filename_02   

                                            path  
0  media/user_name/storage/folder_01/filename_01  
1  media/user_name/storage/folder_02/filename_02  

Вы также можете отключить эту функцию с помощью опции expand_frame_repr. Это отобразит таблицу в одном блоке.

Доступ к атрибутам столбцов DataFrame и автодополнение в IPython

Если метка столбца DataFrame является допустимым именем переменной Python, к столбцу можно обратиться как к атрибутам:

In [113]: df = pd.DataFrame({'foo1' : np.random.randn(5),
   .....:                    'foo2' : np.random.randn(5)})
   .....: 

In [114]: df
Out[114]: 
       foo1      foo2
0  0.909160  1.360298
1 -0.667763 -1.603624
2 -0.101656 -1.648929
3  1.189682  0.145121
4 -0.090648 -2.536359

In [115]: df.foo1
Out[115]: 
0    0.909160
1   -0.667763
2   -0.101656
3    1.189682
4   -0.090648
Name: foo1, dtype: float64

Столбцы также связаны с механизмом автодополнения IPython, поэтому они могут быть дополнены с помощью клавиши Tab:

In [5]: df.fo<TAB>
df.foo1  df.foo2

Panel

Panel — это контейнер, который используется несколько реже, но по-прежнему важен для трёхмерных данных. Термин панельные данные происходит из эконометрики и частично ответственен за название pandas: pan(el)-da(ta)-s. Названия для трёх осей предназначены для придания некоторого семантического смысла описанию операций, связанных с панельными данными, и, в частности, эконометрическому анализу панельных данных. Однако для целей срезки и сортировки коллекции объектов DataFrame вы можете найти имена осей немного произвольными:

• items: ось 0, каждый элемент соответствует DataFrame, содержащемуся внутри
• major_axis: ось 1, это индекс (строки) каждого из DataFrames
• minor_axis: ось 2, это столбцы каждого из DataFrames

Создание Panel работает примерно так, как вы ожидаете:

Из 3D ndarray с необязательными метками осей

In [116]: wp = pd.Panel(np.random.randn(2, 5, 4), items=['Item1', 'Item2'],
   .....:               major_axis=pd.date_range('1/1/2000', periods=5),
   .....:               minor_axis=['A', 'B', 'C', 'D'])
   .....: 

In [117]: wp
Out[117]: 
<class 'pandas.core.panel.Panel'>
Dimensions: 2 (items) x 5 (major_axis) x 4 (minor_axis)
Items axis: Item1 to Item2
Major_axis axis: 2000-01-01 00:00:00 to 2000-01-05 00:00:00
Minor_axis axis: A to D

Из словаря объектов DataFrame

In [118]: data = {'Item1' : pd.DataFrame(np.random.randn(4, 3)),
   .....:         'Item2' : pd.DataFrame(np.random.randn(4, 2))}
   .....: 

In [119]: pd.Panel(data)
Out[119]: 
<class 'pandas.core.panel.Panel'>
Dimensions: 2 (items) x 4 (major_axis) x 3 (minor_axis)
Items axis: Item1 to Item2
Major_axis axis: 0 to 3
Minor_axis axis: 0 to 2

Обратите внимание, что значения в словаре должны быть преобразуемы в DataFrame. Таким образом, они могут быть любым из других допустимых входных данных для DataFrame, как указано выше.

Полезный фабричный метод — Panel.from_dict, который принимает словарь DataFrames, как указано выше, и следующие именованные параметры:

Например, сравните со созданием выше:

In [120]: pd.Panel.from_dict(data, orient='minor')
Out[120]: 
<class 'pandas.core.panel.Panel'>
Dimensions: 3 (items) x 4 (major_axis) x 2 (minor_axis)
Items axis: 0 to 2
Major_axis axis: 0 to 3
Minor_axis axis: Item1 to Item2

Orient особенно полезен для DataFrames смешанного типа. Если вы передадите словарь объектов DataFrame со столбцами смешанного типа, все данные будут преобразованы к типу dtype=object , если вы не передадите orient='minor':

In [121]: df = pd.DataFrame({'a': ['foo', 'bar', 'baz'],
   .....:                    'b': np.random.randn(3)})
   .....: 

In [122]: df
Out[122]: 
     a         b
0  foo -1.264356
1  bar -0.497629
2  baz  1.789719

In [123]: data = {'item1': df, 'item2': df}

In [124]: panel = pd.Panel.from_dict(data, orient='minor')

In [125]: panel['a']
Out[125]: 
  item1 item2
0   foo   foo
1   bar   bar
2   baz   baz

In [126]: panel['b']
Out[126]: 
      item1     item2
0 -1.264356 -1.264356
1 -0.497629 -0.497629
2  1.789719  1.789719

In [127]: panel['b'].dtypes
Out[127]: 
item1    float64
item2    float64
dtype: object

Из DataFrame с помощью метода to_panel

Этот метод был представлен в версии 0.7 для замены LongPanel.to_long, и преобразует DataFrame с двухъярусным индексом в Panel.

In [128]: midx = pd.MultiIndex(levels=[['one', 'two'], ['x','y']], labels=[[1,1,0,0],[1,0,1,0]])

In [129]: df = pd.DataFrame({'A' : [1, 2, 3, 4], 'B': [5, 6, 7, 8]}, index=midx)

In [130]: df.to_panel()
Out[130]: 
<class 'pandas.core.panel.Panel'>
Dimensions: 2 (items) x 2 (major_axis) x 2 (minor_axis)
Items axis: A to B
Major_axis axis: one to two
Minor_axis axis: x to y

Выбор/добавление/удаление элемента Panel

Аналогично тому, как DataFrame работает как словарь Series, Panel работает как словарь DataFrames:

In [131]: wp['Item1']
Out[131]: 
                   A         B         C         D
2000-01-01  0.835993 -0.621868 -0.173710 -0.174326
2000-01-02 -0.354356  2.090183 -0.736019 -1.250412
2000-01-03 -0.581326 -0.244477  0.917119  0.611695
2000-01-04 -1.576078 -0.528562 -0.704643 -0.481453
2000-01-05  1.085093 -1.229749  2.295679 -1.016910

In [132]: wp['Item3'] = wp['Item1'] / wp['Item2']

API для вставки и удаления такой же, как для DataFrame. И так же, как и в DataFrame, если элемент является допустимым идентификатором Python, к нему можно обратиться как к атрибуту и выполнить автодополнение в IPython.

Транспонирование

Panel можно переупорядочить, используя метод transpose (который по умолчанию не создаёт копию, если данные не разнородны):

In [133]: wp.transpose(2, 0, 1)
Out[133]: 
<class 'pandas.core.panel.Panel'>
Dimensions: 4 (items) x 3 (major_axis) x 5 (minor_axis)
Items axis: A to D
Major_axis axis: Item1 to Item3
Minor_axis axis: 2000-01-01 00:00:00 to 2000-01-05 00:00:00

Индексирование/Выбор

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

In [134]: wp['Item1']
Out[134]: 
                   A         B         C         D
2000-01-01  0.835993 -0.621868 -0.173710 -0.174326
2000-01-02 -0.354356  2.090183 -0.736019 -1.250412
2000-01-03 -0.581326 -0.244477  0.917119  0.611695
2000-01-04 -1.576078 -0.528562 -0.704643 -0.481453
2000-01-05  1.085093 -1.229749  2.295679 -1.016910

In [135]: wp.major_xs(wp.major_axis[2])
Out[135]: 
      Item1     Item2     Item3
A -0.581326 -1.271582  0.457167
B -0.244477 -0.861256  0.283861
C  0.917119 -0.597879 -1.533955
D  0.611695 -0.118700 -5.153265

In [136]: wp.minor_axis
Out[136]: Index([u'A', u'B', u'C', u'D'], dtype='object')

In [137]: wp.minor_xs('C')
Out[137]: 
               Item1     Item2      Item3
2000-01-01 -0.173710  2.381645  -0.072937
2000-01-02 -0.736019 -2.413161   0.305002
2000-01-03  0.917119 -0.597879  -1.533955
2000-01-04 -0.704643 -1.536019   0.458746
2000-01-05  2.295679  0.181524  12.646732

Сжатие

Другой способ изменить размерность объекта — squeeze объект длиной 1, аналогично wp['Item1']

In [138]: wp.reindex(items=['Item1']).squeeze()
Out[138]: 
                   A         B         C         D
2000-01-01  0.835993 -0.621868 -0.173710 -0.174326
2000-01-02 -0.354356  2.090183 -0.736019 -1.250412
2000-01-03 -0.581326 -0.244477  0.917119  0.611695
2000-01-04 -1.576078 -0.528562 -0.704643 -0.481453
2000-01-05  1.085093 -1.229749  2.295679 -1.016910

In [139]: wp.reindex(items=['Item1'], minor=['B']).squeeze()
Out[139]: 
2000-01-01   -0.621868
2000-01-02    2.090183
2000-01-03   -0.244477
2000-01-04   -0.528562
2000-01-05   -1.229749
Freq: D, Name: B, dtype: float64

Преобразование в DataFrame

Panel может быть представлен в двумерной форме как DataFrame с иерархическим индексом. См. раздел иерархический индексирование для получения дополнительной информации об этом. Для преобразования Panel в DataFrame используйте метод to_frame:

In [140]: panel = pd.Panel(np.random.randn(3, 5, 4), items=['one', 'two', 'three'],
   .....:                  major_axis=pd.date_range('1/1/2000', periods=5),
   .....:                  minor_axis=['a', 'b', 'c', 'd'])
   .....: 

In [141]: panel.to_frame()
Out[141]: 
                       one       two     three
major      minor                              
2000-01-01 a      0.445900 -1.286198 -1.023189
           b     -0.574496 -0.407154  0.591682
           c      0.872979  0.068084 -0.008919
           d      0.297255 -2.157051 -0.415572
2000-01-02 a     -1.022617 -0.443982 -0.772683
           b      1.091870 -0.881639 -0.516197
           c      1.831444  0.851834  0.626655
           d      1.271808 -1.352515  0.269623
2000-01-03 a     -0.472876  0.228761  1.709250
           b     -0.279340  0.416858 -0.830728
           c      0.495966  0.301709 -0.290244
           d      0.367858  0.569010 -1.588782
2000-01-04 a     -1.530917 -0.047619  0.639406
           b     -0.285890  0.413370  1.055533
           c      0.943062  0.573056 -0.260898
           d      1.361752 -0.154419 -0.289725
2000-01-05 a      0.210373  0.987044  0.279621
           b     -1.945608  0.063191  0.454423
           c      2.532409  0.439086 -0.065750
           d      0.373819  1.657475  1.465709

Panel4D (Экспериментально)

Panel4D — четырёхмерный именованный контейнер, очень похожий на Panel, но с четырьмя именованными измерениями. Он предназначен в качестве тестовой площадки для контейнеров с ещё более высокими измерениями.

• labels: ось 0, каждый элемент соответствует Panel, содержащемуся внутри
• items: ось 1, каждый элемент соответствует DataFrame, содержащемуся внутри
• major_axis: ось 2, это индекс (строки) каждого из DataFrames
• minor_axis: ось 3, это столбцы каждого из DataFrames

Panel4D — подкласс Panel, поэтому большинство методов, работающих с Panel, применимы к Panel4D. Следующие методы отключены:

• join , to_frame , to_excel , to_sparse , groupby

Создание Panel4D работает очень похоже на создание Panel

Из 4D ndarray с необязательными метками осей

In [142]: p4d = pd.Panel4D(np.random.randn(2, 2, 5, 4),
   .....:                  labels=['Label1','Label2'],
   .....:                  items=['Item1', 'Item2'],
   .....:                  major_axis=pd.date_range('1/1/2000', periods=5),
   .....:                  minor_axis=['A', 'B', 'C', 'D'])
   .....: 

In [143]: p4d
Out[143]: 
<class 'pandas.core.panelnd.Panel4D'>
Dimensions: 2 (labels) x 2 (items) x 5 (major_axis) x 4 (minor_axis)
Labels axis: Label1 to Label2
Items axis: Item1 to Item2
Major_axis axis: 2000-01-01 00:00:00 to 2000-01-05 00:00:00
Minor_axis axis: A to D

Из словаря объектов Panel

In [144]: data = { 'Label1' : pd.Panel({ 'Item1' : pd.DataFrame(np.random.randn(4, 3)) }),
   .....:          'Label2' : pd.Panel({ 'Item2' : pd.DataFrame(np.random.randn(4, 2)) }) }
   .....: 

In [145]: pd.Panel4D(data)
Out[145]: 
<class 'pandas.core.panelnd.Panel4D'>
Dimensions: 2 (labels) x 2 (items) x 4 (major_axis) x 3 (minor_axis)
Labels axis: Label1 to Label2
Items axis: Item1 to Item2
Major_axis axis: 0 to 3
Minor_axis axis: 0 to 2

Обратите внимание, что значения в словаре должны быть преобразуемы в Panel. Таким образом, они могут быть любым из других допустимых входных данных для Panel, как указано выше.

Срезы

Срезы работают аналогично Panel. [] срезает первое измерение. .ix позволяет произвольно выполнять срезы и получать объекты с меньшей размерностью

In [146]: p4d['Label1']
Out[146]: 
<class 'pandas.core.panel.Panel'>
Dimensions: 2 (items) x 5 (major_axis) x 4 (minor_axis)
Items axis: Item1 to Item2
Major_axis axis: 2000-01-01 00:00:00 to 2000-01-05 00:00:00
Minor_axis axis: A to D

4D -> Panel

In [147]: p4d.ix[:,:,:,'A']
Out[147]: 
<class 'pandas.core.panel.Panel'>
Dimensions: 2 (items) x 2 (major_axis) x 5 (minor_axis)
Items axis: Label1 to Label2
Major_axis axis: Item1 to Item2
Minor_axis axis: 2000-01-01 00:00:00 to 2000-01-05 00:00:00

4D -> DataFrame

In [148]: p4d.ix[:,:,0,'A']
Out[148]: 
         Label1    Label2
Item1  1.127489  0.015494
Item2 -1.650400  0.130533

4D -> Серия

In [149]: p4d.ix[:,0,0,'A']
Out[149]: 
Label1    1.127489
Label2    0.015494
Name: A, dtype: float64

Транспонирование

Панель 4D можно переупорядочить, используя её transpose метод (который по умолчанию не создаёт копию, если данные не разнородны):

In [150]: p4d.transpose(3, 2, 1, 0)
Out[150]: 
<class 'pandas.core.panelnd.Panel4D'>
Dimensions: 4 (labels) x 5 (items) x 2 (major_axis) x 2 (minor_axis)
Labels axis: A to D
Items axis: 2000-01-01 00:00:00 to 2000-01-05 00:00:00
Major_axis axis: Item1 to Item2
Minor_axis axis: Label1 to Label2

PanelND (Экспериментальная версия)

PanelND — модуль с набором функций-фабрик, позволяющий пользователю создавать N-мерные именованные контейнеры, такие как Panel4D, с набором пользовательских меток осей. Таким образом, можно легко создать контейнер, специфичный для конкретной области.

Следующий пример создаёт Panel5D. Новый объект типа панели должен быть разрезаем на объект меньшей размерности. Здесь мы разрезаем на Panel4D.

In [151]: from pandas.core import panelnd

In [152]: Panel5D = panelnd.create_nd_panel_factory(
   .....:     klass_name   = 'Panel5D',
   .....:     orders  = [ 'cool', 'labels','items','major_axis','minor_axis'],
   .....:     slices  = { 'labels' : 'labels', 'items' : 'items',
   .....:                     'major_axis' : 'major_axis', 'minor_axis' : 'minor_axis' },
   .....:     slicer  = pd.Panel4D,
   .....:     aliases = { 'major' : 'major_axis', 'minor' : 'minor_axis' },
   .....:     stat_axis    = 2)
   .....: 

In [153]: p5d = Panel5D(dict(C1 = p4d))

In [154]: p5d
Out[154]: 
<class 'pandas.core.panelnd.Panel5D'>
Dimensions: 1 (cool) x 2 (labels) x 2 (items) x 5 (major_axis) x 4 (minor_axis)
Cool axis: C1 to C1
Labels axis: Label1 to Label2
Items axis: Item1 to Item2
Major_axis axis: 2000-01-01 00:00:00 to 2000-01-05 00:00:00
Minor_axis axis: A to D

# print a slice of our 5D
In [155]: p5d.ix['C1',:,:,0:3,:]
Out[155]: 
<class 'pandas.core.panelnd.Panel4D'>
Dimensions: 2 (labels) x 2 (items) x 3 (major_axis) x 4 (minor_axis)
Labels axis: Label1 to Label2
Items axis: Item1 to Item2
Major_axis axis: 2000-01-01 00:00:00 to 2000-01-03 00:00:00
Minor_axis axis: A to D

# transpose it
In [156]: p5d.transpose(1,2,3,4,0)
Out[156]: 
<class 'pandas.core.panelnd.Panel5D'>
Dimensions: 2 (cool) x 2 (labels) x 5 (items) x 4 (major_axis) x 1 (minor_axis)
Cool axis: Label1 to Label2
Labels axis: Item1 to Item2
Items axis: 2000-01-01 00:00:00 to 2000-01-05 00:00:00
Major_axis axis: A to D
Minor_axis axis: C1 to C1

# look at the shape & dim
In [157]: p5d.shape
Out[157]: (1, 2, 2, 5, 4)

In [158]: p5d.ndim
Out[158]: 5