Loading and Inspecting CSV Data with Pandas

1. Charger des données avec pd.read_csv()

Créer des DataFrames manuellement est utile pour des tests, mais en pratique, vos données se trouveront presque toujours dans des fichiers. Le format le plus répandu pour les données tabulaires est le CSV (Comma-Separated Values). Il s'agit simplement d'un fichier texte où chaque ligne représente une rangée de données, et les valeurs dans cette rangée sont séparées par des virgules.

La fonction principale de Pandas pour lire ces fichiers est pd.read_csv(). C'est l'une des fonctions que vous utiliserez le plus souvent.

La vidéo suivante est une excellente introduction qui vous montrera comment charger un fichier CSV et ce qu'est un DataFrame.

Comme vous l'avez vu, la commande de base est très simple :

import pandas as pd




# 'df' est l'abréviation courante pour DataFrame
df = pd.read_csv('chemin/vers/votre/fichier.csv') 

Pandas prend le chemin du fichier en argument et s'occupe du reste.

Une des fonctionnalités très pratiques de pd.read_csv() est sa capacité à détecter automatiquement l'en-tête (la première ligne du fichier) et à l'utiliser comme noms pour les colonnes du DataFrame.

Charger des données depuis une URL

Une autre capacité très puissante de pd.read_csv() est de pouvoir lire des données directement depuis une URL sur internet. C'est extrêmement pratique pour travailler avec des jeux de données publics hébergés en ligne, par exemple sur des plateformes comme GitHub.

La vidéo suivante montre très clairement comment faire.

2. Inspecter le DataFrame : head() et info()

Une fois que vous avez chargé vos données, la première chose à faire est de les inspecter pour vous assurer que tout s'est bien passé et pour avoir un premier aperçu de leur contenu. Charger un jeu de données qui contient des millions de lignes et essayer de l'afficher en entier dans votre notebook n'est ni pratique ni utile. Pandas fournit des méthodes simples et efficaces pour cette inspection initiale.

head() et tail() : un premier regard

Les méthodes .head() et .tail() sont vos meilleurs alliées pour jeter un œil rapide à vos données.

• df.head() affiche les 5 premières lignes de votre DataFrame par défaut.
• df.tail() affiche les 5 dernières lignes.

Vous pouvez passer un nombre en argument (par exemple, df.head(10)) pour afficher un nombre de lignes différent.

L'article suivant vous présente ces commandes de base.

info() : le résumé technique

Après avoir eu un aperçu visuel avec .head(), la méthode .info() vous donne un résumé technique essentiel de votre DataFrame. C'est un réflexe que vous devez acquérir après chaque chargement de données.

df.info() vous renseigne sur :

1. Le nombre total de lignes (entrées).
2. Le nombre total de colonnes.
3. La liste de chaque colonne, avec son nom.
4. Le nombre de valeurs non nulles pour chaque colonne. C'est un indicateur crucial pour repérer d'éventuelles données manquantes.
5. Le type de données (Dtype) de chaque colonne (par exemple, int64 pour les entiers, float64 pour les nombres à virgule, object pour le texte).
6. La quantité de mémoire utilisée par le DataFrame.

Voici un exemple plus détaillé de la sortie de .info() et comment l'interpréter.

Exercice pratique

Mettons cela en pratique. Le jeu de données "Iris" est un classique en machine learning. Il est hébergé publiquement et peut être chargé directement via une URL.

Votre tâche :

1. Importez la bibliothèque Pandas.
2. Chargez le jeu de données Iris dans un DataFrame nommé df_iris à partir de cette URL : https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data.
3. Comme ce fichier n'a pas de ligne d'en-tête, vous devrez nommer les colonnes vous-même lors du chargement. Utilisez le paramètre names de pd.read_csv() avec la liste suivante : ['sepal_length', 'sepal_width', 'petal_length', 'petal_width', 'class'].
4. Affichez les 7 premières lignes du DataFrame.
5. Affichez le résumé technique du DataFrame.

Solution

# 1. Importer pandas
import pandas as pd




# 2. Définir l'URL et les noms des colonnes
url = "https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data"
column_names = ['sepal_length', 'sepal_width', 'petal_length', 'petal_width', 'class']




# 3. Charger les données dans un DataFrame en spécifiant les noms de colonnes
df_iris = pd.read_csv(url, names=column_names)




# 4. Afficher les 7 premières lignes
print("Les 7 premières lignes du DataFrame Iris :")
print(df_iris.head(7))

print("\n" + "="*50 + "\n") # Ligne de séparation




# 5. Afficher le résumé technique
print("Résumé technique du DataFrame Iris :")
df_iris.info()

Résultat attendu :

Les 7 premières lignes du DataFrame Iris :
   sepal_length  sepal_width  petal_length  petal_width        class
0           5.1          3.5           1.4          0.2  Iris-setosa
1           4.9          3.0           1.4          0.2  Iris-setosa
2           4.7          3.2           1.3          0.2  Iris-setosa
3           4.6          3.1           1.5          0.2  Iris-setosa
4           5.0          3.6           1.4          0.2  Iris-setosa
5           5.4          3.9           1.7          0.4  Iris-setosa
6           4.6          3.4           1.4          0.3  Iris-setosa

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

Résumé technique du DataFrame Iris :
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 150 entries, 0 to 149
Data columns (total 5 columns):



 #   Column        Non-Null Count  Dtype  
---  ------        --------------  -----  
 0   sepal_length  150 non-null    float64
 1   sepal_width   150 non-null    float64
 2   petal_length  150 non-null    float64
 3   petal_width   150 non-null    float64
 4   class         150 non-null    object 
dtypes: float64(4), object(1)
memory usage: 6.0+ KB

À partir de la sortie .info(), vous pouvez immédiatement conclure que le jeu de données contient 150 entrées, 5 colonnes, qu'il n'y a aucune valeur manquante (150 non-null partout), et que les quatre premières colonnes sont numériques (float64) tandis que la dernière est du texte (object).

Conclusion

Félicitations ! Vous maîtrisez maintenant l'une des compétences les plus fondamentales en analyse de données avec Python. Savoir charger des données et les inspecter rapidement est le point de départ de tout projet.

Les points clés à retenir de cette leçon sont :

• La fonction pd.read_csv() est l'outil principal pour charger des données tabulaires depuis des fichiers locaux ou des URL.
• df.head() vous permet de jeter un premier coup d'œil aux premières lignes de vos données.
• df.info() est une commande essentielle qui fournit un résumé technique complet de votre DataFrame : dimensions, types de données et valeurs manquantes.

Maintenant que nous savons comment importer et inspecter un jeu de données, l'étape suivante consiste à apprendre à extraire les informations qui nous intéressent. Dans la prochaine leçon, nous verrons comment sélectionner des lignes et des colonnes spécifiques de votre DataFrame en utilisant les puissants indexeurs .loc et .iloc.