Notions de base sur les pandas

Qu'est-ce que les pandas

Pandas est une extension Python qui fournit des fonctionnalités pour aider à l'analyse des données. L'analyse préliminaire des données est importante pour créer l'IA, mais avec Pandas (+ Jupyter Notebook), elle peut être analysée très facilement. Il est également utilisé pour saisir des cadres d'intelligence artificielle, il est donc important de savoir comment l'utiliser lors de l'étude de l'intelligence artificielle.

Voici un résumé de ce que vous pouvez faire avec les Pandas.

Installer Pandas

Avec pip, vous pouvez facilement installer Pandas avec la commande suivante.

# pip install pandas

Importer des pandas

Vous pouvez utiliser Pandas avec le "Magic" suivant. Il semble que l'abréviation soit souvent «pd».

import pandas as pd

Le code suivant est écrit en supposant que la "magie" ci-dessus a été exécutée. De plus, NumPy est souvent utilisé, donc NumPy est également décrit en supposant qu'il est importé sous l'abréviation "np".

Type de série et type DataFrame

L'analyse des données est effectuée à l'aide de Pandas, mais Pandas a un type pour stocker les données à analyser. Il s'agit du type Series et du type DataFrame.

Type de série

Si Tableau NumPy est "comme le type de liste Python", le type de série est "comme le type de dictionnaire Python (type dict)". "est. Vous pouvez étiqueter vos données comme une clé de dictionnaire, et vous pouvez faire beaucoup d'autres choses. Il correspond également aux données d'une colonne ou d'un enregistrement (une ligne) du type DataFrame présenté ci-dessous.

Créer un type de série

Vous pouvez créer un type Série principalement à partir d'un type de liste et d'un type de dictionnaire.

Créé à partir du type de dictionnaire (type dict)

Vous pouvez créer un type Série à partir d'un type de dictionnaire (type dict) avec * Series () * de Pandas. La clé de type de dictionnaire devient l'étiquette de type Series et l'élément de type de dictionnaire devient les données de type Series.

Science = {"akiyama": 100, "satou": 75, "tanaka": 120}

# SR = akiyama    100
#      satou       75
#      tanaka     120
#      dtype:   int64
SR = pd.Series(Science)

Créé à partir du tableau NumPy et du type de liste

Vous pouvez créer un type Série à partir d'un type de liste ou d'un tableau NumPy avec Pandas '* Series () *. Lorsqu'elles sont créées avec le type de liste, les étiquettes sont numérotées séquentiellement à partir de "0", mais vous pouvez spécifier l'étiquette séparément.

record = [100, 75, 120]
record_np = np.array(record)
labels = ["akiyama", "satou", "tanaka"]

#Les étiquettes sont des numéros de série à partir de "0"
# SR = 0        100
#      1         75
#      2        120
#      dtype: int64
SR = pd.Series(record)
SR = pd.Series(record_np)

#Spécifiez le libellé avec "index"
# SR = akiyama    100
#      satou       75
#      tanaka     120
#      dtype:   int64
SR = pd.Series(record, index=labels)
SR = pd.Series(record_np, index=labels)

Fonctionnement de type série

Avec le type Série, vous pouvez effectuer diverses opérations.

Afficher uniquement les étiquettes, afficher uniquement les données

Pour le type Série, seule l'étiquette peut être affichée avec un index, et seules les données peuvent être affichées avec des valeurs.

Science = {"akiyama": 100, "satou": 75, "tanaka": 120}

# SR = akiyama    100
#      satou       75
#      tanaka     120
#      dtype:   int64
SR = pd.Series(Science)

# SR.index = Index(['akiyama', 'satou', 'tanaka'], dtype='object')
SR.index

# SR.values est un tableau NumPy
# SR.values = [100 75 120]
SR.values

Nommez le type et l'étiquette de la série

Les types de séries peuvent être nommés par leur nom. Vous pouvez également nommer l'étiquette avec index.name.

Science = {"akiyama": 100, "satou": 75, "tanaka": 120}
SR = pd.Series(Science)

