Visualiser les données avec plotnine – Real Python

By | octobre 12, 2020

Formation gratuite Python

Dans ce didacticiel, vous apprendrez à utiliser ggplot en Python pour créer des visualisations de données à l'aide d'un grammaire des graphiques. Une grammaire des graphiques est un outil de haut niveau qui vous permet de créer des tracés de données de manière efficace et cohérente. Il résume la plupart des détails de bas niveau, vous permettant de vous concentrer sur la création de visualisations significatives et belles pour vos données.

Il existe plusieurs packages Python qui fournissent une grammaire des graphiques. Ce tutoriel se concentre sur plotnine car c’est l’une des plus matures. plotnine est basé sur ggplot2 du langage de programmation R, donc si vous avez une formation en R, vous pouvez considérer plotnine comme l'équivalent de ggplot2 en Python.

Dans ce didacticiel, vous apprendrez à:

  • Installer plotnine et Cahier Jupyter
  • Combinez les différents éléments du grammaire des graphiques
  • Utilisez plotnine pour créer des visualisations de manière efficace et cohérente
  • Exportation vos visualisations de données dans des fichiers

Ce tutoriel suppose que vous avez déjà une certaine expérience de Python et au moins une certaine connaissance de Cahier Jupyter et pandas. Pour vous familiariser avec ces sujets, consultez Jupyter Notebook: une introduction et l'utilisation de Pandas et de Python pour explorer votre ensemble de données.

Configuration de votre environnement

Dans cette section, vous apprendrez à configurer votre environnement. Vous aborderez les sujets suivants:

  1. Créer un environnement virtuel
  2. Installation de plotnine
  3. Installer Juptyer Notebook

Environnements virtuels vous permettent d'installer des packages dans des environnements isolés. Ils sont très utiles lorsque vous souhaitez essayer certains packages ou projets sans perturber votre installation à l’échelle du système. Vous pouvez en savoir plus à leur sujet dans Python Virtual Environments: A Primer.

Exécutez les commandes suivantes pour créer un répertoire nommé visualisation de données et un environnement virtuel à l'intérieur:

$ visualisation de données mkdir
$ CD visualisation de données
$ python3 -m venv venv

Après avoir exécuté les commandes ci-dessus, vous trouverez votre environnement virtuel dans le visualisation de données annuaire. Exécutez la commande suivante pour activer l'environnement virtuel et commencer à l'utiliser:

$ la source ./venv/bin/activate

Lorsque vous activez un environnement virtuel, tout package que vous installez sera installé dans l'environnement sans affecter votre installation à l'échelle du système.

Ensuite, vous installerez plotnine dans l'environnement virtuel à l'aide de pépin installateur de paquets.

Installez plotnine en exécutant cette commande:

L'exécution de la commande ci-dessus rend le plotnine package disponible dans votre environnement virtuel.

Enfin, vous installerez Jupyter Notebook. Bien que cela ne soit pas strictement nécessaire pour utiliser plotnine, vous trouverez Jupyter Notebook vraiment utile lorsque vous travaillez avec des données et créez des visualisations. Si vous n’avez jamais utilisé le programme auparavant, vous pouvez en savoir plus sur Jupyter Notebook: An Introduction.

Pour installer Jupyter Notebook, utilisez la commande suivante:

Félicitations, vous disposez maintenant d'un environnement virtuel avec plotnine et Jupyter Notebook installés! Avec cette configuration, vous pourrez exécuter tous les exemples de code présentés dans ce didacticiel.

Construire votre première parcelle avec ggplot et Python

Dans cette section, vous apprendrez à créer votre première visualisation de données à l'aide de ggplot en Python. Vous apprendrez également à inspecter et à utiliser les exemples de jeux de données inclus avec plotnine.

Les exemples de jeux de données sont très pratiques lorsque vous vous familiarisez avec les fonctionnalités de plotnine. Chaque ensemble de données est fourni sous la forme d'un pandas DataFrame, une structure de données tabulaire bidimensionnelle conçue pour contenir des données.

Vous utiliserez les ensembles de données suivants dans ce didacticiel:

  • économie: Une série chronologique de données économiques américaines
  • mpg: Données de consommation de carburant pour une gamme de véhicules
  • huron: Le niveau du lac Huron entre les années 1875 et 1972

Vous pouvez trouver la liste complète des exemples de jeux de données dans la référence plotnine.

Vous pouvez utiliser Jupyter Notebook pour inspecter n'importe quel ensemble de données. Lancez Jupyter Notebook avec les commandes suivantes:

$ la source ./venv/bin/activate
$ cahier-jupyter

Ensuite, une fois dans Jupyter Notebook, exécutez le code suivant pour voir les données brutes dans le économie base de données:

de plotnine.data importer économie

économie

Le code importe le économie ensemble de données de plotnine.data et le montre dans un tableau:

                        date pce pop psavert uempmed chômeurs
0 1967-07-01 507,4 198712 12,5 4,5 2944
1 1967-08-01 510,5 198911 12,5 4,7 2945
... ... ... ... ... ... ...
572 01/03/2015 12161,5 320707 5,2 12,2 8575
573 01/04/2015 12158,9 320887 5,6 11,7 8549

Comme vous pouvez le voir, l'ensemble de données comprend des informations économiques pour chaque mois entre les années 1967 et 2015. Chaque ligne contient les champs suivants:

  • Date: Le mois où les données ont été collectées
  • pce: Dépenses de consommation personnelle (en milliards de dollars)
  • pop: La population totale (en milliers)
  • psavert: Le taux d'épargne personnelle
  • uempmed: La durée médiane du chômage (en semaines)
  • chômeurs: Le nombre de chômeurs (en milliers)

Maintenant, en utilisant plotnine, vous pouvez créer un graphique pour montrer l'évolution de la population au fil des ans:

    1 de plotnine.data importer économie
    2 de plotnine importer ggplot, aes, geom_line
    3 
    4 (
    5     ggplot(économie)  # Quelles données utiliser
    6     + aes(X="Date", y="pop")  # Quelle variable utiliser
    7     + geom_line()  # Objet géométrique à utiliser pour le dessin
    8 )

Cet exemple de code court crée un tracé à partir de économie base de données. Voici une ventilation rapide:

  1. Ligne 1: Vous importez le économie base de données.

  2. Ligne 2: Vous importez le ggplot () classe ainsi que quelques fonctions utiles de plotnine, aes () et geom_line ().

  3. Ligne 5: Vous créez un objet de tracé en utilisant ggplot (), en passant le économie DataFrame au constructeur.

  4. Ligne 6: Vous ajoutez aes () pour définir la variable à utiliser pour chaque axe, dans ce cas Date et pop.

  5. Ligne 7: Vous ajoutez geom_line () pour spécifier que le graphique doit être dessiné sous forme de graphique linéaire.

L'exécution du code ci-dessus donne la sortie suivante:

Exemple Hello Plotnine

Vous venez de créer un graphique montrant l’évolution de la population au fil du temps!

Dans cette section, vous avez vu les trois composants requis que vous devez spécifier lors de l'utilisation de la grammaire des graphiques:

  1. Les données que vous souhaitez tracer
  2. Les variables à utiliser sur chaque axe
  3. L'objet géométrique à utiliser pour le dessin

Vous avez également vu que différents composants sont combinés à l'aide du + opérateur.

Dans les sections suivantes, vous examinerez plus en détail les grammaires des graphiques et la manière de créer des visualisations de données à l'aide de plotnine.

Comprendre les grammaires des graphiques

Une grammaire de graphiques est un outil de haut niveau qui vous permet de décrire les composants d'un graphique, en vous faisant abstraction des détails de bas niveau de la peinture des pixels dans une toile.

Cela s'appelle un grammaire car il définit un ensemble de composants et les règles pour les combiner pour créer des graphiques, tout comme une grammaire de langage définit comment vous pouvez combiner des mots et des signes de ponctuation pour former des phrases. Vous pouvez en savoir plus sur les fondements des grammaires graphiques dans le livre de Leland Wilkinson La grammaire des graphiques.

Il existe de nombreuses grammaires graphiques différentes, et elles diffèrent par les composants et les règles qu'elles utilisent. La grammaire des graphiques implémentée par plotnine est basée sur ggplot2 à partir du langage de programmation R. Cette grammaire spécifique a été présentée dans l'article de Hadley Wickham «A Layered Grammar of Graphics».

Ci-dessous, vous découvrirez les principaux composants et règles de la grammaire graphique de plotnine et comment les utiliser pour créer des visualisations de données. Tout d'abord, vous récapitulerez les trois composants requis pour créer un tracé:

  1. Les données sont les informations à utiliser lors de la création du tracé.

  2. Esthétique (aes) fournit un mappage entre les variables de données et les variables esthétiques ou graphiques utilisées par le système de dessin sous-jacent. Dans la section précédente, vous avez mappé le Date et pop variables de données aux variables esthétiques des axes x et y.

  3. Objets géométriques (geoms) définit le type d'objet géométrique à utiliser dans le dessin. Vous pouvez utiliser des points, des lignes, des barres et bien d'autres.

