pandas: le meilleur moyen de sélectionner toutes les colonnes dont les noms commencent par X

J'ai un DataFrame:

import pandas as pd
import numpy as np

df = pd.DataFrame({'foo.aa': [1, 2.1, np.nan, 4.7, 5.6, 6.8],
                   'foo.fighters': [0, 1, np.nan, 0, 0, 0],
                   'foo.bars': [0, 0, 0, 0, 0, 1],
                   'bar.baz': [5, 5, 6, 5, 5.6, 6.8],
                   'foo.fox': [2, 4, 1, 0, 0, 5],
                   'nas.foo': ['NA', 0, 1, 0, 0, 0],
                   'foo.manchu': ['NA', 0, 0, 0, 0, 0],})

Je veux sélectionner une valeur de 1 dans les colonnes de départ avec foo.. Est-il une meilleure façon de le faire d'autre que:

df2 = df[(df['foo.aa'] == 1)|
(df['foo.fighters'] == 1)|
(df['foo.bars'] == 1)|
(df['foo.fox'] == 1)|
(df['foo.manchu'] == 1)
]

Quelque chose de semblable à écrire quelque chose comme:

df2= df[df.STARTS_WITH_FOO == 1]

La réponse devrait imprimer un DataFrame comme ceci:

   bar.baz  foo.aa  foo.bars  foo.fighters  foo.fox foo.manchu nas.foo
0      5.0     1.0         0             0        2         NA      NA
1      5.0     2.1         0             1        4          0       0
2      6.0     NaN         0           NaN        1          0       1
5      6.8     6.8         1             0        5          0       0

[4 rows x 7 columns]

InformationsquelleAutor ccsv | 2014-12-03

Il suffit de faire une liste de compréhension pour créer vos colonnes:

In [28]:

filter_col = [col for col in df if col.startswith('foo')]
filter_col
Out[28]:
['foo.aa', 'foo.bars', 'foo.fighters', 'foo.fox', 'foo.manchu']
In [29]:

df[filter_col]
Out[29]:
   foo.aa  foo.bars  foo.fighters  foo.fox foo.manchu
0     1.0         0             0        2         NA
1     2.1         0             1        4          0
2     NaN         0           NaN        1          0
3     4.7         0             0        0          0
4     5.6         0             0        0          0
5     6.8         1             0        5          0

Une autre méthode consiste à créer une série de colonnes et d'utiliser le vectorisées str méthode startswith:

In [33]:

df[df.columns[pd.Series(df.columns).str.startswith('foo')]]
Out[33]:
   foo.aa  foo.bars  foo.fighters  foo.fox foo.manchu
0     1.0         0             0        2         NA
1     2.1         0             1        4          0
2     NaN         0           NaN        1          0
3     4.7         0             0        0          0
4     5.6         0             0        0          0
5     6.8         1             0        5          0

Afin d'obtenir ce que vous voulez, vous devez ajouter les éléments suivants pour filtrer les valeurs qui ne répondent pas à vos ==1 critères:

In [36]:

df[df[df.columns[pd.Series(df.columns).str.startswith('foo')]]==1]
Out[36]:
   bar.baz  foo.aa  foo.bars  foo.fighters  foo.fox foo.manchu nas.foo
0      NaN       1       NaN           NaN      NaN        NaN     NaN
1      NaN     NaN       NaN             1      NaN        NaN     NaN
2      NaN     NaN       NaN           NaN        1        NaN     NaN
3      NaN     NaN       NaN           NaN      NaN        NaN     NaN
4      NaN     NaN       NaN           NaN      NaN        NaN     NaN
5      NaN     NaN         1           NaN      NaN        NaN     NaN

MODIFIER

OK après avoir vu ce que vous voulez l'enchevêtrement réponse est celle-ci:

In [72]:

df.loc[df[df[df.columns[pd.Series(df.columns).str.startswith('foo')]] == 1].dropna(how='all', axis=0).index]
Out[72]:
   bar.baz  foo.aa  foo.bars  foo.fighters  foo.fox foo.manchu nas.foo
0      5.0     1.0         0             0        2         NA      NA
1      5.0     2.1         0             1        4          0       0
2      6.0     NaN         0           NaN        1          0       1
5      6.8     6.8         1             0        5          0       0

Veuillez envisager de déplacer votre option2 vers le haut de votre réponse
downvoter soin d'expliquer?
bien que startswith serait de la pure pandas méthode, à l'aide d'une compréhension de liste est en fait la méthode la plus rapide, donc j'ai posté les deux méthodes

InformationsquelleAutor EdChum

38

