Votre guide de tri des données en Python – Real Python

By | février 15, 2021

Formation Python

Apprentissage des pandas méthodes de tri est un excellent moyen de commencer ou de pratiquer l'analyse de données de base à l'aide de Python. Le plus souvent, l'analyse des données est effectuée avec des feuilles de calcul, SQL ou des pandas. L'un des avantages de l'utilisation des pandas est qu'il peut gérer une grande quantité de données et offre des capacités de manipulation de données très performantes.

Dans ce didacticiel, vous apprendrez à utiliser .sort_values ​​() et .sort_index (), qui vous permettra de trier efficacement les données dans un DataFrame.

À la fin de ce didacticiel, vous saurez comment:

  • Trier un pandas DataFrame par les valeurs d'une ou plusieurs colonnes
  • Utilisez le Ascendant paramètre pour changer le ordre de tri
  • Trier un DataFrame par son indice utilisant .sort_index ()
  • Organiser données manquantes lors du tri des valeurs
  • Trier un DataFrame en place utilisant en place mis à Vrai

Pour suivre ce didacticiel, vous aurez besoin d'une compréhension de base des pandas DataFrames et d'une certaine familiarité avec la lecture de données à partir de fichiers.

Premiers pas avec les méthodes de tri Pandas

Pour rappel, un Trame de données est une structure de données avec des axes étiquetés pour les lignes et les colonnes. Vous pouvez trier un DataFrame par valeur de ligne ou de colonne ainsi que par index de ligne ou de colonne.

Les lignes et les colonnes ont indices, qui sont des représentations numériques de l'emplacement des données dans votre DataFrame. Vous pouvez récupérer des données à partir de lignes ou de colonnes spécifiques en utilisant les emplacements d'index du DataFrame. Par défaut, les numéros d'index commencent à zéro. Vous pouvez également attribuer manuellement votre propre index.

Préparation du jeu de données

Dans ce didacticiel, vous travaillerez avec des données d'économie de carburant compilées par l'Agence américaine de protection de l'environnement (EPA) sur des véhicules fabriqués entre 1984 et 2021. L'ensemble de données sur l'économie de carburant de l'EPA est excellent car il contient de nombreux types d'informations que vous pouvez trier. on, des types de données textuelles aux types de données numériques. L'ensemble de données contient quatre-vingt-trois colonnes au total.

Pour continuer, vous devez avoir installé la bibliothèque pandas Python. Le code de ce tutoriel a été exécuté à l'aide de pandas 1.2.0 et Python 3.9.1.

À des fins d'analyse, vous examinerez les données MPG (miles par gallon) sur les véhicules par marque, modèle, année et autres attributs de véhicule. Vous pouvez spécifier les colonnes à lire dans votre DataFrame. Pour ce didacticiel, vous n'aurez besoin que d'un sous-ensemble des colonnes disponibles.

Voici les commandes pour lire les colonnes pertinentes de l'ensemble de données sur l'économie de carburant dans un DataFrame et pour afficher les cinq premières lignes:

>>>

>>> importer pandas comme pd