Sans l’un de ces trois composants, plotnine ne saurait pas dessiner le graphique.

Vous découvrirez également les composants optionnels que vous pouvez utiliser:

  • Transformations statistiques spécifier les calculs et les agrégations à appliquer aux données avant de les tracer.

  • Balance appliquer une certaine transformation pendant le mappage des données à l'esthétique. Par exemple, vous pouvez parfois utiliser une échelle logarithmique pour mieux refléter certains aspects de vos données.

  • Facettes vous permettent de diviser les données en groupes en fonction de certains attributs, puis de tracer chaque groupe dans un panneau distinct dans le même graphique.

  • Systèmes de coordonnées mappez la position des objets à un emplacement graphique 2D dans le tracé. Par exemple, vous pouvez choisir d’inverser les axes vertical et horizontal si cela a plus de sens dans la visualisation que vous créez.

  • Thèmes vous permet de contrôler les propriétés visuelles telles que les couleurs, les polices et les formes.

Ne vous inquiétez pas si vous ne comprenez pas complètement ce qu'est chaque composant pour le moment. Vous en apprendrez plus à leur sujet tout au long de ce didacticiel.

Tracer des données à l'aide de Python et ggplot

Dans cette section, vous en apprendrez plus sur les trois composants requis pour créer une visualisation de données à l'aide de plotnine:

  1. Les données
  2. Esthétique
  3. Objets géométriques

Vous verrez également comment ils sont combinés pour créer un tracé à partir d'un ensemble de données.

Les données: la source de l'information

Lorsque vous créez une visualisation de données, la première étape consiste à spécifier les données à tracer. Dans plotnine, vous faites cela en créant un ggplot objet et en transmettant l'ensemble de données que vous souhaitez utiliser au constructeur.

Le code suivant crée un ggplot objet utilisant le jeu de données d'exemple d'économie de carburant de plotnine, mpg:

de plotnine.data importer mpg
de plotnine importer ggplot

ggplot(mpg)

Ce code crée un objet appartenant à la classe ggplot en utilisant le mpg base de données. Notez que puisque vous n’avez pas encore spécifié l’esthétique ou l’objet géométrique, le code ci-dessus générera un tracé vide. Ensuite, vous construirez l'intrigue pièce par pièce.

Comme vous l'avez vu précédemment, vous pouvez inspecter l'ensemble de données de Jupyter Notebook avec le code suivant:

de plotnine.data importer mpg

mpg

Ces deux lignes de code importent et affichent l'ensemble de données, affichant la sortie suivante:

        fabricant modèle année cylindrique cylindre trans drv cty hwy classe fl
0 audi a4 1.8 1999 4 auto (l5) f 18 29 p compacte
1 audi a4 1.8 1999 4 manuelle (m5) f 21 29 p compacte
2 audi a4 2.0 2008 4 manuel (m6) f 20 31 p compact
...

La sortie est un tableau contenant les données de consommation de carburant pour 234 voitures de 1999 à 2008. Le déplacement (dépl) est la taille du moteur en litres. cty et autoroute sont la consommation de carburant en miles par gallon pour la conduite en ville et sur autoroute.

Dans les sections suivantes, vous apprendrez les étapes pour transformer ces données brutes en graphiques à l’aide de plotnine.

Esthétique: définir des variables pour chaque axe

Après avoir spécifié les données que vous souhaitez visualiser, l'étape suivante consiste à définir la variable que vous souhaitez utiliser pour chaque axe de votre tracé. Chaque ligne d'un DataFrame peut contenir de nombreux champs, vous devez donc indiquer à plotnine les variables que vous souhaitez utiliser dans le graphique.

L'esthétique associe les variables de données aux attributs graphiques, comme la position 2D et la couleur. Par exemple, le code suivant crée un graphique qui montre les classes de véhicules sur l'axe des x et la consommation de carburant sur l'autoroute sur l'axe des y:

de plotnine.data importer mpg
de plotnine importer ggplot, aes

ggplot(mpg) + aes(X="classe", y="hwy")

En utilisant le ggplot objet de la section précédente comme base de la visualisation, le code cartographie le véhicule classe attribut à l'axe graphique horizontal et au autoroute économie de carburant sur l'axe vertical.

