pandas - index - Seleccione una sección transversal de varias claves de un DataFrame

pandas select columns

Question

Tengo un DataFrame "df" con (time, ticker) Multiindex y columnas de datos bid / ask / etc:

tod last bid ask volume time ticker 2013-02-01 SPY 1600 149.70 150.14 150.17 1300 SLV 1600 30.44 30.38 30.43 3892 GLD 1600 161.20 161.19 161.21 3860

Me gustaría seleccionar una sección transversal de segundo nivel (nivel = 1) con varias teclas. En este momento, puedo hacerlo usando una tecla, es decir

df.xs(''SPY'', level=1)

Lo que me da una serie temporal de SPY. ¿Cuál es la mejor manera de seleccionar una sección transversal de varias teclas, es decir, una sección transversal combinada de SPY y GLD, algo así como:

df.xs([''SPY'', ''GLD''], level=1)

?

Answer 1

Convertir a un panel, entonces la indexación es directa

In [20]: df = pd.DataFrame(dict(time = pd.Timestamp(''20130102''), 
                                A = np.random.rand(3), 
                 ticker=[''SPY'',''SLV'',''GLD''])).set_index([''time'',''ticker''])

In [21]: df
Out[21]: 
                          A
time       ticker          
2013-01-02 SPY     0.347209
           SLV     0.034832
           GLD     0.280951

In [22]: p = df.to_panel()

In [23]: p
Out[23]: 
<class ''pandas.core.panel.Panel''>
Dimensions: 1 (items) x 1 (major_axis) x 3 (minor_axis)
Items axis: A to A
Major_axis axis: 2013-01-02 00:00:00 to 2013-01-02 00:00:00
Minor_axis axis: GLD to SPY

In [24]: p.ix[:,:,[''SPY'',''GLD'']]
Out[24]: 
<class ''pandas.core.panel.Panel''>
Dimensions: 1 (items) x 1 (major_axis) x 2 (minor_axis)
Items axis: A to A
Major_axis axis: 2013-01-02 00:00:00 to 2013-01-02 00:00:00
Minor_axis axis: SPY to GLD

Answer 2

Hay mejores formas de hacerlo con las versiones más recientes de Pandas:

regression_df.loc[(slice(None), [''SPY'', ''GLD'']), :]

Este enfoque requiere que el índice se df.sort_index() lexicográficamente (use df.sort_index() ).

Answer 3

No pude encontrar una forma más directa que no sea usar select :

>>> df

       last   tod
A SPY     1  1600
  SLV     2  1600
  GLD     3  1600

>>> df.select(lambda x: x[1] in [''SPY'',''GLD''])

       last   tod
A SPY     1  1600
  GLD     3  1600

Answer 4

Por lo que vale, hice lo siguiente:

foo = pd.DataFrame(np.random.rand(12,3), 
                   index=pd.MultiIndex.from_product([[''A'',''B'',''C'',''D''],[''Green'',''Red'',''Blue'']], 
                                                    names=[''Letter'',''Color'']),
                   columns=[''X'',''Y'',''Z'']).sort_index()

foo.reset_index()/
   .loc[foo.reset_index().Color.isin({''Green'',''Red''})]/
   .set_index(foo.index.names)

Este enfoque es similar a seleccionar, pero evita la iteración sobre todas las filas con un lambda.

Sin embargo, comparé esto con el enfoque del Panel, y parece que la solución del Panel es más rápida (2.91 ms para index / loc vs 1.48 ms para to_panel / to_frame:

foo.to_panel()[:,:,[''Green'',''Red'']].to_frame()

Veces:

In [56]:
%%timeit
foo.reset_index().loc[foo.reset_index().Color.isin({''Green'',''Red''})].set_index(foo.index.names)
100 loops, best of 3: 2.91 ms per loop

In [57]:
%%timeit
foo2 = foo.reset_index()
foo2.loc[foo2.Color.eq(''Green'') | foo2.Color.eq(''Red'')].set_index(foo.index.names)
100 loops, best of 3: 2.85 ms per loop

In [58]:
%%timeit
foo2 = foo.reset_index()
foo2.loc[foo2.Color.ne(''Blue'')].set_index(foo.index.names)
100 loops, best of 3: 2.37 ms per loop

In [54]:
%%timeit
foo.to_panel()[:,:,[''Green'',''Red'']].to_frame()
1000 loops, best of 3: 1.18 ms per loop

ACTUALIZAR

Después de revisar este tema (nuevamente), observé lo siguiente:

In [100]:
%%timeit
foo2 = pd.DataFrame({k: foo.loc[k] for k in foo.index if k[1] in [''Green'',''Red'']}).transpose()
foo2.index.names = foo.index.names
foo2.columns.names = foo2.columns.names
100 loops, best of 3: 1.97 ms per loop

In [101]:
%%timeit
foo2 = pd.DataFrame.from_dict({k: foo.loc[k] for k in foo.index if k[1] in [''Green'',''Red'']}, orient=''index'')
foo2.index.names = foo.index.names
foo2.columns.names = foo2.columns.names
100 loops, best of 3: 1.82 ms per loop

Si no le importa conservar el orden original y la denominación de los niveles, puede utilizar:

%%timeit
pd.concat({key: foo.xs(key, axis=0, level=1) for key in [''Green'',''Red'']}, axis=0)
1000 loops, best of 3: 1.31 ms per loop

Y si solo estás seleccionando en el primer nivel:

%%timeit
pd.concat({key: foo.loc[key] for key in [''A'',''B'']}, axis=0, names=foo.index.names)
1000 loops, best of 3: 1.12 ms per loop

versus:

%%timeit
foo.to_panel()[:,[''A'',''B''],:].to_frame()
1000 loops, best of 3: 1.16 ms per loop

Otra actualización

Si ordena el índice del ejemplo foo , muchas de las veces anteriores mejoran (los tiempos se han actualizado para reflejar un índice pre-ordenado). Sin embargo, cuando el índice está ordenado, puede usar la solución descrita por user674155:

%%timeit
foo.loc[(slice(None), [''Blue'',''Red'']),:]
1000 loops, best of 3: 582 µs per loop

Este es el más eficiente e intuitivo en mi opinión (el usuario no necesita entender los paneles y cómo se crean a partir de marcos).

Nota: incluso si el índice aún no se ha ordenado, la clasificación del índice de foo sobre la marcha es comparable en rendimiento a la opción to_panel .