Python Pandas: supprimer les entrées sur la base du nombre d'occurrences

Je suis en train de supprimer des entrées à partir d'un bloc de données qui se produisent à moins de 100 fois.
Le bloc de données data ressemble à ceci:

Maintenant, je compte le nombre de balise occurrences comme ceci:

bytag = data.groupby('tag').aggregate(np.count_nonzero)

Mais ensuite je n'arrive pas à comprendre comment faire pour supprimer ces entrées qui ont une faible numération...

Comme @unutbu suggère, veuillez tenir compte de la modification de la accepté de répondre à cette méthode de filtrage est plus simple 🙂 )

InformationsquelleAutor sashkello | 2012-11-19

Edit: Merci à @WesMcKinney pour montrer cette manière beaucoup plus directe:

data[data.groupby('tag').pid.transform(len) > 1]

import pandas
import numpy as np
data = pandas.DataFrame(
    {'pid' : [1,1,1,2,2,3,3,3],
     'tag' : [23,45,62,24,45,34,25,62],
     })

bytag = data.groupby('tag').aggregate(np.count_nonzero)
tags = bytag[bytag.pid >= 2].index
print(data[data['tag'].isin(tags)])

rendements

   pid  tag
1    1   45
2    1   62
4    2   45
7    3   62

un joli one-liner: données[data.groupby('tag').pid.transformer(len) > 1]
Nous avons maintenant la filtre méthode pour cela.

InformationsquelleAutor unutbu

27

Nouveau dans 0.12, grouper les objets ont une filtre méthode, vous permettant de faire ces types d'opérations:
```
In [11]: g = data.groupby('tag')

In [12]: g.filter(lambda x: len(x) > 1)  # pandas 0.13.1
Out[12]:
   pid  tag
1    1   45
2    1   62
4    2   45
7    3   62
```
La fonction (le premier argument de filtre) est appliquée à chaque groupe (sous châssis), et les résultats d'inclure des éléments de l'original DataFrame appartenant à des groupes évaluée à Vrai.

Remarque: dans 0.12 commande est différente de celle de l'original DataFrame, cela a été corrigé dans 0.13+:
```
In [21]: g.filter(lambda x: len(x) > 1)  # pandas 0.12
Out[21]: 
   pid  tag
1    1   45
4    2   45
2    1   62
7    3   62
```
- Je me demande si la commande du résultat n'étant pas dans le même ordre est intentionnel...
- Merci de revenir à cette question à prêcher l'évangile de filtre. La réorganisation est un problème connu que je devrais avoir inclus dans la documentation. La commande est maintenue que si vous définissez dropna=False. Si non, les groupes peuvent être mélangées. Recourir eux serait une perte de temps, alors je l'ai laissé à l'utilisateur, ce qui est un choix discutable.
- Aussi, si il est répété/non ordonnée de l'index, il peut être non négligeable pour les remettre dans l'ordre. Ah ha, actuellement, vous pouvez le faire: g.filter(lambda x: len(x) > 1, dropna=False).dropna() pour maintenir l'ordre.
- oh non, vous ne pouvez pas... comme réindexation ne fonctionne pas avec des répétitions. Si le filtre ne fonctionne pas. Rappelez-vous, ni transformer.
- Si quelqu'un d'autre est de la lecture, le lien au rapport de bogue re répète: github.com/pydata/pandas/issues/4620
- Veuillez considérer ce qui en fait la accepté de répondre. Il est plus simple et est la bonne façon de le faire à l'avenir.
- Wes McKinney est groupby transform est plus de 2x plus rapide que l'utilisation filter
- s'il vous plaît partagez votre référence code! Je n'ai pas vérifié récemment, mais il n'a pas l'habitude d'être le cas.
- Bien sûr! J'ai ajouté un nouvel élément de réponse
InformationsquelleAutor Andy Hayden

df = pd.DataFrame([(1, 2), (1, 3), (1, 4), (2, 1),(2,2,)], columns=['col1', 'col2'])

In [36]: df
Out[36]: 
   col1  col2
0     1     2
1     1     3
2     1     4
3     2     1
4     2     2

gp = df.groupby('col1').aggregate(np.count_nonzero)

In [38]: gp
Out[38]: 
      col2
col1      
1        3
2        2

permet de se rendre où le comte > 2

tf = gp[gp.col2 > 2].reset_index()
df[df.col1 == tf.col1]

Out[41]: 
   col1  col2
0     1     2
1     1     3
2     1     4

Maintenant, j'ai eu l'idée. Une autre manière de faire pourrait être de participer à ces trames de données, il va supprimer la non-correspondance des entrées et je peux laisser compter de la colonne par la suite.
jep qui serait à l'œuvre 2. j'ai l'habitude de simplement utiliser un masque, puis sélectionnez les cols, j'ai besoin d'

InformationsquelleAutor locojay

2

Ici sont quelques-uns des temps d'exécution pour un couple de solutions de posté ici, avec celui qui ne l'est pas (à l'aide de value_counts()) qui est beaucoup plus rapide que les autres solutions:

Créer les données:
```
import pandas as pd
import numpy as np

# Generate some 'users'
np.random.seed(42)
df = pd.DataFrame({'uid': np.random.randint(0, 500, 500)})

# Prove that some entries are 1
print "{:,} users only occur once in dataset".format(sum(df.uid.value_counts() == 1))
```
De sortie:

171 users only occur once in dataset

Temps quelques différentes façons de supprimer des utilisateurs avec une seule entrée. Ces ont été exécutés dans des cellules séparées dans un Jupyter Portable:
```
%%timeit
df.groupby(by='uid').filter(lambda x: len(x) > 1)

%%timeit
df[df.groupby('uid').uid.transform(len) > 1]

%%timeit
vc = df.uid.value_counts()
df[df.uid.isin(vc.index[vc.values > 1])].uid.value_counts()
```
Ces a donné les résultats suivants:
```
10 loops, best of 3: 46.2 ms per loop
10 loops, best of 3: 30.1 ms per loop
1000 loops, best of 3: 1.27 ms per loop
```
- Cela devrait certainement être la accepté de répondre. L'une à l'aide de value_counts() est bien plus rapide que les deux autres, en particulier pour les ensembles de données qui ont un grand nombre de groupes
InformationsquelleAutor zbinsd

Vous devez vous connecter pour publier un commentaire.

Créer les données:

De sortie:

Temps quelques différentes façons de supprimer des utilisateurs avec une seule entrée. Ces ont été exécutés dans des cellules séparées dans un Jupyter Portable:

Ces a donné les résultats suivants: