Manipulez vos données en Python avec Pandas

Rédaction AZYAT Abdelilah,  23/01/2023 (Partie 1)

statistic, analytic, diagram-1564428.jpg
Pandas Python avec des exemples

Pandas est l’un des packages Python de science des données les plus populaires et il est l’outil standard pour travailler avec des données tabulaires.

C’est un package dédié pour la manipulation et l’analyse exploratoire de données. Plus de 100 millions de téléchargements par mois. 

Les fonctions de manipulation de données facilitant l’accessibilité pour agréger, analyser et nettoyer des données. 

C’est pour cela il est utilisé dans plusieurs domaines dont on peut citer : le marketing, finance, commercial, universitaire, économie, statistiques, publicité, analyse Web, neurosciences…

Sommaire

  • Pourquoi utiliser Pandas Python ?
  • Installation de Pandas
  • Structures de données avec Pandas
    • Series
      • Création d’un objet Series grâce à un dictionnaire
      • Création d’un objet Series grâce à un ndarray
      • Accéder aux données d’une série,

    • Dataframe

      • Création d’une Dataframe à partir d’un dictionnaire de séries

      • Accéder aux données dans un objet Dataframe

  • Travailler avec des fichiers (cas de type csv)

  • Visualiser des données avec Matplotlib+Pandas

Pandas permet de manipuler les données en format tabulaire. C’est-à-dire des données sous forme de lignes et de colonnes, également appelées DataFrames. Intuitivement, vous pouvez considérer un DataFrame comme une feuille Excel. 

Parmi les fonctionnalités de Pandas inclut des transformations de données, comme le tri des lignes et la prise de sous-ensembles, pour calculer des statistiques récapitulatives telles que la moyenne, remodeler les DataFrames et joindre les DataFrames ensemble. Il fonctionne bien avec d’autres packages de science des données Python populaires, souvent appelés l’écosystème PyData, y compris ;

Pourquoi utiliser Pandas ?

Il peut être utilisé pour :

  • Importer des données à partir de bases de données, de feuilles de calcul, de fichiers pour lire et écrire dans différents formats (.csv, .txt, .xlsx, .sql, .hdf5, etc…) ;
  • Structurer des donnée sous forme des Dataframes permettant un accès rapide et efficace pour la manipulation des données avec indexation intégrée ;
  • Comprendre les techniques par une documentation très détaillée et facile à lire ;
  • Nettoyer les données, par exemple, en traitant les valeurs manquantes.
  • Ranger les données en remodelant leur structure dans un format approprié pour l’analyse.
  • Agréger les données en calculant des valeurs statistiques telles que la moyenne des colonnes, la corrélation entre elles, etc.
  • Gagner une flexibilité pour traiter des données de type hétérogènes ou manquantes ;
  • Visualiser des données et découvrir des informations pertinentes.

D’autre part, Pandas contient également des fonctionnalités d’analyse de séries chronologiques et d’analyse de données textuelles.

Apprendre Python
Listes
Tuples, Set, Dictionnaires

Comment installer Pandas ?

L’installation de pandas est simple ; utilisez simplement la pip install commande dans votre terminal. 

pip install pandas

Importer des données avec pandas :

Pour commencer à travailler avec pandas, importez le package pandas Python comme indiqué ci-dessous. Lors de l’importation de pandas, l’alias le plus courant pour les pandas est pd.

import pandas as pd

Structures de données avec Pandas

Les Series et les Dataframe sont deux structures de données fournit par Pandas pour manipuler les données.

Les series

Une série est un tableau étiqueté unidimensionnel pouvant contenir tout type de données (entiers, chaînes de caractères, nombres à virgule flottante, listes, dictionnaires, tuples, objets, etc.). Les étiquettes des axes représentent l’index de la série. Pour être plus simple, une série n’est rien d’autre qu’une colonne dans une feuille Excel. La méthode de base pour créer une série est la suivante :

serie = pd.Series(data,  index=index1, index2,…)

L’argument data peut être un dictionnaire, un ndarray (tableau multi-dimensionnel de NumPy) ou même une valeur scalaire.

Exemple  1 :

import pandas as pd