# SR = Students
#      akiyama    100
#      satou       75
#      tanaka     120
#      Name: Science, dtype: int64
SR.name = 'Science'
SR.index.name = 'Students'

Ajouter une nouvelle étiquette / changer d'étiquette

Si vous souhaitez ajouter une nouvelle étiquette au type Série, ajoutez-la comme suit.

Science = {"akiyama": 100, "satou": 75, "tanaka": 120}

# SR = akiyama    100
#      satou       75
#      tanaka     120
#      dtype:   int64
SR = pd.Series(Science)

#Si vous recréez le type de série en utilisant le type de liste de l'étiquette, vous pouvez obtenir le type de série avec la nouvelle étiquette ajoutée.
#À ce stade, les étiquettes qui ne sont pas dans le type de série d'origine ne seront pas héritées.
# SR_new = akiyama     100.0
#          satou        75.0
#          nico          NaN
#          mochidan      NaN
#          dtype:    float64
labels = ["akiyama", "satou", "nico", "mochidan"]
SR_new = pd.Series(SR, index=labels)

Données de type Access Series

Le type de série peut accéder aux données par indice ou nom d'étiquette.

Science = {"akiyama": 100, "satou": 75, "tanaka": 120}

# SR = akiyama    100
#      satou       75
#      tanaka     120
#      dtype:   int64
SR = pd.Series(Science)

# tmp = 75
tmp = SR[1]
tmp = SR["satou"]

#Peut être spécifié en utilisant le type de tranche ou de liste
#Dans ce cas, le type de série est renvoyé
# tmp2 = akiyama    100
#        satou       75
#        dtype:   int64
tmp2 = SR[0:2]
tmp2 = SR[["akiyama", "satou"]]

Déterminer si les données ont des valeurs nulles

Vous pouvez utiliser * isnull () * ou * notnull () * de Pandas pour déterminer si vos données sont nulles.

Science = {"akiyama": 100, "satou": 75, "tanaka": 120}
SR = pd.Series(Science)
SR["satou"] = np.nan

# SR["satou"]Est une valeur manquante(null)
#Les valeurs manquantes changent le type de données en float64
# SR = akiyama    100.0
#      satou        NaN
#      tanaka     120.0
#      dtype:   float64
SR

# akiyama    False
# satou       True
# tanaka     False
# dtype:      bool
pd.isnull(SR)

# akiyama     True
# satou      False
# tanaka      True
# dtype:      bool
pd.notnull(SR)

Afficher / modifier les données qui remplissent les conditions

Vous pouvez juger les données qui remplissent les conditions et afficher / modifier les données qui remplissent les conditions.

Science = {"akiyama": 100, "satou": 75, "tanaka": 120}

# SR = akiyama    100
#      satou       75
#      tanaka     120
#      dtype:   int64
SR = pd.Series(Science)

#Jugement des données sur 80
#Le résultat du jugement est acquis en tant que type Série
# is_Excellent = akiyama     True
#                satou      False
#                tanaka      True
#                dtype:      bool
is_Excellent = SR > 80

#Seules les données supérieures à 80 sont acquises en tant que type Série
# Excellent = akiyama    100
#             tanaka     120
#             dtype:   int64
Excellent = SR[SR > 80]
Excellent = SR[is_Excellent]

#Mettre à jour les données qui remplissent les conditions en attribuant une valeur
# SR = akiyama     80
#      satou       75
#      tanaka      80
#      dtype:   int64
SR[SR > 80] = 80

Supprimer les données spécifiées

Vous pouvez obtenir le type Series avec les données spécifiées supprimées en utilisant * drop () * du type Series.

Science = {"akiyama": 100, "satou": 75, "tanaka": 120}

# SR = akiyama    100
#      satou       75
#      tanaka     120
#      dtype:   int64
SR = pd.Series(Science)

#Spécifiez le nom d'étiquette de la ligne à supprimer
# SR_new = akiyama    100
#          tanaka     120
#          dtype:   int64
SR_new = SR.drop("satou")

Trier les données

Vous pouvez trier par étiquette avec * sort_index () * de type Series et par données avec * sort_values () *.

Science = {"satou": 100, "akiyama": 75, "tanaka": 120}

