[PYTHON] Comment diviser et traiter une trame de données à l'aide de la fonction groupby

À propos de cet article

Dans l'analyse des données à l'aide des pandas de Python, la fonction groupby est une fonction pratique qui calcule pour chaque groupe. J'utilise souvent df.groupby (df ['col1']) ['col2'] **. Mean () ** et **. Describe () ** C'est une fonction orthodoxe telle que Parfois, je souhaite traiter chaque trame de données divisée, J'ai trouvé que la combinaison de l'instruction ** for ** et ** get_group ** peut être traitée facilement, je vais donc la présenter.

Préparation des données

groupby_get_group.py

import pandas as pd
from sklearn.datasets import load_iris
import matplotlib.pyplot as plt
import numpy as np

iris_dataset = load_iris()
df_iris=pd.DataFrame(iris_dataset.data,columns=iris_dataset.feature_names)
#Ajouter une colonne cible
df_iris.loc[:,'target']=iris_dataset.target
#Créer un dictionnaire de noms de produits
iris_map=dict(zip([0,1,2],iris_dataset.target_names))
#Connectez DataFrame et le dictionnaire à la cible de la fonction de carte_Ajouter une colonne pour les noms
df_iris.loc[:,'target_names']=df_iris['target'].map(iris_map)

Essayez d'appliquer la fonction groupby à target_names

Divisez la base de données (** df_iris ) par race ( 'target_names' **). Celui divisé est ** gp **.

groupby_get_group.py

gp = df_iris.groupby('target_names')

Examiner les attributs de l'objet fractionné

In[0]:type(gp)
Out[0]:pandas.core.groupby.generic.DataFrameGroupBy

In[1]:print(gp)
Out[1]:<pandas.core.groupby.generic.DataFrameGroupBy object at 0x0000028788A33708>

Les ensembles de données fractionnés à l'aide de groupby ne peuvent pas être utilisés tels quels. Par conséquent, examinons les attributs, etc. en utilisant l'instruction for.

Utiliser pour la déclaration

In[2]:for d_gp in gp:
          print(d_gp)
Out[2]:
 147                6.5               3.0  ...       2     virginica
 148                6.2               3.4  ...       2     virginica
 149                5.9               3.0  ...       2     virginica
 
 [50 rows x 6 columns])

In[3]:type(d_gp)
out[3]:tuple

Il semble que la trame de données divisée soit stockée sous forme de variable de type tapple (** d_gp **). Ici, afin de vérifier le contenu de la taple, si vous tapez ce qui suit,

In[4]:d_gp[0]
Out[4]:'virginica'
 
In[5]:d_gp[1]
Out[5]:
     sepal length (cm)  sepal width (cm)  ...  target  target_names
100                6.3               3.3  ...       2     virginica
101                5.8               2.7  ...       2     virginica
102                7.1               3.0  ...       2     virginica
103                6.3               2.9  ...       2     virginica

147                6.5               3.0  ...       2     virginica
148                6.2               3.4  ...       2     virginica
149                5.9               3.0  ...       2     virginica

[50 rows x 6 columns]

L'état après l'exécution de l'instruction for est que la trame de données du troisième niveau ** 'virginica' ** de ** "target_names" ** est affectée à ** d_gp **. Tu peux vérifier.

Par conséquent, il est acceptable d'itérer uniquement ** d_gp [1] **, mais ici nous tirons parti de ** d_gp [0] ** et récupérons un ensemble de données spécifique avec la fonction ** get_group **. Je vais le traiter.

Obtenez les données stockées dans le taple par get_group.

L'instruction ** for ** peut récupérer des tapples, Le premier taple contient le niveau de la ligne (variétés: setosa, versicolor, virginica) multiplié par ** groupe par **. Le second contient chaque trame de données.

En utilisant le niveau stocké dans le premier de ce taple comme variable, ** get_group ** extrait la trame de données stockée dans le second du tapple et la traite pour chaque niveau.

Ce qui suit est une base de données divisée pour chaque variété setosa, versicolor, virginica. Spécifiez le type et extrayez le bloc de données Un graphique de "longueur sépale" et "largeur sépale".

groupby_get_group.py

for d_gp in gp:
    df_g=gp.get_group(d_gp[0])
    ##Écrivez ce que vous voulez traiter en utilisant le bloc de données divisé ci-dessous ici
    fig = plt.figure()
    ax = fig.add_subplot(1,1,1)
    X=df_g[df_g.columns[0]].values
    y=df_g[df_g.columns[1]].values
    ax.set_title(str.capitalize(d_gp[0])+"  "+\
                 str.capitalize(df_g.columns[0])+\
                 ' vs '+str.capitalize(df_g.columns[1]))
    ax.scatter(X,y,marker='o',color='darkblue',edgecolor="")
    cor=np.corrcoef(X, y)[0,1]
    ax.set_xlabel(str.capitalize(df_g.columns[0]))
    ax.set_ylabel(str.capitalize(df_g.columns[1]))
    ax.text(0.99, 0.01,"correlation:{0:.2}".format(cor),
                    horizontalalignment='right', verticalalignment='bottom',
                    fontsize=12,color="blue",transform=ax.transAxes)
    plt.show()

c'est tout.

en conclusion

Je posterai sur Qiita pour la première fois. Qiita voulait m'aider, alors j'espère que cela aide quelqu'un.

Les références

Codage de base pour l'analyse de données Python / apprentissage automatique! Introduction à l'utilisation de la bibliothèque pandas (impression top gear) (japonais) Livre (couverture souple) ISBN-10: 4295005657 ISBN-13: 978-4295005650