Python Pandas: Obtenir l'indice de lignes de la colonne qui correspond à la valeur

Donné un DataFrame avec une colonne "BoolCol", nous voulons trouver les indices du DataFrame dans lequel les valeurs de "BoolCol" == True

J'ai actuellement l'itération façon de le faire, ce qui fonctionne parfaitement:

for i in range(100,3000):
    if df.iloc[i]['BoolCol']== True:
         print i,df.iloc[i]['BoolCol']

Mais ce n'est pas le bon panda est la façon de le faire.
Après quelques recherches, je suis actuellement en utilisant ce code:

df[df['BoolCol'] == True].index.tolist()

Ce on me donne une liste d'index, mais ils ne correspondent pas, quand je vérifie en faisant:

df.iloc[i]['BoolCol']

Le résultat est en fait Faux!!

Qui serait la bonne Pandas façon de le faire?

InformationsquelleAutor I want badges | 2014-02-15

312

df.iloc[i] renvoie la ith ligne de df. i ne fait pas référence à l'indice de l'étiquette, i est un index basé sur 0.

En revanche, l'attribut index rendements réels étiquettes d'index, pas numérique de ligne-indices:
```
df.index[df['BoolCol'] == True].tolist()
```
ou, de manière équivalente,
```
df.index[df['BoolCol']].tolist()
```
Vous pouvez voir la différence, très clairement, en jouant avec un DataFrame avec
un non-index par défaut qui n'est pas égal à la ligne de la position numérique:
```
df = pd.DataFrame({'BoolCol': [True, False, False, True, True]},
       index=[10,20,30,40,50])

In [53]: df
Out[53]: 
   BoolCol
10    True
20   False
30   False
40    True
50    True

[5 rows x 1 columns]

In [54]: df.index[df['BoolCol']].tolist()
Out[54]: [10, 40, 50]
```
Si vous souhaitez utiliser l'index,
```
In [56]: idx = df.index[df['BoolCol']]

In [57]: idx
Out[57]: Int64Index([10, 40, 50], dtype='int64')
```
ensuite, vous pouvez sélectionner les lignes à l'aide de loc au lieu de iloc:
```
In [58]: df.loc[idx]
Out[58]: 
   BoolCol
10    True
40    True
50    True

[3 rows x 1 columns]
```
Noter que loc peut également accepter boolean tableaux:
```
In [55]: df.loc[df['BoolCol']]
Out[55]: 
   BoolCol
10    True
40    True
50    True

[3 rows x 1 columns]
```
Si vous avez un booléen tableau, mask, et ont besoin de valeurs d'index ordinales, vous pouvez calculer à l'aide de np.flatnonzero:
```
In [110]: np.flatnonzero(df['BoolCol'])
Out[112]: array([0, 3, 4])
```
Utilisation df.iloc pour sélectionner les lignes par index ordinale:
```
In [113]: df.iloc[np.flatnonzero(df['BoolCol'])]
Out[113]: 
   BoolCol
10    True
40    True
50    True
```
- Une autre façon est de faire df.query('BoolCol').
- Je sais que c'est vieux, mais je me demandais si il existe un moyen facile pour obtenir le 0 basée sur des numéros d'index à partir d'une requête. J'ai besoin de la lci de numéro parce que je veux sélectionner certaines lignes avant et après une ligne répondant à une certaine condition. Donc, mon plan était d'obtenir le 0-indices de lignes réunion de l'état et de créer des tranches pour une utilisation dans lci(). La seule chose que je vois est get_loc, mais il ne peut pas prendre un tableau.
- Si vous avez un booléen masque, vous pouvez trouver l'ordinal indices où la mask est True en utilisant np.flatnonzero. J'ai édité le post ci-dessus pour montrer ce que je veux dire.
- Votre suggestion indices = np.flatnonzero(df[col_name] == category_name) me fait exactement ce que le titre de la question demande, qui est étonnamment difficile à trouver sur Internet.
- Si vous ne voulez revenir à l'index, ce qui est de la surcharge de df[dftest].index? Cela ne crée un intermédiaire du bloc de données (dont les données peuvent être gibabytes). Qu'en est dftest? N'est-ce pas aussi allouer un très grand objet intermédiaire, où le retour de l'index peut être très faible, voire vide. Ces magiquement optimisé à l'aide de paresseux points de vue. Si non, alors il doit sûrement y avoir un moyen efficace.
- Merci pour la correction. Je l'aurais écrit df.index[dftest]. Je vais éditer le post en conséquence.
- Peut-être que vous pouvez ajouter df.index[df.BoolCol.nonzero()[0]].tolist()
InformationsquelleAutor unutbu

Peut être fait à l'aide de numpy où() fonction:

import pandas as pd
import numpy as np

In [716]: df = pd.DataFrame({"gene_name": ['SLC45A1', 'NECAP2', 'CLIC4', 'ADC', 'AGBL4'] , "BoolCol": [False, True, False, True, True] },
       index=list("abcde"))

In [717]: df
Out[717]: 
  BoolCol gene_name
a   False   SLC45A1
b    True    NECAP2
c   False     CLIC4
d    True       ADC
e    True     AGBL4

In [718]: np.where(df["BoolCol"] == True)
Out[718]: (array([1, 3, 4]),)

In [719]: select_indices = list(np.where(df["BoolCol"] == True)[0])

In [720]: df.iloc[select_indices]
Out[720]: 
  BoolCol gene_name
b    True    NECAP2
d    True       ADC
e    True     AGBL4

Si vous n'avez pas toujours besoin d'un indice pour le match, mais au cas où si vous avez besoin de:

In [796]: df.iloc[select_indices].index
Out[796]: Index([u'b', u'd', u'e'], dtype='object')

In [797]: df.iloc[select_indices].index.tolist()
Out[797]: ['b', 'd', 'e']

InformationsquelleAutor Surya

1

D'abord, vous pouvez vérifier query lorsque la cible colonne est de type bool (PS: à propos de la façon de l'utiliser, veuillez vérifier lien )
```
df.query('BoolCol')
Out[123]: 
    BoolCol
10     True
40     True
50     True
```
Après on filtre l'original df par la colonne Booléenne nous pouvons choisir l'index .
```
df=df.query('BoolCol')
df.index
Out[125]: Int64Index([10, 40, 50], dtype='int64')
```
Aussi les pandas ont nonzero, nous avons il suffit de sélectionner le position de True de ligne et l'aide qu'il tranche la DataFrame ou index
```
df.index[df.BoolCol.nonzero()[0]]
Out[128]: Int64Index([10, 40, 50], dtype='int64')
```
InformationsquelleAutor WeNYoBen
0

Moyen Simple est de réinitialiser l'index du DataFrame avant la filtration:
```
df_reset = df.reset_index()
df_reset[df_reset['BoolCol']].index.tolist()
```
Très orthodoxe, mais c'est rapide!

InformationsquelleAutor Ben Druitt

Vous devez vous connecter pour publier un commentaire.