# SR = satou      100
#      akiyama     75
#      tanaka     120
#      dtype:   int64
SR = pd.Series(Science)

#Trier par étiquette dans l'ordre croissant
# SR_index = akiyama     75
#            satou      100
#            tanaka     120
#            dtype:   int64
SR_index = SR.sort_index()

#Lorsque l'argument "inplace" est défini sur "True", le type Series lui-même est mis à jour.
SR.sort_index(inplace = True)

#Si l'argument "croissant" est défini sur "False", le tri sera dans l'ordre décroissant.
SR.sort_index(inplace = True, ascending=False)

#Trier par données par ordre croissant
# SR_values = akiyama     75
#             satou      100
#             tanaka     120
#             dtype:   int64
SR_values = SR.sort_values()

#Lorsque l'argument "inplace" est défini sur "True", le type Series lui-même est mis à jour.
SR.sort_values(inplace = True)

#Si l'argument "croissant" est défini sur "False", le tri sera dans l'ordre décroissant.
SR.sort_values(inplace = True, ascending=False)

Type de DataFrame

Le type DataFrame est "comme une table". Les données à analyser peuvent être au format csv, au format Excel ou des données sur HTML, mais il fournit une fonction pour les lire et les faire fonctionner comme un tableau.

Création d'un type DataFrame

Vous pouvez lire des données dans différents formats en tant que type DataFrame.

Créé à partir d'un fichier csv

Vous pouvez utiliser * read_csv () * ou * read_table () * de Pandas pour créer un type DataFrame à partir d'un fichier csv. À titre d'exemple, le fichier csv suivant existe.

test.csv


No,Name,Score
Students,Science,Math
akiyama,100,100
satou,75,99
tanaka,120,150
suzuki,50,50
mochidan,0,10

Si vous utilisez * read_csv () *, vous pouvez créer un type DataFrame comme suit:

#L'argument est le chemin de lecture, spécifié comme chemin relatif depuis le répertoire courant.
DF = pd.read_csv('test.csv')

#Si Aucun est spécifié pour "en-tête", il sera lu comme données de la première ligne.
DF = pd.read_csv('test.csv', header=None)

Lorsque vous utilisez * read_table () *, vous pouvez spécifier le séparateur. Vous pouvez créer un type DataFrame comme suit:

#L'argument est le chemin de lecture, spécifié comme chemin relatif depuis le répertoire courant.
#Spécifiez un séparateur pour "sep"
DF = pd.read_table('test.csv', sep=',')

#Si Aucun est spécifié pour "en-tête", il sera lu comme données de la première ligne.
DF = pd.read_table('test.csv', , sep=',', header=None)

Dans ces cas, le DF sera du type DataFrame suivant.

Students Science Math
0 akiyama 100 100
1 satou 75 99
2 tanaka 120 150
3 suzuki 50 50
4 mochidan 0 10

Créer à partir du presse-papiers

Vous pouvez utiliser * read_clipboard () * de Pandas pour créer un type de DataFrame à partir du presse-papiers. A titre d'exemple, le tableau suivant existe.

Students Science Math
0 akiyama 100 100
1 satou 75 99
2 tanaka 120 150
3 suzuki 50 50
4 mochidan 0 10

Supposons que vous copiez le tableau ci-dessus et que vous le sauvegardiez dans le presse-papiers. Après cela, vous pouvez créer un type DataFrame comme suit.

DF = pd.read_clipboard()

#Si Aucun est spécifié pour "en-tête", il sera lu comme données de la première ligne.
DF = pd.read_clipboard(header=None)

Créé à partir d'un fichier Excel

Vous pouvez utiliser Pandas * read_excel () * pour créer un type DataFrame à partir d'un fichier Excel. Cependant, sachez que s'il existe des cellules fusionnées, les cellules ne seront pas fusionnées, ce qui entraînera «NaN» pour la valeur et «Sans nom: * x *» pour le nom de la colonne.

#Le premier argument est le chemin de destination de lecture, qui est spécifié comme chemin relatif à partir du répertoire courant.
# sheet_Spécifiez le nom de la feuille à lire dans name
DF = pd.read_excel('test.xlsx', sheet_name='Sheet1')

