Comment accéder aux pandas groupby dataframe par clé

Comment puis-je accéder à la correspondante groupby dataframe dans un groupby objet par la clé? À la suite de groupby:

rand = np.random.RandomState(1)
df = pd.DataFrame({'A': ['foo', 'bar'] * 3,
                   'B': rand.randn(6),
                   'C': rand.randint(0, 20, 6)})
gb = df.groupby(['A'])

Je peux parcourir pour obtenir les clés et les groupes:

In [11]: for k, gp in gb:
             print 'key=' + str(k)
             print gp
key=bar
     A         B   C
1  bar -0.611756  18
3  bar -1.072969  10
5  bar -2.301539  18
key=foo
     A         B   C
0  foo  1.624345   5
2  foo -0.528172  11
4  foo  0.865408  14

Je voudrais être en mesure de faire quelque chose comme

In [12]: gb['foo']
Out[12]:  
     A         B   C
0  foo  1.624345   5
2  foo -0.528172  11
4  foo  0.865408  14

Mais quand je fais ça (bon, en fait j'ai à faire gb[('foo',)]), j'ai cette bizarre pandas.core.groupby.DataFrameGroupBy chose qui ne semble pas avoir des méthodes qui correspondent à la DataFrame je veux.

Le mieux je pense est de

In [13]: def gb_df_key(gb, key, orig_df):
             ix = gb.indices[key]
             return orig_df.ix[ix]

         gb_df_key(gb, 'foo', df)
Out[13]:
     A         B   C
0  foo  1.624345   5
2  foo -0.528172  11
4  foo  0.865408  14

mais c'est le genre de méchant, compte tenu de la façon agréable les pandas est généralement à ces choses.

Ce qui est intégré dans la façon de le faire?

InformationsquelleAutor beardc | 2013-02-06
  1. 151

    Vous pouvez utiliser le get_group méthode:

    In [21]: gb.get_group('foo')
Out[21]: 
     A         B   C
0  foo  1.624345   5
2  foo -0.528172  11
4  foo  0.865408  14

    Remarque: Cela ne nécessite pas la création d'un intermédiaire dictionnaire /copie de chaque subdataframe pour chaque groupe, ce qui sera beaucoup plus efficace de la mémoire que de la création de la naïve dictionnaire avec dict(iter(gb)). C'est parce qu'il utilise des données-structures qui existent déjà dans le groupby objet.

    Vous pouvez sélectionner différents types de colonnes à l'aide de la groupby découpage:

    In [22]: gb[["A", "B"]].get_group("foo")
Out[22]:
     A         B
0  foo  1.624345
2  foo -0.528172
4  foo  0.865408

In [23]: gb["C"].get_group("foo")
Out[23]:
0     5
2    11
4    14
Name: C, dtype: int64
    InformationsquelleAutor Andy Hayden
  2. 60

    Wes McKinney (pandas auteur) en Python pour l'Analyse des Données fournit la recette suivante:

    groups = dict(list(gb))

    qui retourne un dictionnaire dont les clés sont vos étiquettes de groupe et dont les valeurs sont DataFrames, c'est à dire

    groups['foo']

    donnera ce que vous cherchez:

         A         B   C
0  foo  1.624345   5
2  foo -0.528172  11
4  foo  0.865408  14
    • Merci, c'est très utile. Comment puis-je modifier le code pour faire groups = dict(list(gb)) seule colonne store C? Disons que je ne suis pas intéressé dans les autres colonnes, et donc ne veulent pas les stocker.
    • Réponse: dict(list( df.groupby(['A'])['C'] ))
    • Remarque: il est plus efficace (mais équivalent) à utiliser dict(iter(g)). (bien que get_group est le meilleur moyen de / comme il n'implique pas de créer un dictionnaire / vous maintient dans les pandas! 😀 )
    • Je n'étais pas en mesure d'utiliser les groupes(dict(liste(gb)), mais vous pouvez créer un dictionnaire de la manière suivante: gb_dict = {str(indx): str(val) for indx in gb.indx for val in gb.some_key} et ensuite récupérer la valeur par gb_dict[some_key]
    InformationsquelleAutor JD Margulici
  3. 17

    Plutôt que

    gb.get_group('foo')

    Je préfère utiliser gb.groups

    df.loc[gb.groups['foo']]

    Parce que de cette façon, vous pouvez choisir plusieurs colonnes ainsi. par exemple:

    df.loc[gb.groups['foo'],('A','B')]
    • Remarque: Vous pouvez sélectionner différents types de colonnes à l'aide de gb[["A", "B"]].get_group("foo").
    InformationsquelleAutor LegitMe
  4. 5
    gb = df.groupby(['A'])

gb_groups = grouped_df.groups

    Si vous êtes à la recherche sélective grouper les objets, puis, n': gb_groups.les touches () et d'entrées de clé souhaitée en key_list..

    gb_groups.keys()

key_list = [key1, key2, key3 and so on...]

for key, values in gb_groups.iteritems():
    if key in key_list:
        print df.ix[values], "\n"
    InformationsquelleAutor Surya
  5. 2

    Je cherchais un moyen de prélever un échantillon de quelques membres de la GroupBy obj - a dû répondre à la question posée à obtenir ce fait.

    créer groupby objet

    grouped = df.groupby('some_key')

    pick N dataframes et de saisir leurs indicies

    sampled_df_i  = random.sample(grouped.indicies, N)

    saisir les groupes

    df_list  = map(lambda df_i: grouped.get_group(df_i), sampled_df_i)

    éventuellement tourner dans un seul dataframe objet

    sampled_df = pd.concat(df_list, axis=0, join='outer')
    InformationsquelleAutor meyerson