python - index - pandas.at versus.loc

pandas python

Question

He estado explorando cómo optimizar mi código y me encontré con el método .at pandas . Por la documentation

Acceso escalar basado en etiquetas rápidas

Al igual que en loc, at proporciona búsquedas escalares basadas en etiquetas. También puede establecer utilizando estos indexadores.

Así que corrí algunas muestras:

Preparar

import pandas as pd
import numpy as np
from string import letters, lowercase, uppercase

lt = list(letters)
lc = list(lowercase)
uc = list(uppercase)

def gdf(rows, cols, seed=None):
    """rows and cols are what you''d pass
    to pd.MultiIndex.from_product()"""
    gmi = pd.MultiIndex.from_product
    df = pd.DataFrame(index=gmi(rows), columns=gmi(cols))
    np.random.seed(seed)
    df.iloc[:, :] = np.random.rand(*df.shape)
    return df

seed = [3, 1415]
df = gdf([lc, uc], [lc, uc], seed)

print df.head().T.head().T

df parece a

            a                                        
            A         B         C         D         E
a A  0.444939  0.407554  0.460148  0.465239  0.462691
  B  0.032746  0.485650  0.503892  0.351520  0.061569
  C  0.777350  0.047677  0.250667  0.602878  0.570528
  D  0.927783  0.653868  0.381103  0.959544  0.033253
  E  0.191985  0.304597  0.195106  0.370921  0.631576

Vamos a usar .at y .loc y asegurar que obtengo lo mismo

print "using .loc", df.loc[(''a'', ''A''), (''c'', ''C'')]
print "using .at ", df.at[(''a'', ''A''), (''c'', ''C'')]

using .loc 0.37374090276
using .at  0.37374090276

Velocidad de prueba usando .loc

%%timeit
df.loc[(''a'', ''A''), (''c'', ''C'')]

10000 loops, best of 3: 180 µs per loop

Velocidad de prueba usando .at

%%timeit
df.at[(''a'', ''A''), (''c'', ''C'')]

The slowest run took 6.11 times longer than the fastest. This could mean that an intermediate result is being cached.
100000 loops, best of 3: 8 µs per loop

Esto parece ser un gran aumento de velocidad. Incluso en la etapa de almacenamiento en caché 6.11 * 8 es mucho más rápido que 180

Pregunta

¿Cuáles son las limitaciones de .at ? Estoy motivado para usarlo. La documentación dice que es similar a .loc pero no se comporta de manera similar. Ejemplo:

# small df
sdf = gdf([lc[:2]], [uc[:2]], seed)

print sdf.loc[:, :]

          A         B
a  0.444939  0.407554
b  0.460148  0.465239

donde como print sdf.at[:, :] da como resultado TypeError: unhashable type

Así que obviamente no es lo mismo, incluso si la intención es ser similar.

Dicho esto, ¿quién puede proporcionar orientación sobre qué se puede y no se puede hacer con el método .at ?

Answer 1

A medida que preguntaste acerca de las limitaciones de .at , aquí hay una cosa con la que me topé recientemente (usar pandas 0.22). Usemos el ejemplo de la documentación :

df = pd.DataFrame([[0, 2, 3], [0, 4, 1], [10, 20, 30]], index=[4, 5, 6], columns=[''A'', ''B'', ''C''])
df2 = df.copy()

    A   B   C
4   0   2   3
5   0   4   1
6  10  20  30

Si ahora hago

df.at[4, ''B''] = 100

el resultado se ve como se esperaba

    A    B   C
4   0  100   3
5   0    4   1
6  10   20  30

Sin embargo, cuando trato de hacer

 df.at[4, ''C''] = 10.05

Parece que .at intenta conservar el tipo de datos (aquí: int ) :

    A    B   C
4   0  100  10
5   0    4   1
6  10   20  30

Eso parece ser una diferencia para .loc :

df2.loc[4, ''C''] = 10.05

cede lo deseado

    A   B      C
4   0   2  10.05
5   0   4   1.00
6  10  20  30.00

Lo arriesgado en el ejemplo anterior es que sucede en silencio (la conversión de float a int`). Cuando uno intente lo mismo con las cadenas, lanzará un error:

df.at[5, ''A''] = ''a_string''

ValueError: literal no válido para int () con base 10: ''a_string''

Answer 2

Actualización: df.get_value está en desuso a partir de la versión 0.21.0. El uso de df.at o df.iat es el método recomendado para seguir adelante.

df.at solo puede acceder a un único valor a la vez.

df.loc puede seleccionar múltiples filas y / o columnas.

Tenga en cuenta que también hay df.get_value , que puede ser incluso más rápido para acceder a valores individuales:

In [25]: %timeit df.loc[(''a'', ''A''), (''c'', ''C'')]
10000 loops, best of 3: 187 µs per loop

In [26]: %timeit df.at[(''a'', ''A''), (''c'', ''C'')]
100000 loops, best of 3: 8.33 µs per loop

In [35]: %timeit df.get_value((''a'', ''A''), (''c'', ''C''))
100000 loops, best of 3: 3.62 µs per loop

Debajo del capó, df.at[...] llama a df.get_value , pero también realiza una comprobación de tipo de las teclas.