Pandas est une bibliothèque incontournable en Python c’est pourquoi je vous propose ce guide de démarrage. Elle offre des structures de données faciles à utiliser et des outils de manipulation de données performants. Cette librairie est construite sur NumPy, une autre librairie Python pour le calcul scientifique (j’en parle dans cet article). Pandas est particulièrement apprécié pour sa simplicité, sa flexibilité et sa rapidité, ce qui en fait un choix de prédilection pour les scientifiques des données, les analystes et les développeurs. Le but de cet article est d’être un guide de démarrage afin de commencer à travailler avec cette librairie.
Installation de Pandas
Avant de commencer à utiliser Pandas, vous devez l’installer sur votre système. La façon la plus simple de le faire est d’utiliser l’instruction pip, le gestionnaire de paquets de Python. Ouvrez votre terminal ou votre invite de commande et tapez la commande suivante :
pip install pandas
Assurez-vous d’avoir une version récente de Python installée sur votre système avant d’exécuter cette commande.
Les principales structures de données de Pandas
Pandas offre deux structures de données principales : les Series et les DataFrames.
Les Series (données sous forme d’un vecteur)
Les Series sont une structure de données unidimensionnelle. Elles peuvent contenir tous types de variables (entier, réel, chaîne de caractères, …). Généralement, une structure de données de type Series est générée avec un index permettant de faire référence aux éléments qu’elle contient.
series = pd.Series(data, index=index)La variable data peut être de différentes natures : un dictionnaire, un tableau Numpy ou un scalaire. La liste des labels pour définir l’index est donné comme argument dans la variable qui porte le même nom. Si aucun index n’est donné, celui-ci sera alors une numérotation automatique et incrémentale à partir de 0.
s = pd.Series(np.random.randn(5), index=["a", "b", "c", "d", "e"])
a 0.469112
b -0.282863
c -1.509059
d -1.135632
e 1.212112
dtype: float64La structure de données Séries fonctionne comme les vecteurs avec Numpy. Vous pouvez réaliser des opérations basiques très facilement. La grosse différence vient qu’avec Pandas et la structure de données Series, les index sont automatiquement reconnus et alignés entre eux. Cela veut dire que même si vos deux Series ne sont pas triées dans le même ordre, si les index correspondent, vous pouvez directement effectuer vos opérations sans vous soucier de l’ordre.
dic_a = {"b": 1, "a": 0, "c": 2}
dic_b = {"c": 1, "b": 0, "a": 2}
s_a = pd.Series(dic_a)
s_b = pd.Series(dic_b)
s = s_a + s_b
a 2
b 1
c 3
dtype: int64
Si vous faites le calcul mentalement, on observe que les index sont bien respectés malgré le fait qu’ils soient dans un ordre différent.
Les Dataframe (structure de données à deux dimensions)
Le DataFrame est la structure de données la plus utilisée dans Pandas. C’est une table bidimensionnelle, similaire à une feuille de calcul ou à une base de données SQL. Chaque colonne du DataFrame représente une variable et chaque ligne représente une observation. Chaque colonne peut avoir un type différent.
Plusieurs solutions s’offrent à vous pour créer un Dataframe. Vous pouvez utiliser un dictionnaire de listes, Series ou tableau à 1 dimension, directement un tableau à deux dimensions, un autre Dataframe. Nous verrons plusieurs exemples dans la section suivante.
Tout comme l’objet Series, vous pouvez donner des labels à l’index. De plus, les colonnes peuvent également être nommées selon votre besoin en passant dans l’argument columns la liste des noms. Nous allons voir plusieurs exemples dans la section suivante.
Comment créer un Dataframe avec la librairie Pandas en Python
Créer un DataFrame manuellement avec la librairie Pandas
Généralement, pour créer un DataFrame, on part d’un tableau créé via la librairie Numpy. Dans ce cas, la librairie Pandas permet de rajouter des index et des noms aux colonnes. Vous pourrez ainsi manipuler les données directement avec ces labels.
import pandas as pd
import numpy as np
np_array = np.random.randint(0,10,(4,3))
df = pd.DataFrame(np_array,index=list("ABCD"),
columns=["Col1","Col2","Col3"])
print(df)
Col1 Col2 Col3
A 1 0 0
B 6 4 5
C 0 9 8
D 8 9 5
Créer un DataFrame à partir d’un dictionnaire
Dans le cas de la création d’un dataframe avec un dictionnaire, les colonnes seront automatiquement renommées avec les clés du dictionnaire.
df = pd.DataFrame(dico, index=list("ABCD"))
print(df)
col1 col2 col3
A 1 11 21
B 2 12 22
C 3 13 23
D 4 14 24
Depuis un dictionnaire d’objet Series
Nous avons vu précédemment l’objet Series qui ne possède qu’une seule dimension contrairement au DataFrame. Un DataFrame peut alors être créé à partir d’une collection de Series, la collection pouvant être un dictionnaire par exemple.
dic = {
"Series1": pd.Series([1.0, 2.0, 3.0], index=["a", "b", "c"]),
"Series2": pd.Series([1.0, 2.0, 3.0, 4.0], index=["a", "b", "c", "d"]),
}
df = pd.DataFrame(dic)
print(df)
Out:
Series1 Series2
a 1.0 1.0
b 2.0 2.0
c 3.0 3.0
d NaN 4.0
Dans l’exemple présenté, vous aurez pu voir que le nombre d’éléments est différent entre les deux objets Series. Ceci ne pose aucun problème à la création du DataFrame. La librairie Pandas ajoute automatiquement une valeur NaN dans les cases manquantes. Un autre exemple de création de DataFrame est présenté ci-dessous. Dans ce cas, un filtre est réalisé au niveau des index. Les objets Séries possèdent leur propre index et on vient créer un DataFrame avec uniquement une partie des index.
pd.DataFrame(dico, index=["d", "b", "a"])
Out:
Series1 Series2
d NaN 4.0
b 2.0 2.0
a 1.0 1.0
Les résultats est cohérent avec les données déjà renseignées. Enfin, dans ce dernier exemple, un troisième colonne est appelée alors que la première est omise.
pd.DataFrame(d, index=["d", "b", "a"], columns=["Series2", "Series3"])
Out:
Series2 Series3
d 4.0 NaN
b 2.0 NaN
a 1.0 NaN
Ces différentes exemples vous montrent comment créer un DataFrame de différentes manières.
Depuis un fichier CSV
Enfin, une autre solution pour importer des données est de passer par un fichier CSV (Comma Separated Value). Il faut savoir que la librairie Pandas prend en charge différents formats de fichiers, tels que CSV, Excel, JSON, SQL, etc. Nous traiterons ici le cas du fichier CSV. Pour charger un tel fichier, vous pouvez utiliser la fonction read_csv de Pandas :
import pandas as pd
# Charger les données depuis un fichier CSV
df = pd.read_csv('chemin_vers_fichier.csv')
Inspecter les DataFrames
Nous avons vu comment créer des DataFrames et maintenant nous allons voir comment inspecter les données. En effet, si la quantité de données est grande ou si la source n’est pas totalement fiable, il faut vous assurer de la qualité de celles-ci. Une fois que vous avez chargé vos données dans un DataFrame, vous pouvez effectuer diverses opérations pour explorer et manipuler les données.
Afficher les premières et dernières lignes du DataFrame
Les fonctions head et tail permettent d’afficher respectivement le début et la fin des données. Cela est très pratique pour n’avoir qu’une partie des données et vérifier qu’elles correspondent à ce que l’on attend.
# Afficher les 5 premières et dernières lignes
print(df.head())
print(df.tail())
Afficher les données de la structure de données
Pour aller un peu plus loin dans l’analyse, vous pouvez utiliser la commande describe() qui permet d’afficher des données statistiques. Vous retrouverez notamment le nombre de valeurs, la moyenne, l’écart-type, …
# Afficher les données statistiques des données
import pandas as pd
import numpy as np
np_array = np.random.randint(0,10,(4,3))
df = pd.DataFrame(np_array,index=list("ABCD"),
columns=["Col1","Col2","Col3"])
print(df.describe())
Col1 Col2 Col3
count 4.00000 4.000000 4.000000
mean 4.25000 4.750000 2.500000
std 3.40343 2.629956 1.290994
min 1.00000 1.000000 1.000000
25% 2.50000 4.000000 1.750000
50% 3.50000 5.500000 2.500000
75% 5.25000 6.250000 3.250000
max 9.00000 7.000000 4.000000
Accéder aux colonnes spécifiques d’une structure de données
Avec la librairie Pandas, vous pouvez très facilement extraire des colonnes entières pour les utiliser ailleurs. Il suffit juste de mettre le nom de la colonne entre crochets.
# Accéder à la colonne de votre choix
print(df['Col1'])
Out:
A 1
B 7
C 6
D 6
Name: Col1, dtype: int32
Manipulation des données avec Pandas
Ce guide sur la librairie Pandas vous a maintenant donné quelques bases sur la manipulation de données en Python. Suite à vos analyses, vous aurez alors certainement besoin de modifier les DataFrames. Pandas offre de nombreuses fonctionnalités pour atteindre cet objectif. Vous pouvez filtrer les données, ajouter ou supprimer des colonnes, grouper les données, trier les valeurs, remplacer les valeurs manquantes, etc.
Filtrer les données
Une fonction très puissante des DataFrames est de pouvoir filtrer très facilement les données.
import pandas as pd
# Creation des données
df = pd.DataFrame({"A": [600, 600, 800, 800],
"B": [100, 200, 100, 200],
"C": [45, 15, 95,60]
})
df["D"] = df["C"] > 50
print(df)
print(df[df["C"] > 50])
A B C D
0 600 100 45 False
1 600 200 15 False
2 800 100 95 True
3 800 200 60 True
A B C D
2 800 100 95 True
3 800 200 60 TrueDans cet exemple, nous avons créé la colonne D qui est le résultat de la comparaison entre la colonne C et la valeur de 50. Si la valeur de la ligne, en colonne C est supérieure à 50, le résultat sera True sinon False.
Ensuite, nous avons afficher le nouveau DataFrame en appliquant le même filtre. On obtient bien que les lignes où la valeur est True en colonne D. Vous pouvez donc très facilement filtrer vos données en mettant les conditions que vous souhaitez.
Suppression des données
Deux méthodes peuvent être utlisées pour supprimer les données. Elles ressemblent aux méthodes utilisées pour les dictionnaires. Si vous voulez un article détaillé sur les dictionnaires en Python, voici le lien. Pour supprimer un élement du DataFrame, vous pourrez utiliser la commande del ou la méthode pop. Cette dernière permet de récupérer ce qui est retiré dans une variable.
# Création des données
df = pd.DataFrame({"A": [600, 600, 800, 800],
"B": [100, 200, 100, 200],
"C": [45, 15, 95,60]
})
df["D"] = df["C"] > 50
del df["B"]
df_c = df.pop("C")
print(df)
print(df_c)
Out:
A D
0 600 False
1 600 False
2 800 True
3 800 True
0 45
1 15
2 95
3 60Il ne reste donc plus que les colonnes A et D dans le DataFrame. De plus, nous avons bien récupéré la colonne C dans la variable « df_c ».
Ajouter une nouvelle colonne
Nous avons déjà vu juste avant comme créé une nouvelle colonne. Nous allons voir d’autres exemples. La démarche est simple. Il suffit de faire référence au DataFrame en question avec comme argument le nom de la nouvelle colonne entre crochets.
df = pd.DataFrame({"A": [600, 600, 800, 800],
"B": [100, 200, 100, 200],
"C": [45, 15, 95,60]
})
df["E"] = df["A"] + df["B"]
print(df)
Out:
A B C E
0 600 100 45 700
1 600 200 15 800
2 800 100 95 900
3 800 200 60 1000
Nous venons de voir ici une opération très simple d’addition. Ce n’est qu’un petit exemple. Sachez que vous pouvez appliquer des opérations plus complexes tout aussi facilement. De plus, il faut savoir que la librairie Pandas optimisera les calculs en vectorisant les calculs. Cela veut dire que les opérations seront réalisées en parallèle.
Gérer les données manquantes
Les bases de données que vous utiliserez ne seront pas forcément complètes. Il arrivera fréquemment que vous ayez des « trous » dans vos informations. Avec la librairie Pandas en Python, vous avez à disposition plusieurs outils vous permettant de gérer ce cas de figure. L’exemple suivant montre comment détecter très facilement les valeurs manquantes avec la méthode isna :
dic = {
"Series1": pd.Series([1.0, 2.0, 3.0], index=["a", "b", "c"]),
"Series2": pd.Series([1.0, 2.0, 3.0, 4.0], index=["a", "b", "c", "d"]),
}
df = pd.DataFrame(dic)
print(df)
print(df.isna())
Out:
Series1 Series2
a 1.0 1.0
b 2.0 2.0
c 3.0 3.0
d NaN 4.0
Series1 Series2
a False False
b False False
c False False
d True False
Maintenant que nous savons détecter qu’il y a des valeurs manquantes, plusieurs stratégies peuvent être adopter pour gérer ces manques d’informations. Vous pouvez alors remplacer les valeurs manquantes par une valeur prédéterminée comme on peut le voir avec la chaîne de caractère. Egalement, vous pouvez tout à fait récupérer la moyenne de votre série et l’appliquer à la valeur manquante. Vous pourrez ainsi utiliser les restes des informations de votre observation sans changer les données statistiques de l’ensemble.
print(df.fillna("Hello"))
print(df.fillna(df.mean()))
Out:
Series1 Series2
a 1.0 1.0
b 2.0 2.0
c 3.0 3.0
d Hello 4.0
Series1 Series2
a 1.0 1.0
b 2.0 2.0
c 3.0 3.0
d 2.0 4.0
La méthode fillna propose d’autres arguments permettant de complexifier son comportement. Si vous avez une série de valeurs manquantes, avec la méthode ffill vous pouvez alors utiliser la dernière observation valide et la propager jusqu’à la prochaine valeur valide. De plus, vous pouvez modifier la direction de propagation (ligne ou ou colonne) avec le paramètre axis. Plus de détails vous sont données dans la document dédiée en suivant ce lien.
dic = {
"Series1": pd.Series([1.0, 2.0, 3.0, 7.0], index=["a", "b", "c", "g"]),
"Series2": pd.Series([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0],
index=["a", "b", "c", "d", "e", "f", "g"]),
}
df = pd.DataFrame(dic)
print(df)
print(df.fillna(method='ffill'))
Out:
Series1 Series2
a 1.0 1.0
b 2.0 2.0
c 3.0 3.0
d NaN 4.0
e NaN 5.0
f NaN 6.0
g 7.0 7.0
Series1 Series2
a 1.0 1.0
b 2.0 2.0
c 3.0 3.0
d 3.0 4.0
e 3.0 5.0
f 3.0 6.0
g 7.0 7.0
Dans l’exemple précédent, on voit que dans la colonne Series1, la valeur de 3 a été propagée jusqu’à la ligne F, dernière ligne avec une valeur manquante.
Enfin, dans le cas de valeurs manquantes, vous pouvez également faire le choix de supprimer les observations qui en comportent avec la méthode dropna.
print(df.dropna())
Out:
Series1 Series2
a 1.0 1.0
b 2.0 2.0
c 3.0 3.0
g 7.0 7.0
Conversion des données
Suivant la qualité des données dont vous disposez, il se peut que le type associé à une donnée ne soit pas le bon lors de l’import de celle-ci. Vous devrez alors vous assurer que celui-ci soit exploitable au risque de rencontrer des erreurs si vous effectuez des opérations mathématiques sur des chaînes de caractères par exemple. Pour réaliser cette opération, vous avez à disposition la méthode astype pour changer le type d’une colonne de votre DataFrame.
df = pd.DataFrame({'Animal': ['Faucon', 'Faucon', 'Perroquet', 'Perroquet'],
'Vitesse max': ['380.', '370.', '24.', '26.']})
print(df.dtypes)
Out:
Animal object
Vitesse max object
dtype: object
df['Vitesse max'] = df['Vitesse max'].astype('float64')
print(df.dtypes)
print(df["Vitesse max"].mean())
Out:
Animal object
Vitesse max float64
dtype: object
200.0
Si vous aviez calculé la moyenne sur la vitesse maximale avant d’avoir changé le type de données, vous auriez eu une erreur.
Grouper les données
Nous allons voir dans cette section un exemple d’utilisation de la méthode groupby. Elle permet de réaliser un traitement sur les données et de les regrouper suivant un critère. Voici un exemple.
df = pd.DataFrame({'Animal': ['Faucon', 'Faucon', 'Perroquet', 'Perroquet'],
'Vitesse max': [380., 370., 24., 26.]})
print(df)
print(df.groupby(['Animal']).mean(numeric_only=True))
Out:
Animal Vitesse max
0 Faucon 380.0
1 Faucon 370.0
2 Perroquet 24.0
3 Perroquet 26.0
Vitesse max
Animal
Faucon 375.0
Perroquet 25.0
La base de données contient dans la première colonne l’espèce de l’animal et dans la seconde la vitesse maximale observée pour l’espèce associée. On souhaite alors regrouper ls données par espèce avec la moyenne. En une ligne de code, on obtient alors la moyenne de la caractéristique en fonction d’une catégorie donnée.
Opération sur les Dataframes avec Pandas
Dans ce guide de démarrage avec la librairie Pandas en Python, nous avons vu comment créer des DataFrames et comment les analyser. L’étape suivante consiste à réaliser des opérations sur les données.
Nous avons vu dans les exemples précédents des opérations élémentaires comme une addition. En plus de cela, vous pouvez appliquer à un DataFrame une fonction provenant de la libraire Numpy. Le résultat sera alors un DataFrame avec le résultat de l’opération tout en conservant les index.
df = pd.DataFrame({"A": [1, 2, 3, 4, 5],
"B": [-1., -0.5, 0., 0.5, 1.],
"C": [0, 1, 1, 2, 3]
})
print(df)
print(np.exp(df["A"]))
print(np.sin(df["B"]*np.pi))
print(df**2)
Out:
A B C
0 1 -1.0 0
1 2 -0.5 1
2 3 0.0 1
3 4 0.5 2
4 5 1.0 3
0 2.718282
1 7.389056
2 20.085537
3 54.598150
4 148.413159
Name: A, dtype: float64
0 -1.224647e-16
1 -1.000000e+00
2 0.000000e+00
3 1.000000e+00
4 1.224647e-16
Name: B, dtype: float64
A B C
0 1 1.00 0
1 4 0.25 1
2 9 0.00 1
3 16 0.25 4
4 25 1.00 9
Ensuite, voici quelques exemples pour tirer quelques données statistiques de vos données.
print(df)
Out:
A B C
0 1 -1.0 0
1 2 -0.5 1
2 3 0.0 1
3 4 0.5 2
4 5 1.0 3
print(df.mean())
Out:
A 3.0
B 0.0
C 1.4
dtype: float64
print(df.mean(1)) # other axis
Out:
0 0.000000
1 0.833333
2 1.333333
3 2.166667
4 3.000000
dtype: float64
print(df.sum())
Out:
A 15.0
B 0.0
C 7.0
dtype: float64
print(df.count())
Out:
A 5
B 5
C 5
dtype: int64
print(df.min())
Out:
A 1.0
B -1.0
C 0.0
dtype: float64
print(df.max())
A 5.0
B 1.0
C 3.0
dtype: float64
print(df.median())
Out:
A 3.0
B 0.0
C 1.0
dtype: float64
print(df.std())
Out:
A 1.581139
B 0.790569
C 1.140175
dtype: float64
print(df.var())
Out:
A 2.500
B 0.625
C 1.300
dtype: float64
Ces exemples sont des calculs simples mais qui renvoient des données qui pourront être très utiles pour vos traitements statistiques. Pour aller plus loin, je vous conseille aussi de regarder la méthode apply. Elle vous permet d’appliquer une fonction que vous aurez défini suivant un axe choisi par vos soins (en line ou colonne). Voici un exemple très simple issu de la documentation pour illustrer mes propos.
df = pd.DataFrame([[4, 9]] * 3, columns=['A', 'B'])
print(df.apply(np.sqrt))
Out:
A B
0 2.0 3.0
1 2.0 3.0
2 2.0 3.0
Ligne par ligne, la fonction racine carrée sera appliquée aux éléments du DataFrame. Voici le lien vers la documentation pour plus d’informations.
Conclusion
Ce guide de démarrage avec Pandas vous a familiarisé avec les bases de cette librairie puissante en Python pour la manipulation de données. Vous avez appris comment charger des données, créer et manipuler des DataFrames, ainsi que réaliser des opérations courantes sur les données. Pandas offre encore de nombreuses autres fonctionnalités que vous pourrez explorer pour des projets de traitement de données plus avancés. N’hésitez pas à consulter la documentation officielle de Pandas pour en savoir plus, voici le lien. Pour terminer sur ce guide de démarrage sur la librairie Pandas en Python, il faut savoir que les DataFrames sont également très utilisés dans le domaine de l’apprentissage machine (Machine Learning). Si vous souhaitez approfondir le sujet, j’en parle dans cet article.
Et surtout, n’ayez pas peur d’explorer la documentation et réaliser vos premiers essais avec cette librairie. Vous découvrirez plein de fonctionnalités différentes. Pour finir, vous verrez que la manipulation des données n’a jamais été aussi facile. Merci de m’avoir lu, n’hésitez pas à laisser un commentaire, j’y répondrai avec plaisir.
Bonjour ! 🙂
Je n’y connais rien en Python, mais je commence à m’intéresser à l’automatisation.
En particulier pour la création de posts pour les réseaux sociaux.
J’ai réussi une partie, mais l’autre ne marche pas comme je veux.
J’en parle d’ailleurs dans l’article que je viens de publier.
Il y a un mooc qui commence à la fin du mois. Je me suis inscrite.
Merci pour cet article, je vais d’ailleurs reprendre le thème depuis le début, je débute en python. Je suis un grand novice dans ce language encore.
Bonjour, merci pour le commentaire. N’hésite pas si besoin, ce sera avec plaisir si je peux t’aider