Mais le tracé généré est toujours vide car il manque l’objet géométrique pour représenter chaque élément de données.

Objets géométriques: choisissez différents types de tracé

Après avoir défini vos données et les attributs que vous souhaitez utiliser dans le graphique, vous devez spécifier un objet géométrique pour indiquer à plotnine comment les points de données doivent être dessinés.

plotnine fournit de nombreux objets géométriques que vous pouvez utiliser prêts à l'emploi, tels que des lignes, des points, des barres, des polygones et bien plus encore. Une liste de tous les objets géométriques disponibles est disponible dans plotnine's geoms Référence API.

Le code suivant montre comment utiliser l'objet géométrique ponctuel pour tracer des données:

de plotnine.data importer mpg
de plotnine importer ggplot, aes, geom_point

ggplot(mpg) + aes(X="classe", y="hwy") + geom_point()

Dans le code ci-dessus, geom_point () sélectionne l'objet géométrique ponctuel. L'exécution du code produit la sortie suivante:

Graphique montrant la consommation de carburant des véhicules de différentes classes

Comme vous pouvez le voir, la visualisation des données générées a un point pour chaque véhicule de l'ensemble de données. Les axes indiquent la classe du véhicule et la consommation de carburant sur autoroute.

Il existe de nombreux autres objets géométriques que vous pouvez utiliser pour visualiser le même jeu de données. Par exemple, le code suivant utilise l'objet géométrique bar pour afficher le nombre de véhicules pour chaque classe:

de plotnine.data importer mpg
de plotnine importer ggplot, aes, geom_bar

ggplot(mpg) + aes(X="classe") + geom_bar()

Ici, geom_bar () définit l'objet géométrique sur bar. Étant donné que le code ne spécifie aucun attribut pour l'axe des y, geom_bar () regroupe implicitement les points de données par l'attribut utilisé pour l'axe des x, puis utilise le nombre de points dans chaque groupe pour l'axe des y.

En exécutant le code, vous verrez le résultat suivant:

Tracez le nombre de véhicules dans chaque classe à l'aide de barres

La hauteur de chaque barre du graphique représente le nombre de véhicules appartenant à la classe de véhicules correspondante. Vous en apprendrez plus sur l'agrégation de données et le regroupement de ces dernières sections.

Dans cette section, vous avez découvert les trois composants obligatoires qui doivent être spécifiés lors de la création de visualisations de données:

  1. Les données
  2. Esthétique
  3. Objets géométriques

Vous avez également appris à les combiner en utilisant le + opérateur.

Dans les sections suivantes, vous découvrirez certains composants facultatifs que vous pouvez utiliser pour créer des graphiques plus complexes et plus beaux.

Utilisation de Python supplémentaire et ggplot Fonctionnalités pour améliorer les visualisations de données

Dans cette section, vous allez découvrir les composants facultatifs que vous pouvez utiliser lors de la création de visualisations de données avec plotnine. Ces composants peuvent être regroupés en cinq catégories:

  1. Transformations statistiques
  2. Balance
  3. Systèmes de coordonnées
  4. Facettes
  5. Thèmes

Vous pouvez les utiliser pour créer des parcelles plus riches et plus belles.

Transformations statistiques: agrégez et transformez vos données

Les transformations statistiques appliquent un certain calcul aux données avant de les tracer, par exemple pour afficher un indicateur statistique au lieu des données brutes. plotnine comprend plusieurs transformations statistiques que vous pouvez utiliser.

Disons que vous souhaitez créer un histogramme pour afficher les distributions des niveaux du lac Huron de 1875 à 1975. Cet ensemble de données est inclus avec plotnine. Vous pouvez utiliser le code suivant pour inspecter l'ensemble de données de Jupyter Notebook et en savoir plus sur son format:

# Importez notre exemple de jeu de données avec les niveaux du lac Huron 1875–1975
de plotnine.data importer huron

huron

Le code importe et affiche l'ensemble de données, produisant la sortie suivante:

                niveau de l'année décennie
0 1875 580,38 1870
1 1876 581,86 1870
...
96 1971 579,89 1970
97 1972 579,96 1970

Comme vous pouvez le voir, l'ensemble de données contient trois colonnes:

  1. année
  2. niveau
  3. décennie

Vous pouvez maintenant créer l'histogramme en deux étapes:

  1. Regroupez les mesures de niveau dans des bacs.
  2. Affichez le nombre de mesures dans chaque bac à l'aide d'un diagramme à barres.

