Seleccionar con criterios complejos de pandas.DataFrame
Por ejemplo tengo DF simple:
import pandas as pd
from random import randint
df = pd.DataFrame({'A': [randint(1, 9) for x in range(10)],
'B': [randint(1, 9)*10 for x in range(10)],
'C': [randint(1, 9)*100 for x in range(10)]})
¿Puedo seleccionar valores de 'A' para los cuales los valores correspondientes para 'B' serán mayores que 50 y para 'C' no iguales a 900, usando métodos y modismos de Pandas?
¡Seguro! Configuración:
>>> import pandas as pd
>>> from random import randint
>>> df = pd.DataFrame({'A': [randint(1, 9) for x in range(10)],
'B': [randint(1, 9)*10 for x in range(10)],
'C': [randint(1, 9)*100 for x in range(10)]})
>>> df
A B C
0 9 40 300
1 9 70 700
2 5 70 900
3 8 80 900
4 7 50 200
5 9 30 900
6 2 80 700
7 2 80 400
8 5 80 300
9 7 70 800
Podemos aplicar operaciones de columna y obtener objetos de serie booleanos:
>>> df["B"] > 50
0 False
1 True
2 True
3 True
4 False
5 False
6 True
7 True
8 True
9 True
Name: B
>>> (df["B"] > 50) & (df["C"] != 900)
o
>>> (df["B"] > 50) & ~(df["C"] == 900)
0 False
1 False
2 True
3 True
4 False
5 False
6 False
7 False
8 False
9 False
[Actualización, para cambiar al nuevo estilo .loc]:
Y luego podemos usarlos para indexar el objeto. Para acceso de lectura, puede encadenar índices:
>>> df["A"][(df["B"] > 50) & (df["C"] != 900)]
2 5
3 8
Name: A, dtype: int64
pero puedes meterte en problemas debido a la diferencia entre una vista y una copia al hacer esto para acceso de escritura. Puedes usar .locen su lugar:
>>> df.loc[(df["B"] > 50) & (df["C"] != 900), "A"]
2 5
3 8
Name: A, dtype: int64
>>> df.loc[(df["B"] > 50) & (df["C"] != 900), "A"].values
array([5, 8], dtype=int64)
>>> df.loc[(df["B"] > 50) & (df["C"] != 900), "A"] *= 1000
>>> df
A B C
0 9 40 300
1 9 70 700
2 5000 70 900
3 8000 80 900
4 7 50 200
5 9 30 900
6 2 80 700
7 2 80 400
8 5 80 300
9 7 70 800
Otra solución es utilizar el método de consulta :
import pandas as pd
from random import randint
df = pd.DataFrame({'A': [randint(1, 9) for x in xrange(10)],
'B': [randint(1, 9) * 10 for x in xrange(10)],
'C': [randint(1, 9) * 100 for x in xrange(10)]})
print df
A B C
0 7 20 300
1 7 80 700
2 4 90 100
3 4 30 900
4 7 80 200
5 7 60 800
6 3 80 900
7 9 40 100
8 6 40 100
9 3 10 600
print df.query('B > 50 and C != 900')
A B C
1 7 80 700
2 4 90 100
4 7 80 200
5 7 60 800
Ahora, si desea cambiar los valores devueltos en la columna A, puede guardar su índice:
my_query_index = df.query('B > 50 & C != 900').index
....y utilizar .ilocpara cambiarlos, es decir:
df.iloc[my_query_index, 0] = 5000
print df
A B C
0 7 20 300
1 5000 80 700
2 5000 90 100
3 4 30 900
4 5000 80 200
5 5000 60 800
6 3 80 900
7 9 40 100
8 6 40 100
9 3 10 600
¡Y recuerda usar paréntesis!
Tenga en cuenta que &el operador tiene prioridad sobre operadores como >o <etc. Es por eso que
4 < 5 & 6 > 4
evalúa a False. Por lo tanto, si está utilizando pd.loc, debe colocar corchetes alrededor de sus declaraciones lógicas; de lo contrario, obtendrá un error. Por eso haz:
df.loc[(df['A'] > 10) & (df['B'] < 15)]
en lugar de
df.loc[df['A'] > 10 & df['B'] < 15]
lo que resultaría en
TypeError: no se puede comparar una matriz dtyped [float64] con un escalar de tipo [bool]
Puedes usar pandas, tiene algunas funciones integradas para comparar. Entonces, si desea seleccionar valores de "A" que cumplan con las condiciones de "B" y "C" (suponiendo que desee recuperar un objeto pandas DataFrame)
df[['A']][df.B.gt(50) & df.C.ne(900)]
df[['A']]le devolverá la columna A en formato DataFrame.
La función pandas gtdevolverá las posiciones de la columna B que sean mayores que 50 y nedevolverá las posiciones que no sean iguales a 900.
Puede ser más legible asignar cada condición a una variable, especialmente si hay muchas (tal vez con nombres descriptivos) y encadenarlas usando operadores bit a bit como ( &o |). Como beneficio adicional, no necesita preocuparse por los paréntesis ()porque cada condición se evalúa de forma independiente.
m1 = df['B'] > 50
m2 = df['C'] != 900
m3 = df['C'].pow(2) > 1000
m4 = df['B'].mul(4).between(50, 500)
# filter rows where all of the conditions are True
df[m1 & m2 & m3 & m4]
# filter rows of column A where all of the conditions are True
df.loc[m1 & m2 & m3 & m4, 'A']
o coloque las condiciones en una lista y redúzcalas mediante bitwise_andfrom numpy(envoltorio para &).
conditions = [
df['B'] > 50,
df['C'] != 900,
df['C'].pow(2) > 1000,
df['B'].mul(4).between(50, 500)
]
# filter rows of A where all of conditions are True
df.loc[np.bitwise_and.reduce(conditions), 'A']
