La sélection avec des critères complexes de pandas.DataFrame

Par exemple, j'ai simple DF:

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)]})

Puis-je sélectionner des valeurs de A pour lesquelles les valeurs correspondantes pour les " B " sera supérieur à 50, et pour 'C' - pas égale à 900, en utilisant les méthodes et les idiomes de Pandas?

InformationsquelleAutor Gill Bates | 2013-03-09
  1. 348

    Sûr! Programme d'installation:

    >>> 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

    Nous pouvons appliquer des opérations de colonne et obtenir boolean Série d'objets:

    >>> 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)
0    False
1    False
2     True
3     True
4    False
5    False
6    False
7    False
8    False
9    False

    [Mise à jour pour passer à la nouvelle-style .loc]:

    Et puis on peut les utiliser pour d'index de l'objet. Pour l'accès en lecture, vous pouvez indices en chaîne:

    >>> df["A"][(df["B"] > 50) & (df["C"] == 900)]
2    5
3    8
Name: A, dtype: int64

    mais vous pouvez avoir des ennuis à cause de la différence entre une vue et une copie de le faire pour l'accès en écriture. Vous pouvez utiliser .loc à la place:

    >>> 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

    Remarque que j'ai accidentellement tapé == 900 et pas != 900, ou ~(df["C"] == 900), mais je suis trop paresseux pour le fixer. Exercice pour le lecteur. :^)

    • Sur .loc mise à jour - il serait bon si vous préciser où nous en obtenir une copie et d'où la vue.
    • est-il possible de filtrer les pandas dataframe et utiliser l'opérateur OU. Par exemple, si il y avait une colonne de mois, pourriez-vous dire df = data['mois'==JAN OU 'mois' == FÉVR]? Et peut-être inclure une seconde colonnes de faire la requête plus complexe, newdf où col_month = jan OU la feb ET col_day = LUNDI ou WENDNESDAY
    • veuillez demander que d'une question distincte. Personne ne va le voir ici, dans les commentaires sur une vieille réponse.
    • N'oubliez pas les parenthèses - vous obtiendrez des erreurs étranges comme {TypeError}cannot compare a dtyped [int64] array with a scalar of type [bool]
    • N'est-ce pas l'utilisation de parenthèses conduire à des calculs sur l'ensemble de la série? Que faire si nous voulons sous-ensemble à plusieurs reprises pour plus d'efficacité?
    • que faire si je veux sélectionner à partir de la même colonne, mais des conditions différentes par exemple df.loc[(df["B"] > 'abc') & (df["B"] == 'def'), "A"] que ça va marcher, je suis vide df.

    InformationsquelleAutor DSM
  2. 52

    Une autre solution est d'utiliser le requête méthode:

    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

    Maintenant, si vous souhaitez modifier les valeurs renvoyées dans la colonne A, vous pouvez enregistrer leurs index:

    my_query_index = df.query('B > 50 & C != 900').index

    ....et l'utilisation .iloc de les changer je.e:

    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
    InformationsquelleAutor Nikos Tavoularis
  3. 5

    Et n'oubliez pas d'utiliser les parenthèses!

    Gardez à l'esprit que & opérateur prend la priorité sur les opérateurs tels que les > ou < etc. C'est pourquoi 

    4 < 5 & 6 > 4

    évalue à False. Par conséquent, si vous utilisez pd.loc, vous avez besoin de mettre des parenthèses autour de vos déclarations logiques, sinon vous aurez une erreur. C'est pourquoi:

    df.loc[(df['A'] > 10) & (df['B'] < 15)]

    au lieu de 

    df.loc[df['A'] > 10 & df['B'] < 15]

    qui aurait pour résultat

    TypeError: ne peut pas comparer un dtyped [float64] matrice par un scalaire de type [bool]

    InformationsquelleAutor Tomasz Bartkowiak
  4. 1

    Vous pouvez utiliser les pandas, il a quelques fonctions intégrées pour la comparaison. Donc, si vous voulez sélectionner des valeurs de "A" qui sont remplies par les conditions de "B" et "C" (en supposant que vous souhaitez récupérer un DataFrame pandas objet)

    df[['A']][df.B.gt(50) & df.C.ne(900)]

    df[['A']] va vous redonner la colonne A dans DataFrame format.

    pandas 'gt' fonction retourne la position de la colonne B sont supérieurs à 50 et 'ne' sera de retour le postes pas égal à 900.

    InformationsquelleAutor Christopher Matthews