Rendre le travail avec les données agréable – Real Python

By | avril 22, 2020

Expert Python

le Pandas DataFrame est une structure qui contient données bidimensionnelles et son correspondant Étiquettes. Les DataFrames sont largement utilisés dans la science des données, l'apprentissage automatique, le calcul scientifique et de nombreux autres domaines gourmands en données.

Les DataFrames sont similaires aux tables SQL ou aux feuilles de calcul avec lesquelles vous travaillez dans Excel ou Calc. Dans de nombreux cas, les DataFrames sont plus rapides, plus faciles à utiliser et plus puissants que les tableaux ou les feuilles de calcul car ils font partie intégrante des écosystèmes Python et NumPy.

Dans ce didacticiel, vous apprendrez:

  • Quel Pandas DataFrame est et comment en créer un
  • Comment accéder, modifier, ajouter, trier, filtrer et supprimer Les données
  • Comment gérer valeurs manquantes
  • Comment travailler avec Données de séries chronologiques
  • Comment rapidement visualiser Les données

Il est temps de commencer avec Pandas DataFrames!

Présentation du Pandas DataFrame

Les Pandas DataFrames sont des structures de données qui contiennent:

  • Les données organisé en deux dimensions, lignes et colonnes
  • Étiquettes qui correspondent à la Lignes et Colonnes

Vous pouvez commencer à travailler avec DataFrames en important des pandas:

>>>

>>> importation pandas comme pd

Maintenant que vous avez importé des Pandas, vous pouvez travailler avec DataFrames.

Imaginez que vous utilisez Pandas pour analyser les données sur les candidats à un poste de développement d'applications Web avec Python. Supposons que vous vous intéressez aux noms, villes, âges et scores des candidats à un test de programmation Python, ou py-score:

Nom ville âge py-score
101 Xavier Mexico 41 88,0
102 Ann Toronto 28 79,0
103 Jana Prague 33 81,0
104 Yi Shanghai 34 80,0
105 Robin Manchester 38 68,0
106 Amal Caire 31 61,0
107 Nori Osaka 37 84,0

Dans ce tableau, la première ligne contient le étiquettes de colonne (Nom, ville, âge, et py-score). La première colonne contient le étiquettes de ligne (101, 102, etc). Toutes les autres cellules sont remplies du valeurs de données.

Vous avez maintenant tout ce dont vous avez besoin pour créer un Pandas DataFrame.

Il existe plusieurs façons de créer un Pandas DataFrame. Dans la plupart des cas, vous utiliserez le Trame de données constructeur et fournir les données, étiquettes et autres informations. Vous pouvez transmettre les données sous forme de liste bidimensionnelle, de tuple ou de tableau NumPy. Vous pouvez également le passer comme un dictionnaire ou Pandas Séries par exemple, ou comme l'un des autres types de données non couverts dans ce didacticiel.

Pour cet exemple, supposons que vous utilisez un dictionnaire pour transmettre les données:

>>>