#Si Aucun est spécifié pour "en-tête", les données seront lues à partir de la première ligne du fichier Excel.
DF = pd.read_excel('test.xlsx', sheet_name='Sheet1', header=None)

Créé à partir du type de dictionnaire (type dict)

Vous pouvez également créer un type DataFrame à partir d'un type de dictionnaire (type dict). Lorsque les données JSON sont renvoyées par une requête HTTP, etc., si le JSON peut bien être transformé en un type de dictionnaire, les données peuvent être manipulées en tant que type DataFrame.

import pandas as pd
import json

#Par exemple, s'il existe un tel JSON
json_obj = """
{    
    "result": [{"Students": "akiyama", "Science": 100, "Math": 100}, 
               {"Students": "satou"  , "Science":  75, "Math":  99}, 
               {"Students": "tanaka" , "Science": 120, "Math": 150}]
}
"""

#Créer un objet JSON
data = json.loads(json_obj)

#Dans ce cas, les données["result"]Est une liste de types de dictionnaire
# data["result"] = [{'Students': 'akiyama', 'Science': 100, 'Math': 100},
#                   {'Students': 'satou'  , 'Science':  75, 'Math':  99},
#                   {'Students': 'tanaka' , 'Science': 120, 'Math': 150}]
data["result"]

#Pandas DataFrame()Si vous passez une liste de types de dictionnaire comme argument de, vous pouvez en faire un type DataFrame
#1 type de dictionnaire, 1 ligne de type DataFrame
DF = pd.DataFrame(data["result"])

Dans ce cas, le DF sera du type DataFrame suivant.

Students Science Math
0 akiyama 100 100
1 satou 75 99
2 tanaka 120 150

Créé à partir du tableau NumPy et du type de liste

Vous pouvez également créer un type DataFrame à partir d'un tableau NumPy et d'un type de liste.

# data_np = [['akiyama' 100 100],
#            ['satou'    75  99]]
data = [["akiyama", 100, 100], ["satou", 75, 99]]
data_np = np.array(data)

#Spécifiez le nom de la colonne dans "colonnes" (si non spécifié, numéro de série à partir de "0")
DF = pd.DataFrame(data, columns = ['No', 'Name', 'Score'])
DF = pd.DataFrame(data_np, columns = ['No', 'Name', 'Score'])

Dans ce cas, le DF sera du type DataFrame suivant.

Students Science Math
0 akiyama 100 100
1 satou 75 99

Enregistrer le type de DataFrame

Vous pouvez enregistrer le type DataFrame sous forme de fichier.

Enregistrer au format csv

Vous pouvez enregistrer le type DataFrame au format csv en utilisant le type DataFrame * to_csv () *.

#Supposons que vous créez un type DataFrame d'une manière ou d'une autre et que vous apportez diverses modifications.
DF = pd.read_csv('test.csv')

#Le premier argument est le chemin de destination de l'enregistrement, qui est spécifié comme chemin relatif à partir du répertoire actuel.
#Le séparateur par défaut est ",」
DF.to_csv('test_2.csv')

#Vous pouvez également spécifier le séparateur avec "sep"
DF.to_csv('test_3.csv', sep='_')

#Sélectionnable avec ou sans index et en-tête
DF.to_csv("test_4.csv", header=False, index=False)

Opérations de type DataFrame

Si vous utilisez le type DataFrame, vous pouvez effectuer diverses opérations.

Afficher le nom de la colonne, spécifier le nom de la colonne à afficher

Le type DataFrame peut obtenir le nom de la colonne avec des colonnes, ou vous pouvez spécifier le nom de la colonne et obtenir uniquement cette colonne.

data = [["akiyama", 100, 100],
        ["satou"  ,  75,  99]]
DF = pd.DataFrame(data, columns = ['Students', 'Science', 'Math'])

#Afficher le nom de la colonne
# DF.columns = Index(['Students', 'Science', 'Math'], dtype='object')
DF.columns