Le code suivant montre comment ces étapes peuvent être effectuées dans plotnine:

de plotnine.data importer huron
de plotnine importer ggplot, aes, stat_bin, geom_bar

ggplot(huron) + aes(X="niveau") + stat_bin(bacs=dix) + geom_bar()

Dans le code ci-dessus, stat_bin () divise le niveau gamme dans dix bacs de taille égale. Ensuite, le nombre de mesures qui tombe dans chaque case est dessiné à l'aide d'un diagramme à barres.

L'exécution du code produit le graphique suivant:

Histogramme du niveau du lac Huron

Ce graphique montre le nombre de mesures pour chaque gamme de niveaux de lac. Comme vous pouvez le voir, la plupart du temps, le niveau se situait entre 578 et 580.

Pour les tâches les plus courantes, comme la création d'histogrammes, plotnine inclut des fonctions très pratiques qui rendent le code plus concis. Par exemple, avec geom_histogram (), vous pouvez construire l'histogramme ci-dessus comme ceci:

de plotnine.data importer huron
de plotnine importer ggplot, aes, geom_histogram

ggplot(huron) + aes(X="niveau") + geom_histogram(bacs=dix)

En utilisant geom_histogram () revient à utiliser stats_bin () et alors geom_bar (). L'exécution de ce code génère le même graphique que vous avez vu ci-dessus.

Voyons maintenant un autre exemple de transformation statistique. UNE boîte à moustaches est un outil statistique très populaire utilisé pour afficher le minimum, le maximum, la médiane de l'échantillon, les premier et troisième quartiles et les valeurs aberrantes d'un ensemble de données.

Supposons que vous souhaitiez créer une visualisation basée sur le même jeu de données pour afficher une boîte à moustaches pour les mesures de niveau de chaque décennie. Vous pouvez construire ce graphique en deux étapes:

  1. Regroupez les mesures par décennie.
  2. Créez une boîte à moustaches pour chaque groupe.

Vous pouvez faire la première étape en utilisant facteur() dans la spécification esthétique. facteur() regroupe tous les points de données qui partagent la même valeur pour l'attribut spécifié.

Ensuite, une fois que vous avez regroupé les données par décennie, vous pouvez dessiner une boîte à moustaches pour chaque groupe en utilisant geom_boxplot ().

Le code suivant crée un tracé en suivant les étapes décrites ci-dessus:

de plotnine.data importer huron
de plotnine importer ggplot, aes, geom_boxplot

(
  ggplot(huron)
  + aes(X="facteur (décennie)", y="niveau")
  + geom_boxplot()
)

Le code regroupe les lignes de données par décennie en utilisant facteur() puis utilise geom_boxplot () pour créer les boîtes à moustaches.

Comme vous l'avez vu dans l'exemple précédent, certains objets géométriques ont des transformations statistiques implicites. C'est vraiment pratique car cela rend votre code plus concis. En utilisant geom_boxplot () implique stat_boxplot (), qui prend en charge le calcul des quartiles et des valeurs aberrantes.

En exécutant le code ci-dessus, vous obtiendrez le graphique suivant:

Boîte à moustaches du niveau du lac Huron pour chaque décennie

Le graphique montre les distributions des niveaux d'eau à l'aide d'une boîte à moustaches pour chaque décennie.

Il existe d'autres transformations statistiques que vous pouvez utiliser pour créer des visualisations de données à l'aide de ggplot en Python. Vous pouvez en apprendre davantage à leur sujet dans la documentation de l'API stats de plotnine.

Échelles: changer l'échelle des données en fonction de sa signification

Les échelles sont un autre type de transformation que vous pouvez appliquer lors du mappage des données à l'esthétique. Ils peuvent aider à rendre vos visualisations plus faciles à comprendre.

Au début de ce didacticiel, vous avez vu un graphique montrant la population de chaque année depuis 1970. Le code suivant montre comment vous pouvez utiliser des échelles pour afficher les années écoulées depuis 1970 au lieu des dates brutes:

de plotnine.data importer économie
de plotnine importer ggplot, aes, scale_x_timedelta, laboratoires, geom_line

(
    ggplot(économie)
    + aes(X="Date", y="pop")
    + scale_x_timedelta(Nom="Années depuis 1970")
    + laboratoires(Titre=«Évolution de la population», y="Population")
    + geom_line()
)

En utilisant scale_x_timedelta () transforme la valeur x de chaque point en calculant sa différence par rapport à la date la plus ancienne de l'ensemble de données. Notez que le code utilise également laboratoires () pour définir une étiquette plus descriptive sur l'axe des y et le titre.

