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.
Avec pip, vous pouvez facilement installer Pandas avec la commande suivante.
# pip install 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".
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.
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.
Vous pouvez créer un type Série principalement à partir d'un type de liste et d'un type de dictionnaire.
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)
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)
Avec le type Série, vous pouvez effectuer diverses opérations.
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
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'
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)
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"]]
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)
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
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")
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)
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.
Vous pouvez lire des données dans différents formats en tant que type DataFrame.
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 |
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)
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)
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 |
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 |
Vous pouvez enregistrer le type DataFrame sous forme de fichier.
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)
Si vous utilisez le type DataFrame, vous pouvez effectuer diverses opérations.
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 |
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 |
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)
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 |
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 |
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 |
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