#Vous pouvez obtenir la colonne spécifiée en tant que type de série en procédant comme suit
# 0    akiyama
# 1      satou
# Name: Students, dtype: object
DF["Students"]
DF.Students

#Si vous souhaitez obtenir deux colonnes ou plus, spécifiez ces noms de colonne comme type de liste.
#Lors de la récupération de deux colonnes ou plus, il est récupéré par type DataFrame
DF[["Students", "Math"]]

Le DF [["Students", "Math"]] ci-dessus est du type DataFrame suivant.

Students Math
0 akiyama 100
1 satou 99

Affichage en spécifiant le nombre de lignes

En utilisant le type iloc DataFrame, seule la ligne spécifiée peut être récupérée.

data = [["akiyama", 100, 100],
        ["satou"  ,  75,  99]]
DF = pd.DataFrame(data, columns = ['Students', 'Science', 'Math'])

#Vous pouvez obtenir la ligne spécifiée en tant que type Série en procédant comme suit
#Notez que les numéros de ligne commencent par "0"
# Students    satou
# Science        75
# Math           99
# Name: 1, dtype: object
DF.iloc[1]

#Si vous souhaitez obtenir plusieurs lignes, décrivez la plage que vous souhaitez obtenir en tranches
#Lors de la récupération de deux lignes ou plus, il est récupéré par type DataFrame
DF.iloc[0:2]

Le DF.iloc [0: 2] ci-dessus a le type DataFrame suivant.

Students Science Math
0 akiyama 100 100
1 satou 75 99

Afficher uniquement le début, afficher uniquement la fin

Le type DataFrame * head () * peut être utilisé pour afficher uniquement le début, et * tail () * peut être utilisé pour afficher uniquement la fin.

data = [["akiyama", 100, 100],
        ["satou"  ,  75,  99]]
DF = pd.DataFrame(data, columns = ['Students', 'Science', 'Math'])

#Sans argument, affichez les 5 premières lignes
#Si vous spécifiez le nombre de lignes dans l'argument, seul le nombre de lignes spécifié sera affiché depuis le début.
DF.head()
DF.head(1)

#Sans argument, affiche les 5 dernières lignes
#Si vous spécifiez le nombre de lignes dans l'argument, seul le nombre de lignes spécifié sera affiché à partir de la fin
DF.tail()
DF.tail(1)

Créer un nouveau type de DataFrame sur une colonne particulière

Vous pouvez créer un nouveau type DataFrame en utilisant uniquement des colonnes spécifiques du type DataFrame, comme indiqué ci-dessous.

data = [["akiyama", 100, 100],
        ["satou"  ,  75,  99]]
DF = pd.DataFrame(data, columns = ['Students', 'Science', 'Math'])

#Créez un nouveau type de DataFrame en utilisant uniquement "Etudiants" et "Math" de type DataFrame "DF"
#Spécifiez une ligne dans "colonnes", mais si vous spécifiez une colonne qui n'existe pas, toutes les données de cette colonne seront créées en tant que "NaN".
DF_new = DataFrame(DF, columns=['Students', 'Math'])

Le DF_new ci-dessus a le type DataFrame suivant.

Students Math
0 akiyama 100
1 satou 99

Supprimer la ligne ou la colonne spécifiée

En utilisant * drop () * de type DataFrame, vous pouvez obtenir le type DataFrame avec la colonne / ligne spécifiée supprimée.

data = [["akiyama", 100, 100],
        ["satou"  ,  75,  99]]
DF = pd.DataFrame(data, columns = ['Students', 'Science', 'Math'])

#Lors de la suppression d'une ligne, spécifiez l'index de la ligne à supprimer (si elle a un nom d'étiquette, spécifiez le nom d'étiquette)
#Puisque l'index commence à "0", supprimez la deuxième ligne dans ce cas
DF_drop_axis0 = DF.drop(1)

#Lors de la suppression d'une ligne, spécifiez "1" pour l'argument "axe"
#Spécifiez également l'index de la colonne à supprimer (si le nom de la colonne est attaché, spécifiez le nom de la colonne)
#Le nom de la colonne étant joint, supprimez le nom de la colonne "Science"
DF_drop_axis1 = DF.drop("Science", axis=1)

