pandas: filtrer les lignes de DataFrame avec le chaînage des opérateurs

La plupart des opérations en pandaspeut être accompli avec l' opérateur Enchaînement ( groupby, aggregate, apply, etc.), mais la seule façon que j'ai trouvé aux lignes de filtre se fait via l' indexation de support normale

df_filtered = df[df['column'] == value]

C'est peu attrayant car cela nécessite que j'attribue dfune variable avant de pouvoir filtrer sur ses valeurs. Y a-t-il quelque chose de plus semblable au suivant?

df_filtered = df.mask(lambda x: x['column'] == value)

Je ne suis pas tout à fait sûr de ce que vous voulez, et votre dernière ligne de code n'aide pas non plus, mais de toute façon:

Le filtrage "chaîné" se fait en "chaînant" les critères de l'index booléen.

In [96]: df
Out[96]:
   A  B  C  D
a  1  4  9  1
b  4  5  0  2
c  5  5  1  0
d  1  3  9  6

In [99]: df[(df.A == 1) & (df.D == 6)]
Out[99]:
   A  B  C  D
d  1  3  9  6

Si vous souhaitez chaîner des méthodes, vous pouvez ajouter votre propre méthode de masque et l'utiliser.

In [90]: def mask(df, key, value):
   ....:     return df[df[key] == value]
   ....:

In [92]: pandas.DataFrame.mask = mask

In [93]: df = pandas.DataFrame(np.random.randint(0, 10, (4,4)), index=list('abcd'), columns=list('ABCD'))

In [95]: df.ix['d','A'] = df.ix['a', 'A']

In [96]: df
Out[96]:
   A  B  C  D
a  1  4  9  1
b  4  5  0  2
c  5  5  1  0
d  1  3  9  6

In [97]: df.mask('A', 1)
Out[97]:
   A  B  C  D
a  1  4  9  1
d  1  3  9  6

In [98]: df.mask('A', 1).mask('D', 6)
Out[98]:
   A  B  C  D
d  1  3  9  6

Les filtres peuvent être chaînés à l'aide d'une requête Pandas :

df = pd.DataFrame(np.random.randn(30, 3), columns=['a','b','c'])
df_filtered = df.query('a > 0').query('0 < b < 2')

Les filtres peuvent également être combinés en une seule requête:

df_filtered = df.query('a > 0 and 0 < b < 2')

La réponse de @lodagro est excellente. Je voudrais l'étendre en généralisant la fonction de masque comme:

def mask(df, f):
  return df[f(df)]

Ensuite, vous pouvez faire des choses comme:

df.mask(lambda x: x[0] < 0).mask(lambda x: x[1] > 0)

Depuis la version 0.18.1, la .locméthode accepte un appelable pour la sélection. Avec les fonctions lambda, vous pouvez créer des filtres chaînables très flexibles:

import numpy as np
import pandas as pd

df = pd.DataFrame(np.random.randint(0,100,size=(100, 4)), columns=list('ABCD'))
df.loc[lambda df: df.A == 80]  # equivalent to df[df.A == 80] but chainable

df.sort_values('A').loc[lambda df: df.A > 80].loc[lambda df: df.B > df.A]

Si tout ce que vous faites est de filtrer, vous pouvez également omettre le .loc.

Je propose cela pour des exemples supplémentaires. Il s'agit de la même réponse que https://stackoverflow.com/a/28159296/

J'ajouterai d'autres modifications pour rendre ce post plus utile.

pandas.DataFrame.query
querya été fait exactement dans ce but. Tenez compte de la trame de donnéesdf

import pandas as pd
import numpy as np

np.random.seed([3,1415])
df = pd.DataFrame(
    np.random.randint(10, size=(10, 5)),
    columns=list('ABCDE')
)

df

   A  B  C  D  E
