J'ai essayé de résumer comment utiliser les pandas de python
introduction
Cette fois, je vais résumer comment utiliser les pandas.
Beaucoup de gens ont résumé comment utiliser les pandas, donc ce n'est peut-être pas nouveau, mais j'apprécierais que vous puissiez vous entendre avec moi.
L'article précédent résumait comment utiliser numpy, veuillez donc le vérifier si vous le souhaitez.
J'ai résumé le numpy de python
Génération en série
Vous pouvez générer une série en procédant comme suit. Series est un tableau auquel un index est attaché.
import numpy as np
import pandas as pd
series = pd.Series(data=[1, 2, 3, 4, 5], index=['A', 'B', 'C', 'D', 'E'])
print(series)
A 1 B 2 C 3 D 4 E 5 dtype: int64
Il peut également être généré en combinaison avec numpy.
series = pd.Series(data=np.arange(5), index=['A', 'B', 'C', 'D', 'E'])
print(series)
A 0 B 1 C 2 D 3 E 4 dtype: int64
Extraire les données de la série
Les séries peuvent être indexées pour récupérer des données. C'est proche d'un type de dictionnaire.
series = pd.Series(data=np.arange(5), index=['A', 'B', 'C', 'D', 'E'])
print(series['A'])
0
Vous pouvez également utiliser des tranches.
series = pd.Series(data=np.arange(5), index=['A', 'B', 'C', 'D', 'E'])
print(series['A':'D'])
A 0 B 1 C 2 D 3 dtype: int64
Dans le sens d'une tranche normale, les données jusqu'à C, qui est un avant D, doivent être extraites, mais dans le cas de Series, elles sont extraites dans la plage spécifiée par l'index.
Avec loc
Cependant, lors de la récupération de données en spécifiant un index de cette manière, la méthode loc est habituellement utilisée.
series = pd.Series(data=np.arange(5), index=['A', 'B', 'C', 'D', 'E'])
print(series.loc['A':'D'])
A 0 B 1 C 2 D 3 dtype: int64
Vous pouvez spécifier deux index sans utiliser de tranches.
series = pd.Series(data=np.arange(5), index=['A', 'B', 'C', 'D', 'E'])
print(series.loc[['A', 'D']])
A 0 D 3 dtype: int64
Avec iloc
Au lieu d'utiliser l'indice de série, vous pouvez également spécifier l'index du numéro attribué depuis le début et le récupérer.
series = pd.Series(data=np.arange(5), index=['A', 'B', 'C', 'D', 'E'])
print(series.iloc[[0]])
A 0 dtype: int64
Génération DataFrame
Vous pouvez générer un DataFrame en procédant comme suit.
df = pd.DataFrame(data=[[1, 2, 3], [4, 5, 6], [7, 8, 9]], index=['A', 'B', 'C'], columns=['A1', 'A2', 'A3'])
print(df)
A1 A2 A3 A 1 2 3 B 4 5 6 C 7 8 9
De cette manière, le DataFrame est une donnée bidimensionnelle avec «index» et «colonnes» spécifiés.
Lorsqu'il est utilisé dans l'apprentissage automatique, l'index représente le type de données et les colonnes représentent la fonctionnalité des données.
Lire le fichier
C'est une tâche très courante, car les pandas lisent et utilisent essentiellement des fichiers.
Ici, chargez le fichier csv que vous avez créé correctement. Les données suivantes.
Lisons-le.
df = pd.read_csv('train.csv')
print(df)
Voici le résultat de l'exécution.
C'était difficile de voir même si je le copiais, alors je l'ai pressé.
Je voulais indexer «takash» et «kenta», mais ils ne sont pas indexés par défaut.
De cette façon, lors de la lecture de données avec un index, il doit être spécifié par ʻindex_col. Dans cet exemple, les données les plus à gauche sont traitées comme un index, donc définissez ʻindex_col = 0.
df = pd.read_csv('train.csv', index_col=0)
print(df)
De plus, par défaut, la toute première ligne est traitée comme un en-tête. Si vous ne souhaitez pas spécifier la toute première ligne comme en-tête, spécifiez header = None.
df = pd.read_csv('train.csv', header=None)
print(df)
Confirmation du contenu des données
Vérifiez la forme
Vérifions la forme des données. Comme numpy etc., la variable de forme stocke les données de dimension.
df = pd.read_csv('train.csv', index_col=0)
print(df.shape)
(3, 3)
Vérification des statistiques
Vous pouvez vérifier les statistiques des données en utilisant la méthode describe.
df = pd.read_csv('train.csv', index_col=0)
print(df.describe())
De cette façon, vous pouvez obtenir le nombre de données, la moyenne, l'écart type, le minimum, le maximum et le quadrant pour chaque colonne.
Vérifiez le nombre et le type de données
Vous pouvez le vérifier avec le code ci-dessous.
df = pd.read_csv('train.csv', index_col=0)
print(df.info())
<class 'pandas.core.frame.DataFrame'> Index: 3 entries, takash to yoko Data columns (total 3 columns): math 3 non-null int64 Engrish 3 non-null int64 society 3 non-null int64 dtypes: int64(3) memory usage: 96.0+ bytes None
Vous pouvez vérifier les données comme ceci. Aucun commentaire n'est nécessaire.
Vérification des données sans duplication
Si vous utilisez la méthode nunique, vous pouvez vérifier les données sans duplication pour chaque colonne que vous écrivez.
df = pd.read_csv('train.csv', index_col=0)
print(df.nunique())
＞math 3 Engrish 3 society 3 dtype: int64
Cette fois, il n'y a pas eu de duplication, donc le résultat était comme ci-dessus.
Confirmation du nom de la ligne et du nom de la colonne
La variable d'index stocke l'index et la variable de colonnes stocke les noms de colonne. Allons vérifier.
df = pd.read_csv('train.csv', index_col=0)
print(df.index)
print(df.columns)
Index(['takash', 'kenta', 'yoko'], dtype='object') Index(['math', 'Engrish', 'society'], dtype='object')
Vérifiez le total des valeurs manquantes
Vous pouvez voir l'emplacement des valeurs manquantes dans chaque colonne avec le code ci-dessous.
df = pd.read_csv('train.csv', index_col=0)
print(df.isnull())
math Engrish society takash False False False kenta False False False yoko False False False
Étant donné que chaque valeur n'est pas une valeur manquante, False est renvoyé.
Obtenons maintenant la somme des valeurs manquantes avec le code suivant.
df = pd.read_csv('train.csv', index_col=0)
print(df.isnull().sum())
math 0 Engrish 0 society 0 dtype: int64
Sélection et extraction de données DataFrame
Extrayons maintenant les données du DataFrame. Pour le moment, j'ai généré le DataFrame suivant.
df = pd.DataFrame(data=np.random.rand(5, 5),
index=['A', 'B', 'C', 'D', 'E'],
columns=('A1', 'A2', 'A3', 'A4', 'A5'))
np.random.seed(0)
print(df)
np.random.seed (0) vous permet de corriger les nombres aléatoires générés par np.random.rand. Cependant, comme j'exécute le code à chaque fois, les nombres aléatoires changent à chaque fois.
np.random.rand est le code qui génère des nombres aléatoires de 0 à 1.
Sélectionnons et extrayons les columuns avec le code ci-dessous.
df = pd.DataFrame(data=np.random.rand(5, 5),
index=['A', 'B', 'C', 'D', 'E'],
columns=('A1', 'A2', 'A3', 'A4', 'A5'))
np.random.seed(0)
print(df['A1'])
A 0.165899 B 0.144862 C 0.974517 D 0.144633 E 0.806085 Name: A1, dtype: float64
De cette façon, j'ai pu extraire les colonnes.
Vous pouvez utiliser la méthode loc pour spécifier un index pour l'extraction.
df = pd.DataFrame(data=np.random.rand(5, 5),
index=['A', 'B', 'C', 'D', 'E'],
columns=('A1', 'A2', 'A3', 'A4', 'A5'))
np.random.seed(0)
print(df.loc['A'])
A1 0.687867 A2 0.243104 A3 0.568371 A4 0.125892 A5 0.749777 Name: A, dtype: float64
J'ai écrit qu'il est extrait en spécifiant l'index, mais la méthode de spécification avec la méthode loc dans DataFrame est assez similaire à la spécification du tableau bidimensionnel de numpy.
Vous pouvez spécifier loc [ligne: colonne].
Voyons comment l'utiliser ci-dessous.
print(df.loc[:, 'A1'])
A 0.108650 B 0.819086 C 0.250341 D 0.950634 E 0.852035 Name: A1, dtype: float64
Puisque : est spécifié dans la partie ligne, cela signifie que toutes les lignes sont spécifiées et ʻA1` est spécifié dans la colonne, donc les colonnes de A1 sont extraites.
print(df.loc['C', ['A2', 'A4']])
A2 0.129296 A4 0.367573 Name: C, dtype: float64
De cette manière, vous pouvez extraire les données des lignes A2 et A4.
Sélectionnez par condition
Sélectionnons et extrayons les conditions du DataFrame. Vérifions le comportement de df> 0.5 avec le code suivant.
df = pd.DataFrame(data=np.random.rand(5, 5),
index=['A', 'B', 'C', 'D', 'E'],
columns=('A1', 'A2', 'A3', 'A4', 'A5'))
np.random.seed(0)
print(df)
print(df > 0.5)
De cette façon, True est stocké lorsque la valeur du DataFrame satisfait la condition et False est stocké lorsque la condition n'est pas satisfaite.
En utilisant cela, vous pouvez exclure les valeurs qui ne remplissent pas les conditions ci-dessous.
df = pd.DataFrame(data=np.random.rand(5, 5),
index=['A', 'B', 'C', 'D', 'E'],
columns=('A1', 'A2', 'A3', 'A4', 'A5'))
np.random.seed(0)
print(df > 0.5)
print(df[df > 0.5])
En outre, vous pouvez extraire uniquement les lignes qui satisfont les colonnes spécifiques en procédant comme suit.
df = pd.DataFrame(data=np.random.rand(5, 5),
index=['A', 'B', 'C', 'D', 'E'],
columns=('A1', 'A2', 'A3', 'A4', 'A5'))
np.random.seed(0)
print(df)
print(df[df['A3'] > 0.5])
Vous pouvez également ajouter des conditions à l'aide de &, comme indiqué ci-dessous.
df = pd.DataFrame(data=np.random.rand(5, 5),
index=['A', 'B', 'C', 'D', 'E'],
columns=('A1', 'A2', 'A3', 'A4', 'A5'))
np.random.seed(0)
print(df)
print(df[(df['A3'] > 0.2) & (df['A3'] < 0.6)])
Ajouter / supprimer des données dans DataFrame
Vous pouvez ajouter des colonnes en procédant comme suit.
df = pd.DataFrame(data=np.random.rand(5, 5),
index=['A', 'B', 'C', 'D', 'E'],
columns=('A1', 'A2', 'A3', 'A4', 'A5'))
np.random.seed(0)
df['new'] = np.arange(5)
print(df)
Vous pouvez supprimer une colonne en spécifiant le nom de la colonne.
df = pd.DataFrame(data=np.random.rand(5, 5),
index=['A', 'B', 'C', 'D', 'E'],
columns=('A1', 'A2', 'A3', 'A4', 'A5'))
np.random.seed(0)
df = df.drop(columns=['A1', 'A3'])
print(df)
Vous pouvez supprimer une ligne en spécifiant le nom de la ligne.
df = pd.DataFrame(data=np.random.rand(5, 5),
index=['A', 'B', 'C', 'D', 'E'],
columns=('A1', 'A2', 'A3', 'A4', 'A5'))
np.random.seed(0)
df = df.drop(index=['A', 'D'])
print(df)
Traitement des valeurs manquantes
Préparons les données comme suit.
df = pd.DataFrame([[1, 2, 3, np.nan, 5],
[np.nan, 7, 8, 9, 10],
[11, np.nan, 13, 14, 15],
[16, 17, np.nan, 19, 20],
[21, 22, 23, 24, np.nan]],
index=['A', 'B', 'C', 'D', 'E'],
columns=['A1', 'A2', 'A3', 'A4', 'A5'])
print(df)
Vous pouvez utiliser la méthode dropna pour supprimer la ligne qui contient la valeur manquante.
df = df.dropna()
print(df)
Columns: [A1, A2, A3, A4, A5] Index: []
Cette fois, toutes les lignes ont des valeurs manquantes, elles ont donc toutes disparu. De cette manière, si vous appliquez de fortes restrictions, il sera difficile pour les données de rester.
Supprimer les valeurs manquantes dans une colonne particulière
Vous pouvez supprimer les valeurs manquantes pour une colonne particulière en procédant comme suit:
df = pd.DataFrame([[1, 2, 3, np.nan, 5],
[np.nan, 7, 8, 9, 10],
[11, np.nan, 13, 14, 15],
[16, 17, np.nan, 19, 20],
[21, 22, 23, 24, np.nan]],
index=['A', 'B', 'C', 'D', 'E'],
columns=['A1', 'A2', 'A3', 'A4', 'A5'])
df = df[df['A3'].isnull() == False]
print(df)
Si vous utilisez ʻisnull`, True sera retourné si les données sont nan, et False si les données ne sont pas nan. Par conséquent, vous ne pouvez supprimer que les lignes contenant des valeurs manquantes dans A3, comme indiqué ci-dessus.
Supprimer en spécifiant un nombre qui n'est pas une valeur manquante
Argument de dropna En spécifiant l'argument de thresh, il est possible de supprimer des lignes autres que les lignes qui ont des valeurs qui ne manquent pas de valeurs supérieures au nombre spécifié dans l'argument.
Par exemple, «thresh = 4» supprime les lignes qui n'ont pas plus de 4 valeurs non manquantes.
df = pd.DataFrame([[1, 2, 3, np.nan, 5],
[np.nan, 7, 8, 9, 10],
[11, np.nan, 13, 14, 15],
[16, np.nan, np.nan, 19, 20],
[21, 22, 23, 24, np.nan]],
index=['A', 'B', 'C', 'D', 'E'],
columns=['A1', 'A2', 'A3', 'A4', 'A5'])
df = df.dropna(thresh=4)
Si vous définissez ʻaxis = 1`, vous pouvez faire de même pour les colonnes.
df = pd.DataFrame([[1, 2, 3, np.nan, 5],
[np.nan, 7, 8, 9, 10],
[11, np.nan, 13, 14, 15],
[16, np.nan, np.nan, 19, 20],
[21, 22, 23, 24, np.nan]],
index=['A', 'B', 'C', 'D', 'E'],
columns=['A1', 'A2', 'A3', 'A4', 'A5'])
df = df.dropna(thresh=4, axis=1)
print(df)
Remplacer la valeur manquante par une autre valeur
Pour une colonne particulière, vous pouvez affecter la moyenne de la colonne à la valeur manquante pour cette colonne:
df = pd.DataFrame([[1, 2, 3, np.nan, 5],
[np.nan, 7, 8, 9, 10],
[11, np.nan, 13, 14, 15],
[16, np.nan, np.nan, 19, 20],
[21, 22, 23, 24, np.nan]],
index=['A', 'B', 'C', 'D', 'E'],
columns=['A1', 'A2', 'A3', 'A4', 'A5'])
df['A3'] = df['A3'].fillna(df['A3'].mean())
print(df)
Vous pouvez remplacer la valeur moyenne par la valeur manquante pour toutes les colonnes en procédant comme suit.
df = pd.DataFrame([[1, 2, 3, np.nan, 5],
[np.nan, 7, 8, 9, 10],
[11, np.nan, 13, 14, 15],
[16, np.nan, np.nan, 19, 20],
[21, 22, 23, 24, np.nan]],
index=['A', 'B', 'C', 'D', 'E'],
columns=['A1', 'A2', 'A3', 'A4', 'A5'])
df = df.fillna(df.mean())
print(df)
Valeurs manquantes pour les données catégorielles
Créons le DataFrame suivant.
df = pd.DataFrame({'A1': ['A', 'A', 'B', 'B', 'B', 'C', np.nan],
'A2': [1, 2, 3, 4, 5, 6, 7],
'A3': [8, 9, 10, 11, 12, 13, 14]})
print(df)
Vérifions la catégorie et le nombre de données avec le code ci-dessous.
print(df['A1'].value_counts())
B 3 A 2 C 1
Vous pouvez récupérer uniquement les données d'une catégorie spécifique avec le code suivant.
print(df[df['A1'] == 'B'])
A1 A2 A3 2 B 3 10 3 B 4 11 4 B 5 12
Vous pouvez remplir les valeurs manquantes pour les données catégorielles avec le code suivant. Puisque la valeur la plus fréquente est retournée par mode () [0], la valeur la plus fréquente est affectée à la valeur manquante.
df = pd.DataFrame({'A1': ['A', 'A', 'B', 'B', 'B', 'C', np.nan],
'A2': [1, 2, 3, 4, 5, 6, 7],
'A3': [8, 9, 10, 11, 12, 13, 14]})
df['A1'] = df['A1'].fillna(df['A1'].mode()[0])
print(df)
Calculons le pourcentage de données catégorielles avec le code ci-dessous.
df = pd.DataFrame({'A1': ['A', 'A', 'B', 'B', 'B', 'C', np.nan],
'A2': [1, 2, 3, 4, 5, 6, 7],
'A3': [8, 9, 10, 11, 12, 13, 14]})
print(round(df['A1'].value_counts() / len(df), 3))
B 0.429 A 0.286 C 0.143
Vous pouvez utiliser le code ci-dessous pour regrouper des données catégorielles et calculer des statistiques.
df = pd.DataFrame({'A1': ['A', 'A', 'B', 'B', 'B', 'C', np.nan],
'A2': [1, 2, 3, 4, 5, 6, 7],
'A3': [8, 9, 10, 11, 12, 13, 14]})
print(df.groupby('A1').sum())
print(df.groupby('A1').mean())
Jointure DataFrame
Par défaut, ʻaxis = 0`, ils sont donc combinés verticalement.
df1 = pd.DataFrame(data=np.random.rand(3, 3),
index=['A', 'B', 'C'],
columns=['A1', 'A2', 'A3'])
df2 = pd.DataFrame(data=np.random.rand(3, 3),
index=['D', 'E', 'F'],
columns=['A1', 'A2', 'A3'])
df3 = pd.concat([df1, df2])
print(df3)
Si vous spécifiez ʻaxis = 1` comme indiqué ci-dessous, vous pouvez les combiner horizontalement.
Vous devez faire correspondre les «colonnes» lors de la jointure verticale et «index» lors de la jointure horizontale.
df1 = pd.DataFrame(data=np.random.rand(3, 3),
index=['A', 'B', 'C'],
columns=['A1', 'A2', 'A3'])
df2 = pd.DataFrame(data=np.random.rand(3, 3),
index=['A', 'B', 'C'],
columns=['A4', 'A5', 'A6'])
df3 = pd.concat([df1, df2], axis=1)
print(df3)
Application de fonctions à DataFrame
Vous pouvez appliquer une fonction à des données spécifiques en utilisant ʻapply`.
df = pd.DataFrame(data=np.random.rand(3, 3),
index=['A', 'B', 'C'],
columns=['A1', 'A2', 'A3'])
print(df)
df['A1'] = df['A1'].apply(lambda x: x ** 2)
print(df)
Lors de l'application d'une fonction avec plusieurs arguments à un DataFrame, il est pratique de définir une fonction avec un DataFrame comme argument.
df = pd.DataFrame(data=np.random.rand(3, 3),
index=['A', 'B', 'C'],
columns=['A1', 'A2', 'A3'])
print(df)
def matmul(df):
return df['A1'] * df['A2']
df['A4'] = df.apply(matmul, axis=1)
print(df)
Si vous avez plusieurs valeurs de retour, vous pouvez les recevoir comme suit.
df = pd.DataFrame(data=np.random.rand(3, 3),
index=['A', 'B', 'C'],
columns=['A1', 'A2', 'A3'])
def square_and_twice(x):
return pd.Series([x**2, x*2])
df[['square', 'twice']] = df['A3'].apply(square_and_twice)
print(df)
À la fin
Ceci est la fin de cet article.
Merci pour votre relation.
Recommended Posts