TOC

Comment installer le paquet pandas et utiliser les structures de données en Python 3

introduction

Le package Pythonpandas est utilisé pour la manipulation et l'analyse des données, conçu pour vous permettre de travailler avec des données étiquetées ou relationnelles de manière plus intuitive.

Construit sur le packagenumpy,pandas comprend des étiquettes, des indices descriptifs et est particulièrement robuste dans la gestion des formats de données courants et des données manquantes.

Le packagepandas offre une fonctionnalité de feuille de calcul mais travailler avec des données est beaucoup plus rapide avec Python qu'avec une feuille de calcul, etpandas s'avère très efficace.

Dans ce didacticiel, nous allons d'abord installerpandas, puis vous orienter vers les structures de données fondamentales:Series etDataFrames.

Installation depandas

Comme avec les autres packages Python, nous pouvons installerpandas avecpip.

Tout d'abord, passons à noslocal programming environment ouserver-based programming environment de votre choix et installonspandas avec ses dépendances là-bas: 

pip install pandas numpy python-dateutil pytz

Vous devriez recevoir une sortie semblable à celle-ci: 

OutputSuccessfully installed pandas-0.19.2

Si vous préférez installerpandas dansAnaconda, vous pouvez le faire avec la commande suivante: 

conda install pandas

À ce stade, vous êtes prêt à commencer à travailler avec le packagepandas.

Séries

Danspandas, lesSeries sont des tableaux unidimensionnels qui peuvent contenir n'importe queldata type. Les étiquettes des axes sont désignées collectivement sous le nom deindex.

Lançons l’interpréteur Python dans votre ligne de commande comme suit: 

python

Depuis l'interpréteur, importez les packagesnumpy etpandas dans votre espace de noms: 

import numpy as np
import pandas as pd

Avant de travailler avec Series, examinons ce à quoi il ressemble généralement: 

s = pd.Series([data], index=[index])

Vous remarquerez peut-être que les données sont structurées comme un Pythonlist.

Sans déclarer un index

Nous allons saisir des données entières, puis fournir un paramètre de nom pour la série, mais nous éviterons d'utiliser le paramètreindex pour voir commentpandas le remplit implicitement: 

s = pd.Series([0, 1, 4, 9, 16, 25], name='Squares')

Maintenant, appelons la série pour voir ce quepandas en fait: 

s

Nous verrons la sortie suivante, avec l’index dans la colonne de gauche, nos valeurs de données dans la colonne de droite. Sous les colonnes se trouvent des informations sur le nom de la série et le type de données constituant les valeurs. 

Output0     0
1     1
2     4
3     9
4    16
5    25
Name: Squares, dtype: int64

Bien que nous n'ayons pas fourni d'index pour le tableau, il y en a eu un ajouté implicitement des valeurs entières0 à5.

Déclarer un index

Comme le montre la syntaxe ci-dessus, nous pouvons également créer une série avec un index explicite. Nous utiliserons des données sur la profondeur moyenne en mètres des océans de la Terre: 

avg_ocean_depth = pd.Series([1205, 3646, 3741, 4080, 3270], index=['Arctic',  'Atlantic', 'Indian', 'Pacific', 'Southern'])

Maintenant que la série est construite, appelons-la pour voir le résultat: 

avg_ocean_depth
OutputArctic      1205
Atlantic    3646
Indian      3741
Pacific     4080
Southern    3270
dtype: int64

Nous pouvons voir que l'index que nous avons fourni est à gauche avec les valeurs à droite.

Série d'indexation et de tranchage

Avecpandas Series, nous pouvons indexer par le nombre correspondant pour récupérer les valeurs: 

avg_ocean_depth[2]
Output3741

Nous pouvons également découper par numéro d'index pour récupérer des valeurs: 

avg_ocean_depth[2:4]
OutputIndian     3741
Pacific    4080
dtype: int64

De plus, nous pouvons appeler la valeur de l'index pour renvoyer la valeur à laquelle elle correspond: 

avg_ocean_depth['Indian']
Output3741

Nous pouvons également trancher avec les valeurs de l'index pour renvoyer les valeurs correspondantes: 

avg_ocean_depth['Indian':'Southern']
OutputIndian      3741
Pacific     4080
Southern    3270
dtype: int64

Notez que dans ce dernier exemple, lors de la découpe avec des noms d'index, les deux paramètres sont inclusifs et non exclusifs.

Quittons l'interpréteur Python avecquit().

Série initialisée avec dictionnaires

Avecpandas, nous pouvons également utiliser le type de donnéesdictionary pour initialiser une série. De cette façon, nous ne déclarerons pas un index en tant que liste séparée mais utiliserons les clés intégrées en tant qu'index.