0  0  2  7  3  8
1  7  0  6  8  6
2  0  2  0  4  9
3  7  3  2  4  3
4  3  6  7  7  4
5  5  3  7  5  9
6  8  7  6  4  7
7  6  2  6  6  5
8  2  8  7  5  8
9  4  7  6  1  5

Utilisons querypour filtrer toutes les lignes oùD > B

df.query('D > B')

   A  B  C  D  E
0  0  2  7  3  8
1  7  0  6  8  6
2  0  2  0  4  9
3  7  3  2  4  3
4  3  6  7  7  4
5  5  3  7  5  9
7  6  2  6  6  5

Que nous enchaînons

df.query('D > B').query('C > B')
# equivalent to
# df.query('D > B and C > B')
# but defeats the purpose of demonstrating chaining

   A  B  C  D  E
0  0  2  7  3  8
1  7  0  6  8  6
4  3  6  7  7  4
5  5  3  7  5  9
7  6  2  6  6  5

J'avais la même question, sauf que je voulais combiner les critères dans une condition OU. Le format donné par Wouter Overmeire combine les critères en une condition ET telle que les deux doivent être satisfaites:

In [96]: df
Out[96]:
   A  B  C  D
a  1  4  9  1
b  4  5  0  2
c  5  5  1  0
d  1  3  9  6

In [99]: df[(df.A == 1) & (df.D == 6)]
Out[99]:
   A  B  C  D
d  1  3  9  6

Mais j'ai trouvé que, si vous encapsulez chaque condition (... == True)et joignez les critères avec un tuyau, les critères sont combinés dans une condition OR, satisfait chaque fois que l'un d'eux est vrai:

df[((df.A==1) == True) | ((df.D==6) == True)]

pandas propose deux alternatives à la réponse de Wouter Overmeire qui ne nécessitent aucune dérogation. On est .loc[.]avec un callable, comme dans

df_filtered = df.loc[lambda x: x['column'] == value]

l'autre est .pipe(), comme dans

df_filtered = df.pipe(lambda x: x['column'] == value)

Ma réponse est similaire aux autres. Si vous ne souhaitez pas créer de nouvelle fonction, vous pouvez utiliser ce que les pandas ont déjà défini pour vous. Utilisez la méthode du tuyau.

df.pipe(lambda d: d[d['column'] == value])

Si vous souhaitez appliquer tous les masques booléens courants ainsi qu'un masque à usage général, vous pouvez ranger les éléments suivants dans un fichier, puis les affecter simplement comme suit:

pd.DataFrame = apply_masks()

Usage:

A = pd.DataFrame(np.random.randn(4, 4), columns=["A", "B", "C", "D"])
A.le_mask("A", 0.7).ge_mask("B", 0.2)... (May be repeated as necessary

C'est un peu hacky mais cela peut rendre les choses un peu plus propres si vous coupez et modifiez en continu des ensembles de données en fonction des filtres. Il y a aussi un filtre à usage général adapté de Daniel Velkov ci-dessus dans la fonction gen_mask que vous pouvez utiliser avec les fonctions lambda ou autrement si vous le souhaitez.

Fichier à enregistrer (j'utilise masks.py):

import pandas as pd

def eq_mask(df, key, value):
    return df[df[key] == value]

def ge_mask(df, key, value):
    return df[df[key] >= value]

def gt_mask(df, key, value):
    return df[df[key] > value]

def le_mask(df, key, value):
    return df[df[key] <= value]

def lt_mask(df, key, value):
    return df[df[key] < value]

def ne_mask(df, key, value):
    return df[df[key] != value]

def gen_mask(df, f):
    return df[f(df)]

def apply_masks():

    pd.DataFrame.eq_mask = eq_mask
    pd.DataFrame.ge_mask = ge_mask
    pd.DataFrame.gt_mask = gt_mask
    pd.DataFrame.le_mask = le_mask
    pd.DataFrame.lt_mask = lt_mask
    pd.DataFrame.ne_mask = ne_mask
    pd.DataFrame.gen_mask = gen_mask

    return pd.DataFrame

if __name__ == '__main__':
    pass

Cette solution est plus hackeuse en terme d'implémentation, mais je la trouve beaucoup plus propre en terme d'utilisation, et elle est certainement plus générale que les autres proposées.

https://github.com/toobaz/generic_utils/blob/master/generic_utils/pandas/where.py

Vous n'avez pas besoin de télécharger l'intégralité du référentiel: enregistrer le fichier et faire

from where import where as W

devrait suffire. Ensuite, vous l'utilisez comme ceci:

df = pd.DataFrame([[1, 2, True],
                   [3, 4, False], 
                   [5, 7, True]],
                  index=range(3), columns=['a', 'b', 'c'])
# On specific column:
print(df.loc[W['a'] > 2])
print(df.loc[-W['a'] == W['b']])
print(df.loc[~W['c']])
# On entire - or subset of a - DataFrame:
print(df.loc[W.sum(axis=1) > 3])
print(df.loc[W[['a', 'b']].diff(axis=1)['b'] > 1])

Un exemple d'utilisation un peu moins stupide:

data = pd.read_csv('ugly_db.csv').loc[~(W == '$null$').any(axis=1)]

Soit dit en passant: même dans le cas où vous utilisez simplement des cols booléens,

df.loc[W['cond1']].loc[W['cond2']]

peut être beaucoup plus efficace que

df.loc[W['cond1'] & W['cond2']]

car il évalue cond2uniquement où cond1est True.

AVERTISSEMENT: J'ai d'abord donné cette réponse ailleurs parce que je ne l'avais pas vu.

Je veux juste ajouter une démonstration en utilisant locpour filtrer non seulement par lignes mais aussi par colonnes et certains mérites de l'opération chaînée.

Le code ci-dessous peut filtrer les lignes par valeur.

df_filtered = df.loc[df['column'] == value]

En le modifiant un peu, vous pouvez également filtrer les colonnes.

df_filtered = df.loc[df['column'] == value, ['year', 'column']]

Alors pourquoi voulons-nous une méthode chaînée? La réponse est simple à lire si vous avez plusieurs opérations. Par exemple,

res =  df\
    .loc[df['station']=='USA', ['TEMP', 'RF']]\
    .groupby('year')\
    .agg(np.nanmean)

C'est peu attrayant car cela nécessite que j'attribue dfune variable avant de pouvoir filtrer sur ses valeurs.

df[df["column_name"] != 5].groupby("other_column_name")

semble fonctionner: vous pouvez également imbriquer l' []opérateur. Ils l'ont peut-être ajouté depuis que vous avez posé la question.

Si vous définissez vos colonnes pour rechercher en tant qu'index, vous pouvez utiliser DataFrame.xs()pour prendre une coupe transversale. Ce n'est pas aussi polyvalent que les queryréponses, mais cela peut être utile dans certaines situations.

import pandas as pd
import numpy as np

np.random.seed([3,1415])
df = pd.DataFrame(
    np.random.randint(3, size=(10, 5)),
    columns=list('ABCDE')
)

df
# Out[55]: 
#    A  B  C  D  E
# 0  0  2  2  2  2
# 1  1  1  2  0  2
# 2  0  2  0  0  2
# 3  0  2  2  0  1
# 4  0  1  1  2  0
# 5  0  0  0  1  2
# 6  1  0  1  1  1
# 7  0  0  2  0  2
# 8  2  2  2  2  2
# 9  1  2  0  2  1

df.set_index(['A', 'D']).xs([0, 2]).reset_index()
# Out[57]: 
#    A  D  B  C  E
# 0  0  2  2  2  2
# 1  0  2  1  1  0

Vous pouvez également tirer parti de la bibliothèque numpy pour les opérations logiques. C'est assez rapide.

df[np.logical_and(df['A'] == 1 ,df['B'] == 6)]