L'exécution du code montre ce tracé:

Tracé montrant l'échelle delta de la date, les étiquettes et les titres

Sans modifier les données, vous avez rendu la visualisation plus facile à comprendre et plus conviviale pour le lecteur. Comme vous pouvez le voir, le graphique a maintenant de meilleures descriptions et l'axe des x montre les années écoulées depuis 1970 au lieu des dates.

plotnine fournit un grand nombre de transformations d'échelle parmi lesquelles vous pouvez choisir, y compris des échelles logarithmiques et d'autres échelles non linéaires. Vous pouvez en apprendre davantage à leur sujet dans la référence API des balances de plotnine.

Systèmes de coordonnées: mapper des valeurs de données à un espace 2D

Un système de coordonnées définit la manière dont les points de données sont mappés aux emplacements graphiques 2D dans le tracé. Vous pouvez le considérer comme une carte des variables mathématiques aux positions graphiques. Le choix du bon système de coordonnées peut améliorer la lisibilité de vos visualisations de données.

Reprenons l'exemple précédent du graphique à barres pour compter les véhicules appartenant à différentes classes. Vous avez créé le tracé à l'aide du code suivant:

de plotnine.data importer mpg
de plotnine importer ggplot, aes, geom_bar

ggplot(mpg) + aes(X="classe") + geom_bar()

Le code utilise geom_bar () pour dessiner une barre pour chaque classe de véhicule. Puisqu'aucun système de coordonnées particulier n'est défini, celui par défaut est utilisé.

L'exécution du code génère le tracé suivant:

Tracez le nombre de véhicules dans chaque classe à l'aide de barres

La hauteur de chaque barre du graphique représente le nombre de véhicules dans une classe.

Bien qu'il n'y ait rien de mal avec le graphique ci-dessus, les mêmes informations pourraient être mieux visualisées en inversant les axes pour afficher des barres horizontales au lieu de verticales.

plotnine fournit plusieurs fonctions qui vous permettent de modifier le système de coordonnées. Vous pouvez inverser les axes en utilisant coord_flip ():

de plotnine.data importer mpg
de plotnine importer ggplot, aes, geom_bar, coord_flip

ggplot(mpg) + aes(X="classe") + geom_bar() + coord_flip()

Le code inverse les axes x et y en utilisant coord_flip (). En exécutant le code, vous verrez le graphique suivant:

Véhicules dans chaque diagramme à barres de classe avec coordonnées inversées

Ce graphique montre les mêmes informations que vous avez vues dans le graphique précédent, mais en inversant les axes, vous trouverez peut-être plus facile de comprendre et de comparer différentes barres.

Il n’existe pas de règle absolue sur le meilleur système de coordonnées. Vous devez choisir celui qui convient le mieux à votre problème et à vos données. Essayez-les et faites des expériences pour savoir ce qui fonctionne pour chaque cas. Vous pouvez trouver plus d'informations sur les autres systèmes de coordonnées dans la référence API de coordonnées de plotnine.

Facettes: tracer des sous-ensembles de données dans des panneaux dans le même tracé

Dans cette section, vous allez découvrir facettes, l'une des fonctionnalités les plus intéressantes de plotnine. Les facettes vous permettent de regrouper les données selon certains attributs, puis de tracer chaque groupe individuellement, mais dans la même image. Ceci est particulièrement utile lorsque vous souhaitez afficher plus de deux variables dans le même graphique.

Par exemple, supposons que vous souhaitiez utiliser l'ensemble de données sur la consommation de carburant (mpg) et construisez un graphique montrant les miles par gallon pour chaque taille de moteur (déplacement) pour chaque classe de véhicule pour chaque année. Dans ce cas, votre tracé doit afficher les informations de quatre variables:

  1. autoroute: Miles par gallon
  2. déplaire: La taille du moteur
  3. classe: Classe de véhicule
  4. année: Année modèle

Cela présente un défi, car vous avez plus de variables que de dimensions graphiques. Vous pourriez utiliser une perspective 3D si vous deviez afficher trois variables, mais un graphique en quatre dimensions est difficile à imaginer.

Il existe une astuce en deux étapes que vous pouvez utiliser face à ce problème:

  1. Commencez par partitionner les données en groupes où tous les points de données d'un groupe partagent les mêmes valeurs pour certains attributs.

  2. Tracez chaque groupe individuellement, en affichant uniquement les attributs non utilisés dans le regroupement.