Créons un fichier appeléocean.py et ajoutons le dictionnaire suivant avec un appel pour l’imprimer.

ocean.py

import numpy as np
import pandas as pd

avg_ocean_depth = pd.Series({
                    'Arctic': 1205,
                    'Atlantic': 3646,
                    'Indian': 3741,
                    'Pacific': 4080,
                    'Southern': 3270
})

print(avg_ocean_depth)

Maintenant, nous pouvons exécuter le fichier sur la ligne de commande: 

python ocean.py

Nous recevrons le résultat suivant: 

OutputArctic      1205
Atlantic    3646
Indian      3741
Pacific     4080
Southern    3270
dtype: int64

La série est affichée de manière organisée, avec l'index (composé de nos clés) à gauche et l'ensemble de valeurs à droite.

Cela se comportera comme les autres dictionnaires Python en ce sens que vous pouvez accéder aux valeurs en appelant la clé, ce que nous pouvons faire comme suit:

ocean_depth.py

...
print(avg_ocean_depth['Indian'])
print(avg_ocean_depth['Atlantic':'Indian'])
Output3741
Atlantic    3646
Indian      3741
dtype: int64

Cependant, ces séries étant désormais des objets Python, vous ne pourrez plus utiliser les fonctions de dictionnaire.

Les dictionnaires Python fournissent une autre forme pour configurer Series enpandas.

DataFrames

LesDataFrames sont des structures de données étiquetées à 2 dimensions qui ont des colonnes qui peuvent être constituées de différents types de données.

Les DataFrames sont similaires aux tableurs ou aux tables SQL. En général, lorsque vous travaillez avecpandas, les DataFrames seront l’objet le plus courant que vous utiliserez.

Pour comprendre le fonctionnement du DataFramepandas, configurons deux séries, puis transmettons-les dans un DataFrame. La première série sera notre sérieavg_ocean_depth d'avant, et la seconde seramax_ocean_depth qui contient les données de la profondeur maximale de chaque océan sur Terre en mètres.

ocean.py

import numpy as np
import pandas as pd


avg_ocean_depth = pd.Series({
                    'Arctic': 1205,
                    'Atlantic': 3646,
                    'Indian': 3741,
                    'Pacific': 4080,
                    'Southern': 3270
})

max_ocean_depth = pd.Series({
                    'Arctic': 5567,
                    'Atlantic': 8486,
                    'Indian': 7906,
                    'Pacific': 10803,
                    'Southern': 7075
})

Une fois ces deux séries configurées, ajoutons le DataFrame au bas du fichier, sous la sériemax_ocean_depth. Dans notre exemple, ces deux séries ont les mêmes étiquettes d'index, mais si vous aviez des séries avec des étiquettes différentes, les valeurs manquantes seraient étiquetéesNaN.

Ceci est construit de telle sorte que nous puissions inclure des étiquettes de colonne, que nous déclarons comme clés des variables de la série. Pour voir à quoi ressemble le DataFrame, appelons-le pour l’imprimer.

ocean.py

...
max_ocean_depth = pd.Series({
                    'Arctic': 5567,
                    'Atlantic': 8486,
                    'Indian': 7906,
                    'Pacific': 10803,
                    'Southern': 7075
})

ocean_depths = pd.DataFrame({
                    'Avg. Depth (m)': avg_ocean_depth,
                    'Max. Depth (m)': max_ocean_depth
})

print(ocean_depths)
Output          Avg. Depth (m)  Max. Depth (m)
Arctic              1205            5567
Atlantic            3646            8486
Indian              3741            7906
Pacific             4080           10803
Southern            3270            7075

La sortie montre nos deux en-têtes de colonne avec les données numériques sous chacun, et les étiquettes des clés du dictionnaire se trouvent à gauche.

Tri des données dans les cadres de données

Nous pouvonssort the data in the DataFrame en utilisant la fonctionDataFrame.sort_values(by=...).

Par exemple, utilisons le paramètre booléenascending, qui peut êtreTrue ouFalse. Notez queascending est un paramètre que nous pouvons passer à la fonction, mais que la descente ne l'est pas.

ocean_depth.py

...
print(ocean_depths.sort_values('Avg. Depth (m)', ascending=True))
Output          Avg. Depth (m)  Max. Depth (m)
Arctic              1205            5567
Southern            3270            7075
Atlantic            3646            8486
Indian              3741            7906
Pacific             4080           10803

À présent, la sortie affiche les nombres allant de valeurs basses aux valeurs élevées dans la colonne entière la plus à gauche.

Analyse statistique avec DataFrames

Ensuite, regardonssome summary statistics que nous pouvons collecter à partir depandas avec la fonctionDataFrame.describe().