>>> column_subset = [[[[
...     "identifiant",
...     "Fabriquer",
...     "maquette",
...     "an",
...     "cylindres",
...     "type de carburant",
...     "trany",
...     "mpgData",
...     "city08",
...     "Highway08"
... ]

>>> df = pd.read_csv(
...     "https://www.fueleconomy.gov/feg/epadata/vehicles.csv",
...     utiliser=column_subset,
...     nrows=100
... )

>>> df.diriger()
            city08 cylindres carburantType ... mpgData trany year
0 19 4 Régulier ... Y Manuel 5 vitesses 1985
1 9 12 Régulier ... N Manuel 5 vitesses 1985
2 23 4 Régulier ... Y Manuel 5 vitesses 1985
3 10 8 Régulier ... N Automatique 3 vitesses 1985
4 17 4 Premium ... N Manuel 5 vitesses 1993
[5 rows x 10 columns]

En appelant .read_csv () avec l'URL de l'ensemble de données, vous pouvez charger les données dans un DataFrame. La réduction des colonnes entraîne des temps de chargement plus rapides et une utilisation de la mémoire inférieure. Pour limiter davantage la consommation de mémoire et pour avoir une idée rapide des données, vous pouvez spécifier le nombre de lignes à charger en utilisant nrows.

Se familiariser avec .sort_values ​​()

Tu utilises .sort_values ​​() pour trier les valeurs d'un DataFrame le long de l'un ou l'autre des axes (colonnes ou lignes). En règle générale, vous souhaitez trier les lignes d'un DataFrame en fonction des valeurs d'une ou plusieurs colonnes:

Pandas DataFrame trié par valeurs de colonne

La figure ci-dessus montre les résultats de l'utilisation .sort_values ​​() pour trier les lignes du DataFrame en fonction des valeurs du autoroute08 colonne. Ceci est similaire à la façon dont vous trieriez les données dans une feuille de calcul à l'aide d'une colonne.

Se familiariser avec .sort_index ()

Tu utilises .sort_index () pour trier un DataFrame par son index de ligne ou ses étiquettes de colonne. La différence d'utiliser .sort_values ​​() est que vous triez le DataFrame en fonction de son index de ligne ou des noms de colonne, et non en fonction des valeurs de ces lignes ou colonnes:

Pandas DataFrame trié par index de ligne

L'index de ligne du DataFrame est encadré en bleu dans la figure ci-dessus. Un index n'est pas considéré comme une colonne et vous n'avez généralement qu'un seul index de ligne. L'index de ligne peut être considéré comme les numéros de ligne, qui commencent à zéro.

Tri de votre DataFrame sur une seule colonne

Pour trier le DataFrame en fonction des valeurs d'une seule colonne, vous utiliserez .sort_values ​​(). Par défaut, cela renverra un nouveau DataFrame trié par ordre croissant. Il ne modifie pas le DataFrame d'origine.

Tri par colonne par ordre croissant

Utiliser .sort_values ​​(), vous passez un seul argument à la méthode contenant le nom de la colonne sur laquelle vous souhaitez trier. Dans cet exemple, vous triez le DataFrame par le ville08 colonne, qui représente le MPG de la ville pour les voitures à carburant uniquement:

>>>

>>> df.sort_values("city08")
                city08 cylindres carburantType ... mpgData trany year
99 9 8 Premium ... N Automatique 4 vitesses 1993
1 9 12 Régulier ... N Manuel 5 vitesses 1985
80 9 8 Régulier ... N Automatique 3 vitesses 1985
47 9 8 Régulier ... N Automatique 3 vitesses 1985
3 10 8 Régulier ... N Automatique 3 vitesses 1985
.. ... ... ... ... ... ... ...
9 23 4 Régulier ... Y Automatique 4 vitesses 1993
8 23 4 Régulier ... Y Manuel 5 vitesses 1993
7 23 4 Régulier ... Y Automatique 3 vitesses 1993
76 23 4 Régulier ... Y Manuel 5 vitesses 1993
2 23 4 Régulier ... Y Manuel 5 vitesses 1985
[100 rows x 10 columns]

Cela trie votre DataFrame en utilisant les valeurs de colonne de ville08, montrant en premier les véhicules avec le MPG le plus bas. Par défaut, .sort_values ​​() trie vos données dans ordre croissant. Bien que vous n'ayez pas spécifié de nom pour l'argument que vous avez transmis .sort_values ​​(), vous avez utilisé le par paramètre, que vous verrez dans l'exemple suivant.

Modification de l'ordre de tri

Un autre paramètre de .sort_values ​​() est Ascendant. Par défaut .sort_values ​​() a Ascendant mis à Vrai. Si vous voulez que le DataFrame soit trié Ordre décroissant, alors tu peux passer Faux à ce paramètre:

>>>

>>> df.sort_values(
...     par="city08",
...     Ascendant=Faux
... )
                city08 cylindres carburantType ... mpgData trany year
9 23 4 Régulier ... Y Automatique 4 vitesses 1993
2 23 4 Régulier ... Y Manuel 5 vitesses 1985
7 23 4 Régulier ... Y Automatique 3 vitesses 1993
8 23 4 Régulier ... Y Manuel 5 vitesses 1993
76 23 4 Régulier ... Y Manuel 5 vitesses 1993
.. ... ... ... ... ... ... ...
58 10 8 Régulier ... N Automatique 3 vitesses 1985
80 9 8 Régulier ... N Automatique 3 vitesses 1985
1 9 12 Régulier ... N Manuel 5 vitesses 1985
47 9 8 Régulier ... N Automatique 3 vitesses 1985
99 9 8 Premium ... N Automatique 4 vitesses 1993
[100 rows x 10 columns]

En passant Faux à Ascendant, vous inversez l'ordre de tri. Désormais, votre DataFrame est trié par ordre décroissant de MPG moyen mesuré dans les conditions de la ville. Les véhicules avec les valeurs MPG les plus élevées sont dans les premières lignes.

Choisir un algorithme de tri

Il est bon de noter que les pandas vous permettent de choisir différents algorithmes de tri à utiliser avec les deux .sort_values ​​() et .sort_index (). Les algorithmes disponibles sont tri rapide, tri par fusion, et tas de choses. Pour plus d'informations sur ces différents algorithmes de tri, consultez Algorithmes de tri en Python.

L'algorithme utilisé par défaut lors du tri sur une seule colonne est tri rapide. Pour changer cela en un algorithme de tri stable, utilisez tri par fusion. Vous pouvez le faire avec le gentil paramètre dans .sort_values ​​() ou .sort_index (), comme ça:

>>>

>>> df.sort_values(
...     par="city08",
...     Ascendant=Faux,
...     gentil="tri par fusion"
... )
                city08 cylindres carburantType ... mpgData trany year
2 23 4 Régulier ... Y Manuel 5 vitesses 1985
7 23 4 Régulier ... Y Automatique 3 vitesses 1993
8 23 4 Régulier ... Y Manuel 5 vitesses 1993
9 23 4 Régulier ... Y Automatique 4 vitesses 1993
10 23 4 Régulier ... Y Manuel 5 vitesses 1993
.. ... ... ... ... ... ... ...
69 10 8 Régulier ... N Automatique 3 vitesses 1985
1 9 12 Régulier ... N Manuel 5 vitesses 1985
47 9 8 Régulier ... N Automatique 3 vitesses 1985
80 9 8 Régulier ... N Automatique 3 vitesses 1985
99 9 8 Premium ... N Automatique 4 vitesses 1993
[100 rows x 10 columns]

Utilisant gentil, vous définissez l'algorithme de tri sur tri par fusion. La sortie précédente utilisait la valeur par défaut tri rapide algorithme. En regardant les index en surbrillance, vous pouvez voir que les lignes sont dans un ordre différent. Ceci est dû au fait tri rapide n'est pas un algorithme de tri stable, mais tri par fusion est.

Lorsque vous triez plusieurs enregistrements ayant la même clé, un algorithme de tri stable conservera l'ordre d'origine de ces enregistrements après le tri. Pour cette raison, l'utilisation d'un algorithme de tri stable est nécessaire si vous prévoyez d'effectuer plusieurs tris.

Tri de votre DataFrame sur plusieurs colonnes

Dans l'analyse des données, il est courant de vouloir trier vos données en fonction des valeurs de plusieurs colonnes. Imaginons que vous ayez un ensemble de données avec le prénom et le nom des personnes. Il serait judicieux de trier par nom de famille, puis par prénom, de sorte que les personnes portant le même nom de famille soient classées par ordre alphabétique selon leurs prénoms.

Dans le premier exemple, vous avez trié votre DataFrame sur une seule colonne nommée ville08. Du point de vue de l’analyse, le MPG en ville est un facteur important qui pourrait déterminer l’opportunité d’une voiture. En plus du MPG dans des conditions urbaines, vous pouvez également consulter MPG pour les conditions routières. Pour trier par deux clés, vous pouvez passer une liste de noms de colonnes à par:

>>>

>>> df.sort_values(
...     par=[[[["city08", "Highway08"]
... )[[[[[[[["city08", "Highway08"]]
                city08 autoroute08
80 9 10
47 9 11
99 9 13
1 9 14
58 10 11
.. ... ...
9 23 30
10 23 30
8 23 31
76 23 31
2 23 33
[100 rows x 2 columns]

En spécifiant une liste des noms de colonnes ville08 et autoroute08, vous triez le DataFrame sur deux colonnes en utilisant .sort_values ​​(). L'exemple suivant expliquera comment spécifier l'ordre de tri et pourquoi il est important de prêter attention à la liste des noms de colonnes que vous utilisez.

Trier par plusieurs colonnes par ordre croissant

Pour trier le DataFrame sur plusieurs colonnes, vous devez fournir une liste de noms de colonnes. Par exemple, pour trier par Fabriquer et maquette, vous devez créer la liste suivante puis la transmettre à .sort_values ​​():

>>>

>>> df.sort_values(
...     par=[[[["Fabriquer", "maquette"]
... )[[[[[[[["Fabriquer", "maquette"]]
                                        faire modèle
0 Alfa Romeo Spider Veloce 2000
18 Audi 100
19 Audi 100
20 BMW 740i
21 BMW 740il
.. ... ...
12 Volkswagen Golf III / GTI
13 Volkswagen Jetta III
15 Volkswagen Jetta III
16 Volvo 240
17 Volvo 240
[100 rows x 2 columns]

Maintenant, votre DataFrame est trié par ordre croissant de Fabriquer. S'il existe au moins deux marques identiques, elles sont triées par maquette. L'ordre dans lequel les noms de colonnes sont spécifiés dans votre liste correspond à la façon dont votre DataFrame sera trié.

Modification de l'ordre de tri des colonnes

Étant donné que vous triez à l'aide de plusieurs colonnes, vous pouvez spécifier l'ordre dans lequel vos colonnes sont triées. Si vous souhaitez modifier l'ordre de tri logique de l'exemple précédent, vous pouvez modifier l'ordre des noms de colonne dans la liste que vous passez à la par paramètre:

>>>

>>> df.sort_values(
...     par=[[[["maquette", "Fabriquer"]
... )[[[[[[[["Fabriquer", "maquette"]]
                                                    faire modèle
18 Audi 100
19 Audi 100
16 Volvo 240
17 Volvo 240
75 Mazda 626
.. ... ...
62 Ford Thunderbird
63 Ford Thunderbird
88 Oldsmobile Toronado
42 CX Automotive XM v6
43 CX Automotive XM v6a
[100 rows x 2 columns]

Votre DataFrame est maintenant trié par maquette colonne par ordre croissant, puis triée par Fabriquer s'il y en a deux ou plus du même modèle. Vous pouvez voir que la modification de l'ordre des colonnes modifie également l'ordre dans lequel les valeurs sont triées.

Trier par plusieurs colonnes par ordre décroissant

Jusqu'à présent, vous n'avez trié que par ordre croissant sur plusieurs colonnes. Dans l'exemple suivant, vous allez trier par ordre décroissant en fonction de la Fabriquer et maquette Colonnes. Pour trier par ordre décroissant, définissez Ascendant à Faux:

>>>

>>> df.sort_values(
...     par=[[[["Fabriquer", "maquette"],
...     Ascendant=Faux
... )[[[[[[[["Fabriquer", "maquette"]]
                                        faire modèle
16 Volvo 240
17 Volvo 240
13 Volkswagen Jetta III
15 Volkswagen Jetta III
11 Volkswagen Golf III / GTI
.. ... ...
21 BMW 740il
20 BMW 740i
18 Audi 100
19 Audi 100
0 Alfa Romeo Spider Veloce 2000
[100 rows x 2 columns]

Les valeurs du Fabriquer sont dans l'ordre alphabétique inverse et les valeurs dans la maquette colonne sont dans l'ordre décroissant pour toutes les voitures avec le même Fabriquer. Avec les données textuelles, le tri est sensible aux majuscules et minuscules, ce qui signifie que le texte en majuscules apparaîtra en premier dans l'ordre croissant et en dernier dans l'ordre décroissant.

Tri par plusieurs colonnes avec différents ordres de tri

Vous vous demandez peut-être s'il est possible de trier à l'aide de plusieurs colonnes et de faire en sorte que ces colonnes utilisent différentes Ascendant arguments. Avec les pandas, vous pouvez le faire avec un seul appel de méthode. Si vous souhaitez trier certaines colonnes par ordre croissant et certaines colonnes par ordre décroissant, vous pouvez passer une liste de booléens à Ascendant.

Dans cet exemple, vous triez votre DataFrame par le Fabriquer, maquette, et ville08 colonnes, avec les deux premières colonnes triées par ordre croissant et ville08 triés par ordre décroissant. Pour ce faire, vous transmettez une liste de noms de colonnes à par et une liste de booléens à Ascendant:

>>>

>>> df.sort_values(
...     par=[[[["Fabriquer", "maquette", "city08"],
...     Ascendant=[[[[Vrai, Vrai, Faux]
... )[[[[[[[["Fabriquer", "maquette", "city08"]]
                                        faire le modèle city08
0 Alfa Romeo Spider Veloce 2000 19
18 Audi 100 17
19 Audi 100 17
20 BMW 740i 14
21 BMW 740il 14
.. ... ... ...
11 Volkswagen Golf III / GTI 18
15 Volkswagen Jetta III 20
13 Volkswagen Jetta III 18
17 Volvo 240 19
16 Volvo 240 18
[100 rows x 3 columns]

Maintenant, votre DataFrame est trié par Fabriquer et maquette par ordre croissant, mais avec le ville08 colonne par ordre décroissant. Ceci est utile car il regroupe les voitures dans un ordre catégorique et affiche en premier les voitures MPG les plus élevées.

Tri de votre DataFrame sur son index

Avant de trier sur l'index, il est judicieux de savoir ce que représente un index. Un DataFrame a un .indice propriété, qui par défaut est une représentation numérique de l'emplacement de ses lignes. Vous pouvez considérer l'index comme les numéros de ligne. Cela facilite la recherche et l'identification rapides des lignes.

Tri par index par ordre croissant

Vous pouvez trier un DataFrame en fonction de son index de ligne avec .sort_index (). Le tri par valeurs de colonne comme vous l'avez fait dans les exemples précédents réorganise les lignes de votre DataFrame, de sorte que l'index se désorganise. Cela peut également se produire lorsque vous filtrez un DataFrame ou lorsque vous déposez ou ajoutez des lignes.

Pour illustrer l'utilisation de .sort_index (), commencez par créer un nouveau DataFrame trié en utilisant .sort_values ​​():

>>>

>>> sorted_df = df.sort_values(par=[[[["Fabriquer", "maquette"])
>>> sorted_df
                city08 cylindres carburantType ... mpgData trany year
0 19 4 Régulier ... Y Manuel 5 vitesses 1985
18 17 6 ​​Premium ... Y Automatique 4 vitesses 1993
19 17 6 ​​Premium ... N Manuel 5 vitesses 1993
20 14 8 Premium ... N Automatique 5 vitesses 1993
21 14 8 Premium ... N Automatique 5 vitesses 1993
.. ... ... ... ... ... ... ...
12 21 4 Régulier ... Y Manuel 5 vitesses 1993
13 18 4 Régulier ... N Automatique 4 vitesses 1993
15 20 4 Régulier ... N Manuel 5 vitesses 1993
16 18 4 Régulier ... Y Automatique 4 vitesses 1993
17 19 4 Régulier ... Y Manuel 5 vitesses 1993
[100 rows x 10 columns]

Vous avez créé un DataFrame qui est trié à l'aide de plusieurs valeurs. Remarquez comment l'index de ligne n'est pas dans un ordre particulier. Pour remettre votre nouveau DataFrame dans l'ordre d'origine, vous pouvez utiliser .sort_index ():

>>>

>>> sorted_df.sort_index()
                city08 cylindres carburantType ... mpgData trany year
0 19 4 Régulier ... Y Manuel 5 vitesses 1985
1 9 12 Régulier ... N Manuel 5 vitesses 1985
2 23 4 Régulier ... Y Manuel 5 vitesses 1985
3 10 8 Régulier ... N Automatique 3 vitesses 1985
4 17 4 Premium ... N Manuel 5 vitesses 1993
.. ... ... ... ... ... ... ...
95 17 6 ​​Régulier ... Y Automatique 3 vitesses 1993
96 17 6 ​​Régulier ... N Automatique 4 vitesses 1993
97 15 6 Régulier ... N Automatique 4 vitesses 1993
98 15 6 Régulier ... N Manuel 5 vitesses 1993
99 9 8 Premium ... N Automatique 4 vitesses 1993
[100 rows x 10 columns]

L'index est maintenant dans l'ordre croissant. Juste comme .sort_values ​​(), l'argument par défaut pour Ascendant dans .sort_index () est Vrai, et vous pouvez passer à l'ordre décroissant en passant Faux. Le tri sur l'index n'a aucun impact sur les données elles-mêmes car les valeurs restent inchangées.

Ceci est particulièrement utile lorsque vous avez attribué un index personnalisé avec .set_index (). Si vous souhaitez définir un index personnalisé à l'aide de Fabriquer et maquette colonnes, vous pouvez ensuite transmettre une liste à .set_index ():

>>>

>>> assign_index_df = df.set_index(
...     [[[["Fabriquer", "maquette"]
... )
>>> assign_index_df
                                                                                                                                        city08 cylindres ... trany year
faire modèle ...
Alfa Romeo Spider Veloce 2000 19 4 ... Manuelle 5 vitesses 1985
Ferrari Testarossa 9 12 ... Manuelle 5 vitesses 1985
Dodge Charger 23 4 ... Manuelle 5 vitesses 1985
                                                B150 / B250 Wagon 2WD 10 8 ... Automatique 3 vitesses 1985
Subaru Legacy AWD Turbo 17 4 ... Manuelle 5 vitesses 1993
                                                                                                                                        ... ... ... ... ...
Pontiac Grand Prix 17 6 ​​... Automatique 3 vitesses 1993
                                                Grand Prix 17 6 ​​... Automatique 4 vitesses 1993
                                                Grand Prix 15 6 ... Automatique 4 vitesses 1993
                                                Grand Prix 15 6 ... Manuelle 5 vitesses 1993
Rolls-Royce Brooklands / Brklnds L 9 8 ... Automatique 4 vitesses 1993
[100 rows x 8 columns]

En utilisant cette méthode, vous remplacez l'index de ligne basé sur un entier par défaut par deux étiquettes d'axe. Ceci est considéré comme un MultiIndex ou un index hiérarchique. Votre DataFrame est maintenant indexé par plus d'une clé, que vous pouvez trier avec .sort_index ():

>>>

>>> assign_index_df.sort_index()
                                                                                                                            city08 cylindres ... trany year
faire modèle ...
Alfa Romeo Spider Veloce 2000 19 4 ... Manuelle 5 vitesses 1985
Audi 100 17 6 ​​... Automatique 4 vitesses 1993
                                            100 17 6 ​​... Manuel 5 vitesses 1993
BMW 740i 14 8 ... Automatique 5 vitesses 1993
                                            740il 14 8 ... Automatique 5 vitesses 1993
                                                                                                                            ... ... ... ... ...
Volkswagen Golf III / GTI 21 4 ... Manuelle 5 vitesses 1993
                                            Jetta III 18 4 ... Automatique 4 vitesses 1993
                                            Jetta III 20 4 ... Manuelle 5 vitesses 1993
Volvo 240 18 4 ... Automatique 4 vitesses 1993
                                            240 19 4 ... Manuel 5 vitesses 1993
[100 rows x 8 columns]

Commencez par attribuer un nouvel index à votre DataFrame à l'aide du Fabriquer et maquette colonnes, puis vous triez l'index en utilisant .sort_index (). Vous pouvez en savoir plus sur l'utilisation .set_index () dans la documentation pandas.

Tri par index par ordre décroissant

Pour l'exemple suivant, vous allez trier votre DataFrame par son index dans l'ordre décroissant. N'oubliez pas de trier votre DataFrame avec .sort_values ​​() que vous pouvez inverser l'ordre de tri en définissant Ascendant à Faux. Ce paramètre fonctionne également avec .sort_index (), vous pouvez donc trier votre DataFrame dans l'ordre inverse comme ceci:

>>>

>>> assign_index_df.sort_index(Ascendant=Faux)
                                                                                                                            city08 cylindres ... trany year
faire modèle ...
Volvo 240 18 4 ... Automatique 4 vitesses 1993
                                            240 19 4 ... Manuel 5 vitesses 1993
Volkswagen Jetta III 18 4 ... Automatique 4 vitesses 1993
                                            Jetta III 20 4 ... Manuelle 5 vitesses 1993
                                            Golf III / GTI 18 4 ... Automatique 4 vitesses 1993
                                                                                                                            ... ... ... ... ...
BMW 740il 14 8 ... Automatique 5 vitesses 1993
                                            740i 14 8 ... Automatique 5 vitesses 1993
Audi 100 17 6 ​​... Automatique 4 vitesses 1993
                                            100 17 6 ​​... Manuel 5 vitesses 1993
Alfa Romeo Spider Veloce 2000 19 4 ... Manuelle 5 vitesses 1985
[100 rows x 8 columns]

Maintenant, votre DataFrame est trié par son index dans l'ordre décroissant. Une différence entre l'utilisation .sort_index () et .sort_values ​​() est-ce .sort_index () n'a pas par car il trie un DataFrame sur l'index de ligne par défaut.

Exploration des concepts avancés de tri d'index

Il existe de nombreux cas dans l'analyse de données où vous souhaitez trier sur un index hiérarchique. Vous avez déjà vu comment vous pouvez utiliser Fabriquer et maquette dans un MultiIndex. Pour cet ensemble de données, vous pouvez également utiliser le identifiant colonne comme un index.

Réglage du identifiant comme index peut être utile pour relier les ensembles de données connexes. Par exemple, l'ensemble de données sur les émissions de l'EPA utilise également identifiant pour représenter les ID d'enregistrement de véhicule. Cela relie les données sur les émissions aux données sur la consommation de carburant. Le tri de l'index des deux ensembles de données dans DataFrames pourrait accélérer en utilisant d'autres méthodes telles que .fusionner(). Pour en savoir plus sur la combinaison de données dans les pandas, consultez Combiner des données dans les pandas avec merge (), .join () et concat ().

Trier les colonnes de votre DataFrame

Vous pouvez également utiliser les étiquettes de colonne de votre DataFrame pour trier les valeurs de ligne. Utilisant .sort_index () avec le paramètre optionnel axe mis à 1 triera le DataFrame par les étiquettes de colonne. L'algorithme de tri est appliqué au étiquettes d'axe au lieu des données réelles. Cela peut être utile pour l'inspection visuelle du DataFrame.

Travailler avec le DataFrame axe

Lorsque vous utilisez .sort_index () sans passer d'arguments explicites, il utilise axe = 0 comme argument par défaut. Le axe d'un DataFrame fait référence soit à l'index (axe = 0) ou les colonnes (axe = 1). Vous pouvez utiliser les deux axes pour indexer et sélectionner des données dans un DataFrame ainsi que pour trier les données.

Utilisation d'étiquettes de colonne pour trier

Vous pouvez également utiliser les étiquettes de colonne d'un DataFrame comme clé de tri pour .sort_index (). Réglage axe à 1 trie les colonnes de votre DataFrame en fonction des étiquettes de colonne:

>>>

>>> df.sort_index(axe=1)
                city08 cylindres carburantType ... mpgData trany year
0 19 4 Régulier ... Y Manuel 5 vitesses 1985
1 9 12 Régulier ... N Manuel 5 vitesses 1985
2 23 4 Régulier ... Y Manuel 5 vitesses 1985
3 10 8 Régulier ... N Automatique 3 vitesses 1985
4 17 4 Premium ... N Manuel 5 vitesses 1993
.. ... ... ... ... ... ... ...
95 17 6 ​​Régulier ... Y Automatique 3 vitesses 1993
96 17 6 ​​Régulier ... N Automatique 4 vitesses 1993
97 15 6 Régulier ... N Automatique 4 vitesses 1993
98 15 6 Régulier ... N Manuel 5 vitesses 1993
99 9 8 Premium ... N Automatique 4 vitesses 1993
[100 rows x 10 columns]

Les colonnes de votre DataFrame sont triées de gauche à droite par ordre alphabétique croissant. Si vous souhaitez trier les colonnes par ordre décroissant, vous pouvez utiliser croissant = Faux:

>>>

>>> df.sort_index(axe=1, Ascendant=Faux)
                année trany mpgData ... fuelType cylindres city08
0 1985 Manuel 5 vitesses Y ... Régulier 4 19
1 1985 Manuel 5 vitesses N ... Régulier 12 9
2 1985 Manuel 5 vitesses Y ... Régulier 4 23
3 1985 Automatique 3 vitesses N ... Régulière 8 10
4 1993 Manuel 5 vitesses N ... Premium 4 17
.. ... ... ... ... ... ... ...
95 1993 Automatique 3 vitesses Y ... Régulier 6 17
96 1993 Automatique 4 vitesses N ... Régulière 6 17
97 1993 Automatique 4 vitesses N ... Régulière 6 15
98 1993 Manuel 5 vitesses N ... Régulier 6 15
99 1993 Automatique 4 vitesses N ... Premium 8 9
[100 rows x 10 columns]

Utilisant axe = 1 dans .sort_index (), vous avez trié les colonnes de votre DataFrame dans l'ordre croissant et décroissant. Cela pourrait être plus utile dans d'autres ensembles de données, comme celui dans lequel les étiquettes de colonne correspondent aux mois de l'année. Dans ce cas, il serait judicieux d'organiser vos données par ordre croissant ou décroissant par mois.

Travailler avec des données manquantes lors du tri dans Pandas

Les données du monde réel comportent souvent de nombreuses imperfections. Bien que pandas dispose de plusieurs méthodes que vous pouvez utiliser pour nettoyer vos données avant de les trier, il est parfois agréable de voir quelles données sont manquantes pendant le tri. Vous pouvez le faire avec le na_position paramètre.

Le sous-ensemble des données d'économie de carburant utilisé pour ce didacticiel ne contient aucune valeur manquante. Pour illustrer l'utilisation de na_position, vous devez d'abord créer des données manquantes. Le morceau de code suivant crée une nouvelle colonne basée sur l'existant mpgData colonne, mappage VraimpgData équivaut à Oui et NaN là où ce n'est pas le cas:

>>>

>>> df[[[["mpgData_"] = df[[[["mpgData"].carte("Y": Vrai)
>>> df
                city08 cylindres fuelType ... trany year mpgData_
0 19 4 Régulier ... Manuel 5 vitesses 1985 Vrai
1 9 12 Régulier ... Manuel 5 vitesses 1985 NaN
2 23 4 Régulier ... Manuel 5 vitesses 1985 Vrai
3 10 8 Régulier ... Automatique 3 vitesses 1985 NaN
4 17 4 Premium ... Manuel 5 vitesses 1993 NaN
.. ... ... ... ... ... ... ...
95 17 6 ​​Régulier ... Automatique 3 vitesses 1993 Vrai
96 17 6 ​​Régulier ... Automatique 4 vitesses 1993 NaN
97 15 6 Régulier ... Automatique 4 vitesses 1993 NaN
98 15 6 Régulier ... Manuel 5 vitesses 1993 NaN
99 9 8 Premium ... Automatique 4 vitesses 1993 NaN
[100 rows x 11 columns]

Vous avez maintenant une nouvelle colonne nommée mpgData_ qui contient les deux Vrai et NaN valeurs. Vous utiliserez cette colonne pour voir quel effet na_position a lorsque vous utilisez les deux méthodes de tri. Pour en savoir plus sur l'utilisation .carte(), vous pouvez lire Pandas Project: Make a Gradebook With Python & Pandas.

Comprendre le na_position Paramètre dans .sort_values ​​()

.sort_values ​​() accepte un paramètre nommé na_position, qui aide à organiser les données manquantes dans la colonne sur laquelle vous effectuez le tri. Si vous triez sur une colonne avec des données manquantes, les lignes avec les valeurs manquantes apparaîtront à la fin de votre DataFrame. Cela se produit indépendamment du fait que vous triiez par ordre croissant ou décroissant.

Voici à quoi ressemble votre DataFrame lorsque vous triez sur la colonne avec des données manquantes:

>>>

>>> df.sort_values(par="mpgData_")
                city08 cylindres fuelType ... trany year mpgData_
0 19 4 Régulier ... Manuel 5 vitesses 1985 Vrai
55 18 6 Régulier ... Automatique 4 vitesses 1993 Vrai
56 18 6 Régulier ... Automatique 4 vitesses 1993 Vrai
57 16 6 Premium ... Manuel 5 vitesses 1993 Vrai
59 17 6 ​​Régulier ... Automatique 4 vitesses 1993 Vrai
.. ... ... ... ... ... ... ...
94 18 6 Régulier ... Automatique 4 vitesses 1993 NaN
96 17 6 ​​Régulier ... Automatique 4 vitesses 1993 NaN
97 15 6 Régulier ... Automatique 4 vitesses 1993 NaN
98 15 6 Régulier ... Manuel 5 vitesses 1993 NaN
99 9 8 Premium ... Automatique 4 vitesses 1993 NaN
[100 rows x 11 columns]

Pour modifier ce comportement et faire apparaître les données manquantes en premier dans votre DataFrame, vous pouvez définir na_position à première. Le na_position le paramètre n'accepte que les valeurs dernier, qui est la valeur par défaut, et première. Voici comment utiliser na_postion dans .sort_values ​​():

>>>

>>> df.sort_values(
...     par="mpgData_",
...     na_position="première"
... )
                city08 cylindres fuelType ... trany year mpgData_
1 9 12 Régulier ... Manuel 5 vitesses 1985 NaN
3 10 8 Régulier ... Automatique 3 vitesses 1985 NaN
4 17 4 Premium ... Manuel 5 vitesses 1993 NaN
5 21 4 Régulier ... Automatique 3 vitesses 1993 NaN
11 18 4 Régulier ... Automatique 4 vitesses 1993 NaN
.. ... ... ... ... ... ... ...
32 15 8 Premium ... Automatique 4 vitesses 1993 Vrai
33 15 8 Premium ... Automatique 4 vitesses 1993 Vrai
37 17 6 ​​Régulier ... Automatique 3 vitesses 1993 Vrai
85 17 6 ​​Régulier ... Automatique 4 vitesses 1993 Vrai
95 17 6 ​​Régulier ... Automatique 3 vitesses 1993 Vrai
[100 rows x 11 columns]

Désormais, toutes les données manquantes dans les colonnes sur lesquelles vous avez effectué le tri seront affichées en haut de votre DataFrame. Ceci est particulièrement utile lorsque vous commencez à analyser vos données et que vous ne savez pas s'il y a des valeurs manquantes.

Comprendre le na_position Paramètre dans .sort_index ()

.sort_index () accepte aussi na_position. Votre DataFrame n’aura généralement pas NaN valeurs comme faisant partie de son index, donc ce paramètre est moins utile dans .sort_index (). Cependant, il est bon de savoir que si votre DataFrame a NaN dans l'index de ligne ou dans un nom de colonne, vous pouvez l'identifier rapidement en utilisant .sort_index () et na_position.

By default, this parameter is set to last, which places NaN values at the end of the sorted result. To change that behavior and have the missing data first in your DataFrame, set na_position à first.

Using Sort Methods to Modify Your DataFrame

In all the examples you’ve seen so far, both .sort_values() et .sort_index() have returned DataFrame objects when you called those methods. That’s because sorting in pandas doesn’t work in place by default. In general, this is the most common and preferred way to analyze your data with pandas since it creates a new DataFrame instead of modifying the original. This allows you to preserve the state of the data from when you read it from your file.

However, you can modify the original DataFrame directly by specifying the optional parameter inplace with the value of Vrai. The majority of pandas methods include the inplace parameter. Below, you’ll see a few examples of using inplace=True to sort your DataFrame in place.

Using .sort_values() In Place

Avec inplace set to Vrai, you modify the original DataFrame, so the sort methods return Aucun. Sort your DataFrame by the values of the city08 column like the very first example, but with inplace set to Vrai:

>>>

>>> df.sort_values("city08", inplace=Vrai)

Notice how calling .sort_values() doesn’t return a DataFrame. Here’s what the original df looks like:

>>>

>>> df
                city08  cylinders fuelType  ...            trany  year mpgData_
99       9          8  Premium  ...  Automatic 4-spd  1993      NaN
1        9         12  Regular  ...     Manual 5-spd  1985      NaN
80       9          8  Regular  ...  Automatic 3-spd  1985      NaN
47       9          8  Regular  ...  Automatic 3-spd  1985      NaN
3       10          8  Regular  ...  Automatic 3-spd  1985      NaN
..     ...        ...      ...  ...              ...   ...      ...
9       23          4  Regular  ...  Automatic 4-spd  1993     True
8       23          4  Regular  ...     Manual 5-spd  1993     True
7       23          4  Regular  ...  Automatic 3-spd  1993     True
76      23          4  Regular  ...     Manual 5-spd  1993     True
2       23          4  Regular  ...     Manual 5-spd  1985     True
[100 rows x 11 columns]

Dans le df object, the values are now sorted in ascending order based on the city08 column. Your original DataFrame has been modified, and the changes will persist. It’s generally a good idea to avoid using inplace=True for analysis because the changes to your DataFrame can’t be undone.

Using .sort_index() In Place

The next example illustrates that inplace also works with .sort_index().

Since the index was created in ascending order when you read your file into a DataFrame, you can modify your df object again to get it back to its initial order. Use .sort_index() avec inplace set to Vrai to modify the DataFrame:

>>>

>>> df.sort_index(inplace=Vrai)
>>> df
                city08  cylinders fuelType  ...            trany  year mpgData_
0       19          4  Regular  ...     Manual 5-spd  1985     True
1        9         12  Regular  ...     Manual 5-spd  1985      NaN
2       23          4  Regular  ...     Manual 5-spd  1985     True
3       10          8  Regular  ...  Automatic 3-spd  1985      NaN
4       17          4  Premium  ...     Manual 5-spd  1993      NaN
..     ...        ...      ...  ...              ...   ...      ...
95      17          6  Regular  ...  Automatic 3-spd  1993     True
96      17          6  Regular  ...  Automatic 4-spd  1993      NaN
97      15          6  Regular  ...  Automatic 4-spd  1993      NaN
98      15          6  Regular  ...     Manual 5-spd  1993      NaN
99       9          8  Premium  ...  Automatic 4-spd  1993      NaN
[100 rows x 11 columns]

Now your DataFrame has been modified again using .sort_index(). Since your DataFrame still has its default index, sorting it in ascending order puts the data back into its original order.

If you’re familiar with Python’s built-in functions sort() et sorted(), then the inplace parameter available in the pandas sort methods might feel very similar. For more information, you can check out How to Use sorted() and sort() in Python.

Conclusion

You now know how to use two core methods of the pandas library: .sort_values() et .sort_index(). With this knowledge, you can perform basic data analysis with a DataFrame. While there are a lot of similarities between these two methods, seeing the difference between them makes it clear which one to use for different analytical tasks.

In this tutorial, you’ve learned how to:

  • Sort a pandas DataFrame by the values of one or more columns
  • Use the ascending parameter to change the sort order
  • Sort a DataFrame by its index using .sort_index()
  • Organize missing data while sorting values
  • Sort a DataFrame in place using inplace set to Vrai

These methods are a big part of being proficient with data analysis. They’ll help you build a strong foundation on which you can perform more advanced pandas operations. If you want to see some examples of more advanced uses of pandas sort methods, then the pandas documentation is a great resource.

[ad_2]