Créer des DataFrames
Construisez des DataFrames à partir de dictionnaires de listes, de listes de dictionnaires et de tableaux NumPy, puis examinez leur forme, leurs colonnes et leurs types de données.
Créer des DataFrames est une leçon Pandas & NumPy Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Pandas & NumPy Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Pandas & NumPy Academy comprend 4 leçons au total.
Qu’est-ce qu’un DataFrame ?
Un DataFrame est une structure de données bidimensionnelle, de taille modifiable et étiquetée : il s’agit essentiellement d’un tableau composé de lignes et de colonnes, comparable à une feuille de calcul ou à une table SQL. Chaque colonne est une Series Pandas partageant le même index de lignes. Les DataFrames peuvent contenir des colonnes de types différents, ce qui les rend parfaits pour les jeux de données réels mélangeant nombres, texte et dates.
import pandas as pd
df = pd.DataFrame({'name': ['Alice', 'Bob', 'Carol'],
'age': [30, 25, 35],
'score': [88.5, 72.0, 95.3]})
print(df)Créer un DataFrame à partir d’un dictionnaire de listes
La manière la plus courante de construire un DataFrame consiste à utiliser un dictionnaire de listes : les clés deviennent les noms des colonnes et les listes deviennent leurs valeurs. Toutes les listes doivent avoir la même longueur. Par défaut, l’index des lignes est 0, 1, 2, ... sauf si vous en indiquez un avec index=. Ce modèle correspond à la façon dont les données CSV sont souvent représentées en Python.
import pandas as pd
df = pd.DataFrame({
'city': ['Berlin', 'Paris', 'Rome'],
'pop': [3.6, 2.2, 2.8],
'country': ['DE', 'FR', 'IT']
})
print(df.shape) # (3, 3)
print(df.dtypes)Créer un DataFrame à partir d’une liste de dictionnaires
Vous pouvez également transmettre une liste de dictionnaires, chaque dictionnaire représentant une ligne. Les clés absentes d’un dictionnaire produisent NaN dans la colonne correspondante. Ce format est courant lors de la consommation d’API JSON qui renvoient une liste d’objets représentant des enregistrements. Pandas aligne automatiquement toutes les clés des dictionnaires pour former l’ensemble des colonnes.
import pandas as pd
rows = [
{'name': 'Alice', 'age': 30, 'dept': 'Eng'},
{'name': 'Bob', 'age': 25}, # 'dept' missing -> NaN
{'name': 'Carol', 'age': 35, 'dept': 'HR'}
]
df = pd.DataFrame(rows)
print(df)Créer un DataFrame à partir d’un tableau NumPy
La transmission d’un tableau NumPy à deux dimensions crée un DataFrame dont les noms de colonnes sont des entiers (0, 1, 2, ...) et dont l’index est par défaut un RangeIndex. Fournissez columns= et index= pour ajouter des étiquettes explicites. C’est le lien entre le calcul numérique avec NumPy et l’analyse de données étiquetées avec Pandas.
import pandas as pd
import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
df = pd.DataFrame(arr,
columns=['x', 'y', 'z'],
index=['r1', 'r2', 'r3'])
print(df)Définir un index personnalisé lors de la création
Le paramètre index= définit les étiquettes des lignes lors de la création. Les choix courants incluent des chaînes représentant des dates, des identifiants ou des noms de catégories qui rendent la recherche de lignes pertinente. Un index bien choisi rend l’accès avec .loc intuitif et permet de puissantes opérations sur les séries temporelles lorsqu’il s’agit d’un DatetimeIndex.
import pandas as pd
df = pd.DataFrame(
{'revenue': [100, 200, 150], 'costs': [80, 160, 90]},
index=['Jan', 'Feb', 'Mar']
)
print(df)
print(df.loc['Feb']) # select row 'Feb'Inspecter les colonnes, les types et l’index
Trois attributs vous renseignent immédiatement sur la structure d’un DataFrame : df.columns fournit un Index contenant les noms de colonnes, df.dtypes renvoie une Series associant chaque colonne à son type, et df.index décrit les étiquettes des lignes. Ce sont les premières vérifications à effectuer sur tout nouveau DataFrame afin de comprendre les données dont vous disposez avant de les transformer.
import pandas as pd
df = pd.DataFrame({'a': [1, 2], 'b': [3.0, 4.0], 'c': ['x', 'y']})
print(df.columns) # Index(['a', 'b', 'c'], dtype='object')
print(df.dtypes)
# a int64
# b float64
# c object
print(df.index) # RangeIndex(start=0, stop=2, step=1)Spécifier l’ordre des colonnes
Lors de la construction à partir d’un dictionnaire, l’ordre des colonnes suit l’ordre d’insertion du dictionnaire (Python 3.7 et versions ultérieures). Si vous avez besoin d’un ordre précis, transmettez le paramètre columns= avec une liste de noms de colonnes. Tout nom absent des données produira une colonne NaN ; tout nom présent dans les données mais absent de la liste sera exclu. Vous pouvez ainsi sélectionner et ordonner les colonnes lors de la construction.
import pandas as pd
data = {'c': [3, 6], 'a': [1, 4], 'b': [2, 5]}
df = pd.DataFrame(data, columns=['a', 'b', 'c'])
print(df.columns.tolist()) # ['a', 'b', 'c']Créer un DataFrame à partir d’un dictionnaire de Series
La transmission d’un dictionnaire de Series Pandas aligne les données sur l’union de tous les index. Lorsqu’une Series ne possède pas une étiquette présente dans une autre, la cellule correspondante du résultat contient NaN. Il s’agit de la méthode de construction la plus attentive aux index ; elle est utilisée pour combiner des colonnes calculées séparément qui peuvent avoir un nombre de lignes ou des étiquettes différents.
import pandas as pd
s1 = pd.Series([1, 2, 3], index=['a', 'b', 'c'])
s2 = pd.Series([10, 20], index=['b', 'c'])
df = pd.DataFrame({'col1': s1, 'col2': s2})
print(df)
# col1 col2
# a 1.0 NaN
# b 2.0 10.0
# c 3.0 20.0shape, len et size
df.shape renvoie un tuple (nrows, ncols). len(df) renvoie le nombre de lignes. df.size renvoie le nombre total de cellules (lignes × colonnes). Ce sont les vérifications de cohérence les plus rapides après le chargement des données, pour confirmer que vous avez reçu le nombre d’enregistrements attendu et qu’aucune colonne n’a été supprimée silencieusement.
import pandas as pd
df = pd.DataFrame({'a': range(5), 'b': range(5), 'c': range(5)})
print(df.shape) # (5, 3)
print(len(df)) # 5
print(df.size) # 15 (5 rows x 3 cols)Créer un DataFrame vide
Vous pouvez créer un DataFrame vide avec des noms de colonnes et des types précis afin de l’utiliser comme modèle ou accumulateur. Ajoutez des lignes avec pd.concat([df, new_row])m. La spécification des types lors de la création évite une inférence coûteuse lorsque des lignes sont ajoutées ultérieurement. Un DataFrame vide est également utile comme point de départ dans des boucles de collecte de données itératives.
import pandas as pd
df = pd.DataFrame(columns=['name', 'score'])
new_row = pd.DataFrame([{'name': 'Alice', 'score': 90}])
df = pd.concat([df, new_row], ignore_index=True)
print(df)Copier un DataFrame
Affecter un DataFrame à une nouvelle variable crée une référence, et non une copie : toute modification de l’un modifie l’autre. Utilisez df.copy() pour créer une copie indépendante. Cette précaution est importante avant d’effectuer des transformations que vous ne souhaitez pas appliquer à l’original, ou lorsque vous voulez conserver une sauvegarde avant nettoyage tout en construisant une version nettoyée.
import pandas as pd
original = pd.DataFrame({'a': [1, 2, 3]})
ref = original # same object!
copy = original.copy() # independent copy
ref['a'] = 99
print(original['a'].tolist()) # [99 99 99] -- ref modified original
print(copy['a'].tolist()) # [1, 2, 3] -- copy unchangedVérification rapide
Vérifiez votre compréhension de la création des DataFrames présentée dans cette leçon.
Récapitulatif de la leçon
Dans cette leçon, vous avez appris que les DataFrames peuvent être créés à partir de dictionnaires de listes, de listes de dictionnaires ou de tableaux NumPy, que les attributs columns, dtypes et index décrivent la structure du tableau et que df.copy() est nécessaire pour obtenir une copie indépendante plutôt qu’une référence. Nous allons maintenant sélectionner des colonnes et des lignes précises avec la notation entre crochets, .loc et .iloc.
Questions Fréquemment Posées
La leçon « Créer des DataFrames » est-elle gratuite ?
Oui — le texte complet de « Créer des DataFrames » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Pandas & NumPy Academy, passe à CoddyKit PRO. Le cours Pandas & NumPy Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Créer des DataFrames » ?
Construisez des DataFrames à partir de dictionnaires de listes, de listes de dictionnaires et de tableaux NumPy, puis examinez leur forme, leurs colonnes et leurs types de données. Tu pratiques Pandas & NumPy Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Pandas & NumPy Academy ?
Aucune expérience préalable n'est requise. Pandas & NumPy Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.
Combien de temps prend la leçon « Créer des DataFrames » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Pandas & NumPy Academy ?
Oui. Chaque leçon Pandas & NumPy Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Créer des DataFrames
- Sélectionner des colonnes et des lignes
- Ajouter et supprimer des colonnes
- Inspection de base des DataFrames