Sans passer de paramètres particuliers, la fonctionDataFrame.describe() fournira les informations suivantes pour les types de données numériques:

Revenir Ce que cela veut dire

count

Compte de fréquence; le nombre de fois où quelque chose se produit

mean

La moyenne ou la moyenne

std

L'écart type, une valeur numérique utilisée pour indiquer dans quelle mesure les données varient

min

Le nombre minimum ou le plus petit de l'ensemble

25%

25e centile

50%

50e centile

75%

75e centile

max

Le nombre maximum ou le plus grand de l'ensemble

Laissez Python imprimer ces données statistiques pour nous en appelant notreocean_depths DataFrame avec la fonctiondescribe():

ocean.py

...
print(ocean_depths.describe())

Lorsque nous exécuterons ce programme, nous recevrons le résultat suivant: 

Output       Avg. Depth (m)  Max. Depth (m)
count        5.000000        5.000000
mean      3188.400000     7967.400000
std       1145.671113     1928.188347
min       1205.000000     5567.000000
25%       3270.000000     7075.000000
50%       3646.000000     7906.000000
75%       3741.000000     8486.000000
max       4080.000000    10803.000000

Vous pouvez maintenant comparer la sortie ici au DataFrame d’origine et avoir une meilleure idée des profondeurs moyennes et maximales des océans de la Terre, en tant que groupe.

Gestion des valeurs manquantes

Souvent, lorsque vous travaillez avec des données, vous aurez des valeurs manquantes. Le packagepandas fournit de nombreuses façons différentes pourworking with missing data, qui se réfère aux donnéesnull, ou des données qui ne sont pas présentes pour une raison quelconque. Danspandas, ceci est appelé données NA et est rendu commeNaN.

Nous allons parcourirdropping missing values avec la fonctionDataFrame.dropna() etfilling missing values avec la fonctionDataFrame.fillna(). Cela garantira que vous ne rencontrez pas de problèmes dès le début.

Créons un nouveau fichier appeléuser_data.py et remplissons-le avec des données qui ont des valeurs manquantes et transformons-le en DataFrame:

user_data.py

import numpy as np
import pandas as pd


user_data = {'first_name': ['Sammy', 'Jesse', np.nan, 'Jamie'],
        'last_name': ['Shark', 'Octopus', np.nan, 'Mantis shrimp'],
        'online': [True, np.nan, False, True],
        'followers': [987, 432, 321, np.nan]}

df = pd.DataFrame(user_data, columns = ['first_name', 'last_name', 'online', 'followers'])

print(df)

Notre appel à imprimer nous montre la sortie suivante lorsque nous exécutons le programme: 

Output  first_name      last_name online  followers
0      Sammy          Shark   True      987.0
1      Jesse        Octopus    NaN      432.0
2        NaN            NaN  False      321.0
3      Jamie  Mantis shrimp   True        NaN

Il y a pas mal de valeurs manquantes ici.

Commençons par supprimer les valeurs manquantes avecdropna().

user_data.py

...
df_drop_missing = df.dropna()

print(df_drop_missing)

Puisqu'il n'y a qu'une seule ligne pour laquelle il ne manque aucune valeur dans notre petit jeu de données, c'est la seule ligne qui reste intacte lorsque nous exécutons le programme: 

Output  first_name last_name online  followers
0      Sammy     Shark   True      987.0

Au lieu de supprimer les valeurs, nous pouvons à la place remplir les valeurs manquantes avec une valeur de notre choix, telle que0. Nous y parviendrons avecDataFrame.fillna(0).

Supprimez ou commentez les deux dernières lignes que nous avons ajoutées à notre fichier et ajoutez ce qui suit:

user_data.py

...
df_fill = df.fillna(0)

print(df_fill)

Lorsque nous exécutons le programme, nous recevons le résultat suivant: 

Output  first_name      last_name online  followers
0      Sammy          Shark   True      987.0
1      Jesse        Octopus      0      432.0
2          0              0  False      321.0
3      Jamie  Mantis shrimp   True        0.0

Maintenant, toutes nos colonnes et lignes sont intactes, et au lieu d'avoirNaN comme valeurs, nous avons maintenant0 qui remplissent ces espaces. Vous remarquerez que les flotteurs sont utilisés lorsque cela convient.

À ce stade, vous pouvez trier les données, effectuer une analyse statistique et gérer les valeurs manquantes dans les DataFrames.

Conclusion

Ce didacticiel a couvert des informations introductives pour l'analyse de données avecpandas et Python 3. Vous devriez maintenant avoir installépandas et pouvez travailler avec les structures de données Series et DataFrames danspandas.

Related