# création d’un dictionnaire
note_matiere = {
    « Electronique »:10, « math »:12, « programmation »:17
}
print(note_matiere)
# création de Series avec dictionnaire
serie = pd.Series(note_matiere)
print(serie)
print(« les indices: », serie.index) # affiche les index de serie
print(« serie.array: », serie.array,« \n« ) # afficher les valeurs de la serie
print(« Bonne note est: {} ».format(serie[« programmation »]))
x=« gestion »in serie # tester si gestion existe dans serie
print(x)

Le résultat de ce code est le suivant :

{‘Electronique’: 10, ‘math’: 12, ‘programmation’: 17}

Electronique     10

math             12

programmation    17

dtype: int64

les indices: Index([‘Electronique’, ‘math’, ‘programmation’], dtype=’object’)

serie.array: <PandasArray>

[10, 12, 17]

Length: 3, dtype: int64

Bonne note est: 17

False

Remarque :

Avec un dictionnaire, une série peut avoir un index de taille différente de la taille du dictionnaire.

Exemple 2 : 

# Exemple d’une serie ayant index de taille différente à celle du dictionnaire

note_matiere = {« Electronique »:10, « Math »:12, « Programmation »:17}
serie = pd.Series(note_matiere, index=[« Electronique », « Math », « Algorithméque », « Anglais » ])
print(serie)

 

Résultat :

Electronique     10.0

Math             12.0

Algorithméque     NaN

Anglais           NaN

Création d’un objet Series grâce à un ndarray

Dans le cas où la data est de type ndarray, l’index passé en paramètre doit être de la même longueur que data. Si aucun index n’est spécifié, un index sera créé avec les valeurs [0, …, len(data) – 1].

Exemple 3 : création d’un objet Series représentant le nombre d’habitants de trois provinces comme index:

# Exemple : serie avec ndarray
import numpy as np

serie1= pd.Series(np.array([43328, 62049, 58720]), index=[« Al Hoceima « , ‘Chefchaouen’, « Larache « ])
print(« serie1=\n« ,serie1)

Vous allez obtenir le résultat suivant en exécutant le code ci-dessus :

serie1=

 Al Hoceima     43328

Chefchaouen    62049

Larache        58720

Accéder aux données d’une série

Avec Pandas, il y a trois méthodes d’accès pour sélectionner les données d’un objet Series:

  • L’opérateur d’indexation [ ] ;
  • Les méthodes .loc() et .iloc() ;

Il faut savoir qu’une série possède deux indices :

  •  Un index positionnel ou implicite,
  •  Un index explicite,

Nous pouvons accéder aux valeurs d’un objet Series à l’aide des étiquettes et des indices de position. Reprenant l’exemple 2 :

print(serie[« Electronique »])  # accéder à la valeur de la clé     Electronique dans serie
print(serie[2])  # afficher la valeur ayant index 2

Vous obtiendrez le résultat suivant :

10

17

D’ailleurs, nous pouvons utiliser des indices négatifs et des tranches, comme pour une liste :