Pour revenir à l'exemple, vous pouvez regrouper les véhicules par classe et par année, puis tracer chaque groupe pour afficher le déplacement et les miles par gallon. La visualisation suivante a été générée à l'aide de cette technique:

Exemple de graphique utilisant des facettes pour afficher des sous-graphiques pour les classes de véhicules et les années

Comme vous pouvez le voir dans le graphique ci-dessus, il y a un panneau pour chaque groupe. Chaque panneau montre les miles par gallon pour différents déplacements de moteur appartenant à cette classe de véhicule et à cette année.

Cette visualisation de données a été générée avec le code suivant:

de plotnine.data importer mpg
de plotnine importer ggplot, aes, facet_grid, laboratoires, geom_point

(
    ggplot(mpg)
    + facet_grid(facettes="année ~ classe")
    + aes(X="dépl", y="hwy")
    + laboratoires(
        X="La taille du moteur",
        y="Miles par gallon",
        Titre="Miles par gallon pour chaque année et classe de véhicule",
    )
    + geom_point()
)

Le code partitionne les données par année et par classe de véhicule en utilisant facet_grid (), en lui passant les attributs à utiliser pour le partitionnement avec facettes = "année ~ classe". Pour chaque partition de données, le tracé est construit à l'aide des composants que vous avez vus dans les sections précédentes, comme l'esthétique, les objets géométriques et laboratoires ().

facet_grid () affiche les partitions dans une grille, en utilisant un attribut pour les lignes et l'autre pour les colonnes. plotnine fournit d'autres méthodes de facettage que vous pouvez utiliser pour partitionner vos données à l'aide de plus de deux attributs. Pour en savoir plus, consultez la référence API des facettes de plotnine.

Thèmes: améliorez l'apparence de votre visualisation

Un autre excellent moyen d'améliorer la présentation de vos visualisations de données consiste à choisir un thème autre que celui par défaut pour faire ressortir vos graphiques, les rendant plus beaux et plus dynamiques.

plotnine comprend plusieurs thèmes parmi lesquels vous pouvez choisir. Le code suivant génère le même graphique que celui que vous avez vu dans la section précédente, mais en utilisant le thème sombre:

de plotnine.data importer mpg
de plotnine importer ggplot, aes, facet_grid, laboratoires, geom_point, theme_dark

(
    ggplot(mpg)
    + facet_grid(facettes="année ~ classe")
    + aes(X="dépl", y="hwy")
    + laboratoires(
        X="La taille du moteur",
        y="Miles par gallon",
        Titre="Miles par gallon pour chaque année et classe de véhicule",
    )
    + geom_point()
    + theme_dark()
)

Dans le code ci-dessus, en spécifiant theme_dark () dit à plotnine de dessiner l'intrigue en utilisant un thème sombre. Voici le graphique généré par ce code:

Thème sombre de Plotnine

Comme vous pouvez le voir sur l'image, la définition du thème affecte les couleurs, les polices et les styles de formes.

theme_xkcd () est un autre thème qui mérite d'être mentionné car il vous donne un look de bande dessinée vraiment cool. Cela donne à vos visualisations de données l'apparence des bandes dessinées xkcd:

Thème xkcd de Plotnine

Choisir le bon thème peut vous aider à attirer et à retenir l'attention de votre public. Vous pouvez voir une liste des thèmes disponibles dans la référence API des thèmes de plotnine.

Dans les sections précédentes, vous avez découvert les aspects les plus importants des grammaires graphiques et comment utiliser plotnine pour créer des visualisations de données. En utilisant ggplot en Python vous permet de créer des visualisations progressivement, en vous concentrant d'abord sur vos données, puis en ajoutant et en ajustant des composants pour améliorer sa représentation graphique.

Dans la section suivante, vous apprendrez à utiliser les couleurs et à exporter vos visualisations.

Visualisation des données multidimensionnelles

Comme vous l'avez vu dans la section sur les facettes, l'affichage de données avec plus de deux variables présente certains défis. Dans cette section, vous apprendrez à afficher trois variables en même temps, en utilisant des couleurs pour représenter les valeurs.

Par exemple, revenir à l'ensemble de données sur l'économie de carburant (mpg), supposons que vous souhaitiez visualiser la relation entre le nombre de cylindres du moteur et le rendement énergétique, mais que vous souhaitiez également inclure les informations sur les classes de véhicules dans le même graphique.