>>> Les données = 
...     'Nom': [[[[«Xavier», «Ann», «Jana», «Yi», «Robin», «Amal», «Nori»],
...     'ville': [[[[«Mexico», «Toronto», «Prague», «Shanghai»,
...              'Manchester', 'Caire', «Osaka»],
...     'âge': [[[[41, 28, 33, 34, 38, 31, 37],
...     «py-score»: [[[[88,0, 79,0, 81,0, 80,0, 68,0, 61,0, 84,0]
... 

>>> row_labels = [[[[101, 102, 103, 104, 105, 106, 107]

Les données est une variable Python qui fait référence au dictionnaire qui contient vos données candidates. Il contient également les étiquettes des colonnes:

  • 'Nom'
  • 'ville'
  • 'âge'
  • «py-score»

Finalement, row_labels fait référence à une liste qui contient les étiquettes des lignes, qui sont des nombres allant de 101 à 107.

Vous êtes maintenant prêt à créer un Pandas DataFrame:

>>>

>>> df = pd.Trame de données(Les données=Les données, indice=row_labels)
>>> df
                            nom ville âge py-score
101 Xavier Mexico 41 88,0
102 Ann Toronto 28 79,0
103 Jana Prague 33 81,0
104 Yi Shanghai 34 80,0
105 Robin Manchester 38 68,0
106 Amal Le Caire 31 61,0
107 Nori Osaka 37 84,0

C'est ça! df est une variable qui contient la référence à votre Pandas DataFrame. Ce Pandas DataFrame ressemble à la table candidate ci-dessus et présente les fonctionnalités suivantes:

  • Étiquettes de ligne de 101 à 107
  • Étiquettes de colonne tel que 'Nom', 'ville', 'âge', et «py-score»
  • Les données tels que les noms des candidats, les villes, les âges et les résultats des tests Python

Cette figure montre les étiquettes et les données de df:

mmst-pandas-df-1

Les libellés de ligne sont soulignés en bleu, tandis que les libellés de colonne sont soulignés en rouge et les valeurs des données sont soulignées en violet.

Les DataFrames Pandas peuvent parfois être très volumineux, ce qui rend impossible la consultation de toutes les lignes à la fois. Vous pouvez utiliser .tête() pour montrer les premiers éléments et .queue() pour afficher les derniers éléments:

>>>

>>> df.tête(n=2)
                            nom ville âge py-score
101 Xavier Mexico 41 88,0
102 Ann Toronto 28 79,0

>>> df.queue(n=2)
                    nom ville âge py-score
106 Amal Le Caire 31 61,0
107 Nori Osaka 37 84,0

C’est ainsi que vous pouvez afficher uniquement le début ou la fin d’un Pandas DataFrame. Le paramètre n spécifie le nombre de lignes à afficher.

Vous pouvez accéder à une colonne dans un Pandas DataFrame de la même manière que vous obtiendrez une valeur à partir d'un dictionnaire:

>>>

>>> villes = df[[[['ville']
>>> villes
101 Mexico
102 Toronto
103 Prague
104 Shanghai
105 Manchester
106 Le Caire
107 Osaka
Nom: ville, dtype: objet

C'est le moyen le plus pratique pour obtenir une colonne d'un Pandas DataFrame.

Si le nom de la colonne est une chaîne qui est un identifiant Python valide, vous pouvez utiliser notation par points pour y accéder. Autrement dit, vous pouvez accéder à la colonne de la même manière que vous obtiendriez l'attribut d'une instance de classe:

>>>

>>> df.ville
101 Mexico
102 Toronto
103 Prague
104 Shanghai
105 Manchester
106 Le Caire
107 Osaka
Nom: ville, dtype: objet

C’est ainsi que vous obtenez une colonne particulière. Vous avez extrait la colonne qui correspond au libellé 'ville', qui contient les emplacements de tous vos candidats.

Il est important de noter que vous avez extrait à la fois les données et les étiquettes de ligne correspondantes:

mmst-pandas-df-2

Chaque colonne d'un Pandas DataFrame est une instance de pandas.Series, une structure qui contient des données unidimensionnelles et leurs étiquettes. Vous pouvez obtenir un seul élément d'un Séries objet comme vous le feriez avec un dictionnaire, en utilisant son étiquette comme clé:

>>>

>>> villes[[[[102]
«Toronto»

Dans ce cas, «Toronto» est la valeur des données et 102 est l'étiquette correspondante. Comme vous le verrez dans une section ultérieure, il existe d'autres façons d'obtenir un élément particulier dans un Pandas DataFrame.

Vous pouvez également accéder à une ligne entière avec l'accesseur .loc[]:

>>>

>>> df.loc[[[[103]
nom Jana
ville Prague
33 ans
py-score 81
Nom: 103, dtype: objet

Cette fois, vous avez extrait la ligne correspondant au libellé 103, qui contient les données du candidat nommé Jana. En plus des valeurs de données de cette ligne, vous avez extrait les étiquettes des colonnes correspondantes:

mmst-pandas-df-3

La ligne retournée est également une instance de pandas.Series.

Création d'un cadre de données Pandas

Comme déjà mentionné, il existe plusieurs façons de créer un Pandas DataFrame. Dans cette section, vous apprendrez à le faire en utilisant le Trame de données constructeur avec:

  • Dictionnaires Python
  • Listes Python
  • Tableaux NumPy bidimensionnels
  • Des dossiers

Il existe également d'autres méthodes, que vous pouvez découvrir dans la documentation officielle.

Vous pouvez commencer par importer des pandas avec NumPy, que vous utiliserez dans les exemples suivants:

>>>

>>> importation engourdi comme np
>>> importation pandas comme pd

C'est ça. Vous êtes maintenant prêt à créer des DataFrames.

Création d'un cadre de données Pandas avec des dictionnaires

Comme vous l'avez déjà vu, vous pouvez créer un Pandas DataFrame avec un dictionnaire Python:

>>>

>>>  = 'X': [[[[1, 2, 3], 'y': np.tableau([[[[2, 4, 8]), «z»: 100

>>> pd.Trame de données()
            x y z
0 1 2 100
1 2 4 100
2 3 8 100

Les clés du dictionnaire sont les étiquettes de colonne de DataFrame et les valeurs de dictionnaire sont les valeurs de données dans les colonnes DataFrame correspondantes. Les valeurs peuvent être contenues dans un tuple, une liste, un tableau NumPy unidimensionnel, Pandas Séries objet, ou l'un de plusieurs autres types de données. Vous pouvez également fournir une valeur unique qui sera copiée sur toute la colonne.

Il est possible de contrôler l'ordre des colonnes avec le Colonnes paramètre et les étiquettes de ligne avec indice:

>>>

>>> pd.Trame de données(, indice=[[[[100, 200, 300], Colonnes=[[[[«z», 'y', 'X'])
                            z y x
100 100 2 1
200 100 4 2
300 100 8 3

Comme vous pouvez le voir, vous avez spécifié les libellés des lignes 100, 200, et 300. Vous avez également forcé l'ordre des colonnes: z, y, X.

Création d'un cadre de données Pandas avec des listes

Une autre façon de créer un Pandas DataFrame est d'utiliser une liste de dictionnaires:

>>>

>>> l = [{[{[{['X': 1, 'y': 2, «z»: 100,
...      'X': 2, 'y': 4, «z»: 100,
...      'X': 3, 'y': 8, «z»: 100]

>>> pd.Trame de données(l)
            x y z
0 1 2 100
1 2 4 100
2 3 8 100

Encore une fois, les clés de dictionnaire sont les étiquettes de colonne et les valeurs de dictionnaire sont les valeurs de données dans le DataFrame.

Vous pouvez également utiliser un imbriqué liste, ou une liste de listes, comme valeurs de données. Si vous le faites, il est sage de spécifier explicitement les étiquettes des colonnes, des lignes ou des deux lorsque vous créez le DataFrame:

>>>

>>> l = [[[[[[[[1, 2, 100],
...      [[[[2, 4, 100],
...      [[[[3, 8, 100]]

>>> pd.Trame de données(l, Colonnes=[[[['X', 'y', «z»])
            x y z
0 1 2 100
1 2 4 100
2 3 8 100

C’est ainsi que vous pouvez utiliser une liste imbriquée pour créer un Pandas DataFrame. Vous pouvez également utiliser une liste de tuples de la même manière. Pour ce faire, remplacez simplement les listes imbriquées dans l'exemple ci-dessus par des tuples.

Création d'un DataFrame Pandas avec des tableaux NumPy

Vous pouvez passer un tableau NumPy bidimensionnel au Trame de données constructeur de la même manière que vous le faites avec une liste:

>>>

>>> arr = np.tableau([[[[[[[[1, 2, 100],
...                 [[[[2, 4, 100],
...                 [[[[3, 8, 100]])

>>> df_ = pd.Trame de données(arr, Colonnes=[[[['X', 'y', «z»])
>>> df_
            x y z
0 1 2 100
1 2 4 100
2 3 8 100

Bien que cet exemple ressemble presque à l'implémentation de la liste imbriquée ci-dessus, il présente un avantage: vous pouvez spécifier le paramètre facultatif copie.

Quand copie est réglé sur Faux (son paramètre par défaut), les données du tableau NumPy ne sont pas copiées. Cela signifie que les données d'origine de la baie sont affectées au Pandas DataFrame. Si vous modifiez le tableau, votre DataFrame changera également:

>>>

>>> arr[[[[0, 0] = 1000

>>> df_
                        x y z
0 1000 2 100
1 2 4 100
2 3 8 100

Comme vous pouvez le voir, lorsque vous modifiez le premier élément de arr, vous modifiez également df_.

Si ce comportement n'est pas celui que vous souhaitez, vous devez spécifier copy = True dans le Trame de données constructeur. De cette façon, df_ sera créé avec une copie des valeurs de arr au lieu des valeurs réelles.

Création d'un cadre de données Pandas à partir de fichiers

Vous pouvez enregistrer et charger les données et les étiquettes d'un Pandas DataFrame vers et à partir d'un certain nombre de types de fichiers, y compris CSV, Excel, SQL, JSON, etc. Il s'agit d'une fonctionnalité très puissante.

Vous pouvez enregistrer votre candidat à l'emploi DataFrame dans un fichier CSV avec .to_csv ():

>>>

>>> df.to_csv('data.csv')

L'instruction ci-dessus produira un fichier CSV appelé data.csv dans votre répertoire de travail:

, nom, ville, âge, py-score
101, Xavier, Mexico, 41,88,0
102, Ann, Toronto, 28,79.0
103, Jana, Prague, 33,81,0
104, Yi, Shanghai, 34,80.0
105, Robin, Manchester, 38,68,0
106, Amal, Le Caire, 31,61.0
107, Nori, Osaka, 37,84,0

Maintenant que vous avez un fichier CSV avec des données, vous pouvez le charger avec read_csv ():

>>>

>>> pd.read_csv('data.csv', index_col=0)
                            nom ville âge py-score
101 Xavier Mexico 41 88,0
102 Ann Toronto 28 79,0
103 Jana Prague 33 81,0
104 Yi Shanghai 34 80,0
105 Robin Manchester 38 68,0
106 Amal Le Caire 31 61,0
107 Nori Osaka 37 84,0

C’est ainsi que vous obtenez un Pandas DataFrame à partir d’un fichier. Dans ce cas, index_col = 0 spécifie que les étiquettes de ligne se trouvent dans la première colonne du fichier CSV.

Récupération des étiquettes et des données

Maintenant que vous avez créé votre DataFrame, vous pouvez commencer à y récupérer des informations. Avec Pandas, vous pouvez effectuer les actions suivantes:

  • Récupérer et modifier les étiquettes de lignes et de colonnes sous forme de séquences
  • Représenter les données sous forme de tableaux NumPy
  • Vérifier et ajuster les types de données
  • Analyser la taille de Trame de données objets

Étiquettes Pandas DataFrame en tant que séquences

Vous pouvez obtenir les étiquettes de ligne du DataFrame avec .indice et ses étiquettes de colonne avec .Colonnes:

>>>

>>> df.indice
Int64Index ([1, 2, 3, 4, 5, 6, 7], dtype = 'int64')

>>> df.Colonnes
Indice(['name', 'city', 'age', 'py-score'], dtype = 'objet')

Vous avez maintenant les étiquettes de lignes et de colonnes en tant que types spéciaux de séquences. Comme vous pouvez le faire avec n'importe quelle autre séquence Python, vous pouvez obtenir un seul élément:

>>>

>>> df.Colonnes[[[[1]
'ville'

En plus d'extraire un élément particulier, vous pouvez appliquer d'autres opérations de séquence, y compris l'itération à travers les étiquettes des lignes ou des colonnes. Cependant, cela est rarement nécessaire car Pandas propose d'autres façons d'itérer sur les DataFrames, que vous verrez dans une section ultérieure.

Vous pouvez également utiliser cette approche pour modifier les étiquettes:

>>>

>>> df.indice = np.arange(dix, 17)

>>> df.indice
Int64Index ([10, 11, 12, 13, 14, 15, 16], dtype = 'int64')

>>> df
                        nom ville âge py-score
10 Xavier Mexico 41 88,0
11 Ann Toronto 28 79,0
12 Jana Prague 33 81,0
13 Yi Shanghai 34 80,0
14 Robin Manchester 38 68,0
15 Amal Le Caire 31 61,0
16 Nori Osaka 37 84,0

Dans cet exemple, vous utilisez numpy.arange () pour générer une nouvelle séquence d'étiquettes de lignes contenant les entiers de dix à 16. En apprendre davantage sur arange (), consultez NumPy arange (): Comment utiliser np.arange ().

N'oubliez pas que si vous essayez de modifier un élément particulier de .indice ou .Colonnes, vous obtiendrez un Erreur-type.

Données sous forme de tableaux NumPy

Parfois, vous souhaiterez peut-être extraire des données d'un Pandas DataFrame sans ses étiquettes. Pour obtenir un tableau NumPy avec les données sans étiquette, vous pouvez utiliser soit .to_numpy () ou .valeurs:

>>>

>>> df.to_numpy()
tableau ([['Xavier', 'Mexico City', 41, 88.0],
       ['Ann', 'Toronto', 28, 79.0],
       ['Jana', 'Prague', 33, 81.0],
       ['Yi', 'Shanghai', 34, 80.0],
       ['Robin', 'Manchester', 38, 68.0],
       ['Amal', 'Cairo', 31, 61.0],
       ['Nori', 'Osaka', 37, 84.0]], dtype = objet)

Tous les deux .to_numpy () et .valeurs fonctionnent de manière similaire, et ils renvoient tous les deux un tableau NumPy avec les données du Pandas DataFrame:

mmst-pandas-df-4

La documentation Pandas suggère d'utiliser .to_numpy () en raison de la flexibilité offerte par deux paramètres facultatifs:

  1. dtype: Utilisez ce paramètre pour spécifier le type de données du tableau résultant. Il est réglé sur Aucun par défaut.
  2. copie: Définissez ce paramètre sur Faux si vous souhaitez utiliser les données d'origine du DataFrame. Réglez-le sur Vrai si vous souhaitez faire une copie des données.

cependant, .valeurs existe depuis bien plus longtemps que .to_numpy (), qui a été introduit dans la version 0.24.0 de Pandas. Cela signifie que vous verrez probablement .valeurs plus souvent, en particulier dans les anciens codes.

Types de données

le types de valeurs de données, aussi appelé Types de données ou dtypes, sont importants car ils déterminent la quantité de mémoire utilisée par DataFrame, ainsi que sa vitesse de calcul et son niveau de précision.

Pandas s'appuie fortement sur les types de données NumPy. Cependant, Pandas 1.0 a introduit quelques types supplémentaires:

Vous pouvez obtenir les types de données pour chaque colonne d'un Pandas DataFrame avec .dtypes:

>>>

>>> df.dtypes
objet de nom
objet de la ville
âge int64
py-score float64
dtype: objet

Comme vous pouvez le voir, .dtypes renvoie un Séries objet avec les noms de colonne comme étiquettes et les types de données correspondants comme valeurs.

Si vous souhaitez modifier le type de données d'une ou plusieurs colonnes, vous pouvez utiliser .astype ():

>>>

>>> df_ = df.astype(dtype='âge': np.int32, «py-score»: np.float32)
>>> df_.dtypes
objet de nom
objet de la ville
âge int32
py-score float32
dtype: objet

Le paramètre le plus important et le seul obligatoire de .astype () est dtype. Il attend un type de données ou un dictionnaire. Si vous passez un dictionnaire, les clés sont les noms des colonnes et les valeurs sont les types de données correspondants souhaités.

Comme vous pouvez le voir, les types de données pour les colonnes âge et py-score dans le DataFrame df sont les deux int64, qui représente des entiers 64 bits (ou 8 octets). cependant, df_ offre également un type de données entier plus petit, 32 bits (4 octets) appelé int32.

Pandas DataFrame Size

Les attributs .ndim, .Taille, et .forme renvoyer le nombre de dimensions, le nombre de valeurs de données dans chaque dimension et le nombre total de valeurs de données, respectivement:

>>>

>>> df_.ndim
2

>>> df_.forme
(7, 4)

>>> df_.Taille
28

Trame de données les instances ont deux dimensions (lignes et colonnes), donc .ndim Retour 2. UNE Séries objet, d'autre part, n'a qu'une seule dimension, donc dans ce cas, .ndim retournerais 1.

le .forme l'attribut renvoie un tuple avec le nombre de lignes (dans ce cas 7) et le nombre de colonnes (4). Finalement, .Taille renvoie un entier égal au nombre de valeurs dans le DataFrame (28).

Vous pouvez même vérifier la quantité de mémoire utilisée par chaque colonne avec .utilisation de la mémoire():

>>>

>>> df_.utilisation de la mémoire()
Index 56
nom 56
ville 56
28 ans
py-score 28
dtype: int64

Comme vous pouvez le voir, .utilisation de la mémoire() renvoie une série avec les noms de colonnes comme étiquettes et l'utilisation de la mémoire en octets comme valeurs de données. Si vous souhaitez exclure l'utilisation de la mémoire de la colonne qui contient les étiquettes de ligne, passez l'argument facultatif index = Faux.

Dans l'exemple ci-dessus, les deux dernières colonnes, âge et py-score, utilisez 28 octets de mémoire chacun. C'est parce que ces colonnes ont sept valeurs, chacune étant un entier qui prend 32 bits ou 4 octets. Sept entiers multipliés par 4 octets correspondent chacun à un total de 28 octets d'utilisation de la mémoire.

Accès et modification des données

Vous avez déjà appris à obtenir une ligne ou une colonne particulière d'un Pandas DataFrame en tant que Séries objet:

>>>

>>> df[[[['Nom']
10 Xavier
11 Ann
12 Jana
13 Yi
14 Robin
15 Amal
16 Nori
Nom: nom, dtype: objet

>>> df.loc[[[[dix]
nom Xavier
ville Mexico
41 ans
py-score 88
Nom: 10, dtype: objet

Dans le premier exemple, vous accédez à la colonne Nom comme vous accéderiez à un élément à partir d'un dictionnaire, en utilisant son étiquette comme clé. Si le libellé de la colonne est un identifiant Python valide, vous pouvez également utiliser la notation par points pour accéder à la colonne. Dans le deuxième exemple, vous utilisez .loc[] pour obtenir la ligne par son étiquette, dix.

Obtention de données avec des accesseurs

En plus de l'accesseur .loc[], que vous pouvez utiliser pour obtenir des lignes ou des colonnes par leurs étiquettes, Pandas propose l'accesseur .iloc[], qui récupère une ligne ou une colonne par son index entier. Dans la plupart des cas, vous pouvez utiliser l'un des deux:

>>>

>>> df.loc[[[[dix]
nom Xavier
ville Mexico
41 ans
py-score 88
Nom: 10, dtype: objet

>>> df.iloc[[[[0]
nom Xavier
ville Mexico
41 ans
py-score 88
Nom: 10, dtype: objet

df.loc[10] renvoie la ligne avec l'étiquette dix. De même, df.iloc[0] renvoie la ligne avec l'index de base zéro 0, qui est la première ligne. Comme vous pouvez le voir, les deux instructions renvoient la même ligne en tant que Séries objet.

Pandas a quatre accesseurs au total:

  1. .loc[] accepte les étiquettes des lignes et des colonnes et retourne Series ou DataFrames. Vous pouvez l'utiliser pour obtenir des lignes ou des colonnes entières, ainsi que leurs parties.

  2. .iloc[] accepte les indices de base et de lignes de base zéro et retourne Series ou DataFrames. Vous pouvez l'utiliser pour obtenir des lignes ou des colonnes entières, ou leurs parties.

  3. .à[] accepte les étiquettes des lignes et des colonnes et renvoie une seule valeur de données.

  4. .iat[] accepte les indices de base et de lignes de base zéro et renvoie une seule valeur de données.

Parmi ceux-ci, .loc[] et .iloc[] sont particulièrement puissants. Ils prennent en charge le découpage et l'indexation de type NumPy. Vous pouvez les utiliser pour accéder à une colonne:

>>>

>>> df.loc[:[:[:[: 'ville']
10 Mexico
11 Toronto
12 Prague
13 Shanghai
14 Manchester
15 Le Caire
16 Osaka
Nom: ville, dtype: objet

>>> df.iloc[:[:[:[: 1]
10 Mexico
11 Toronto
12 Prague
13 Shanghai
14 Manchester
15 Le Caire
16 Osaka
Nom: ville, dtype: objet

df.loc[:, 'city'] renvoie la colonne ville. La construction slice (:) à la place de l'étiquette de ligne signifie que toutes les lignes doivent être incluses. df.iloc[:, 1] renvoie la même colonne car l'index de base zéro 1 fait référence à la deuxième colonne, ville.

Tout comme vous pouvez avec NumPy, vous pouvez fournir des tranches avec des listes ou des tableaux au lieu d'index pour obtenir plusieurs lignes ou colonnes:

>>>

>>> df.loc[[[[11:15, [[[['Nom', 'ville']]
                    nom ville
11 Ann Toronto
12 Jana Prague
13 Yi Shanghai
14 Robin Manchester
15 Amal Le Caire

>>> df.iloc[[[[1:6, [[[[0, 1]]
                    nom ville
11 Ann Toronto
12 Jana Prague
13 Yi Shanghai
14 Robin Manchester
15 Amal Le Caire

Dans cet exemple, vous utilisez:

  • Tranches pour obtenir les lignes avec les étiquettes 11 à travers 15, qui sont équivalents aux indices 1 à travers 5
  • Listes pour obtenir les colonnes Nom et ville, qui sont équivalents aux indices 0 et 1

Les deux instructions renvoient un Pandas DataFrame avec le intersection des cinq lignes et deux colonnes souhaitées.

Cela fait apparaître une différence très importante entre .loc[] et .iloc[]. Comme vous pouvez le voir dans l'exemple précédent, lorsque vous passez les étiquettes de ligne 11:15 à .loc[], vous obtenez les rangées 11 à travers 15. Cependant, lorsque vous passez les indices de ligne 1: 6 à .iloc[], vous obtenez uniquement les lignes avec les indices 1 à travers 5.

La raison pour laquelle vous obtenez uniquement des indices 1 à travers 5 est que, avec .iloc[], la index d'arrêt d'une tranche est exclusif, ce qui signifie qu'il est exclu des valeurs renvoyées. Ceci est cohérent avec les séquences Python et les tableaux NumPy. Avec .loc[], cependant, les indices de démarrage et d'arrêt sont tous deux compris, ce qui signifie qu'ils sont inclus avec les valeurs renvoyées.

Vous pouvez ignorer des lignes et des colonnes avec .iloc[] de la même manière que pour les tranches de tuples, les listes et les tableaux NumPy:

>>>

>>> df.iloc[[[[1:6:2, 0]
11 Ann
13 Yi
15 Amal
Nom: nom, dtype: objet

Dans cet exemple, vous spécifiez les indices de ligne souhaités avec la tranche 1: 6: 2. Cela signifie que vous commencez par la ligne contenant l'index 1 (la deuxième ligne), arrêtez-vous avant la ligne avec l'index 6 (la septième rangée) et sautez toutes les deux rangées.

Au lieu d'utiliser la construction slicing, vous pouvez également utiliser la classe Python intégrée tranche(), aussi bien que numpy.s_[] ou pd.IndexSlice[]:

>>>

>>> df.iloc[[[[tranche(1, 6, 2), 0]
11 Ann
13 Yi
15 Amal
Nom: nom, dtype: objet

>>> df.iloc[[[[np.s_[[[[1:6:2], 0]
11 Ann
13 Yi
15 Amal
Nom: nom, dtype: objet

>>> df.iloc[[[[pd.IndexSlice[[[[1:6:2], 0]
11 Ann
13 Yi
15 Amal
Nom: nom, dtype: objet

Vous pourriez trouver l'une de ces approches plus pratique que d'autres en fonction de votre situation.

Il est possible d'utiliser .loc[] et .iloc[] pour obtenir des valeurs de données particulières. Cependant, lorsque vous n'avez besoin que d'une seule valeur, Pandas recommande d'utiliser les accesseurs spécialisés .à[] et .iat[]:

>>>

>>> df.à[[[[12, 'Nom']
«Jana»

>>> df.iat[[[[2, 0]
«Jana»

Ici, vous avez utilisé .à[] pour obtenir le nom d'un seul candidat à l'aide des libellés de colonne et de ligne correspondants. Vous avez également utilisé .iat[] pour récupérer le même nom en utilisant ses index de colonne et de ligne.

Définition de données avec des accesseurs

Vous pouvez utiliser des accesseurs pour modifier des parties d'un Pandas DataFrame en transmettant une séquence Python, un tableau NumPy ou une valeur unique:

>>>

>>> df.loc[:[:[:[: «py-score»]
10 88,0
11 79,0
12 81,0
13 80,0
14 68,0
15 61,0
16 84,0
Nom: py-score, dtype: float64

>>> df.loc[:[:[:[:13, «py-score»] = [[[[40, 50, 60, 70]
>>> df.loc[[[[14:, «py-score»] = 0

>>> df[[[[«py-score»]
10 40,0
11 50,0
12 60,0
13 70,0
14 0,0
15 0,0
16 0,0
Nom: py-score, dtype: float64

La déclaration df.loc[:13, 'py-score'] = [40, 50, 60, 70] modifie les quatre premiers éléments (lignes dix à travers 13) dans la colonne py-score en utilisant les valeurs de votre liste fournie. En utilisant df.loc[14:, 'py-score'] = 0 définit les valeurs restantes de cette colonne sur 0.

L'exemple suivant montre que vous pouvez utiliser des indices négatifs avec .iloc[] pour accéder ou modifier les données:

>>>

>>> df.iloc[:[:[:[: -1] = np.tableau([[[[88,0, 79,0, 81,0, 80,0, 68,0, 61,0, 84,0])

>>> df[[[[«py-score»]
10 88,0
11 79,0
12 81,0
13 80,0
14 68,0
15 61,0
16 84,0
Nom: py-score, dtype: float64

Dans cet exemple, vous avez accédé et modifié la dernière colonne («py-score»), qui correspond à l'index de la colonne entière -1. Ce comportement est cohérent avec les séquences Python et les tableaux NumPy.

Insertion et suppression de données

Pandas propose plusieurs techniques pratiques pour insérer et supprimer des lignes ou des colonnes. Vous pouvez choisir parmi eux en fonction de votre situation et de vos besoins.

Insertion et suppression de lignes

Imaginez que vous souhaitez ajouter une nouvelle personne à votre liste de candidats. Vous pouvez commencer par créer un nouveau Séries objet qui représente ce nouveau candidat:

>>>

>>> John = pd.Séries(Les données=[[[['John', 'Boston', 34, 79],
...                  indice=df.Colonnes, Nom=17)
>>> John
nom John
ville Boston
34 ans
py-score 79
Nom: 17, dtype: objet

>>> John.Nom
17

Le nouvel objet a des étiquettes qui correspondent aux étiquettes de colonne de df. C’est pourquoi vous avez besoin index = df.columns.

Vous pouvez ajouter John comme une nouvelle ligne à la fin de df avec .ajouter():

>>>

>>> df = df.ajouter(John)
>>> df
                        nom ville âge py-score
10 Xavier Mexico 41 88,0
11 Ann Toronto 28 79,0
12 Jana Prague 33 81,0
13 Yi Shanghai 34 80,0
14 Robin Manchester 38 68,0
15 Amal Le Caire 31 61,0
16 Nori Osaka 37 84,0
17 John Boston 34 79,0

Ici, .ajouter() renvoie le Pandas DataFrame avec la nouvelle ligne ajoutée. Remarquez comment Pandas utilise l'attribut john.name, qui est la valeur 17, pour spécifier le libellé de la nouvelle ligne.

Vous avez ajouté une nouvelle ligne avec un seul appel à .ajouter(), et vous pouvez le supprimer en un seul appel à .laissez tomber():

>>>

>>> df = df.laissez tomber(Étiquettes=[[[[17])
>>> df
                        nom ville âge py-score
10 Xavier Mexico 41 88,0
11 Ann Toronto 28 79,0
12 Jana Prague 33 81,0
13 Yi Shanghai 34 80,0
14 Robin Manchester 38 68,0
15 Amal Le Caire 31 61,0
16 Nori Osaka 37 84,0

Ici, .laissez tomber() supprime les lignes spécifiées avec le paramètre Étiquettes. Par défaut, il renvoie le Pandas DataFrame avec les lignes spécifiées supprimées. Si vous passez inplace = True, le DataFrame d'origine sera modifié et vous obtiendrez Aucun comme valeur de retour.

Insertion et suppression de colonnes

La manière la plus simple d'insérer une colonne dans un Pandas DataFrame est de suivre la même procédure que vous utilisez lorsque vous ajoutez un élément à un dictionnaire. Voici comment ajouter une colonne contenant les scores de vos candidats à un test JavaScript:

>>>

>>> df[[[[«js-score»] = np.tableau([[[[71,0, 95,0, 88,0, 79,0, 91,0, 91,0, 80,0])
>>> df
                        nom ville âge py-score js-score
10 Xavier Mexico 41 88,0 71,0
11 Ann Toronto 28 79,0 95,0
12 Jana Prague 33 81,0 88,0
13 Yi Shanghai 34 80,0 79,0
14 Robin Manchester 38 68,0 91,0
15 Amal Le Caire 31 61,0 91,0
16 Nori Osaka 37 84,0 80,0

Maintenant, le DataFrame d'origine a une colonne de plus, js-score, à sa fin.

Vous n'êtes pas obligé de fournir une séquence complète de valeurs. Vous pouvez ajouter une nouvelle colonne avec une seule valeur:

>>>

>>> df[[[['score total'] = 0,0
>>> df
                        nom ville âge score py score js score total score
10 Xavier Mexico 41 88,0 71,0 0,0
11 Ann Toronto 28 79,0 95,0 0,0
12 Jana Prague 33 81,0 88,0 0,0
13 Yi Shanghai 34 80,0 79,0 0,0
14 Robin Manchester 38 68,0 91,0 0,0
15 Amal Le Caire 31 61,0 91,0 0,0
16 Nori Osaka 37 84,0 80,0 0,0

Le DataFrame df a maintenant une colonne supplémentaire remplie de zéros.

Si vous avez utilisé des dictionnaires dans le passé, cette façon d'insérer des colonnes vous est peut-être familière. Cependant, il ne vous permet pas de spécifier l'emplacement de la nouvelle colonne. Si l'emplacement de la nouvelle colonne est important, vous pouvez utiliser .insérer() au lieu:

>>>

>>> df.insérer(loc=4, colonne=«django-score»,
...           valeur=np.tableau([[[[86,0, 81,0, 78,0, 88,0, 74,0, 70,0, 81,0]))
>>> df
                        nom ville âge score py score django score js score total
10 Xavier Mexico 41 88,0 86,0 71,0 0,0
11 Ann Toronto 28 79,0 81,0 95,0 0,0
12 Jana Prague 33 81,0 78,0 88,0 0,0
13 Yi Shanghai 34 80,0 88,0 79,0 0,0
14 Robin Manchester 38 68,0 74,0 91,0 0,0
15 Amal Le Caire 31 61,0 70,0 91,0 0,0
16 Nori Osaka 37 84,0 81,0 80,0 0,0

Vous venez d'insérer une autre colonne avec le score du test Django. Le paramètre loc détermine l'emplacement ou l'index de base zéro de la nouvelle colonne dans Pandas DataFrame. colonne définit le libellé de la nouvelle colonne, et valeur spécifie les valeurs de données à insérer.

Vous pouvez supprimer une ou plusieurs colonnes d'un Pandas DataFrame comme vous le feriez avec un dictionnaire Python standard, en utilisant le del déclaration:

>>>

>>> del df[[[['score total']
>>> df
                        nom ville âge py-score django-score js-score
10 Xavier Mexico 41 88,0 86,0 71,0
11 Ann Toronto 28 79,0 81,0 95,0
12 Jana Prague 33 81,0 78,0 88,0
13 Yi Shanghai 34 80,0 88,0 79,0
14 Robin Manchester 38 68,0 74,0 91,0
15 Amal Le Caire 31 61,0 70,0 91,0
16 Nori Osaka 37 84,0 81,0 80,0

Maintenant vous avez df sans la colonne score total. Une autre similitude avec les dictionnaires est la possibilité d'utiliser .pop(), qui supprime la colonne spécifiée et la renvoie. Cela signifie que vous pourriez faire quelque chose comme df.pop ('score total') à la place d'utiliser del.

Vous pouvez également supprimer une ou plusieurs colonnes avec .laissez tomber() comme vous l'avez fait précédemment avec les lignes. Encore une fois, vous devez spécifier les étiquettes des colonnes souhaitées avec Étiquettes. De plus, lorsque vous souhaitez supprimer des colonnes, vous devez fournir l'argument axe = 1:

>>>

>>> df = df.laissez tomber(Étiquettes='âge', axe=1)
>>> df
                        nom ville py-score django-score js-score
10  Xavier  Mexico City      88.0          86.0      71.0
11     Ann      Toronto      79.0          81.0      95.0
12    Jana       Prague      81.0          78.0      88.0
13      Yi     Shanghai      80.0          88.0      79.0
14   Robin   Manchester      68.0          74.0      91.0
15    Amal        Cairo      61.0          70.0      91.0
16    Nori        Osaka      84.0          81.0      80.0

You’ve removed the column age from your DataFrame.

By default, .drop() returns the DataFrame without the specified columns unless you pass inplace=True.

Applying Arithmetic Operations

You can apply basic arithmetic operations such as addition, subtraction, multiplication, and division to Pandas Séries et DataFrame objects the same way you would with NumPy arrays:

>>>

>>> df[[[['py-score'] + df[[[['js-score']
10    159.0
11    174.0
12    169.0
13    159.0
14    159.0
15    152.0
16    164.0
dtype: float64

>>> df[[[['py-score'] / 100
10    0.88
11    0.79
12    0.81
13    0.80
14    0.68
15    0.61
16    0.84
Name: py-score, dtype: float64

You can use this technique to insert a new column to a Pandas DataFrame. For example, try calculating a total score as a linear combination of your candidates’ Python, Django, and JavaScript scores:

>>>

>>> df[[[['total'] =
...     0,4 * df[[[['py-score'] + 0,3 * df[[[['django-score'] + 0,3 * df[[[['js-score']
>>> df
                        name         city  py-score  django-score  js-score  total
10  Xavier  Mexico City      88.0          86.0      71.0   82.3
11     Ann      Toronto      79.0          81.0      95.0   84.4
12    Jana       Prague      81.0          78.0      88.0   82.2
13      Yi     Shanghai      80.0          88.0      79.0   82.1
14   Robin   Manchester      68.0          74.0      91.0   76.7
15    Amal        Cairo      61.0          70.0      91.0   72.7
16    Nori        Osaka      84.0          81.0      80.0   81.9

Now your DataFrame has a column with a total score calculated from your candidates’ individual test scores. Even better, you achieved that with just a single statement!

Applying NumPy and SciPy Functions

Most NumPy and SciPy routines can be applied to Pandas Séries ou DataFrame objects as arguments instead of as NumPy arrays. To illustrate this, you can calculate candidates’ total test scores using the NumPy routine numpy.average().

Instead of passing a NumPy array to numpy.average(), you’ll pass a part of your Pandas DataFrame:

>>>

>>> import numpy as np

>>> score = df.iloc[:[:[:[: 2:5]
>>> score
                py-score  django-score  js-score
10      88.0          86.0      71.0
11      79.0          81.0      95.0
12      81.0          78.0      88.0
13      80.0          88.0      79.0
14      68.0          74.0      91.0
15      61.0          70.0      91.0
16      84.0          81.0      80.0

>>> np.average(score, axis=1,
...            weights=[[[[0,4, 0,3, 0,3])
array([82.3, 84.4, 82.2, 82.1, 76.7, 72.7, 81.9])

The variable score now refers to the DataFrame with the Python, Django, and JavaScript scores. Vous pouvez utiliser score as an argument of numpy.average() and get the linear combination of columns with the specified weights.

But that’s not all! You can use the NumPy array returned by average() as a new column of df. First, delete the existing column total de df, and then append the new one using average():

>>>

>>> del df[[[['total']
>>> df
                        name         city  py-score  django-score  js-score
10  Xavier  Mexico City      88.0          86.0      71.0
11     Ann      Toronto      79.0          81.0      95.0
12    Jana       Prague      81.0          78.0      88.0
13      Yi     Shanghai      80.0          88.0      79.0
14   Robin   Manchester      68.0          74.0      91.0
15    Amal        Cairo      61.0          70.0      91.0
16    Nori        Osaka      84.0          81.0      80.0

>>> df[[[['total'] = np.average(df.iloc[:[:[:[: 2:5], axis=1,
...                          weights=[[[[0,4, 0,3, 0,3])
>>> df
                        name         city  py-score  django-score  js-score  total
10  Xavier  Mexico City      88.0          86.0      71.0   82.3
11     Ann      Toronto      79.0          81.0      95.0   84.4
12    Jana       Prague      81.0          78.0      88.0   82.2
13      Yi     Shanghai      80.0          88.0      79.0   82.1
14   Robin   Manchester      68.0          74.0      91.0   76.7
15    Amal        Cairo      61.0          70.0      91.0   72.7
16    Nori        Osaka      84.0          81.0      80.0   81.9

The result is the same as in the previous example, but here you used the existing NumPy function instead of writing your own code.

Sorting a Pandas DataFrame

You can sort a Pandas DataFrame with .sort_values():

>>>

>>> df.sort_values(par='js-score', ascending=False)
                        name         city  py-score  django-score  js-score  total
11     Ann      Toronto      79.0          81.0      95.0   84.4
14   Robin   Manchester      68.0          74.0      91.0   76.7
15    Amal        Cairo      61.0          70.0      91.0   72.7
12    Jana       Prague      81.0          78.0      88.0   82.2
16    Nori        Osaka      84.0          81.0      80.0   81.9
13      Yi     Shanghai      80.0          88.0      79.0   82.1
10  Xavier  Mexico City      88.0          86.0      71.0   82.3

This example sorts your DataFrame by the values in the column js-score. The parameter par sets the label of the row or column to sort by. ascending specifies whether you want to sort in ascending (Vrai) or descending (False) order, the latter being the default setting. You can pass axis to choose if you want to sort rows (axis=0) or columns (axis=1).

If you want to sort by multiple columns, then just pass lists as arguments for par et ascending:

>>>

>>> df.sort_values(par=[[[['total', 'py-score'], ascending=[[[[False, False])
                        name         city  py-score  django-score  js-score  total
11     Ann      Toronto      79.0          81.0      95.0   84.4
10  Xavier  Mexico City      88.0          86.0      71.0   82.3
12    Jana       Prague      81.0          78.0      88.0   82.2
13      Yi     Shanghai      80.0          88.0      79.0   82.1
16    Nori        Osaka      84.0          81.0      80.0   81.9
14   Robin   Manchester      68.0          74.0      91.0   76.7
15    Amal        Cairo      61.0          70.0      91.0   72.7

In this case, the DataFrame is sorted by the column total, but if two values are the same, then their order is determined by the values from the column py-score.

The optional parameter inplace can also be used with .sort_values(). It’s set to False by default, ensuring .sort_values() returns a new Pandas DataFrame. When you set inplace=True, the existing DataFrame will be modified and .sort_values() will return Aucun.

If you’ve ever tried to sort values in Excel, then you might find the Pandas approach much more efficient and convenient. When you have large amounts of data, Pandas can significantly outperform Excel.

Filtering Data

Data filtering is another powerful feature of Pandas. It works similarly to indexing with Boolean arrays in NumPy.

If you apply some logical operation on a Séries object, then you’ll get another Series with the Boolean values Vrai et False:

>>>

>>> filter_ = df[[[['django-score'] >= 80
>>> filter_
10     True
11     True
12    False
13     True
14    False
15    False
16     True
Name: django-score, dtype: bool

In this case, df['django-score'] >= 80 returns Vrai for those rows in which the Django score is greater than or equal to 80. It returns False for the rows with a Django score less than 80.

You now have the Series filter_ filled with Boolean data. The expression df[filter_] returns a Pandas DataFrame with the rows from df that correspond to Vrai dans filter_:

>>>

>>> df[[[[filter_]
                        name         city  py-score  django-score  js-score  total
10  Xavier  Mexico City      88.0          86.0      71.0   82.3
11     Ann      Toronto      79.0          81.0      95.0   84.4
13      Yi     Shanghai      80.0          88.0      79.0   82.1
16    Nori        Osaka      84.0          81.0      80.0   81.9

Comme vous pouvez le voir, filter_[10], filter_[11], filter_[13], et filter_[16] sont Vrai, so df[filter_] contains the rows with these labels. D'autre part, filter_[12], filter_[14], et filter_[15] sont False, so the corresponding rows don’t appear in df[filter_].

You can create very powerful and sophisticated expressions by combining logical operations with the following operators:

  • NE PAS (~)
  • ET (&)
  • OU (|)
  • XOR (^)

For example, you can get a DataFrame with the candidates whose py-score et js-score are greater than or equal to 80:

>>>

>>> df[([([([(df[[[['py-score'] >= 80) & (df[[[['js-score'] >= 80)]
                name    city  py-score  django-score  js-score  total
12  Jana  Prague      81.0          78.0      88.0   82.2
16  Nori   Osaka      84.0          81.0      80.0   81.9

The expression (df['py-score'] >= 80) & (df['js-score'] >= 80) returns a Series with Vrai in the rows for which both py-score et js-score are greater than or equal to 80 and False in the others. In this case, only the rows with the labels 12 et 16 satisfy both conditions.

You can also apply NumPy logical routines instead of operators.

For some operations that require data filtering, it’s more convenient to use .where(). It replaces the values in the positions where the provided condition isn’t satisfied:

>>>

>>> df[[[['django-score'].(cond=df[[[['django-score'] >= 80, other=0,0)
10    86.0
11    81.0
12     0.0
13    88.0
14     0.0
15     0.0
16    81.0
Name: django-score, dtype: float64

In this example, the condition is df['django-score'] >= 80. The values of the DataFrame or Series that calls .where() will remain the same where the condition is Vrai and will be replaced with the value of other (in this case 0,0) where the condition is False.

Determining Data Statistics

Pandas provides many statistical methods for DataFrames. You can get basic statistics for the numerical columns of a Pandas DataFrame with .describe():

>>>

>>> df.describe()
                                py-score  django-score   js-score      total
count   7.000000      7.000000   7.000000   7.000000
mean   77.285714     79.714286  85.000000  80.328571
std     9.446592      6.343350   8.544004   4.101510
min    61.000000     70.000000  71.000000  72.700000
25%    73.500000     76.000000  79.500000  79.300000
50%    80.000000     81.000000  88.000000  82.100000
75%    82.500000     83.500000  91.000000  82.250000
max    88.000000     88.000000  95.000000  84.400000

Here, .describe() returns a new DataFrame with the number of rows indicated by count, as well as the mean, standard deviation, minimum, maximum, and quartiles of the columns.

If you want to get particular statistics for some or all of your columns, then you can call methods such as .mean() ou .std():

>>>

>>> df.mean()
py-score        77.285714
django-score    79.714286
js-score        85.000000
total           80.328571
dtype: float64

>>> df[[[['py-score'].mean()
77.28571428571429

>>> df.std()
py-score        9.446592
django-score    6.343350
js-score        8.544004
total           4.101510
dtype: float64

>>> df[[[['py-score'].std()
9.446591726019244

When applied to a Pandas DataFrame, these methods return Series with the results for each column. When applied to a Séries object, or a single column of a DataFrame, the methods return scalars.

To learn more about statistical calculations with Pandas, check out Descriptive Statistics With Python and NumPy, SciPy, and Pandas: Correlation With Python.

Handling Missing Data

Missing data is very common in data science and machine learning. But never fear! Pandas has very powerful features for working with missing data. In fact, its documentation has an entire section dedicated to working with missing data.

Pandas usually represents missing data with NaN (not a number) values. In Python, you can get NaN with float('nan'), math.nan, ou numpy.nan. Starting with Pandas 1.0, newer types like BooleanDtype, Int8Dtype, Int16Dtype, Int32Dtype, et Int64Dtype utilisation pandas.NA as a missing value.

Here’s an example of a Pandas DataFrame with a missing value:

>>>

>>> df_ = pd.DataFrame('x': [[[[1, 2, np.nan, 4])
>>> df_
                    X
0  1.0
1  2.0
2  NaN
3  4.0

The variable df_ refers to the DataFrame with one column, X, and four values. The third value is nan and is considered missing by default.

Calculating With Missing Data

Many Pandas methods omit nan values when performing calculations unless they are explicitly instructed ne pas à:

>>>

>>> df_.mean()
x    2.333333
dtype: float64

>>> df_.mean(skipna=False)
x   NaN
dtype: float64

In the first example, df_.mean() calculates the mean without taking NaN (the third value) into account. It just takes 1.0, 2.0, et 4.0 and returns their average, which is 2.33.

However, if you instruct .mean() not to skip nan values with skipna=False, then it will consider them and return nan if there’s any missing value among the data.

Filling Missing Data

Pandas has several options for filling, or replacing, missing values with other values. One of the most convenient methods is .fillna(). You can use it to replace missing values with:

  • Specified values
  • The values above the missing value
  • The values below the missing value

Here’s how you can apply the options mentioned above:

>>>

>>> df_.fillna(valeur=0)
                    X
0  1.0
1  2.0
2  0.0
3  4.0

>>> df_.fillna(method='ffill')
                    X
0  1.0
1  2.0
2  2.0
3  4.0

>>> df_.fillna(method='bfill')
                    X
0  1.0
1  2.0
2  4.0
3  4.0

In the first example, .fillna(value=0) replaces the missing value with 0,0, which you specified with valeur. In the second example, .fillna(method='ffill') replaces the missing value with the value above it, which is 2.0. In the third example, .fillna(method='bfill') uses the value below the missing value, which is 4.0.

Another popular option is to apply interpolation and replace missing values with interpolated values. You can do this with .interpolate():

>>>

>>> df_.interpolate()
                    X
0  1.0
1  2.0
2  3.0
3  4.0

Comme vous pouvez le voir, .interpolate() replaces the missing value with an interpolated value.

You can also use the optional parameter inplace avec .fillna(). Doing so will:

  • Create and return a new DataFrame when inplace=False
  • Modify the existing DataFrame and return Aucun quand inplace=True

The default setting for inplace est False. cependant, inplace=True can be very useful when you’re working with large amounts of data and want to prevent unnecessary and inefficient copying.

Deleting Rows and Columns With Missing Data

In certain situations, you might want to delete rows or even columns that have missing values. You can do this with .dropna():

>>>

>>> df_.dropna()
                    X
0  1.0
1  2.0
3  4.0

In this case, .dropna() simply deletes the row with nan, including its label. It also has the optional parameter inplace, which behaves the same as it does with .fillna() et .interpolate().

Iterating Over a Pandas DataFrame

As you learned earlier, a DataFrame’s row and column labels can be retrieved as sequences with .index et .columns. You can use this feature to iterate over labels and get or set data values. However, Pandas provides several more convenient methods for iteration:

Avec .items() et .iteritems(), you iterate over the columns of a Pandas DataFrame. Each iteration yields a tuple with the name of the column and the column data as a Séries object:

>>>

>>> pour col_label, col dans df.iteritems():
...     impression(col_label, col, sep=" n", end="nn")
...
Nom
10    Xavier
11       Ann
12      Jana
13        Yi
14     Robin
15      Amal
16      Nori
Name: name, dtype: object

city
10    Mexico City
11        Toronto
12         Prague
13       Shanghai
14     Manchester
15          Cairo
16          Osaka
Name: city, dtype: object

py-score
10    88.0
11    79.0
12    81.0
13    80.0
14    68.0
15    61.0
16    84.0
Name: py-score, dtype: float64

django-score
10    86.0
11    81.0
12    78.0
13    88.0
14    74.0
15    70.0
16    81.0
Name: django-score, dtype: float64

js-score
10    71.0
11    95.0
12    88.0
13    79.0
14    91.0
15    91.0
16    80.0
Name: js-score, dtype: float64

total
10    82.3
11    84.4
12    82.2
13    82.1
14    76.7
15    72.7
16    81.9
Name: total, dtype: float64

That’s how you use .items() et .iteritems().

Avec .iterrows(), you iterate over the rows of a Pandas DataFrame. Each iteration yields a tuple with the name of the row and the row data as a Séries object:

>>>

>>> pour row_label, row dans df.iterrows():
...     impression(row_label, row, sep=" n", end="nn")
...
dix
name                 Xavier
city            Mexico City
py-score                 88
django-score             86
js-score                 71
total                  82.3
Name: 10, dtype: object

11
name                Ann
city            Toronto
py-score             79
django-score         81
js-score             95
total              84.4
Name: 11, dtype: object

12
name              Jana
city            Prague
py-score            81
django-score        78
js-score            88
total             82.2
Name: 12, dtype: object

13
name                  Yi
city            Shanghai
py-score              80
django-score          88
js-score              79
total               82.1
Name: 13, dtype: object

14
name                 Robin
city            Manchester
py-score                68
django-score            74
js-score                91
total                 76.7
Name: 14, dtype: object

15
name             Amal
city            Cairo
py-score           61
django-score       70
js-score           91
total            72.7
Name: 15, dtype: object

16
name             Nori
city            Osaka
py-score           84
django-score       81
js-score           80
total            81.9
Name: 16, dtype: object

That’s how you use .iterrows().

De même, .itertuples() iterates over the rows and in each iteration yields a named tuple with (optionally) the index and data:

>>>

>>> pour row dans df.loc[:[:[:[: [[[['name', 'city', 'total']].itertuples():
...     impression(row)
...
Pandas(Index=10, name='Xavier', city='Mexico City', total=82.3)
Pandas(Index=11, name='Ann', city='Toronto', total=84.4)
Pandas(Index=12, name='Jana', city='Prague', total=82.19999999999999)
Pandas(Index=13, name='Yi', city='Shanghai', total=82.1)
Pandas(Index=14, name='Robin', city='Manchester', total=76.7)
Pandas(Index=15, name='Amal', city='Cairo', total=72.7)
Pandas(Index=16, name='Nori', city='Osaka', total=81.9)

You can specify the name of the named tuple with the parameter Nom, which is set to 'Pandas' par défaut. You can also specify whether to include row labels with indice, which is set to Vrai par défaut.

Working With Time Series

Pandas excels at handling time series. Although this functionality is partly based on NumPy datetimes and timedeltas, Pandas provides much more flexibility.

Creating DataFrames With Time-Series Labels

In this section, you’ll create a Pandas DataFrame using the hourly temperature data from a single day.

You can start by creating a list (or tuple, NumPy array, or other data type) with the data values, which will be hourly temperatures given in degrees Celsius:

>>>

>>> temp_c = [[[[ 8.0,  7.1,  6.8,  6,4,  6.0,  5.4,  4.8,  5,0,
...            9.1, 12.8, 15.3, 19,1, 21.2, 22.1, 22,4, 23.1,
...           21,0, 17.9, 15,5, 14.4, 11.9, 11,0, 10.2,  9.1]

Now you have the variable temp_c, which refers to the list of temperature values.

The next step is to create a sequence of dates and times. Pandas provides a very convenient function, date_range(), for this purpose:

>>>

>>> dt = pd.date_range(début='2019-10-27 00:00:00.0', periods=24,
...                    freq='H')
>>> dt
DatetimeIndex(['2019-10-2700:00:00''2019-10-2701:00:00'['2019-10-2700:00:00''2019-10-2701:00:00'['2019-10-2700:00:00''2019-10-2701:00:00'['2019-10-2700:00:00''2019-10-2701:00:00'
                                                            '2019-10-27 02:00:00', '2019-10-27 03:00:00',
                                                            '2019-10-27 04:00:00', '2019-10-27 05:00:00',
                                                            '2019-10-27 06:00:00', '2019-10-27 07:00:00',
                                                            '2019-10-27 08:00:00', '2019-10-27 09:00:00',
                                                            '2019-10-27 10:00:00', '2019-10-27 11:00:00',
                                                            '2019-10-27 12:00:00', '2019-10-27 13:00:00',
                                                            '2019-10-27 14:00:00', '2019-10-27 15:00:00',
                                                            '2019-10-27 16:00:00', '2019-10-27 17:00:00',
                                                            '2019-10-27 18:00:00', '2019-10-27 19:00:00',
                                                            '2019-10-27 20:00:00', '2019-10-27 21:00:00',
                                                            '2019-10-27 22:00:00', '2019-10-27 23:00:00'],
                                                        dtype='datetime64[ns]', freq='H')

date_range() accepts the arguments that you use to specify the start or end of the range, number of periods, frequency, time zone, and more.

Now that you have the temperature values and the corresponding dates and times, you can create the DataFrame. In many cases, it’s convenient to use date-time values as the row labels:

>>>

>>> temp = pd.DataFrame(Les données='temp_c': temp_c, indice=dt)
>>> temp
                                                                                    temp_c
2019-10-27 00:00:00     8.0
2019-10-27 01:00:00     7.1
2019-10-27 02:00:00     6.8
2019-10-27 03:00:00     6.4
2019-10-27 04:00:00     6.0
2019-10-27 05:00:00     5.4
2019-10-27 06:00:00     4.8
2019-10-27 07:00:00     5.0
2019-10-27 08:00:00     9.1
2019-10-27 09:00:00    12.8
2019-10-27 10:00:00    15.3
2019-10-27 11:00:00    19.1
2019-10-27 12:00:00    21.2
2019-10-27 13:00:00    22.1
2019-10-27 14:00:00    22.4
2019-10-27 15:00:00    23.1
2019-10-27 16:00:00    21.0
2019-10-27 17:00:00    17.9
2019-10-27 18:00:00    15.5
2019-10-27 19:00:00    14.4
2019-10-27 20:00:00    11.9
2019-10-27 21:00:00    11.0
2019-10-27 22:00:00    10.2
2019-10-27 23:00:00     9.1

C'est ça! You’ve created a DataFrame with time-series data and date-time row indices.

Indexing and Slicing

Once you have a Pandas DataFrame with time-series data, you can conveniently apply slicing to get just a part of the information:

>>>

>>> temp[[[['2019-10-27 05':'2019-10-27 14']
                                                                                    temp_c
2019-10-27 05:00:00     5.4
2019-10-27 06:00:00     4.8
2019-10-27 07:00:00     5.0
2019-10-27 08:00:00     9.1
2019-10-27 09:00:00    12.8
2019-10-27 10:00:00    15.3
2019-10-27 11:00:00    19.1
2019-10-27 12:00:00    21.2
2019-10-27 13:00:00    22.1
2019-10-27 14:00:00    22.4

This example shows how to extract the temperatures between 05:00 and 14:00 (5 a.m. and 2 p.m.). Although you’ve provided strings, Pandas knows that your row labels are date-time values and interprets the strings as dates and times.

Resampling and Rolling

You’ve just seen how to combine date-time row labels and use slicing to get the information you need from the time-series data. This is just the beginning. It gets better!

If you want to split a day into four six-hour intervals and get the mean temperature for each interval, then you’re just one statement away from doing so. Pandas provides the method .resample(), which you can combine with other methods such as .mean():

>>>

>>> temp.resample(rule='6h').mean()
                                                                                                temp_c
2019-10-27 00:00:00   6.616667
2019-10-27 06:00:00  11.016667
2019-10-27 12:00:00  21.283333
2019-10-27 18:00:00  12.016667

You now have a new Pandas DataFrame with four rows. Each row corresponds to a single six-hour interval. For example, the value 6.616667 is the mean of the first six temperatures from the DataFrame temp, whereas 12.016667 is the mean of the last six temperatures.

Instead of .mean(), you can apply .min() ou .max() to get the minimum and maximum temperatures for each interval. You can also use .sum() to get the sums of data values, although this information probably isn’t useful when you’re working with temperatures.

You might also need to do some rolling-window analysis. This involves calculating a statistic for a specified number of adjacent rows, which make up your window of data. You can “roll” the window by selecting a different set of adjacent rows to perform your calculations on.

Your first window starts with the first row in your DataFrame and includes as many adjacent rows as you specify. You then move your window down one row, dropping the first row and adding the row that comes immediately after the last row, and calculate the same statistic again. You repeat this process until you reach the last row of the DataFrame.

Pandas provides the method .rolling() for this purpose:

>>>

>>> temp.rolling(fenêtre=3).mean()
                                                                                                temp_c
2019-10-27 00:00:00        NaN
2019-10-27 01:00:00        NaN
2019-10-27 02:00:00   7.300000
2019-10-27 03:00:00   6.766667
2019-10-27 04:00:00   6.400000
2019-10-27 05:00:00   5.933333
2019-10-27 06:00:00   5.400000
2019-10-27 07:00:00   5.066667
2019-10-27 08:00:00   6.300000
2019-10-27 09:00:00   8.966667
2019-10-27 10:00:00  12.400000
2019-10-27 11:00:00  15.733333
2019-10-27 12:00:00  18.533333
2019-10-27 13:00:00  20.800000
2019-10-27 14:00:00  21.900000
2019-10-27 15:00:00  22.533333
2019-10-27 16:00:00  22.166667
2019-10-27 17:00:00  20.666667
2019-10-27 18:00:00  18.133333
2019-10-27 19:00:00  15.933333
2019-10-27 20:00:00  13.933333
2019-10-27 21:00:00  12.433333
2019-10-27 22:00:00  11.033333
2019-10-27 23:00:00  10.100000

Now you have a DataFrame with mean temperatures calculated for several three-hour windows. The parameter fenêtre specifies the size of the moving time window.

In the example above, the third value (7.3) is the mean temperature for the first three hours (00:00:00, 01:00:00, et 02:00:00). The fourth value is the mean temperature for the hours 02:00:00, 03:00:00, et 04:00:00. The last value is the mean temperature for the last three hours, 21:00:00, 22:00:00, et 23:00:00. The first two values are missing because there isn’t enough data to calculate them.

Plotting With Pandas DataFrames

Pandas allows you to visualize data or create plots based on DataFrames. It uses Matplotlib in the background, so exploiting Pandas’ plotting capabilities is very similar to working with Matplotlib.

If you want to display the plots, then you first need to import matplotlib.pyplot:

>>>

>>> import matplotlib.pyplot as plt

Now you can use pandas.DataFrame.plot() to create the plot and plt.show() to display it:

>>>

>>> temp.plot()

>>> plt.montrer()

Maintenant .plot() returns a plot object that looks like this:

mmst-pandas-df-5

You can also apply .plot.line() and get the same result. Tous les deux .plot() et .plot.line() have many optional parameters that you can use to specify the look of your plot. Some of them are passed directly to the underlying Matplotlib methods.

You can save your figure by chaining the methods .get_figure() et .savefig():

>>>

>>> temp.plot().get_figure().savefig('temperatures.png')

This statement creates the plot and saves it as a file called 'temperatures.png' in your working directory.

You can get other types of plots with a Pandas DataFrame. For example, you can visualize your job candidate data from before as a histogram with .plot.hist():

>>>

>>> df.loc[:[:[:[: [[[['py-score', 'total']].plot.hist(bins=5, alpha=0,4)

>>> plt.montrer()

In this example, you extract the Python test score and total score data and visualize it with a histogram. The resulting plot looks like this:

mmst-pandas-df-6

This is just the basic look. You can adjust details with optional parameters including .plot.hist(), Matplotlib’s plt.rcParams, and many others. You can find detailed explanations in the Anatomy of Matplotlib.

Lectures complémentaires

Pandas DataFrames are very comprehensive objects that support many operations not mentioned in this tutorial. Some of these include:

The official Pandas tutorial summarizes some of the available options nicely. If you want to learn more about Pandas and DataFrames, then you can check out these tutorials:

You’ve learned that Pandas DataFrames handle two-dimensional data. If you need to work with labeled data in more than two dimensions, you can check out xarray, another powerful Python library for data science with very similar features to Pandas.

If you work with big data and want a DataFrame-like experience, then you might give Dask a chance and use its DataFrame API. UNE Dask DataFrame contains many Pandas DataFrames and performs computations in a paresseux manner.

Conclusion

You now know what a Pandas DataFrame is, what some of its features are, and how you can use it to work with data efficiently. Pandas DataFrames are powerful, user-friendly data structures that you can use to gain deeper insight into your datasets!

In this tutorial, you’ve learned:

  • What a Pandas DataFrame is and how to create one
  • Comment access, modify, add, sort, filter, and delete Les données
  • Comment utiliser NumPy routines with DataFrames
  • How to handle missing values
  • How to work with time-series data
  • Comment visualize data contained in DataFrames

You’ve learned enough to cover the fundamentals of DataFrames. If you want to dig deeper into working with data in Python, then check out the entire range of Pandas tutorials.

If you have questions or comments, then please put them in the comment section below.