Le DF_drop_axis0 ci-dessus est du type DataFrame suivant.

Students Science Math
0 akiyama 100 100

DF_drop_axis1 a le type DataFrame suivant.

Students Math
0 akiyama 100
1 satou 99

Ajouter une colonne

Vous pouvez ajouter une nouvelle colonne au type DataFrame comme suit:

data = [["akiyama", 100, 100],
        ["satou"  ,  75,  99]]
DF = pd.DataFrame(data, columns = ['Students', 'Science', 'Math'])

#Ajout de la colonne "Anglais". Spécifiez "NaN" comme valeur initiale.
DF['English'] = np.nan
Students Science Math English
0 akiyama 100 100 NaN
1 satou 75 99 NaN

Vous pouvez également ajouter des colonnes à l'aide du type Série.

data = [["akiyama", 100, 100],
        ["satou"  ,  75,  99]]
DF = pd.DataFrame(data, columns = ['Students', 'Science', 'Math'])

# English = 0        100
#           1         30
#           dtype: int64
English = pd.Series([100, 30], index=[0, 1])

#Les données sont insérées là où l'index du côté de la série et l'index du type DataFrame correspondent.
#S'il n'y a pas de correspondance, ce sera "NaN"
DF['English'] = English
Students Science Math English
0 akiyama 100 100 100
1 satou 75 99 30

Afficher les données qui remplissent les conditions

Vous pouvez juger les données qui remplissent les conditions et afficher les données qui remplissent les conditions.

data = [["akiyama", 100, 100],
        ["satou"  ,  75,  99]]
DF = pd.DataFrame(data, columns = ['Students', 'Science', 'Math'])

#Déterminez s'il existe plus de 80 données pour "Science" et "Math"
DF_80over = DF[["Science", "Math"]] > 80

#Afficher les lignes avec "Science" sur 80
Science_80over = DF[DF['Science'] > 80]

Le DF_80over ci-dessus a le type DataFrame suivant.

Science Math
0 True True
1 False True

Science_80over a le type de DataFrame suivant.

Students Science Math
0 akiyama 100 100

Recommended Posts

Notions de base sur les pandas
Pandas
Mémo Pandas
Principes de base de Pandas pour les débutants ① Lecture et traitement
Bases de Linux
Les bases de Python
Principes de base de NumPy
Les bases de Python ④
Les bases de Git
Notes de pandas
Les bases de Python ③
Les bases de Django
Mémorandum de Pandas
Les bases de Python
Les bases de Python
Les bases de Python ③
mémorandum pandas
mémo pandas
Les bases de Python ②
Les bases de Python ②
Lien récapitulatif des bases de Pandas pour les débutants
pandas SettingWithCopyWarning
mémo d'auto-apprentissage pandas
Les bases de Pandas pour les débutants ③ Créez un histogramme avec matplotlib
bases de python: liste
Mémorandum de base Python
Principes de base du script Shell # 2
Mes pandas (Python)
Excel-> pandas-> sqlite
Les bases de #Python (#matplotlib)
Principes de base de Python CGI
bases de python: dictionnaire
[pandas] Conseils GroupBy
lecture de données pandas
À propos de décrire les pandas
liens relatifs aux pandas
Pandas de valeur manquante
9rep - Pandas MySQL
[Pandas] Principes de base du traitement des données de date à l'aide de dt
Bases de python ①
bases de la tranche de python
# Principes de base de Python (portée)
Aller aux bases de la classe
Les bases de #Python (#Numpy 1/2)
Les bases de #Python (#Numpy 2/2)
Apprendre sans enseignant 1 Principes de base
# Bases de Python (fonctions)
Mémorandum d'opération Pandas
principes de base des tableaux python
Trier par pandas
Principes de base du profilage Python
Principes de base des commandes Linux
Principes de base de Python #Numpy
bases de python: fonctions
Principes de base de Pandas pour les débutants ② Présentation des données de saisie
mémo pandas python
Les bases de #Python (classe)
Résumé des bases de Python
série pandas partie 1
[Note] les pandas se désempilent