Comme alternative au facettage, vous pouvez utiliser des couleurs pour représenter la valeur de la troisième variable. Pour ce faire, vous devez mapper le nombre de cylindres du moteur sur l'axe x et les miles par gallon sur l'axe y, puis utiliser différentes couleurs pour représenter les classes de véhicules.

Le code suivant crée la visualisation de données décrite:

de plotnine.data importer mpg
de plotnine importer ggplot, aes, laboratoires, geom_point

(
    ggplot(mpg)
    + aes(X="cyl", y="hwy", Couleur="classe")
    + laboratoires(
        X="Cylindres de moteur",
        y="Miles par gallon",
        Couleur="Classe de véhicule",
        Titre="Miles par gallon pour les cylindres de moteur et les classes de véhicules",
    )
    + geom_point()
)

La classe de véhicule est mappée à la couleur graphique en passant color = "classe" dans la définition esthétique.

L'exécution du code affiche ce graphique:

Tracer en utilisant des couleurs pour représenter les classes de véhicules

Comme vous pouvez le voir, les points ont des couleurs différentes selon la classe à laquelle appartient le véhicule.

Dans cette section, vous avez appris une autre façon d'afficher plus de deux variables dans un graphique en utilisant ggplot en Python. Lorsque vous avez trois variables, vous devez choisir entre l'utilisation de facettes et de couleurs en fonction de l'approche qui rend la visualisation des données plus facile à comprendre.

Exportation de tracés vers des fichiers

Dans certaines situations, vous devrez enregistrer les tracés générés dans des fichiers image par programmation au lieu de les afficher dans Jupyter Notebook.

plotnine fournit un très pratique enregistrer() méthode que vous pouvez utiliser pour exporter un tracé sous forme d'image et l'enregistrer dans un fichier. Par exemple, le morceau de code suivant montre comment vous pouvez enregistrer le graphique vu au début du didacticiel dans un fichier nommé myplot.png:

de plotnine.data importer économie
de plotnine importer ggplot, aes, geom_line

myPlot = ggplot(économie) + aes(X="Date", y="pop") + geom_line()
myPlot.enregistrer("myplot.png", dpi=600)

Dans ce code, vous stockez l'objet de visualisation de données dans myPlot puis invoquez enregistrer() pour exporter le graphique sous forme d'image et le stocker sous myplot.png.

Vous pouvez modifier certains paramètres d'image lors de l'utilisation enregistrer(), comme les points d'image par pouce (dpi). Ceci est vraiment utile lorsque vous avez besoin d'images de haute qualité à inclure dans des présentations ou des articles.

plotnine comprend également une méthode pour enregistrer divers graphiques dans un seul fichier PDF. Vous pouvez en apprendre davantage et voir quelques exemples intéressants dans la documentation save_as_pdf_pages de plotnine.

Pouvoir exporter vos visualisations de données ouvre de nombreuses possibilités. Vous n'êtes pas obligé d'afficher uniquement vos données dans Jupyter Notebook interactif. Vous pouvez également générer des graphiques et les exporter pour une analyse ou un traitement ultérieur.

Conclusion

En utilisant ggplot en Python vous permet de créer des visualisations de données de manière très concise et cohérente. Comme vous l'avez vu, même des tracés complexes et beaux peuvent être créés avec quelques lignes de code à l'aide de plotnine.

Dans ce didacticiel, vous avez appris à:

  • Installer plotnine et Cahier Jupyter
  • Combinez les différents éléments du grammaire des graphiques
  • Utilisez plotnine pour créer des visualisations de manière efficace et cohérente.
  • Exportation vos visualisations de données dans des fichiers

Ce didacticiel utilise les exemples de jeux de données inclus dans plotnine, mais vous pouvez utiliser tout ce que vous avez appris pour créer des visualisations à partir d'autres données. Pour savoir comment charger vos données dans pandas DataFrames, la structure de données utilisée par plotnine, consultez Utiliser Pandas et Python pour explorer votre ensemble de données.

Enfin, jetez un œil à la documentation de plotnine pour continuer votre parcours ggplot en Python, et visitez également la galerie de plotnine pour plus d'idées et d'inspiration.

Il existe d'autres packages de visualisation de données Python qui méritent d'être mentionnés, comme Altair et HoloViews. Jetez-y un coup d'œil avant de choisir un outil pour votre prochain projet. Utilisez ensuite tout ce que vous avez appris pour créer des visualisations de données incroyables qui vous aident, vous et d'autres, à mieux comprendre les données!