print(« // »*22)
print(serie[« Electronique »])  # accéder à la valeur de la clé Electronique dans serie
print(serie[2])  # afficher la valeur ayant index 2
print(serie[2:])
print(serie[-3])
print(« // »*22)
print(serie[:])

Utilisation des méthodes .loc() et .iloc()

Pandas fournit deux méthodes d’accès aux données :

  • loc() fait référence à l’étiquette.
  • iloc() fait référence à l’indice de position.

Remarques :

    1. On peut utiliser .iloc() sur un objet Series de manière similaire à l’utilisation de l’opérateur d’indexation [] sur une liste.
    2. On peut utiliser .loc() sur une série comme nous le ferions avec l’opérateur d’indexation [] sur un dictionnaire.
    3. .iloc()exclut l’élément de fermeture, mais .loc() l’inclut.

Dataframe

La Dataframe est une structure de données la plus puissante en Pandas qui organise des données en lignes et en colonnes. Autrement dit, c’est une structure de données bidimensionnelle (2D).

Il s’agit d’une sorte d’une feuille de calcul, ou bien un dictionnaire d’objets Series.

Généralement, Dataframe est l’objet le plus utilisé. Il peut être construit à partir de types variés :

  • Un numpy.ndarray (2D) ;
  • Un dictionnaire de ndarrays 1D, listes, dicts, ou Series ;
  • Une série ;
  • Un autre Dataframe.

 

Les avantages de Dataframe:

  • Exploiter des données provenant de différentes sources de et de différents formats de données ;
  • Réaliser des statistiques en réalisant des opérations sur les données, telles que : calcul de la moyenne, la médiane, le maximum ou le minimum de chaque ou de plusieurs colonnes.  Chercher s’il y a une corrélation entre les colonne X et Y. Voir la distribution des données de la colonne Z;
  • Nettoyer les données en supprimant les valeurs manquantes et en filtrant les lignes ou les colonnes selon certains critères
  • Visualiser les données à l’aide de Matplotlib ; tout en tracçant  des graphiques sous plusieurs formes: des barres, des lignes, des histogrammes, des bulles, etc. ;
  • Persister les données nettoyées et traitées dans des fichiers tels que: CSV, Excel, JSON, TXT, ou une même dans une base de données.

Par la méthode suivante on peut créer une Dataframe   :

df= pd.Dataframe(data,  index=index, columns=columns)

  • L’argument index représente l’ensemble des étiquettes de lignes,
  • L’argument columns désigne l’ensemble des étiquettes de colonnes.

Reprenons l’exemple 2; création d’un dataframe à partir d’un dictionnaire de deux series

note_examen= {
    « Electronique »: pd.Series([2, 11, 13, 17], index=[« Said », « Karim », « Jalal », « Sahar »]),
    « Math »: pd.Series([11, 15, 7, 10], index=[« Said », « Karim », « Jalal », « Sahar »])
    }
df = pd.DataFrame(note_examen)
print(df)

Le résultat retourné est un tableau :

Electronique  Math

Said                       2           11

Karim                   11         15

Jalal                     13           7

Sahar                   17          10

Les étiquettes (labels) des colonnes et des lignes sont accessibles via les attributs « columns » et « index » respectivement de la manière suivante :

note_exam= {
    « Electronique »: pd.Series([2, 11, 13, 17], index=[« Said », « Karim », « Jalal », « Sahar »]),
    « Math »: pd.Series([11, 15, 7, 10], index=[« Said », « Karim », « Jalal », « Sahar »])
    }
df = pd.DataFrame(note_exam)
print(df)
print(df.index)
print(df.columns)

 

Résultat:

============================================

       Electronique  Math

Said                       2    11

Karim                   11    15

Jalal                      13     7

Sahar                   17    10

Index([‘Said’, ‘Karim’, ‘Jalal’, ‘Sahar’], dtype=’object’)

Index([‘Electronique’, ‘Math’], dtype=’object’)

Création d’une Dataframe à partir d’un dictionnaire

On peut utiliser ndarray ou une liste. Les ndarrays doivent tous être de la même longueur. Si un index est déclaré, il doit aussi être de la même longueur que les tableaux. Si aucun index n’est pas déclaré, le résultat sera range(n), où n est la longueur du tableau.

Exemple 4:

region_popul={
            ‘Region’:[‘Oued EdDahab Lagouira’,‘Laayoune Boujdour Sakia ElHamra’,
                      ‘Guelmim Es Semara’,‘Souss Massa Draa’],
            ‘Population’ :[142955,301744,501921,3601917],
            ‘Ménages’:[29385,67140,98867,747476]
            }

# create a dataframe with a dict
df = pd.DataFrame(region_popul)
print(df)

Résultat de ce code :

                                                             Region                         Population      Ménages

0                              Oued EdDahab Lagouira                             142955           29385

1            Laayoune Boujdour Sakia ElHamra                            301744            67140

2                                          Guelmim Es Semara                         501921          98867

3                                          Souss Massa Draa                         3601917         747476

Accéder aux données d’un objet Dataframe

Puisque un Dataframe n’est qu’un ensemble d’objets Series, on peut utiliser les mêmes outils d’accès aux éléments d’un objet Series. La différence essentielle réside dans la dimension supplémentaire du Dataframe.

L’opérateur d’indexation peut être utilisé pour les colonnes et les méthodes d’accès .loc() et .iloc() pour les lignes.

Utilisation de l’opérateur d’indexation

Si on considère un Dataframe comme un dictionnaire dont les valeurs sont des séries, il est logique qu’on puisse accéder à ses colonnes avec l’opérateur d’indexation ou par attribut.

Si on reprend l’exemple 2 précédent:

print( » accés par attribut »,« == »*10)

print(df.Region)
print(« indexation par label: Population »,« ++ »*10)
print(df[« Population »])

On obtient:

# accéder à la colonne Population (indexation par label)

accés par attribut =======================================

0              Oued EdDahab Lagouira

1    Laayoune Boujdour Sakia ElHamra

2                  Guelmim Es Semara

3                   Souss Massa Draa

Name: Region, dtype: object

indexation par label: Population +++++++++++++++++++++++++++

0     142955

1     301744

2     501921

3    3601917

Name: Population, dtype: int64

Opérations statistiques sur un objet Dataframe

Pour faire une analyse statistique on peut effectuer des opérations statistiques sur les données qui sont structurée à l’aide d’un objet Dataframe, à savoir ; sum(), mean(), max(), median(), info()…

L’analyse statistique peut être utilisée pour réaliser les tâches suivantes:

  • Localiser des zones de pertinence, de cohérence, ou de diversité dans les données.
  • Elaborer des prédictions futures basées sur des données.
  • Chercher les informations clés d’un ensemble de données
  • Résumer les informations.

Reprenons l’exemple 4, et calculons la somme, la moyenne et le maximum:

# operations sur dataframe; sum, mean, max
print(« sum: », »== »*22)
print(df.sum())
print(« mean: », « == »*22)
print(df.mean())
print(« max: », »== »*22)
print(df.max())

On obtiendrait les résultats suivants :

sum: ============================================

Region        Oued EdDahab LagouiraLaayoune Boujdour Sakia E…

Population                                                                                   4548537

Ménages                                                                                      942868

dtype: object

mean: ============================================

Population         1137134.25

Ménages            235717.00

dtype:   float64

max: ============================================

Region        Souss Massa Draa

Population             3601917

Ménages                 747476

dtype: object

Utiliser des méthodes head() et tail() :
  • On peut afficher les premiers ou les dernières lignes d’une dataframe en utilisant les méthodes « head() » et « tail()»
  • Dans l’exemple 4, on veut récupérer les deux premières lignes et la dernière seulemnt ;

print(df.head(2))
print(« tail: »,« == »*22)
print(df.tail(1))

 

                                             Region                 Population         Ménages

0            Oued EdDahab Lagouira              142955                   29385

1  Laayoune Boujdour Sakia ElHamra      301744               67140

tail: ============================================

                        Region                  Population                 Ménages

3  Souss Massa Draa                    3601917              747476

 

Travailler avec des fichiers (cas de type csv) :

  • Pandas permet de manipuler des données via des fichiers en écrire et en lecture, comme par exemple, Excel, CSV et de nombreux autres types de fichiers.
  • Des fonctions telles que la méthode read_csv() qui permette d’opérer avec des fichiers. Nous pouvons l’utiliser pour charger des données dans les instances de type Series ou DataFrame.
  • Dans cette section nous verrons comment exploiter un fichier csv.
Utiliser un fichier csv avec Pandas
  • Le format CSV (Comma Separated Values) est très populaire pour le stockage des données.
  • Un grand nombre de stockage de données se présentent sous la forme de fichiers CSV qui peuvent être utilisés soit directement dans un tableur comme Excel, soit chargés dans des langages de programmation comme R ou Python.
  • Les dataframes de Pandas sont assez puissants pour traiter des données tabulaires bidimensionnelles.
  • Pour lire un fichier csv avec Pandas, la fonction read_csv() peut être utilisée. Elle est fournie avec un certain nombre de paramètres différents. Voici la syntaxe générale pour charger un fichier csv dans un dataframe :
import pandas as pd
df = pd.read_csv(path_to_file)
  • L’argument « path_to_file » précise le chemin d’accès au fichier CSV qu’on veut ouvrir. Il peut s’agir de n’importe quel chemin de chaîne valide ou d’une URL. Elle renvoie un objet dataframe.
  • Dans l’exemple suivant, on veut ouvrir un fichier csv contenant des données sur les effectives d’élèves de provinces de la région Tanger-Tétouan-Alhoceima, Maroc. Chaque ligne contient les noms relatives aux provinces, et les colonnes représentent les effectives inscris.

df_regions= pd.read_csv(« population_regions.csv », sep=« ; »,encoding=« ISO-8859-1 »)
print(df_regions)