Maintenant que les pandas' index de soutien des opérations de la chaîne, sans doute le plus simple et le meilleur moyen de sélectionner les colonnes commençant par " foo " est juste:
```
df.loc[:, df.columns.str.startswith('foo')]
```
Alternativement, vous pouvez filtrer la colonne (ou une ligne) des étiquettes avec df.filtre(). Pour spécifier une expression régulière pour faire correspondre les noms commençant par foo.:
```
>>> df.filter(regex=r'^foo\.', axis=1)
   foo.aa  foo.bars  foo.fighters  foo.fox foo.manchu
0     1.0         0             0        2         NA
1     2.1         0             1        4          0
2     NaN         0           NaN        1          0
3     4.7         0             0        0          0
4     5.6         0             0        0          0
5     6.8         1             0        5          0
```
Pour ne sélectionner que les lignes requises (contenant un 1) et les colonnes, vous pouvez utiliser loc, sélectionnez les colonnes à l'aide de filter (ou toute autre méthode) et les lignes à l'aide de any:
```
>>> df.loc[(df == 1).any(axis=1), df.filter(regex=r'^foo\.', axis=1).columns]
   foo.aa  foo.bars  foo.fighters  foo.fox foo.manchu
0     1.0         0             0        2         NA
1     2.1         0             1        4          0
2     NaN         0           NaN        1          0
5     6.8         1             0        5          0
```
- ce sujet de la sélection de la partie? où df[colonnes]==1 est appliqué serait je viens de faire une boucle for ou est-il un moyen plus rapide?
- Je pense que tu pourrais juste écrire df.filter(regex=r'^foo\.', axis=1) == 1 (laissez-moi savoir si j'ai mal compris ce que vous voulez).
- il est proche, vous juste besoin de convertir les booléens et de supprimer certaines lignes. Si vous exécutez le code, je l'ai, a toutes les colonnes en place, mais seulement a des lignes 0,1,2,5 parce qu'ils avaient de la valeur 1 sur la colonne avec le titre foo
- Ah - j'ai ajouté à ma réponse. Laissez-moi savoir si quelque chose est manquant.
- ouais vous avez un supplément de sélectionner et exclu les colonnes sans les "foo" dans le nom
InformationsquelleAutor Alex Riley

Ma solution. Il peut être plus lent sur les performances:

a = pd.concat(df[df[c] == 1] for c in df.columns if c.startswith('foo'))
a.sort_index()


   bar.baz  foo.aa  foo.bars  foo.fighters  foo.fox foo.manchu nas.foo
0      5.0     1.0         0             0        2         NA      NA
1      5.0     2.1         0             1        4          0       0
2      6.0     NaN         0           NaN        1          0       1
5      6.8     6.8         1             0        5          0       0

InformationsquelleAutor Robbie Liu

Une autre option pour la sélection des entrées souhaitées est d'utiliser map:

df.loc[(df == 1).any(axis=1), df.columns.map(lambda x: x.startswith('foo'))]

qui vous donne toutes les colonnes pour les lignes qui contiennent un 1:

   foo.aa  foo.bars  foo.fighters  foo.fox foo.manchu
0     1.0         0             0        2         NA
1     2.1         0             1        4          0
2     NaN         0           NaN        1          0
5     6.8         1             0        5          0

La sélection d'une ligne est fait par

(df == 1).any(axis=1)

comme dans @ajcr la réponse qui vous donne:

0     True
1     True
2     True
3    False
4    False
5     True
dtype: bool

ce qui signifie que la ligne 3 et 4 ne contient pas de 1 et ne sera pas sélectionné.

La sélection des colonnes est effectué à l'aide Boolean indexation comme ceci:

df.columns.map(lambda x: x.startswith('foo'))

Dans l'exemple ci-dessus cela renvoie

array([False,  True,  True,  True,  True,  True, False], dtype=bool)

Donc, si une colonne n'a pas commencer avec foo, False est retourné et la colonne n'est donc pas sélectionné.

Si vous voulez juste pour renvoyer toutes les lignes qui contiennent un 1 - que votre sortie désirée le suggère, vous pouvez simplement faire

df.loc[(df == 1).any(axis=1)]

qui renvoie

   bar.baz  foo.aa  foo.bars  foo.fighters  foo.fox foo.manchu nas.foo
0      5.0     1.0         0             0        2         NA      NA
1      5.0     2.1         0             1        4          0       0
2      6.0     NaN         0           NaN        1          0       1
5      6.8     6.8         1             0        5          0       0

InformationsquelleAutor Cleb

Vous devez vous connecter pour publier un commentaire.